format_engine 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de6ff33cc2d740c1ac1721bc6f2a40bf745208b0
-  data.tar.gz: 9ef57766216651bd454e32ff5cecb8d0c187c39e
+  metadata.gz: f114053c3cff51fcde5ac482b6e27463110adc68
+  data.tar.gz: 0721a2c7c92b65dbcb1f6f410f0dbb759530df8a
 SHA512:
-  metadata.gz: 915a1c8a1bcda84ae78e197f990a67519511be97174b36574028af18fded89589bf3425cb666c23e85508057fa876c521038c390d2c164a10e8926caa9f3f972
-  data.tar.gz: 8d80d8e21223443b3806633d7b2ccbf1fbd714a2488c1dd3a67a8096a988eaba26cd04f9b38e0bca0cb42261394bd1927b98213802335d5e30d9ea496e3bf5a0
+  metadata.gz: 4ae828117862ee0e38f5b670f4ddeb78b69f1868db1b18978db53dc8b2a97f851cb3ed6c5eca960f53a43ff442fb471e769b743cb7b5e040647883af68680f5d
+  data.tar.gz: 6b613688092373d7eec2d7cf66336a23f9cc8dfe45008f88d0d98a74b4d63486327350700d52a4f742472c4bf465acee477d34c41bad85ff5b5ad8261b82a9f7

data/README.md

@@ -97,9 +97,10 @@ have been extracted from the input string.
 
                (?<var> \g<lead>\g<flags>[-+]?(\d+(\.\d+)?)?[a-zA-Z]){0}
                (?<set> \g<lead>\g<flags>(\d+(,\d+)?)?\[([^\]\\]|\\.)+\]){0}
+               (?<rgx> \g<lead>\g<flags>\/([^\\ \/]|\\.)*\/([imx]*)){0}
                (?<per> \g<lead>%){0}
 
-               \g<var> | \g<set> | \g<per>
+               \g<var> | \g<set> | \g<rgx> | \g<per>
               }x
 
 ### Var
@@ -108,12 +109,20 @@ A format specification of the classical form:
     %[flags][+/-][width[.precision]]letter
 
 ### Set
-A reguluar expression set (or un-set) of the form:
+A regular expression set (or un-set), used for parsing only, of the form:
 
-  %[flags][[min_width,]max_width]"["[^]set_chars"]"
+    %[flags][[min_width,]max_width]"["[^]set_chars"]"
+
+### Rgx
+A full blown regular expression, used for parsing only, of the form:
+
+    %[flags]/regex stuff goes here/[options]
+
+Supported options are i, m, and x.
 
 ### Per
-A %% which evaluates to a literal character %.
+A %% which evaluates to a literal character %. This is the old school
+alternative to \\% which is preferred.
 
 ### Literal
 Text in between the various format specifications is treated as literal text.
@@ -122,12 +131,12 @@ Text in between the various format specifications is treated as literal text.
 
 The format specification:
 ```ruby
-"Elapsed = %*02H:%M:%-5.2S %d%% %@1[!?]"
+"Elapsed = %*02H:%M:%-5.2S %d%% %@1[!?] %/a+b+c+/i"
 ```
 creates the following format specification array:
 
 ```ruby
-#<FormatEngine::FormatSpec:0x1b4e288
+#<FormatEngine::FormatSpec:0x1be2140
  @specs=
   [Literal("Elapsed = "),
    Variable("%*H", ["02"]),
@@ -139,7 +148,9 @@ creates the following format specification array:
    Variable("%d", nil),
    Literal("%"),
    Literal(" "),
-   Set("%@[!?]", "%@[", /[!?]{1,1}/)]>
+   Set("%@[!?]", "%@[", /[!?]{1,1}/),
+   Literal(" "),
+   Regex("%/a+b+c+/i", "%/", /a+b+c+/i)]>
 ```
 Where literals are processed as themselves, except:
 * If that literal ends with a space, that space will parse zero or more spaces.
@@ -153,13 +164,15 @@ precision fields) in the library and executing the corresponding block. The
 format string can be seen in the above sample as the first string in the
 Variable
 
-Sets work by looking into the input string with their regular expression. Sets
-are only ever used when parsing, never for formatting. Sets are executed by
-first looking up their long name, listed first, and then if the long name is not
-found, their short name, listed second is tried.
+Sets and Regexes work by looking into the input string with their regular
+expression. Both are only ever used when parsing, never for formatting.
+They are executed by first looking up their long name, listed first, and
+then if the long name is not found, their short name, listed second is tried.
+
+**Note:** If a format specification does not correspond to an entry in the
+library, an exception occurs. For example
 
-**Note:** If a format string does not correspond to an entry in the library,
-an exception occurs.
+    RuntimeError detected: Unsupported tag = "%!!!d"
 
 ## Formatting / Parsing Blocks
 
@@ -195,7 +208,7 @@ Methods
 * found? - Did the last parse succeed?
 * found - The text found by the last parse (or parse!) operation.
 
-###Format Specifier Attributes
+###Variable Format Specifier Attributes
 The format specifier, used in both formatting and parsing and accessed as the
 fmt attribute, has itself, the following attributes:
 * has_width? - Was a width specified?
@@ -206,6 +219,10 @@ fmt attribute, has itself, the following attributes:
 * prec_str - The actual precision text or an empty string.
 * parm_str - The actual parameter (width and precision) text or an empty string.
 
+###Set and Regex Format Specifier Attributes
+* width - Always 0.
+* regex - The internal regex compiled for this specification
+
 ## Contributing
 
 #### Plan A

data/lib/format_engine/format_spec.rb

@@ -1,21 +1,15 @@
 #Analysis of format/parse specification strings.
 
+require_relative 'format_spec/parse_regex'
 require_relative 'format_spec/literal'
 require_relative 'format_spec/variable'
 require_relative 'format_spec/set'
+require_relative 'format_spec/rgx'
 
 module FormatEngine
 
   #The format string parser.
   class FormatSpec
-    #The regex used to parse variable specifications.
-    REGEX = %r{(?<lead>  (^|(?<=[^\\]))%){0}
-               (?<flags> [~@#$^&*=?_<>|!]*){0}
-               (?<var> \g<lead>\g<flags>[-+]?(\d+(\.\d+)?)?[a-zA-Z]){0}
-               (?<set> \g<lead>\g<flags>(\d+(,\d+)?)?\[([^\]\\]|\\.)+\]){0}
-               (?<per> \g<lead>%){0}
-               \g<var> | \g<set> | \g<per>
-              }x
 
     #The array of specifications that were extracted.
     attr_reader :specs
@@ -43,6 +37,7 @@ module FormatEngine
           @specs << case
                     when match_data[:var] then FormatVariable.new(mid)
                     when match_data[:set] then FormatSet.new(mid)
+                    when match_data[:rgx] then FormatRgx.new(mid)
                     when match_data[:per] then FormatLiteral.new("\%")
                     else fail "Impossible case in scan_spec."
                     end

data/lib/format_engine/format_spec/parse_regex.rb

@@ -0,0 +1,16 @@
+module FormatEngine
+
+  #The format string parser.
+  class FormatSpec
+    #The regex used to parse variable specifications.
+    REGEX = %r{(?<lead>  (^|(?<=[^\\]))%){0}
+               (?<flags> [~@#$^&*=?_<>|!]*){0}
+               (?<var> \g<lead>\g<flags>[-+]?(\d+(\.\d+)?)?[a-zA-Z]){0}
+               (?<set> \g<lead>\g<flags>(\d+(,\d+)?)?\[([^\]\\]|\\.)+\]){0}
+               (?<rgx> \g<lead>\g<flags>\/([^\\ \/]|\\.)*\/([imx]*)){0}
+               (?<per> \g<lead>%){0}
+               \g<var> | \g<set> | \g<rgx> | \g<per>
+              }x
+   end
+
+end

data/lib/format_engine/format_spec/rgx.rb

@@ -0,0 +1,58 @@
+module FormatEngine
+
+  #A format engine set specification.
+  class FormatRgx
+
+    #The full name of the set.
+    attr_reader :long_name
+
+    #The short form name of the set.
+    attr_reader :short_name
+
+    #The regular expression part of this set specification.
+    attr_reader :regex
+
+    #The width parameter. Handled internally so this is always zero.
+    def width
+      0
+    end
+
+    #Setup a variable format specification.
+    def initialize(format)
+      @long_name = format
+      pre, _, post = format.partition('/')
+      @short_name = pre + '/'
+
+      exp, _, options = post.partition(/(?<=[^\\])\// )
+      opt = (options.include?('x') ? Regexp::EXTENDED   : 0) |
+            (options.include?('i') ? Regexp::IGNORECASE : 0) |
+            (options.include?('m') ? Regexp::MULTILINE  : 0)
+
+      @regex = Regexp.new(exp.gsub(/\\\//, '/'), opt)
+    end
+
+    #Is this format item supported by the engine's library?
+    def validate(engine)
+      @block = engine[@long_name] || engine[@short_name]
+      fail "Unsupported tag = #{@raw.inspect}" unless @block
+      true
+    end
+
+    #Format onto the output string
+    def do_format(spec_info)
+      fail "The tag %{@raw} may not be used in formatting."
+    end
+
+    #Parse from the input string
+    def do_parse(spec_info)
+      spec_info.instance_exec(&@block)
+    end
+
+    #Inspect for debugging.
+    def inspect
+      "Regex(#{@long_name.inspect}, #{@short_name.inspect}, #{regex.inspect})"
+    end
+
+  end
+
+end

data/lib/format_engine/version.rb

@@ -1,5 +1,5 @@
 
 module FormatEngine
   # The version of the format_engine gem.
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/tests/engine_base_tests.rb

@@ -13,6 +13,30 @@ class EngineBaseTester < Minitest::Test
 
     assert_equal(42, test["%A"])
     assert_equal(nil, test["%B"])
+    assert(test[:before])
+    assert(test[:after])
+    assert_equal(3, test.library.length)
+  end
+
+  def test_the_engine_cache
+    lib = {
+      "%A" => lambda { puts "Processing %A" },
+      "%B" => lambda { puts "Processing %B" },
+      "%C" => lambda { puts "Processing %C" }
+    }
+
+    spec = "%A %B %C"
+
+    e1 = FormatEngine::Engine.new(lib)
+
+    s1a = e1.send(:get_spec, spec)
+    s1b = e1.send(:get_spec, spec)
+    assert_equal(s1a, s1b)
+
+    e2 = FormatEngine::Engine.new(lib)
+
+    s2 = e2.send(:get_spec, spec)
+    refute_equal(s1a, s2)
   end
 
 end

data/tests/format_engine_tests.rb

@@ -17,7 +17,6 @@ class FormatEngineTester < Minitest::Test
     assert_equal("Jane, Doe 21", cust.strfmt("%f, %l %a"))
   end
 
-
   def test_basic_parsing
     cust = Customer.strprs("Jane, Doe 21", "%f, %l %a")
 

data/tests/format_spec_tests.rb

@@ -194,4 +194,14 @@ class FormatSpecTester < Minitest::Test
     assert_equal(")", test.specs[6].literal)
   end
 
+  def test_that_it_scans_regex_formats
+    test = FormatEngine::FormatSpec.new "%/ABC/"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatRgx, test.specs[0].class)
+    assert_equal(/ABC/, test.specs[0].regex)
+  end
+
+
+
 end

data/tests/parser_engine_tests.rb

@@ -13,16 +13,21 @@ class ParserTester < Minitest::Test
 
   def make_parser
     FormatEngine::Engine.new(
-      "%a"    => lambda { tmp[:age] = found.to_i if parse(/\d+/) },
-      "%f"    => lambda { tmp[:fn] = found if parse(/(\w)+/) },
-      "%F"    => lambda { tmp[:fn] = found.upcase if parse(/(\w)+/) },
-      "%-F"   => lambda { tmp[:fn] = found.capitalize if parse(/(\w)+/) },
-      "%l"    => lambda { tmp[:ln] = found if parse(/(\w)+/ ) },
-      "%L"    => lambda { tmp[:ln] = found.upcase if parse(/(\w)+/) },
-      "%-L"   => lambda { tmp[:ln] = found.capitalize if parse(/(\w)+/) },
-      "%["    => lambda { parse! fmt.regex },
-      "%t"    => lambda { parse("\t") },
-      "%!t"   => lambda { parse!("\t") },
+      "%a"  => lambda { tmp[:age] = found.to_i if parse(/\d+/) },
+      "%f"  => lambda { tmp[:fn] = found if parse(/(\w)+/) },
+      "%F"  => lambda { tmp[:fn] = found.upcase if parse(/(\w)+/) },
+      "%-F" => lambda { tmp[:fn] = found.capitalize if parse(/(\w)+/) },
+      "%l"  => lambda { tmp[:ln] = found if parse(/(\w)+/ ) },
+      "%L"  => lambda { tmp[:ln] = found.upcase if parse(/(\w)+/) },
+      "%-L" => lambda { tmp[:ln] = found.capitalize if parse(/(\w)+/) },
+      "%["  => lambda { parse! fmt.regex },
+      "%[A-Z]" =>
+               lambda { tmp[:ln] = found if parse! fmt.regex },
+      "%/"  => lambda { parse! fmt.regex },
+      "%/[A-Z]+/i" =>
+               lambda { tmp[:ln] = found if parse! fmt.regex },
+      "%t"  => lambda { parse("\t") },
+      "%!t" => lambda { parse!("\t") },
 
       :after  => lambda do
         set dst.new(*[tmp[:fn], tmp[:ln], tmp[:age]].delete_if(&:nil?))
@@ -105,6 +110,33 @@ class ParserTester < Minitest::Test
     assert_equal("Squidly", result.first_name)
     assert_equal("Jones", result.last_name)
     assert_equal(55, result.age)
+
+    spec =  "%f %[A-Z] %a"
+    result = engine.do_parse("Squidly JONES 55", TestPerson, spec)
+
+    assert_equal(TestPerson, result.class)
+    assert_equal("Squidly", result.first_name)
+    assert_equal("JONES", result.last_name)
+    assert_equal(55, result.age)
+  end
+
+  def test_that_it_can_parse_regexes
+    engine = make_parser
+    spec =  "%f %l %/[Aa]ge/ %a"
+    result = engine.do_parse("Squidly Jones age 55", TestPerson, spec)
+
+    assert_equal(TestPerson, result.class)
+    assert_equal("Squidly", result.first_name)
+    assert_equal("Jones", result.last_name)
+    assert_equal(55, result.age)
+
+    spec =  "%f %/[A-Z]+/i %a"
+    result = engine.do_parse("Squidly Jones 55", TestPerson, spec)
+
+    assert_equal(TestPerson, result.class)
+    assert_equal("Squidly", result.first_name)
+    assert_equal("Jones", result.last_name)
+    assert_equal(55, result.age)
   end
 
   def test_that_it_can_detect_errors

data/tests/rgx_spec_tests.rb

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+require_relative '../lib/format_engine'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+class RgxSpecTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_the_parms
+    test = FormatEngine::FormatRgx.new("%/ABC/")
+    assert_equal(0, test.width)
+    assert_equal(/ABC/, test.regex)
+    assert_equal('Regex("%/ABC/", "%/", /ABC/)', test.inspect)
+
+    test = FormatEngine::FormatRgx.new("%*/ABC/")
+    assert_equal(0, test.width)
+    assert_equal(/ABC/, test.regex)
+    assert_equal('Regex("%*/ABC/", "%*/", /ABC/)', test.inspect)
+
+    test = FormatEngine::FormatRgx.new("%/ABC/x")
+    assert_equal(0, test.width)
+    assert_equal(/ABC/x, test.regex)
+    assert_equal('Regex("%/ABC/x", "%/", /ABC/x)', test.inspect)
+
+    test = FormatEngine::FormatRgx.new("%/ABC/i")
+    assert_equal(0, test.width)
+    assert_equal(/ABC/i, test.regex)
+    assert_equal('Regex("%/ABC/i", "%/", /ABC/i)', test.inspect)
+
+    test = FormatEngine::FormatRgx.new("%/ABC/m")
+    assert_equal(0, test.width)
+    assert_equal(/ABC/m, test.regex)
+    assert_equal('Regex("%/ABC/m", "%/", /ABC/m)', test.inspect)
+
+    test = FormatEngine::FormatRgx.new("%/ABC/xi")
+    assert_equal(0, test.width)
+    assert_equal(/ABC/ix, test.regex)
+    assert_equal('Regex("%/ABC/xi", "%/", /ABC/ix)', test.inspect)
+
+    test = FormatEngine::FormatRgx.new("%/ABC/mi")
+    assert_equal(0, test.width)
+    assert_equal(/ABC/mi, test.regex)
+    assert_equal('Regex("%/ABC/mi", "%/", /ABC/mi)', test.inspect)
+
+    test = FormatEngine::FormatRgx.new("%/ABC/xim")
+    assert_equal(0, test.width)
+    assert_equal(/ABC/ixm, test.regex)
+    assert_equal('Regex("%/ABC/xim", "%/", /ABC/mix)', test.inspect)
+
+    test = FormatEngine::FormatRgx.new("%/A\\/C/")
+    assert_equal(0, test.width)
+    assert_equal('Regex("%/A\\\\/C/", "%/", /A\/C/)', test.inspect)
+    assert_equal(/A\/C/, test.regex)
+
+  end
+
+  def test_unsupported_methods
+    test = FormatEngine::FormatRgx.new("%/ABC/")
+
+    assert_raises() {test.has_width?}
+    assert_raises() {test.width_str}
+    assert_raises() {test.has_prec?}
+    assert_raises() {test.prec}
+    assert_raises() {test.prec_str}
+    assert_raises() {test.parm_str}
+  end
+
+
+end

data/tests/set_spec_tests.rb

@@ -21,5 +21,21 @@ class SetSpecTester < Minitest::Test
     assert_equal(0, test.width)
     assert_equal(/[ABC]{5,10}/, test.regex)
 
+    test = FormatEngine::FormatSet.new("%0,10[ABC]")
+    assert_equal(0, test.width)
+    assert_equal(/[ABC]{0,10}/, test.regex)
+
   end
+
+  def test_unsupported_methods
+    test = FormatEngine::FormatSet.new("%[ABC]")
+
+    assert_raises() {test.has_width?}
+    assert_raises() {test.width_str}
+    assert_raises() {test.has_prec?}
+    assert_raises() {test.prec}
+    assert_raises() {test.prec_str}
+    assert_raises() {test.parm_str}
+  end
+
 end

data/tests/variable_spec_tests.rb

@@ -46,4 +46,11 @@ class VariableSpecTester < Minitest::Test
     assert_equal("-10.5", test.parm_str)
 
   end
+
+  def test_unsupported_methods
+    test = FormatEngine::FormatVariable.new("%B")
+
+    assert_raises() {test.regex}
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: format_engine
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Peter Camilleri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-19 00:00:00.000000000 Z
+date: 2016-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -101,6 +101,8 @@ files:
 - lib/format_engine/engine.rb
 - lib/format_engine/format_spec.rb
 - lib/format_engine/format_spec/literal.rb
+- lib/format_engine/format_spec/parse_regex.rb
+- lib/format_engine/format_spec/rgx.rb
 - lib/format_engine/format_spec/set.rb
 - lib/format_engine/format_spec/variable.rb
 - lib/format_engine/spec_info.rb
@@ -118,6 +120,7 @@ files:
 - tests/formatter_engine_tests.rb
 - tests/literal_spec_tests.rb
 - tests/parser_engine_tests.rb
+- tests/rgx_spec_tests.rb
 - tests/scan_tests.rb
 - tests/set_spec_tests.rb
 - tests/variable_spec_tests.rb