Class: Codecal::Calc

Inherits:
Object
  • Object
show all
Includes:
Mask, Modulo, Validation
Defined in:
lib/codecal.rb

Constant Summary collapse

@@MASK_ALPHABET = 
['a','4','p','9','h','r','7','q','c','3','b','2','j','s','6','d','t','8','k','u','e','v','f','w','x','5','m','y','g','z','n']

Instance Method Summary collapse

Methods included from Mask

#convert_masked_code_typo, #get_mask_offset, #mask_alphabet_include?, #mask_char, #mask_code, #un_mask_char, #unmask_code

Methods included from Modulo

#simple_code_calculate

Methods included from Validation

#all_digits?, #all_letters_or_digits?, #is_legal_mask?, #is_legal_masked_code?

Constructor Details

#initialize(mask_alphabet = nil) ⇒ Calc

Returns a new instance of Calc.



15
16
17
18
19
20
21
22
23
24
 
# File 'lib/codecal.rb', line 15

def initialize(mask_alphabet = nil)
  if mask_alphabet.is_a?(String) && 
      mask_alphabet.size > 26 &&
      all_letters_or_digits?(mask_alphabet) &&
      mask_alphabet.size == mask_alphabet.split('').uniq.size
    @mask_alphabet = mask_alphabet.split('')
  else
    @mask_alphabet = @@MASK_ALPHABET  
  end
end

Instance Method Details

#code_generate_with_mask(mask, number) ⇒ Object 



41
42
43
44
45
46
47
48
49
 
# File 'lib/codecal.rb', line 41

def code_generate_with_mask(mask, number)
  errormsg = "mark should be string of letter or number and length should >= 5" unless is_legal_mask?(mask)
  return {success:false, error: errormsg} if errormsg
  result = simple_code_generate(number)
  return result unless result[:success]
  offset = get_mask_offset(mask)
  # puts "masked code: #{result[:customer_code]}"
  {success:true, customer_code: mask_code(offset, result[:customer_code])}
end

#get_unmasked_code(mask, masked_code) ⇒ Object 



69
70
71
72
73
74
75
76
77
 
# File 'lib/codecal.rb', line 69

def get_unmasked_code(mask, masked_code)
  return false unless is_legal_masked_code?(masked_code)
  return false unless is_legal_mask?(mask)
  masked_code = convert_masked_code_typo(masked_code)

  offset = get_mask_offset(mask)
  code = unmask_code(offset, masked_code)
  masked_code.size == code.size ? code : false
end

#simple_code_generate(number) ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/codecal.rb', line 26

def simple_code_generate(number)
  errormsg = ""
  if number == nil
    errormsg += "parameter is nil. "
    return {success:false, error: errormsg}
  end
  errormsg += "the type of the code to be encrypted should be Integer. " unless all_digits?(number.to_s)
  if errormsg.size == 0
    cal_array = (number.to_i.to_s).split("").map! {|i| i.to_i}
    {success:true, customer_code: simple_code_calculate(cal_array) }
  else
    {success:false, error: errormsg}
  end
end

#validate_masked_code(mask, masked_code) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/codecal.rb', line 57

def validate_masked_code(mask, masked_code)
  return false unless is_legal_masked_code?(masked_code)
  return false unless is_legal_mask?(mask)
  masked_code = convert_masked_code_typo(masked_code)

  offset = get_mask_offset(mask)
  result = simple_code_generate(unmask_code(offset, masked_code)[0..-2].to_i)

  return false unless result[:success]
  return masked_code == mask_code(offset, result[:customer_code])
end

#validate_simple_code(simple_code) ⇒ Object 



51
52
53
54
55
 
# File 'lib/codecal.rb', line 51

def validate_simple_code(simple_code)
  return false unless simple_code && simple_code.to_i > 0 && simple_code.size > 1
  calcode = simple_code_calculate(simple_code[0..-2].split("").map! {|i| i.to_i})
  return simple_code == calcode
end