casegen 1.3.0 → 2.0.0

data/lib/agents/sets/enum/inject.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+=begin
+---Enumerable#inject
+---Enumerable#sum [block]
+
+Code adapted from Pickaxe book, p.102.
+See source file for examples.
+
+==version
+
+Enumerable tools 1.6
+
+=end
+
+# module Enumerable
+#
+#   def inject n
+#     each { |i|
+#       n = yield n, i
+#     }
+#     n
+#   end
+#   alias :accumulate :inject
+#
+#   def sum
+#     if block_given?
+#       inject(0) { |n, i| n + yield(i) }
+#     else
+#       inject(0) { |n, i| n + i }
+#     end
+#   end
+#
+#   def product
+#     if block_given?
+#       inject(1) { |n, i| n * yield(i) }
+#     else
+#       inject(1) { |n, i| n * i }
+#     end
+#   end
+#
+# end
+
+if __FILE__ == $0
+
+  x = (0..9).collect { |i| [i, i*i] }
+  p x
+  p x.sum { |v| v[1] }
+
+end

data/{src → lib}/casegen.rb

@@ -1,11 +1,5 @@
 require 'singleton'
 
-class Fixnum
-  def even?
-    self.divmod(2)[1] == 0
-  end
-end
-
 class String
   def outdent
     a = $1 if match(/\A(\s*)(.*\n)(?:\1.*\n|\n)*\z/)
@@ -143,7 +137,7 @@ module CLabs
 
     class CaseGen
       def CaseGen.version
-        '1.3.0'
+        '2.0.0'
       end
 
       def initialize(data)

data/test/agents/console_output_test.rb

@@ -0,0 +1,27 @@
+require_relative '../test_helper'
+require_relative '../../lib/agents/sets.rb'
+
+FakeAgent = Struct.new(:titles, :combinations)
+
+include CLabs::CaseGen
+
+class TestConsoleOutput < Minitest::Test
+  def test_simple_output
+    data = nil
+    agents = [
+      FakeAgent.new(["col a", "col b"], [[1, 2], [3, 4]])
+    ]
+    sio = StringIO.new
+    ConsoleOutput.new(data, agents, sio)
+    expected = <<~_
+      +-------+-------+
+      | col a | col b |
+      +-------+-------+
+      | 1     | 2     |
+      | 3     | 4     |
+      +-------+-------+
+
+    _
+    assert_equal expected, sio.string
+  end
+end

data/test/agents/sets.test.rb

@@ -0,0 +1,227 @@
+$LOAD_PATH << "#{__dir__}/../../lib/agents"
+require 'minitest/autorun'
+require 'sets'
+
+include CLabs::CaseGen
+
+class TestParsing < Minitest::Test
+  def test_sets_default
+    data = <<~CASEDATA
+      bar: 1, 2, 3,456.98
+       foo list:a, b, c
+    CASEDATA
+    cases = Sets.new(data)
+    assert_equal(2, cases.sets.length)
+    
+    assert_equal("bar", cases.sets[0].name)
+    assert_equal(["1", "2", "3,456.98"], cases.sets[0].data)
+    
+    assert_equal("foo list", cases.sets[1].name)
+    assert_equal(["a", "b", "c"], cases.sets[1].data)
+  end
+
+  def test_set_by_name_matching
+    # may seem obvious, but the regex matching used at one point would get confused when a name was reused in sets
+    sets = Sets.new("foo bar: 1, 2\nbar quux: 3, 4")
+    set = sets.set_by_name('bar quux')
+    assert_equal 'bar quux', set.name
+  end
+end
+
+class TestCombinations < Minitest::Test
+  def test_combos_2_by_2
+    sets = Sets.new("a: 1, 2\nb:3, 4")
+    assert_equal([['1', '3'], ['1', '4'], ['2', '3'], ['2', '4']], sets.combinations)
+    assert_equal(['a', 'b'], sets.titles)
+  end
+
+  def test_combos_2_by_3
+    sets = Sets.new("a: 1, 2\nb:3, 4, 5")
+    assert_equal([['1', '3'], ['1', '4'], ['1', '5'],
+                  ['2', '3'], ['2', '4'], ['2', '5']], sets.combinations)
+    assert_equal(['a', 'b'], sets.titles)
+  end
+end
+
+class TestRulesParsing < Minitest::Test
+  def test_rules_single
+    data = <<~RULES
+      exclude foo = bar
+    RULES
+    rules = Rules.new(data)
+    assert_equal(1, rules.length)
+    assert_equal(ExcludeRule, rules[0].class)
+    assert_equal("foo = bar", rules[0].criteria.to_s)
+    assert_equal("", rules[0].description)
+  end
+  
+  def test_rules_two
+    data = <<~RULES
+      exclude foo = bar
+        should foo equal bar, we want to exclude that combination
+      
+      exclude bar = foo
+        as well, if bar equals foo,
+        that case has got to go
+    RULES
+    rules = Rules.new(data)
+    assert_equal(2, rules.length)
+    assert_equal(ExcludeRule, rules[0].class)
+    assert_equal("foo = bar", rules[0].criteria.to_s)
+    assert_equal("should foo equal bar, we want to exclude that combination", rules[0].description)
+
+    assert_equal(ExcludeRule, rules[1].class)
+    assert_equal("bar = foo", rules[1].criteria.to_s)
+    assert_equal("as well, if bar equals foo,\nthat case has got to go", rules[1].description)
+  end
+  
+  def test_exclude_rule_parsing
+    data = <<~RULES
+      exclude foo = bar
+        should foo equal bar, we want to exclude that combination
+    RULES
+    rule = ExcludeRule.new(data)
+    assert_equal("foo = bar", rule.criteria.to_s)
+    assert_equal(["foo"], rule.criteria.set_names)
+    assert_equal(["bar"], rule.criteria.set_values)
+    assert_equal("should foo equal bar, we want to exclude that combination", rule.description)
+    
+  end
+  
+  def test_rules_set_name_not_found
+    sets = Sets.new("set.a: foo, bar\nset.b: fu, bahr")
+    data = <<~RULES
+      exclude set_a = bar AND set_b = barh
+        should foo equal bar, we want to exclude that combination
+    RULES
+    begin
+      Rules.new(data, [sets])
+      fail('should throw')
+    rescue ParserException => e
+      assert_equal("Invalid set name <set_a> in rule <set_a = bar AND set_b = barh>. Valid set names are <set.a, set.b>.", e.message)
+    end
+  end
+
+  def test_rules_set_value_not_found
+    sets = Sets.new("set a: foo, bar\nset b: fu, bahr")
+    data = <<~RULES
+      exclude set a = bar AND set b = barh
+        should foo equal bar, we want to exclude that combination
+    RULES
+    begin
+      Rules.new(data, [sets])
+      fail('should throw')
+    rescue ParserException => e
+      assert_equal("Invalid set value <barh> in rule <set a = bar AND set b = barh>. Valid set values for <set b> are <fu, bahr>.", e.message)
+    end
+  end
+  
+  class TestCriteria < Minitest::Test
+    def test_simple_equality
+      crit = Criteria.new("a = b")
+      assert_equal(['a'], crit.set_names)
+      assert_equal(['b'], crit.set_values)
+      assert_equal(true, crit.match({'a' => 'b'}))
+      assert_equal(false, crit.match({'a' => 'c'}))
+      assert_equal(false, crit.match({'b' => 'a'}))
+      assert_equal(true, crit.match({'a' => 'b', 'f' => 'g'}))
+    end
+    
+    def test_boolean_and
+      crit = Criteria.new("a = b AND c == d")
+      assert_equal(['a', 'c'], crit.set_names)
+      assert_equal(['b', 'd'], crit.set_values)
+      assert_equal(true, crit.match({'a' => 'b', 'c' => 'd'}))
+      assert_equal(false, crit.match({'a' => 'd', 'c' => 'b'}))
+      assert_equal(true, crit.match({'c' => 'd', 'a' => 'b'}))
+      assert_equal(false, crit.match({'a' => 'b'}))
+      assert_equal(false, crit.match({'c' => 'd'}))
+      assert_equal(false, crit.match({'a' => 'b', 'd' => 'c'}))
+      assert_equal(false, crit.match({'c' => 'd', 'b' => 'a'}))
+      
+      # not case sensitive
+      assert_equal(false, crit.match({'A' => 'b', 'c' => 'd'}))
+      assert_equal(false, crit.match({'a' => 'B', 'c' => 'd'}))
+      assert_equal(false, crit.match({'a' => 'b', 'C' => 'd'}))
+      assert_equal(false, crit.match({'a' => 'b', 'c' => 'D'}))
+    end
+    
+    def test_invalid_boolean_and
+      begin
+        Criteria.new("a = b AND a = d")
+        fail("should throw")
+      rescue ParserException => e
+        assert_equal("Rule cannot have the same set <a> equal to different values <b, d>", e.message)
+      end
+
+      begin
+        Criteria.new("a = b AND a = d AND a = c")
+        fail("should throw")
+      rescue ParserException => e
+        # in this case, the exception is figured out before the a = c can be parsed
+        assert_equal("Rule cannot have the same set <a> equal to different values <b, d>", e.message)
+      end
+    end
+  end
+  
+  class TestRulesOnSets < Minitest::Test
+    def test_simple
+      sets = Sets.new("a: 1, 2\nb: 3, 4")
+      rules = Rules.new("exclude a = 1\nexclude b=4", [sets])
+      assert_equal([['2', '3']], rules.combinations)
+      assert_equal(['a', 'b'], rules.titles)
+    end
+  end
+
+  class TestRubyCaseArray < Minitest::Test
+    def test_default_case_name
+      sets = Sets.new("a: 1, 2\nb:3, 4")
+      out = MockStdOut.new
+      RubyArrayOutput.new("", [sets], out)
+      expected = <<~TEXT
+        Case = Struct.new(:a, :b)
+
+        cases = [Case.new("1", "3"),
+                 Case.new("1", "4"),
+                 Case.new("2", "3"),
+                 Case.new("2", "4")]
+      TEXT
+      assert_equal(expected, out.to_s)
+    end
+
+    def test_specified_case_name
+      sets = Sets.new("a: 1, 2\nb:3, 4")
+      out = MockStdOut.new
+      RubyArrayOutput.new("DataSubmitCase", [sets], out)
+      expected = <<~TEXT
+        DataSubmitCase = Struct.new(:a, :b)
+
+        cases = [DataSubmitCase.new("1", "3"),
+                 DataSubmitCase.new("1", "4"),
+                 DataSubmitCase.new("2", "3"),
+                 DataSubmitCase.new("2", "4")]
+      TEXT
+      assert_equal(expected, out.to_s)
+    end
+  end
+
+  class MockStdOut
+    def initialize
+      @s = ''
+    end
+
+    def puts(s)
+      @s << s << "\n"
+    end
+
+    def print(s)
+      @s << s
+    end
+
+    def to_s
+      @s
+    end
+  end
+end
+
+

data/test/agents_test.rb

@@ -0,0 +1,41 @@
+$LOAD_PATH << "#{__dir__}/../lib"
+require 'minitest/autorun'
+require 'casegen'
+
+include CLabs::CaseGen
+
+class TestAgents < Minitest::Test
+  def setup
+    Agents.instance.clear
+  end
+
+  def teardown
+    Agents.instance.clear
+  end
+
+  def test_register
+    assert_equal(0, Agents.instance.length)
+    begin
+      Agents.instance.register("phil")
+      fail("should have thrown")
+    rescue AgentException
+      # expected -- can't register a non subclass
+    end
+
+    Agents.instance.register(SampleAgent)
+    assert_equal(1, Agents.instance.length)
+    Agents.instance.each do |ag| assert_equal(SampleAgent, ag) end
+  end
+
+  def test_get_agent_by_id
+    Agents.instance.register(SampleAgent)
+    result = Agents.instance.get_agent_by_id("sample")
+    assert_equal(SampleAgent, result)
+  end
+
+  def test_id_registered
+    assert_equal(false, Agents.instance.id_registered?(SampleAgent.agent_id))
+    Agents.instance.register(SampleAgent)
+    assert_equal(true, Agents.instance.id_registered?(SampleAgent.agent_id))
+  end
+end

data/test/parser_test.rb

@@ -0,0 +1,163 @@
+$LOAD_PATH << "#{__dir__}/../lib"
+require 'minitest/autorun'
+require 'casegen'
+
+include CLabs::CaseGen
+
+class SampleAgent < Agent
+  def SampleAgent.agent_id
+    "sample"
+  end
+end
+
+class Foo < Agent
+  def Foo.agent_id
+    "foo"
+  end
+end
+
+class TestParser < Minitest::Test
+  def setup
+    Agents.instance.register(SampleAgent)
+    Agents.instance.register(Foo)
+  end
+
+  def test_parse
+    data = <<~CASEDATA
+      sample
+      ------
+      sample_data
+      
+      foo
+      ---
+      sample_data
+      
+      sample(foo, sample)
+      ------------
+      sample_data
+      plus
+        some extra
+    CASEDATA
+
+    parser = Parser.new(data)
+    assert_equal(3, parser.agents.length)
+
+    sample_a = parser.agents[0]
+    foo = parser.agents[1]
+    sample_b = parser.agents[2]
+    assert_equal(SampleAgent, sample_a.class)
+    assert_equal("sample_data", sample_a.data)
+    assert_equal([], sample_a.reference_agents)
+
+    assert_equal(Foo, foo.class)
+    assert_equal("sample_data", foo.data)
+    assert_equal([], foo.reference_agents)
+
+    assert_equal(SampleAgent, sample_b.class)
+    assert_equal("sample_data\nplus\n  some extra", sample_b.data)
+    assert_equal([foo, sample_a], sample_b.reference_agents)
+  end
+
+  def test_parse_no_sets
+    data = <<~CASEDATA
+    CASEDATA
+
+    parser = Parser.new(data)
+    assert_equal(0, parser.agents.length)
+  end
+
+  def test_parse_agent_with_missing_hyphen_line
+    data = <<~CASEDATA
+      sample
+      
+      sample_data
+    CASEDATA
+
+    Parser.new(data)
+    fail("should have thrown")
+  rescue ParserException => e
+    assert_equal("Expected hyphen line after the agent declaration for <SampleAgent>", e.message)
+  end
+
+  def test_parse_agent_name_without_dash_delimiter
+    data = <<~CASEDATA
+      sample
+    CASEDATA
+
+    Parser.new(data)
+    fail("should have thrown")
+  rescue ParserException => e
+    assert_equal("Expected hyphen line after the agent declaration for <SampleAgent>", e.message)
+  end
+
+  def test_parse_agent_name_without_dash_delimiter_and_empty_line_to_start
+    data = <<~CASEDATA
+
+      sample
+    CASEDATA
+
+    Parser.new(data)
+    fail("should have thrown")
+  rescue ParserException => e
+    assert_equal("Expected hyphen line after the agent declaration for <SampleAgent>", e.message)
+  end
+
+  def test_parse_just_agent_with_underline
+    data = <<~CASEDATA
+      sample
+      -
+    CASEDATA
+
+    parser = Parser.new(data)
+    assert_equal(1, parser.agents.length)
+    sample = parser.agents[0]
+    assert_equal(SampleAgent, sample.class)
+    assert_equal("", sample.data)
+    assert_equal([], sample.reference_agents)
+  end
+
+  def test_parse_just_agent_with_empty_data
+    data = <<~CASEDATA
+      sample
+      -
+
+    CASEDATA
+
+    parser = Parser.new(data)
+    assert_equal(1, parser.agents.length)
+    sample = parser.agents[0]
+    assert_equal(SampleAgent, sample.class)
+    assert_equal("", sample.data)
+    assert_equal([], sample.reference_agents)
+  end
+
+  def test_parse_invalid_agent
+    data = <<~CASEDATA
+      sermple
+      ------
+      sample_data
+    CASEDATA
+
+    begin
+      Parser.new(data)
+      fail("should throw")
+    rescue ParserException
+      # expected
+    end
+  end
+
+  def test_parse_invalid_referenced_agent
+    data = <<~CASEDATA
+      sample(fu)
+      ------
+      sample_data
+    CASEDATA
+
+    begin
+      Parser.new(data)
+      fail("should throw")
+    rescue ParserException
+      # expected
+    end
+  end
+end