postkode 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2fd1287a7b3abfa42ef8bc62d07106dd7190ec66
-  data.tar.gz: 441a7a4b106ec9b10e3612f88a2a95234feaa63a
+  metadata.gz: bca6338640f4dc4a6aedb862d8065b681e2bb6ca
+  data.tar.gz: 279c9e6c14171ee348bf6fb90abb0523dab4471b
 SHA512:
-  metadata.gz: 31c53d909ff7b2388d19d46980ab95e5a775d0693850cc720f50b89f935a3257d72fe33611db3d81311d110d5baa2e7f59a7b3724483b928552110d8083c05b1
-  data.tar.gz: edaf91965c9454e5997234fdc928eb216974e8104d86730de38d78297ef12db083af602c75b764c2e961316b7cfdedc03ce46b48659f89d9d006891a5680fccf
+  metadata.gz: cf27be6284a05bef246e3851f0ab23592cae2082f603949bcfd27292a50753147402ac7e1d6689d25a3f60308a9537fba8ee43650d2d82c738ce879e95f1fd4d
+  data.tar.gz: 2e9304709f696fc3585ce2dd097d5275ea1d6dac9eeac785b3bb728a65b8242d0ee31222fb5291b6d5d393c25faf51c380d411a55324905ecb46aebbe2a5c190

data/lib/postkode.rb

@@ -1,30 +1,40 @@
 # encoding: utf-8
+require_relative 'strrand'
 
 # Handles validation of UK-style postcodes
 class Postkode
-
   # Validating UK Postcodes
   # Correct as at 2014-09-15
   # References below
   # https://www.gov.uk/government/uploads/system/uploads/attachment_data/file/283357/ILRSpecification2013_14Appendix_C_Dec2012_v1.pdf
   # http://en.wikipedia.org/wiki/Postcodes_in_the_United_Kingdom#Validation
-  # Areas with only single-digit districts: BR, FY, HA, HD, HG, HR, HS, HX, JE, LD, SM, SR, WC, WN, ZE (although WC is always subdivided by a further letter, e.g. WC1A).
+  # Areas with only single-digit districts: BR, FY, HA, HD, HG, HR, HS, HX, JE,
+  #       LD, SM, SR, WC, WN, ZE (although WC is always subdivided by a
+  #       further letter, e.g. WC1A).
   # Areas with only double-digit districts: AB, LL, SO.
-  # Areas with a district '0' (zero): BL, BS, CM, CR, FY, HA, PR, SL, SS (BS is the only area to have both a district 0 and a district 10).
-  # The following central London single-digit districts have been further divided by inserting a letter after the digit and before the space: EC1–EC4 (but not EC50), SW1, W1, WC1, WC2, and part of E1 (E1W), N1 (N1C and N1P), NW1 (NW1W) and SE1 (SE1P).
+  # Areas with a district '0' (zero): BL, BS, CM, CR, FY, HA, PR, SL, SS (BS is
+  #       the only area to have both a district 0 and a district 10).
+  # The following central London single-digit districts have been further
+  #       divided by inserting a letter after the digit and before the space:
+  #       EC1-EC4 (but not EC50), SW1, W1, WC1, WC2, and part of E1 (E1W),
+  #       N1 (N1C and N1P), NW1 (NW1W) and SE1 (SE1P).
   # The letters QVX are not used in the first position.
   # The letters IJZ are not used in the second position.
-  # The only letters to appear in the third position are ABCDEFGHJKPSTUW when the structure starts with A9A.
-  # The only letters to appear in the fourth position are ABEHMNPRVWXY when the structure starts with AA9A.
-  # The final two letters do not use the letters CIKMOV, so as not to resemble digits or each other when hand-written.
-  # Post code sectors are one of ten digits: 0 to 9 with 0 only used once 9 has been used in a post town, save for Croydon and Newport (see above).
+  # The only letters to appear in the third position are ABCDEFGHJKPSTUW when
+  #       the structure starts with A9A.
+  # The only letters to appear in the fourth position are ABEHMNPRVWXY when
+  #       the structure starts with AA9A.
+  # The final two letters do not use the letters CIKMOV, so as not to resemble
+  #       digits or each other when hand-written.
+  # Post code sectors are one of ten digits: 0 to 9 with 0 only used once 9
+  #       has been used in a post town, save for Croydon and Newport (above).
 
-  A1    = "[A-PR-UWYZ]"
-  A2    = "[A-HK-Y]"
-  A3    = "[A-HJKPS-UW]"
-  A4    = "[ABEHMNPRV-XY]"
-  A5    = "[ABD-HJLN-UW-Z]"
-  N     = "[0-9]"
+  A1    = '[A-PR-UWYZ]'
+  A2    = '[A-HK-Y]'
+  A3    = '[A-HJKPS-UW]'
+  A4    = '[ABEHMNPRV-XY]'
+  A5    = '[ABD-HJLN-UW-Z]'
+  N     = '[0-9]'
   AANN  = A1 + A2 + N + N     # the six possible first-part combos
   AANA  = A1 + A2 + N + A4
   ANA   = A1 + N + A3
@@ -39,8 +49,8 @@ class Postkode
   NORMAL_PART_POSTCODE_PATTERN  = /[ ]*(#{PART_ONE})[ ]*/
   NORMAL_POSTCODE_RE = Regexp.new(NORMAL_POSTCODE_VALID, Regexp::IGNORECASE)
 
-  def self.validate(string, return_parts=false)
-    return false if string.nil? || string == "" || string == false
+  def self.validate(string, return_parts = false)
+    return false if string.nil? || string == '' || string == false
     result = string.match(NORMAL_POSTCODE_RE)
     return false if result.nil?
 
@@ -48,14 +58,14 @@ class Postkode
   end
 
   def self.get_first_section(string)
-    self.get_outcode(string)
+    get_outcode(string)
   end
 
   def self.get_outcode(string)
     found = Postkode.validate(string, true)
     found ? found[0] : nil
   end
-  
+
   def self.get_inward(string)
     found = Postkode.validate(string, true)
     found ? found[1] : nil
@@ -63,11 +73,24 @@ class Postkode
 
   def self.find_in_string(string)
     res = string.scan(NORMAL_POSTCODE_PATTERN)
-    res.length>0 ? res : nil
+    res.length > 0 ? res : nil
   end
 
   def self.find_partial_in_string(string)
     res = string.scan(NORMAL_PART_POSTCODE_PATTERN)
-    res.length>0 ? res : nil
+    res.length > 0 ? res : nil
+  end
+
+  def self.validate_and_normalize(string)
+    return nil unless validate(string)
+    validate(string, true).
+      map(&:to_s).
+      map(&:upcase).
+      join(" ")
+  end
+
+  def self.random()
+    generator_pattern = "#{[AANN, AANA, ANA, ANN, AAN, AN].sample} #{PART_TWO}"
+    StringRandom.random_regex(generator_pattern)
   end
 end

data/lib/strrand.rb

@@ -0,0 +1,311 @@
+#
+# = strrand.rb: Generates a random string from a pattern
+#
+# Author:: tama <repeatedly@gmail.com>
+#
+# StringRandom is derived from the String::Random written in Perl.
+# See http://search.cpan.org/~steve/String-Random-0.22/
+#
+# == Example
+#
+#   string_random = StringRandom.new
+#   string_random.random_pattern('CCcc!ccn')  #=> ZIop$ab1
+#
+# refer to test/test_stringrandom.rb
+#
+# == Format
+#
+# === Regular expression syntax
+#
+# *_regex methods use this rule.
+#
+# The following regular expression elements are supported.
+#
+# [\w]  Alphanumeric + "_".
+# [\d]  Digits.
+# [\W]  Printable characters other than those in \w.
+# [\D]  Printable characters other than those in \d.
+# [.]   Printable characters.
+# [[]]  Character classes.
+# [{}]  Repetition.
+# [*]   Same as {0,}.
+# [+]   Same as {1,}
+# [?]   Same as {0,1}.
+#
+# === Patterns
+#
+# random_pattern and random_string methods use this rule.
+#
+# The following patterns are pre-defined.
+#
+# [c]  Any lowercase character [a-z]
+# [C]  Any uppercase character [A-Z]
+# [n]  Any digit [0-9]
+# [!]  A punctuation character [~`!@$%^&*()-_+={}[]|\:;"'.<>?/#,]
+# [.]  Any of the above
+# [s]  A "salt" character [A-Za-z0-9./]
+# [b]  Any binary data
+#
+# Pattern can modify and add as bellow.
+#
+#   string_random['C'] = ['n']
+#   string_random['A'] = Array('A'..'Z') | Array('a'..'z')
+#
+# Pattern must be a flattened array that elements are one character.
+# Other types cause undefined behavior(raise exception, success, etc...).
+#
+class StringRandom
+  Upper  = Array('A'..'Z')
+  Lower  = Array('a'..'z')
+  Digit  = Array('0'..'9')
+  Punct  = [33..47, 58..64, 91..96, 123..126].map { |r| r.map { |val| val.chr } }.flatten
+  Any    = Upper | Lower | Digit | Punct
+  Salt   = Upper | Lower | Digit | ['.', '/']
+  Binary = (0..255).map { |val| val.chr }
+
+  # These are the regex-based patterns.
+  Pattern = {
+    # These are the regex-equivalents.
+    '.'  => Any,
+    '\d' => Digit,
+    '\D' => Upper | Lower | Punct,
+    '\w' => Upper | Lower | Digit | ['_'],
+    '\W' => Punct.reject { |val| val == '_' },
+    '\s' => [' ', "\t"],
+    '\S' => Upper | Lower | Digit | Punct,
+
+    # These are translated to their double quoted equivalents.
+    '\t' => ["\t"],
+    '\n' => ["\n"],
+    '\r' => ["\r"],
+    '\f' => ["\f"],
+    '\a' => ["\a"],
+    '\e' => ["\e"]
+  }
+  # These are the old patterns for random_pattern.
+  OldPattern = {
+    'C' => Upper,
+    'c' => Lower,
+    'n' => Digit,
+    '!' => Punct,
+    '.' => Any,
+    's' => Salt,
+    'b' => Binary
+  }
+
+  #
+  # Singleton method version of random_regex.
+  #
+  def self.random_regex(patterns)
+    StringRandom.new.random_regex(patterns)
+  end
+
+  #
+  # Same as StringRandom#random_pattern if single argument.
+  # Optionally, references to lists containing
+  # other patterns can be passed to the function.
+  # Those lists will be used for 0 through 9 in the pattern.
+  #
+  def self.random_string(pattern, *pattern_list)
+    string_random = StringRandom.new
+
+    pattern_list.each_with_index do |new_pattern, i|
+      string_random[i.to_s] = new_pattern
+    end
+
+    string_random.random_pattern(pattern)
+  end
+
+  #
+  # _max_ is default length for creating random string
+  #
+  def initialize(max = 10)
+    @max   = max
+    @map   = OldPattern.clone
+    @regch = {
+      "\\" => method(:regch_slash),
+      '.'  => method(:regch_dot),
+      '['  => method(:regch_bracket),
+      '*'  => method(:regch_asterisk),
+      '+'  => method(:regch_plus),
+      '?'  => method(:regch_question),
+      '|'  => method(:regch_pipe),
+      '{'  => method(:regch_brace)
+    }
+  end
+
+  #
+  # Returns a random string that will match
+  # the regular expression passed in the list argument.
+  #
+  def random_regex(patterns)
+    return _random_regex(patterns) unless patterns.instance_of?(Array)
+
+    result = []
+    patterns.each do |pattern|
+      result << _random_regex(pattern)
+    end
+    result
+  end
+
+  #
+  # Returns a random string based on the concatenation
+  # of all the pattern strings in the list.
+  #
+  def random_pattern(patterns)
+    return _random_pattern(patterns) unless patterns.instance_of?(Array)
+
+    result = []
+    patterns.each do |pattern|
+      result << _random_pattern(pattern)
+    end
+    result
+  end
+
+  #
+  # Returns a random string pattern
+  #
+  def [](key)
+    @map[key]
+  end
+
+  #
+  # Adds a random string pattern
+  #
+  # _pattern_ must be flattened array
+  #
+  def []=(key, pattern)
+    @map[key] = pattern
+  end
+
+  private
+
+  def _random_regex(pattern)
+    string = []
+    chars  = pattern.split(//)
+    non_ch = /[\$\^\*\(\)\+\{\}\]\?]/  # not supported chars
+
+    while ch = chars.shift
+      if @regch.has_key?(ch)
+        @regch[ch].call(ch, chars, string)
+      else
+        warn "'#{ch}' not implemented. treating literally." if ch =~ non_ch
+        string << [ch]
+      end
+    end
+
+    result = ''
+    string.each do |ch|
+      result << ch[rand(ch.size)]
+    end
+    result
+  end
+
+  def _random_pattern(pattern)
+    string = ''
+
+    pattern.split(//).each do |ch|
+      raise %Q(Unknown pattern character "#{ch}"!) unless @map.has_key?(ch)
+      string << @map[ch][rand(@map[ch].size)]
+    end
+
+    string
+  end
+
+  #-
+  # The folloing methods are defined for regch.
+  # These characters are treated specially in random_regex.
+  #+
+
+  def regch_slash(ch, chars, string)
+    raise 'regex not terminated' if chars.empty?
+
+    tmp = chars.shift
+    if tmp == 'x'
+      # This is supposed to be a number in hex, so
+      # there had better be at least 2 characters left.
+      tmp = chars.shift + chars.shift
+      string << tmp.hex.chr
+    elsif tmp =~ /[0-7]/
+      warn 'octal parsing not implemented. treating literally.'
+      string << tmp
+    elsif Pattern.has_key?(ch + tmp)
+      string << Pattern[ch + tmp]
+    else
+      warn "'\\#{tmp}' being treated as literal '#{tmp}'"
+      string << tmp
+    end
+  end
+
+  def regch_dot(ch, chars, string)
+    string << Pattern[ch]
+  end
+
+  def regch_bracket(ch, chars, string)
+    tmp = []
+
+    while ch = chars.shift and ch != ']'
+      if ch == '-' and !chars.empty? and !tmp.empty?
+        max  = chars.shift
+        min  = tmp.last
+        tmp << min = min.succ while min < max
+      else
+        warn "${ch}' will be treated literally inside []" if ch =~ /\W/
+        tmp << ch
+      end
+    end
+    raise 'unmatched []' if ch != ']'
+
+    string << tmp
+  end
+
+  def regch_asterisk(ch, chars, string)
+    chars = '{0,}'.split('').concat(chars)
+  end
+
+  def regch_pipe(ch, chars, string)
+puts("CHARS: #{chars.join('/')}")
+puts("STRING: #{string.join('/')}")
+puts
+puts
+    chars = ""
+  end
+
+  def regch_plus(ch, chars, string)
+    chars = '{1,}'.split('').concat(chars)
+  end
+
+  def regch_question(ch, chars, string)
+    chars = '{0,1}'.split('').concat(chars)
+  end
+
+  def regch_brace(ch, chars, string)
+    # { isn't closed, so treat it literally.
+    return string << ch unless chars.include?('}')
+
+    tmp = ''
+    while ch = chars.shift and ch != '}'
+      raise "'#{ch}' inside {} not supported" unless ch =~ /[\d,]/
+      tmp << ch
+    end
+
+    tmp = if tmp =~ /,/
+      raise "malformed range {#{tmp}}" unless tmp =~ /^(\d*),(\d*)$/
+
+      min = $1.length.nonzero? ? $1.to_i : 0
+      max = $2.length.nonzero? ? $2.to_i : @max
+      raise "bad range {#{tmp}}" if min > max
+
+      min == max ? min : min + rand(max - min + 1)
+    else
+      tmp.to_i
+    end
+
+    if tmp.nonzero?
+      last = string.last
+      (tmp - 1).times { string << last }
+    else
+      string.pop
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: postkode
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - K M Lawrence
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-06 00:00:00.000000000 Z
+date: 2015-03-28 00:00:00.000000000 Z
 dependencies: []
 description: Postcode validation module
 email: keith.lawrence@upbeatproductions.com
@@ -19,6 +19,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/postkode.rb
+- lib/strrand.rb
 homepage: http://rubygems.org/gems/postkode
 licenses:
 - MIT
@@ -39,7 +40,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: postkode