format_engine 0.0.1

data/lib/format_engine/spec_info.rb

@@ -0,0 +1,83 @@
+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.
+  #* hsh - 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.
+  #* hsh - 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, :hsh
+
+    #General accessors
+    attr_accessor :fmt
+
+    # Set up the spec info.
+    def initialize(src, dst, fmt, engine, hsh = {})
+      @src, @dst, @fmt, @engine, @hsh = src, dst, fmt, engine, hsh
+    end
+
+    # Concatenate onto the formatted output string.
+    def cat(str)
+      @dst << str
+    end
+
+    # Set the result of this parsing operation.
+    def set(obj)
+      @dst = obj
+    end
+
+    # Parse the source string for a string or regex
+    def parse(tgt)
+      @result = src.partition(tgt)
+
+      if found?
+        @src = @result[2]
+        @result[1]
+      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
+    end
+
+    # Was the last parse a success?
+    def found?
+       @result[0].empty? && !@result[1].empty?
+    end
+
+    # What was found by the last parse?
+    def found
+      @result[1]
+    end
+
+  end
+
+end

data/lib/format_engine/version.rb

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

data/lib/format_engine.rb

@@ -0,0 +1,11 @@
+#The format_engine gem top source file.
+
+require 'English'
+
+require 'format_engine/format_spec'
+require 'format_engine/engine'
+require 'format_engine/spec_info'
+require 'format_engine/attr_formatter'
+require 'format_engine/attr_parser'
+
+require 'format_engine/version'

data/mocks/README.md

@@ -0,0 +1,10 @@
+# FormatEngine - The mocks folder.
+
+This is a new idea that is being evaluated. In order to keep code DRY and
+encourage proper care and maintenance of mocks and stubs, this folder
+will contain those mocks and stubs. The idea is that by making them into
+separate entities in their own right, they just might get a little more
+respect.
+
+In addition, it may encourage the sharing and increased scrutiny of these
+testing tools and thus improve productivity and quality.

data/mocks/demo/demo_format.rb

@@ -0,0 +1,13 @@
+#* mocks/demo/demo_formatting.rb - Formatting specifications for the \Customer class.
+class Customer
+
+  extend FormatEngine::AttrFormatter
+
+  ##
+  #The specification of the formatter method of the demo \Customer class.
+
+  attr_formatter :strfmt,
+  {"%f"  => lambda {cat src.first_name.ljust(fmt.width) },
+   "%l"  => lambda {cat src.last_name.ljust(fmt.width)  } }
+
+end

data/mocks/demo/demo_parse.rb

@@ -0,0 +1,14 @@
+#* mocks/demo/demo_parse.rb - Parsing specifications for the \Customer class.
+class Customer
+
+  extend FormatEngine::AttrParser
+
+  ##
+  #The specification of the parser method of the demo \Customer class.
+
+  attr_parser :strprs,
+  {"%f"    => lambda { hsh[:fn] = found if parse(/(\w)+/ ) },
+   "%l"    => lambda { hsh[:ln] = found if parse(/(\w)+/ ) },
+   :after  => lambda { set dst.new(hsh[:fn], hsh[:ln]) } }
+
+end

data/mocks/demo.rb

@@ -0,0 +1,18 @@
+# A simple class of customer info.
+
+require_relative 'demo/demo_format'
+require_relative 'demo/demo_parse'
+
+#A demo class for the format_engine gem.
+class Customer
+  #Demo customer first name.
+  attr_reader :first_name
+
+  #Demo customer last name
+  attr_reader :last_name
+
+  #Create an instance of the demo customer.
+  def initialize(first_name, last_name)
+    @first_name, @last_name = first_name, last_name
+  end
+end

data/mocks/test_person_mock.rb

@@ -0,0 +1,10 @@
+
+# A mock class to test formatting
+class TestPerson
+  attr_reader :first_name
+  attr_reader :last_name
+
+  def initialize(first_name, last_name)
+    @first_name, @last_name = first_name, last_name
+  end
+end

data/reek.txt

@@ -0,0 +1,2 @@
+
+0 total warnings

data/tests/engine_base_tests.rb

@@ -0,0 +1,18 @@
+require_relative '../lib/format_engine'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+class EngineBaseTester < Minitest::Test
+
+  #Track mini-test progress.
+  MinitestVisible.track self, __FILE__
+
+  def test_that_it_has_a_library
+    test = FormatEngine::Engine.new({"%A" => 42})
+
+    assert_equal(42, test["%A"])
+    assert_equal(nil, test["%B"])
+  end
+
+end

data/tests/format_engine_tests.rb

@@ -0,0 +1,29 @@
+require_relative '../lib/format_engine'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+require_relative '../mocks/demo'
+
+# A full test of the formatter/parser engine.
+class FormatEngineTester < Minitest::Test
+
+  #Track mini-test progress.
+  MinitestVisible.track self, __FILE__
+
+  def test_basic_formatting
+    cust = Customer.new("Jane", "Doe")
+
+    assert_equal("Jane, Doe", cust.strfmt("%f, %l"))
+  end
+
+
+  def test_basic_parsing
+    cust = Customer.strprs("Jane, Doe", "%f, %l")
+
+    assert_equal(Customer, cust.class)
+    assert_equal("Jane", cust.first_name)
+    assert_equal("Doe", cust.last_name)
+  end
+
+end

data/tests/format_spec_tests.rb

@@ -0,0 +1,120 @@
+require_relative '../lib/format_engine'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+class FormatSpecTester < Minitest::Test
+
+  #Track mini-test progress.
+  MinitestVisible.track self, __FILE__
+
+  def test_that_it_scans_literal_formats
+    test = FormatEngine::FormatSpec.get_spec "ABCDEFG!"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatLiteral, test.specs[0].class)
+    assert_equal("ABCDEFG!", test.specs[0].literal)
+  end
+
+  def test_that_it_scans_simple_variable_formats
+    test = FormatEngine::FormatSpec.get_spec "%A"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
+    assert_equal("%A", test.specs[0].format)
+    assert_equal(nil, test.specs[0].parms)
+  end
+
+  def test_that_it_scans_option_variable_formats
+    "~@#&^&*-+=?_<>\\/.,|".each_char do |char|
+      test = FormatEngine::FormatSpec.get_spec "%#{char}A"
+      assert_equal(Array, test.specs.class)
+      assert_equal(1, test.specs.length)
+      assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
+      assert_equal("%#{char}A", test.specs[0].format)
+    end
+  end
+
+  def test_that_it_scans_single_variable_formats
+    test = FormatEngine::FormatSpec.get_spec "%123A"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
+    assert_equal("%A", test.specs[0].format)
+
+    assert_equal(Array, test.specs[0].parms.class)
+    assert_equal(1, test.specs[0].parms.length)
+    assert_equal("123", test.specs[0].parms[0])
+  end
+
+  def test_that_it_scans_double_variable_formats
+    test = FormatEngine::FormatSpec.get_spec "%123.456A"
+    assert_equal(Array, test.specs.class)
+    assert_equal(1, test.specs.length)
+    assert_equal(FormatEngine::FormatVariable, test.specs[0].class)
+    assert_equal("%A", test.specs[0].format)
+
+    assert_equal(Array, test.specs[0].parms.class)
+    assert_equal(2, test.specs[0].parms.length)
+    assert_equal("123", test.specs[0].parms[0])
+    assert_equal("456", test.specs[0].parms[1])
+  end
+
+  def test_multipart_formats
+    test = FormatEngine::FormatSpec.get_spec "T(%+02A:%3B:%4.1C)"
+
+    assert_equal(Array, test.specs.class)
+    assert_equal(7, test.specs.length)
+
+    assert_equal(FormatEngine::FormatLiteral, test.specs[0].class)
+    assert_equal("T(", test.specs[0].literal)
+
+    assert_equal(FormatEngine::FormatVariable, test.specs[1].class)
+    assert_equal("%+A", test.specs[1].format)
+    assert_equal(1, test.specs[1].parms.length)
+    assert_equal("02", test.specs[1].parms[0])
+
+    assert_equal(FormatEngine::FormatLiteral, test.specs[2].class)
+    assert_equal(":", test.specs[2].literal)
+
+    assert_equal(FormatEngine::FormatVariable, test.specs[3].class)
+    assert_equal("%B", test.specs[3].format)
+    assert_equal(1, test.specs[3].parms.length)
+    assert_equal("3", test.specs[3].parms[0])
+
+    assert_equal(FormatEngine::FormatLiteral, test.specs[4].class)
+    assert_equal(":", test.specs[4].literal)
+
+    assert_equal(FormatEngine::FormatVariable, test.specs[5].class)
+    assert_equal("%C", test.specs[5].format)
+    assert_equal(2, test.specs[5].parms.length)
+    assert_equal("4", test.specs[5].parms[0])
+    assert_equal("1", test.specs[5].parms[1])
+
+    assert_equal(FormatEngine::FormatLiteral, test.specs[6].class)
+    assert_equal(")", test.specs[6].literal)
+  end
+
+  def test_that_it_validates
+    engine = { "%A" => true, "%B" => true }
+
+    test = FormatEngine::FormatSpec.get_spec "%A and %B"
+    assert_equal(test, test.validate(engine))
+
+    test = FormatEngine::FormatSpec.get_spec "%A and %C"
+    assert_raises(RuntimeError) { test.validate(engine) }
+  end
+
+  def test_that_it_caches
+    t1 = FormatEngine::FormatSpec.get_spec "%123.456A"
+    t2 = FormatEngine::FormatSpec.get_spec "%123.456A"
+    assert(t1.object_id == t2.object_id)
+
+    t3 = FormatEngine::FormatSpec.get_spec "%123.457A"
+    assert(t1.object_id != t3.object_id)
+
+    t4 = FormatEngine::FormatSpec.get_spec "%123.457A"
+    assert(t4.object_id == t3.object_id)
+  end
+
+end

data/tests/formatter_engine_tests.rb

@@ -0,0 +1,71 @@
+require_relative '../lib/format_engine'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+require_relative '../mocks/test_person_mock'
+
+# Test the internals of the formatter engine. This is not the normal interface.
+class FormatterTester < Minitest::Test
+
+  #Track mini-test progress.
+  MinitestVisible.track self, __FILE__
+
+  def make_formatter
+    FormatEngine::Engine.new(
+      "%f"  => lambda {cat src.first_name.ljust(fmt.width) },
+      "%-f" => lambda {cat src.first_name.rjust(fmt.width) },
+      "%F"  => lambda {cat src.first_name.upcase.ljust(fmt.width) },
+      "%-F" => lambda {cat src.first_name.upcase.rjust(fmt.width) },
+      "%l"  => lambda {cat src.last_name.ljust(fmt.width)},
+      "%-l" => lambda {cat src.last_name.rjust(fmt.width)},
+      "%L"  => lambda {cat src.last_name.upcase.ljust(fmt.width) },
+      "%-L" => lambda {cat src.last_name.upcase.rjust(fmt.width) })
+  end
+
+  def make_person
+    TestPerson.new("Squidly", "Jones")
+  end
+
+  def make_spec(str)
+    FormatEngine::FormatSpec.get_spec str
+  end
+
+  def make_all(str)
+    [make_formatter, make_person, make_spec(str)]
+  end
+
+  def test_that_it_can_format_normally
+    engine, obj, spec = make_all("Name = %f %l")
+    assert_equal("Name = Squidly Jones", engine.do_format(obj, spec))
+  end
+
+  def test_that_it_can_format_shouting
+    engine, obj, spec = make_all("Name = %F %L")
+    assert_equal("Name = SQUIDLY JONES", engine.do_format(obj, spec))
+  end
+
+  def test_that_it_can_format_wider
+    engine, obj, spec = make_all("Name = %10f %10l")
+    assert_equal("Name = Squidly    Jones     ", engine.do_format(obj, spec))
+  end
+
+  def test_that_it_can_format_right
+    engine, obj, spec = make_all("Name = %-10f %-10l")
+    assert_equal("Name =    Squidly      Jones", engine.do_format(obj, spec))
+  end
+
+  def test_that_it_calls_before_and_after
+    engine = FormatEngine::Engine.new(
+      :before => lambda {dst << "((" },
+      :after  => lambda {dst << "))" })
+
+    spec = FormatEngine::FormatSpec.get_spec "Test"
+    assert_equal("((Test))", engine.do_format(nil, spec))
+  end
+
+  def test_that_it_rejects_bad_specs
+    engine, obj, spec = make_all("Name = %f %j")
+    assert_raises(RuntimeError) { engine.do_format(obj, spec) }
+  end
+end

data/tests/literal_spec_tests.rb

@@ -0,0 +1,23 @@
+require_relative '../lib/format_engine'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+class LiteralSpecTester < Minitest::Test
+
+  #Track mini-test progress.
+  MinitestVisible.track self, __FILE__
+
+  def test_that_it_validates_always
+    test = FormatEngine::FormatLiteral.new("Test 1 2 3")
+    assert_equal(test, test.validate(nil))
+  end
+
+  def test_that_it_formats
+    spec_info = FormatEngine::SpecInfo.new(nil, "", nil, nil, {})
+    test = FormatEngine::FormatLiteral.new("Test 1 2 3")
+    test.do_format(spec_info)
+
+    assert_equal("Test 1 2 3", spec_info.dst)
+  end
+end

data/tests/parser_engine_tests.rb

@@ -0,0 +1,95 @@
+require_relative '../lib/format_engine'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+require_relative '../mocks/test_person_mock'
+
+# Test the internals of the parser engine. This is not the normal interface.
+class ParserTester < Minitest::Test
+
+  #Track mini-test progress.
+  MinitestVisible.track self, __FILE__
+
+  def make_parser
+    FormatEngine::Engine.new(
+      "%f"    => lambda { hsh[:fn] = found if parse(/(\w)+/ ) },
+      "%F"    => lambda { hsh[:fn] = found.upcase if parse(/(\w)+/) },
+      "%-F"   => lambda { hsh[:fn] = found.capitalize if parse(/(\w)+/) },
+      "%l"    => lambda { hsh[:ln] = found if parse(/(\w)+/ ) },
+      "%L"    => lambda { hsh[:ln] = found.upcase if parse(/(\w)+/) },
+      "%-L"   => lambda { hsh[:ln] = found.capitalize if parse(/(\w)+/) },
+      "%s"    => lambda { parse(/\s+/) },
+      "%,s"   => lambda { parse(/[,\s]\s*/) },
+      "%t"    => lambda { parse("\t") },
+      "%!t"   => lambda { parse!("\t") },
+
+      :after  => lambda { set TestPerson.new(hsh[:fn], hsh[:ln]) })
+  end
+
+  def test_that_it_can_parse
+    engine = make_parser
+    spec = FormatEngine::FormatSpec.get_spec "%f, %l"
+    result = engine.do_parse("Squidly, Jones", TestPerson, spec)
+
+    assert_equal(TestPerson, result.class)
+    assert_equal("Squidly", result.first_name)
+    assert_equal("Jones", result.last_name)
+  end
+
+  def test_that_it_can_parse_loudly
+    engine = make_parser
+    spec = FormatEngine::FormatSpec.get_spec "%F, %L"
+    result = engine.do_parse("Squidly, Jones", TestPerson, spec)
+
+    assert_equal(TestPerson, result.class)
+    assert_equal("SQUIDLY", result.first_name)
+    assert_equal("JONES", result.last_name)
+  end
+
+  def test_that_it_can_fix_shouting
+    engine = make_parser
+    spec = FormatEngine::FormatSpec.get_spec "%-F, %-L"
+    result = engine.do_parse("SQUIDLY, JONES", TestPerson, spec)
+
+    assert_equal(TestPerson, result.class)
+    assert_equal("Squidly", result.first_name)
+    assert_equal("Jones", result.last_name)
+  end
+
+  def test_that_it_can_flex_parse
+    engine = make_parser
+    spec = FormatEngine::FormatSpec.get_spec "%f%,s%l"
+    result = engine.do_parse("Squidly, Jones", TestPerson, spec)
+
+    assert_equal(TestPerson, result.class)
+    assert_equal("Squidly", result.first_name)
+    assert_equal("Jones", result.last_name)
+  end
+
+  def test_that_it_can_tab_parse
+    engine = make_parser
+    spec = FormatEngine::FormatSpec.get_spec "%f%t%l"
+    result = engine.do_parse("Squidly\tJones", TestPerson, spec)
+
+    assert_equal(TestPerson, result.class)
+    assert_equal("Squidly", result.first_name)
+    assert_equal("Jones", result.last_name)
+  end
+
+  def test_that_it_can_detect_errors
+    engine = make_parser
+    spec = FormatEngine::FormatSpec.get_spec "%f, %l"
+
+    assert_raises(RuntimeError) do
+      engine.do_parse("Squidly Jones", TestPerson, spec)
+    end
+
+    spec = FormatEngine::FormatSpec.get_spec "%f%!t%l"
+
+    assert_raises(RuntimeError) do
+      engine.do_parse("Squidly Jones", TestPerson, spec)
+    end
+  end
+
+end

data/tests/variable_spec_tests.rb

@@ -0,0 +1,34 @@
+require_relative '../lib/format_engine'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+class VariableSpecTester < Minitest::Test
+
+  #Track mini-test progress.
+  MinitestVisible.track self, __FILE__
+
+  def test_that_it_validates
+    engine = { "%A" => true }
+
+    test = FormatEngine::FormatVariable.new("%A")
+    assert_equal(test, test.validate(engine))
+
+    test = FormatEngine::FormatVariable.new("%B")
+    assert_raises(RuntimeError) { test.validate(engine) }
+  end
+
+  def test_the_parms
+    test = FormatEngine::FormatVariable.new("%B")
+    assert_equal(0, test.width)
+    assert_equal(0, test.prec)
+
+    test = FormatEngine::FormatVariable.new("%10B")
+    assert_equal(10, test.width)
+    assert_equal(0, test.prec)
+
+    test = FormatEngine::FormatVariable.new("%10.5B")
+    assert_equal(10, test.width)
+    assert_equal(5, test.prec)
+  end
+end