casegen 2.0.0 → 3.0.1

data/lib/agents/sets.rb

@@ -1,313 +0,0 @@
-require "#{File.dirname(__FILE__)}/../casegen"
-$LOAD_PATH << "#{File.expand_path(File.join(File.dirname(__FILE__), 'sets'))}"
-require 'enum/op'
-require 'tablesmith'
-
-class String
-  def to_u
-    self.gsub(/ /, '_')
-  end
-end
-
-module CLabs::CaseGen
-  class Set
-    attr_reader :name, :data
-
-    def initialize(name, data_array)
-      @name = name
-      @data = data_array
-      strip_data
-    end
-
-    def strip_data
-      @data.collect! do |datum| datum.strip end
-    end
-
-    def values
-      @data
-    end
-  end
-
-  class Sets < Agent
-    attr_accessor :sets, :combinations, :set_titles
-
-    def Sets.agent_id
-      "casegen:sets"
-    end
-
-    def initialize(data, reference_agents=nil)
-      @data = data
-      @sets = []
-      parse_sets
-    end
-
-    def parse_sets
-      set_names = @data.scan(/^\s*(\w.*):/)
-      set_data = @data.scan(/:(.*)/)
-      sets = set_names.flatten.zip(set_data.flatten)
-      sets.each do |set_array|
-        @sets << Set.new(set_array[0], set_array[1].split(/, /))
-      end
-      generate_combinations
-    end
-
-    def generate_combinations
-      arrays = []
-      @set_titles = []
-      @sets.each do |set| arrays << set.data; @set_titles << set.name end
-      @combinations = all(*arrays)
-    end
-
-    def titles
-      @set_titles
-    end
-
-    def all(*args)
-      result = []
-      EnumerableOperator::Product.new(*args).each { |tuple|
-        result << tuple
-      }
-      result
-    end
-
-    def set_names
-      names = []
-      @sets.each do |set| names << set.name end
-      names
-    end
-
-    def set_by_name(setname)
-      @sets.detect do |set| set.name =~ /#{Regexp.escape(setname)}/ end
-    end
-
-  end
-
-  class Criteria
-    attr_reader :set_names, :set_values, :equalities
-
-    def initialize(data)
-      @data = data
-      @equalities = {}
-      parse
-    end
-
-    def parse
-      @data.split(/AND/).each do |bit|
-        set_name, set_value = bit.split(/==|=/)
-        set_name.strip!; set_value.strip!
-        if @equalities.keys.include?(set_name)
-          raise ParserException.new("Rule cannot have the same set <#{set_name}> equal to different values <#{@equalities[set_name]}, #{set_value}>")
-        end
-        @equalities[set_name] = set_value
-      end
-      @set_names = @equalities.keys
-      @set_values = @equalities.values
-    end
-
-    # hash keys should be valid set names and hash values should be valid
-    # set values in the named set
-    def match(hash)
-      # must match all equalities
-      @equalities.each_pair do |eq_name, eq_value|
-        actual_value = hash[eq_name]
-        return false if actual_value.nil?
-        return false if actual_value != eq_value
-      end
-      return true
-    end
-
-    def to_s
-      @data
-    end
-  end
-
-  class Rule
-    attr_reader :criteria, :description, :data
-
-    def initialize(rule_data)
-      @data = rule_data
-      parse_rule
-    end
-
-    def parse_rule
-      data = @data.sub(self.class.regexp, '')
-      criteria_data, *@description = data.split(/\n/)
-      criteria_data.strip!
-      @criteria = Criteria.new(criteria_data)
-      @description = (@description.join("\n") + "\n").outdent.strip
-    end
-  end
-
-  class ExcludeRule < Rule
-    def type_description
-      "exclude"
-    end
-
-    def ExcludeRule.regexp
-      /^exclude/i
-    end
-
-    def ExcludeRule.create(rule_data)
-      return ExcludeRule.new(rule_data) if rule_data =~ regexp
-      return nil
-    end
-  end
-
-  class Rules < Agent
-    def Rules.agent_id
-      "casegen:rules"
-    end
-
-    def initialize(data, reference_agents=[])
-      @data = data
-      @agents = reference_agents
-      @rules = []
-      @rule_classes = []
-      ObjectSpace.each_object(Class) do |obj|
-        @rule_classes << obj if obj.ancestors.include?(Rule) && obj != Rule
-      end
-      parse_data
-    end
-
-    def parse_data
-      raw_rules = @data.split(/(?=^\S)/)
-
-      raw_rules.each do |rule|
-        @rule_classes.each do |rule_class|
-          @rules << rule_class.create(rule.strip)
-        end
-      end
-      @rules.compact!
-      @rules.flatten!
-      validate_rules
-    end
-
-    def validate_rules
-      @agents.each do |agent|
-        if agent.class == Sets
-          @rules.each do |rule|
-            rule.criteria.equalities.each_pair do |set_name, set_value|
-              set = agent.set_by_name(set_name)
-              if set.nil?
-                raise ParserException.new("Invalid set name <#{set_name}> " +
-                  "in rule <#{rule.criteria}>. Valid set names are <#{agent.set_names.join(', ')}>.")
-              end
-              if !set.values.include?(set_value)
-                raise ParserException.new("Invalid set value <#{set_value}> " +
-                  "in rule <#{rule.criteria}>. Valid set values for <#{set.name}> " +
-                  "are <#{set.values.join(', ')}>.")
-              end
-            end
-          end
-        end
-      end
-    end
-
-    def length
-      @rules.length
-    end
-
-    def [](index)
-      return @rules[index]
-    end
-
-    def each(&block)
-      @rules.each(&block)
-    end
-
-    def combinations
-      return @combinations if !@combinations.nil?
-      if @agents[0].class == Sets
-        agent = @agents[0]
-        @combinations = []
-        agent.combinations.each do |combo|
-          delete = false
-          combo_hash = {}
-          i = 0
-          # combo is an array of values, in the same order of the set_titles.
-          # combo_hash will have set names matched with set values
-          agent.set_titles.each do |title|
-            combo_hash[title] = combo[i]
-            i += 1
-          end
-          @rules.each do |rule|
-            delete |= rule.criteria.match(combo_hash)
-          end
-          @combinations << combo if !delete
-        end
-        return @combinations
-      end
-      return []
-    end
-
-    def titles
-      @agents[0].titles
-    end
-
-    def to_s
-      puts @agents[0].combinations.inspect if !@agents[0].nil?
-      puts
-      puts @rules.inspect
-    end
-  end
-
-  class ConsoleOutput < Agent
-    def ConsoleOutput.agent_id
-      "casegen:console"
-    end
-
-    def initialize(data, reference_agents, io=STDOUT)
-      @data = data
-      @agents = reference_agents
-      table = [@agents[0].titles] + @agents[0].combinations
-      io.puts table.to_table.pretty_inspect
-      io.puts
-      @agents[0].each do |rule|
-        io.puts rule.data
-        io.puts
-      end if @agents[0].is_a?(Rules)
-    end
-  end
-
-  class RubyArrayOutput < Agent
-    def self.agent_id
-      "casegen:ruby_array"
-    end
-
-    def initialize(data, reference_agents, io=STDOUT)
-      @io = io
-      @struct_name = "Case"
-      @struct_name = data if !data.empty?
-      @agents = reference_agents
-      @agents.each do |agent| execute(agent) end
-    end
-
-    def execute(agent)
-      struct_header = "#{@struct_name} = Struct.new("
-      struct = ''
-      agent.titles.each do |title|
-        struct << ', ' if !struct.empty?
-        struct << ":#{title.to_u.downcase}"
-      end
-      struct << ')'
-
-      guts_header = 'cases = ['
-      guts = ''
-      agent.combinations.each do |combo|
-        guts << ",\n#{' ' * guts_header.length}" if !guts.empty?
-        guts << "#{@struct_name}.new#{combo.inspect.gsub(/\[/, '(').gsub(/\]/, ')')}"
-      end
-      @io.print(struct_header)
-      @io.print(struct)
-      @io.print("\n\n")
-      @io.print(guts_header)
-      @io.print(guts)
-      @io.print("]\n")
-    end
-  end
-end
-
-if __FILE__ == $0
-  sets = CLabs::CaseGen::Sets.new("a: 1, 2\nb: 3, 4")
-  puts sets.combinations
-end

data/test/agents/console_output_test.rb

@@ -1,27 +0,0 @@
-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

@@ -1,227 +0,0 @@
-$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

@@ -1,41 +0,0 @@
-$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