format_engine 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbd9eddd61c278dea142573e9edc3ff65aa622f9
-  data.tar.gz: 5d4637bb827e30c3230cb44b9f4e02d8640af24e
+  metadata.gz: e58ab6d2894a40beaf8ca35a5ed4483cc577741a
+  data.tar.gz: 88e61103fdaf4e4dd5e0eec8c871dee94ff54e17
 SHA512:
-  metadata.gz: ec88dfaf16365f492b9ab47f15885a476218e7e610a74726b9199d077a5ae061579304d5f6d7aceb8612d39abb8757c3003731d8f223d04fc07aa188158fbe0d
-  data.tar.gz: 8c4926a9a3abba6ac9fc2b36155e08a8f987714201da795891106aab22ade47887b4ed2aa9a731d21158591649272513e742e26739de4b0a22af27bd74dd4d82
+  metadata.gz: 6e45c594310117150e99b10b89a2f0ed9b2df80a80b5e0126037a90b62e04abbf9a596e1159328b69f6bf504d284423e16c634ce8c376227a19c2dc1e8a50054
+  data.tar.gz: 5e9fd537fb2ad8e03b3ce6cef6e4b779a809d514fa859c2d038b6b91c6df014b2a138ef52087ece7309d7303f19b731629826c8335f64b5032bb49dc67bd2322

data/README.md

@@ -181,7 +181,7 @@ most welcomed.
 
 #### Plan A
 
-1. Fork it ( https://github.com/[my-github-username]/format_engine/fork )
+1. Fork it ( https://github.com/PeterCamilleri/format_engine/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/format_engine.gemspec

@@ -19,6 +19,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 1.9.3'
+
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency 'minitest', "~> 5.5.1"

data/lib/format_engine/engine.rb

@@ -31,10 +31,10 @@ module FormatEngine
     #* src - The source object being formatted.
     #* format_spec_str - The format specification string.
     def do_format(src, format_spec_str)
-      spec_info = SpecInfo.new(src, "", nil, self, {})
+      spec_info = SpecInfo.new(src, "", self)
 
-      due_process(spec_info, format_spec_str) do |fmt|
-        fmt.do_format(spec_info)
+      due_process(spec_info, format_spec_str) do |format|
+        spec_info.do_format(format)
       end
     end
 
@@ -44,23 +44,29 @@ module FormatEngine
     #* dst - The class of the object being created.
     #* parse_spec_str - The format specification string.
     def do_parse(src, dst, parse_spec_str)
-      spec_info = SpecInfo.new(src, dst, nil, self, {})
+      spec_info = SpecInfo.new(src, dst, self)
 
-      due_process(spec_info, parse_spec_str) do |fmt|
-        fmt.do_parse(spec_info)
+      due_process(spec_info, parse_spec_str) do |format|
+        spec_info.do_parse(format)
       end
     end
 
+    private
+
     #Do the actual work of parsing the formatted input.
     #<br>Parameters
     #* spec_info - The state of the process.
     #* spec_str - The format specification string.
     #* block - A code block performed for each format specification.
-    def due_process(spec_info, spec_str, &block)
-      spec = FormatSpec.get_spec(spec_str).validate(self)
+    def due_process(spec_info, spec_str)
+      format_spec = FormatSpec.get_spec(spec_str).validate(self)
 
       spec_info.instance_exec(&self[:before])
-      spec.specs.each(&block)
+
+      format_spec.specs.each do |format|
+        break if yield(format) == :break
+      end
+
       spec_info.instance_exec(&self[:after])
 
       spec_info.dst

data/lib/format_engine/format_spec/literal.rb

@@ -13,6 +13,11 @@ module FormatEngine
       @has_tail = @head != @literal
     end
 
+    #The width parameter. Handled literally so this is always zero.
+    def width
+      0
+    end
+
     # Is this literal supported by the engine? YES!
     def validate(_engine)
       self

data/lib/format_engine/format_spec/set.rb

@@ -9,6 +9,11 @@ module FormatEngine
     #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)
       @raw = format
@@ -41,7 +46,6 @@ module FormatEngine
 
     #Parse from the input string
     def do_parse(spec_info)
-      spec_info.fmt = self
       spec_info.instance_exec(&spec_info.engine[self.format])
     end
 

data/lib/format_engine/format_spec/variable.rb

@@ -67,21 +67,13 @@ module FormatEngine
       has_prec? ? parms[1] : ""
     end
 
-    #Build up a regular expression for parsing.
-    def regex(base)
-      qualifier = has_width? ? "{1,#{width}}": "+"
-      Regexp.new("#{base}#{qualifier}")
-    end
-
     #Format onto the output string
     def do_format(spec_info)
-      spec_info.fmt = self
       spec_info.instance_exec(&spec_info.engine[self.format])
     end
 
     #Parse from the input string
     def do_parse(spec_info)
-      spec_info.fmt = self
       spec_info.instance_exec(&spec_info.engine[self.format])
     end
 

data/lib/format_engine/format_spec.rb

@@ -4,21 +4,6 @@ require_relative 'format_spec/literal'
 require_relative 'format_spec/variable'
 require_relative 'format_spec/set'
 
-# Format String Specification Syntax (BNF):
-#  spec = (text | item | set)+
-#  item = "%" flag* sign? (parm ("." parm)? )? command
-#  set  = "%" flag* parm? "[" chrs "]"
-#  flag = ( "~" | "@" | "#" | "&" | "^"  |
-#           "&" | "*" | "-" | "+" | "="  |
-#           "?" | "_" | "<" | ">" | "\\" |
-#           "/" | "." | "," | "|" | "!"  )
-#  sign = ("+" | "-")
-#  parm = ("0" .. "9" )+
-#  chrs = (not_any("]") | "\\" "]")+
-#  command = ("a" .. "z" | "A" .. "Z")
-#
-#  Sample: x = FormatSpec.get_spec "Elapsed = %*3.1H:%02M!"
-
 module FormatEngine
 
   #The format string parser.
@@ -27,8 +12,9 @@ module FormatEngine
     REGEX = %r{(?<flags> [~@#$^&*\=?_<>\\\/\.,\|!]*){0}
                (?<parms> [-+]?(\d+(\.\d+)?)?){0}
                (?<var> %\g<flags>\g<parms>[a-zA-Z]){0}
-               (?<set> %\g<flags>\d*\[([^\]]|\\\])+\]){0}
-               \g<var> | \g<set>
+               (?<set> %\g<flags>\d*\[([^\]\\]|\\.)+\]){0}
+               (?<per> %%){0}
+               \g<var> | \g<set> | \g<per>
               }x
 
     #Don't use new, use get_spec instead.
@@ -63,6 +49,7 @@ module FormatEngine
           @specs << case
                     when match_data[:var] then FormatVariable.new(mid)
                     when match_data[:set] then FormatSet.new(mid)
+                    when match_data[:per] then FormatLiteral.new("\%")
                     else fail "Impossible case in scan_spec."
                     end
           fmt_string = match_data.post_match

data/lib/format_engine/spec_info.rb

@@ -1,43 +1,26 @@
 module FormatEngine
 
   #A little package of info about the engine's progress.
-  #In the context of a formatting / parsing block, the
-  #"self" of that block is an instance of SpecInfo.
-  #<br>
-  #<br>The components of that instance Struct are:
-  #<br>
-  #<br>When Formatting:
-  #* src - The object that is the source of the data.
-  #* dst - A string that receives the formatted output.
-  #* fmt - The format specification currently being processed.
-  #* engine - The formatting engine. Mostly for access to the library.
-  #* tmp - A utility hash so that the formatting process can retain state.
-  #<br>Methods
-  #* cat - Append the string that follows to the formatted output.
-  #<br>
-  #<br>When Parsing:
-  #* src - A string that is the source of formatted input.
-  #* dst - The class of the object being created.
-  #* fmt - The parse specification currently being processed.
-  #* engine - The parsing engine. Mostly for access to the library.
-  #* tmp - A utility hash so that the parsing process can retain state.
-  #<br>Methods
-  #* set - Set the return value of the parsing operation to the value that follows.
-  #* parse - Look for the string or regex parm that follows. Return the data found or nil.
-  #* parse! - Like parse but raises an exception (with optional msg) if not found.
-  #* found? - Did the last parse succeed?
-  #* found - The text found by the last parse (or parse!) operation.
   class SpecInfo
 
-    # General readers
-    attr_reader :src, :dst, :engine, :tmp
+    #The source data for formatting, string input for parsing.
+    attr_reader :src
 
-    #General accessors
-    attr_accessor :fmt
+    #The destination of the process.
+    attr_reader :dst
+
+    #The formatting engine.
+    attr_reader :engine
+
+    #A hash for state storage for the formatting/parsing process.
+    attr_reader :tmp
+
+    #The format specifier currently being processed.
+    attr_reader :fmt
 
     # Set up the spec info.
-    def initialize(src, dst, fmt, engine, tmp = {})
-      @src, @dst, @fmt, @engine, @tmp = src, dst, fmt, engine, tmp
+    def initialize(src, dst, engine)
+      @src, @dst, @engine, @tmp = src, dst, engine, {}
     end
 
     # Concatenate onto the formatted output string.
@@ -50,34 +33,66 @@ module FormatEngine
       @dst = obj
     end
 
-    # Parse the source string for a string or regex
-    def parse(tgt)
-      @result = src.partition(tgt)
+    #Pass the formatting action along to the current format element.
+    def do_format(fmt)
+      (@fmt = fmt).do_format(self)
+    end
+
+    #Pass the parsing action along to the current format element.
+    def do_parse(fmt)
+      (@fmt = fmt).do_parse(self)
+    end
+
+    # Parse the source string for a target string or regex or return nil.
+    def parse(target)
+      #Handle the width option if specified.
+      if (width = fmt.width) > 0
+        head, tail = src[0...width], src[width..-1] || ""
+      else
+        head, tail = src, ""
+      end
 
+      #Do the parse on the input string.
+      @prematch, @match, @postmatch = head.partition(target)
+
+      #Analyze the results.
       if found?
-        @src = @result[2]
-        @result[1]
+        @src = @postmatch + tail
+        @match
       else
         nil
       end
     end
 
-    # Parse the source string for a string or regex or raise error.
-    def parse!(tgt, msg = "#{tgt.inspect} not found")
-      fail "Parse error: #{msg}" unless parse(tgt)
-      found
+    # Parse the source string for a target string or regex or raise error.
+    def parse!(target, msg = "#{target.inspect} not found")
+      fail "Parse error: #{msg}" unless parse(target)
+      @match
+    end
+
+    #Grab some text
+    def grab
+      if (width = fmt.width) > 0
+        result, @src = src[0...width], src[width..-1] || ""
+      elsif width == -1
+        result, @src = src, ""
+      elsif width < 0
+        result, @src = src[0..width], src[(width+1)..-1] || ""
+      else
+        result, @src = src[0...1], src[1..-1] || ""
+      end
+
+      result
     end
 
     # Was the last parse a success?
     def found?
-       @result[0].empty? && !@result[1].empty?
+       @prematch.empty? && !@match.empty?
     end
 
     # What was found by the last parse?
     def found
-      @result[1]
+      @match
     end
-
   end
-
-end
+end

data/lib/format_engine/version.rb

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

data/tests/formatter_engine_tests.rb

@@ -24,16 +24,8 @@ class FormatterTester < Minitest::Test
     TestPerson.new("Squidly", "Jones", 21)
   end
 
-  def make_spec(str)
-    str
-  end
-
   def make_all(str)
-    [make_formatter, make_person, make_spec(str)]
-  end
-
-  def test_crazy
-    assert_equal("0.4.0", FormatEngine::VERSION)
+    [make_formatter, make_person, str]
   end
 
   def test_that_it_can_format_normally

data/tests/literal_spec_tests.rb

@@ -14,7 +14,7 @@ class LiteralSpecTester < Minitest::Test
   end
 
   def test_that_it_formats
-    spec_info = FormatEngine::SpecInfo.new(nil, "", nil, nil, {})
+    spec_info = FormatEngine::SpecInfo.new(nil, "", nil)
     test = FormatEngine::FormatLiteral.new("Test 1 2 3")
     test.do_format(spec_info)
 

data/tests/parser_engine_tests.rb

@@ -25,7 +25,7 @@ class ParserTester < Minitest::Test
       "%!t"   => lambda { parse!("\t") },
 
       :after  => lambda do
-        set TestPerson.new(*[tmp[:fn], tmp[:ln], tmp[:age]].delete_if(&:nil?))
+        set dst.new(*[tmp[:fn], tmp[:ln], tmp[:age]].delete_if(&:nil?))
       end)
   end
 

data/tests/scan_tests.rb

@@ -10,32 +10,127 @@ class ScanTester < Minitest::Test
   #Track mini-test progress.
   MinitestVisible.track self, __FILE__
 
+  DECIMAL  = /[+-]?\d+/
+  HEX      = /[+-]?(0[xX])?\h+/
+  OCTAL    = /[+-]?(0[oO])?[0-7]+/
+  BINARY   = /[+-]?(0[bB])?[01]+/
+  INTEGER  = /[+-]?((0[xX]\h+)|(0[bB][01]+)|(0[oO]?[0-7]*)|([1-9]\d*))/
+  FLOAT    = /[+-]?\d+(\.\d+)?([eE][+-]?\d+)?/
+  RATIONAL = /[+-]?\d+\/\d+(r)?/
+  COMPLEX  = %r{(?<num> \d+(\.\d+)?([eE][+-]?\d+)?){0}
+                [+-]?\g<num>[+-]\g<num>[ij]
+               }x
+  QUOTED   = /("([^\\"]|\\.)*")|('([^\\']|\\.)*')/
+
   def make_parser
     FormatEngine::Engine.new(
-      "%d"    => lambda do
-        dst << found.to_i if parse(fmt.regex("\\d"))
-      end,
+      "%b"  => lambda {parse(BINARY) ? dst << found.to_i(2) : :break},
+      "%*b" => lambda {parse(BINARY) || :break},
 
-      "%*d"   => lambda do
-        parse(fmt.regex("\\d"))
-      end,
+      "%c"  => lambda {dst << grab},
+      "%*c" => lambda {grab},
+
+      "%d"  => lambda {parse(DECIMAL) ? dst << found.to_i : :break},
+      "%*d" => lambda {parse(DECIMAL) || :break},
+
+      "%f"  => lambda {parse(FLOAT) ? dst << found.to_f : :break},
+      "%*f" => lambda {parse(FLOAT) || :break},
 
-      "%["    => lambda do
-        dst << found if parse(fmt.regex)
+      "%i"  => lambda {parse(INTEGER) ? dst << found.to_i(0) : :break},
+      "%*i" => lambda {parse(INTEGER) || :break},
+
+      "%j"  => lambda {parse(COMPLEX) ? dst << Complex(found) : :break},
+      "%*j" => lambda {parse(COMPLEX) || :break},
+
+      "%o"  => lambda {parse(OCTAL) ? dst << found.to_i(8) : :break},
+      "%*o" => lambda {parse(OCTAL) || :break},
+
+      "%q"  => lambda do
+        parse(QUOTED) ? dst << found[1..-2].gsub(/\\./) {|seq| seq[-1]} : :break
       end,
+      "%*q" => lambda {parse(QUOTED) || :break},
+
+      "%r"  => lambda {parse(RATIONAL) ? dst << found.to_r : :break},
+      "%*r" => lambda {parse(RATIONAL) || :break},
 
-      "%*["   => lambda do
-        parse(fmt.regex)
-      end)
+      "%s"  => lambda {parse(/\S+/) ? dst << found : :break},
+      "%*s" => lambda {parse(/\S+/) || :break},
+
+      "%u"  => lambda {parse(/\d+/) ? dst << found.to_i : :break},
+      "%*u" => lambda {parse(/\d+/) || :break},
+
+      "%x"  => lambda {parse(HEX) ? dst << found.to_i(16) : :break},
+      "%*x" => lambda {parse(HEX) || :break},
+
+      "%["  => lambda {parse(fmt.regex) ? dst << found : :break},
+      "%*[" => lambda {parse(fmt.regex) || :break})
   end
 
   def test_that_it_can_scan
     engine = make_parser
     spec = "%d %2d %4d"
-    result = engine.do_parse("12 34 56", [], spec)
+    result = engine.do_parse("12 34 -56", [], spec)
+    assert_equal([12, 34, -56] , result)
 
-    assert_equal(Array, result.class)
-    assert_equal([12, 34, 56] , result)
+    spec = "%i %i %i %i %i"
+    result = engine.do_parse("255 0b11111111 0377 0xFF 0 ", [], spec)
+    assert_equal([255, 255, 255, 255, 0] , result)
+
+    spec = "%o %o %o"
+    result = engine.do_parse("7 10 377", [], spec)
+    assert_equal([7, 8, 255] , result)
+
+    spec = "%b %b %b"
+    result = engine.do_parse("10 10011 11110000", [], spec)
+    assert_equal([2, 19, 240] , result)
+
+    spec = "%x %x %x %x %x"
+    result = engine.do_parse("0 F FF FFF FFFF", [], spec)
+    assert_equal([0, 15, 255, 4095, 65535] , result)
+
+    spec = "%s %*s %s"
+    result = engine.do_parse("Hello Silly World", [], spec)
+    assert_equal(["Hello", "World"] , result)
+
+    spec = "%5c %*5c %5c"
+    result = engine.do_parse("Hello Silly World", [], spec)
+    assert_equal(["Hello", "World"] , result)
+
+    spec = "%i %-1c"
+    result = engine.do_parse("42 The secret is X", [], spec)
+    assert_equal([42, "The secret is X"] , result)
+
+    spec = "%i %-2c%c"
+    result = engine.do_parse("42 The secret is X", [], spec)
+    assert_equal([42, "The secret is ", "X"] , result)
+
+    spec = "%i %*-2c%c"
+    result = engine.do_parse("42 The secret is X", [], spec)
+    assert_equal([42,  "X"] , result)
+
+    spec = "%f %f %f"
+    result = engine.do_parse("9.99 1.234e56 -1e100", [], spec)
+    assert_equal([9.99, 1.234e56, -1e100] , result)
+
+    spec = "%f%% %f%%"
+    result = engine.do_parse("85% 75%", [], spec)
+    assert_equal([85, 75] , result)
+
+    spec = "%u %u %u"
+    result = engine.do_parse("12 34 -56", [], spec)
+    assert_equal([12, 34] , result)
+
+    spec = "%r %r %r"
+    result = engine.do_parse("1/2 3/4r -5/6", [], spec)
+    assert_equal(['1/2'.to_r, '3/4'.to_r, '-5/6'.to_r] , result)
+
+    spec = "%j %j %j"
+    result = engine.do_parse("1+2i 3+4j -5e10-6.2i", [], spec)
+    assert_equal([Complex('1+2i'), Complex('3+4j'), Complex('-5e10-6.2i')] , result)
+
+    spec = "%q %*q %q %q"
+    result = engine.do_parse("'quote' 'silly' \"un quote\" 'a \\''  ", [], spec)
+    assert_equal(["quote", "un quote", "a '"] , result)
   end
 
   def test_missing_data
@@ -56,6 +151,15 @@ class ScanTester < Minitest::Test
     assert_equal([12, 34, 56] , result)
   end
 
+  def test_malformed_data
+    engine = make_parser
+    spec = "%d %d %d"
+    result = engine.do_parse("12 igloo 34 56", [], spec)
+
+    assert_equal(Array, result.class)
+    assert_equal([12] , result)
+  end
+
   def test_skipped_data
     engine = make_parser
     spec = "%d %2d %*d %d"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: format_engine
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Peter Camilleri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-03 00:00:00.000000000 Z
+date: 2016-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -132,7 +132,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="