casegen 2.0.0 → 3.0.1

data/lib/case_gen/combo_matcher.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CaseGen
+  module ComboMatcher
+    def matches_criteria(combo, additional_ignore_keys = [])
+      criteria_keys = (@rule_data.keys - additional_ignore_keys) - ignore_keys
+      criteria = @rule_data.slice(*criteria_keys)
+      criteria == combo.hash_row.slice(*criteria_keys)
+    end
+
+    def ignore_keys
+      %i[description reason note index]
+    end
+  end
+end

data/lib/case_gen/exclude_rule.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module CaseGen
+  class ExcludeRule
+    include ComboMatcher
+    include RuleDescription
+
+    attr_reader :rule_data, :description
+
+    def initialize(rule_data)
+      @rule_data = rule_data
+      @description = rule_description(rule_data)
+      @criteria = rule_data[:criteria]
+    end
+
+    def apply(combos)
+      matches = combos.select do |combo|
+        case @criteria
+        when String
+          combo.instance_eval(@criteria)
+        when Proc
+          combo.instance_exec(&@criteria)
+        when nil
+          # if the rule data has keys matching the combo, then compare the
+          # values of provided keys.
+          matches_criteria(combo)
+        else
+          raise "Unknown rule criteria class: #{@criteria.class}"
+        end
+      end
+
+      process_matches(combos, matches)
+    end
+
+    private
+
+    def process_matches(combos, matches)
+      combos.each do |combo|
+        next unless matches.include?(combo)
+        next if combo.excluded?
+
+        combo.exclude_with(self)
+        expect_keys = combo.names.select { |name| combo.send(name) == :expect }
+        expect_keys.each do |expect_key|
+          combo.send("#{expect_key}=", '')
+        end
+      end
+    end
+  end
+end

data/lib/case_gen/expect_rule.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CaseGen
+  class ExpectRule
+    include ComboMatcher
+
+    def initialize(rule_data)
+      @rule_data = rule_data
+    end
+
+    def apply(combos)
+      combos.each do |combo|
+        expect_keys = combo.names.select { |name| combo.send(name) == :expect }
+        next if expect_keys.none?
+
+        next unless matches_criteria(combo, expect_keys)
+
+        expect_keys.each do |expect_key|
+          combo.send("#{expect_key}=", @rule_data[expect_key])
+        end
+      end
+    end
+  end
+end

data/lib/case_gen/generator.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'tablesmith'
+
+module CaseGen
+  class Generator
+    attr_reader :sets, :rules, :combos, :exclusions
+
+    def initialize(sets, rules)
+      @sets = sets.map do |title, values|
+        CaseGen::Set.new(title, values)
+      end
+      @rules = rules
+      @combos = generate_combinations
+      apply_rules
+    end
+
+    private
+
+    def generate_combinations
+      hash_pairs = @sets.map(&:hash_pairs)
+      product_of(hash_pairs).map { |c| Combination.new(c) }
+    end
+
+    def product_of(sets)
+      head, *rest = sets
+      head.product(*rest)
+    end
+
+    def apply_rules
+      @rules.each do |type, rules|
+        klass = CaseGen.const_get("#{type.to_s.capitalize}Rule")
+        rules.each_with_index do |rule_data, idx|
+          rule_data[:index] = idx + 1
+          klass.new(rule_data).apply(@combos)
+        end
+      end
+    end
+  end
+end

data/lib/case_gen/output/exclude.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module CaseGen
+  class Exclude < CaseGen::Output
+  end
+end

data/lib/case_gen/output/exclude_as_table.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CaseGen
+  class ExcludeAsTable < CaseGen::Output
+    def exclude_output(exclude)
+      "\n#{as_table(exclude)}"
+    end
+
+    def exclude_description(rule)
+      rule.description
+    end
+  end
+end

data/lib/case_gen/output/exclude_as_text.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module CaseGen
+  class ExcludeAsText < CaseGen::Output
+    def exclude_output(_)
+      body = @generator.rules[:exclude].map do |rule|
+        [rule[:criteria], "  #{rule_description(rule)}", '']
+      end
+      (header + body).join("\n")
+    end
+  end
+end

data/lib/case_gen/output/exclude_inline.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CaseGen
+  class ExcludeInline < CaseGen::Output
+    def partition_exclusions?
+      false
+    end
+
+    def exclude_description(rule)
+      rule.description
+    end
+  end
+end

data/lib/case_gen/output/exclude_inline_footnotes.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module CaseGen
+  class ExcludeInlineFootnotes < CaseGen::Output
+    def partition_exclusions?
+      false
+    end
+
+    def exclude_description(rule)
+      "[#{rule.rule_data[:index]}]"
+    end
+
+    def exclude_output(_)
+      body = @generator.rules[:exclude].map do |rule|
+        ["[#{rule[:index]}] #{rule_description(rule)}"]
+      end
+      (header + body).join("\n")
+    end
+  end
+end

data/lib/case_gen/output.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module CaseGen
+  class Output
+    def self.create(generator, output_type = :exclude)
+      klass_name = output_type.to_s.split('_').map(&:capitalize).join.to_s
+      Object.const_get("CaseGen::#{klass_name}").new(generator)
+    end
+
+    include RuleDescription
+
+    def initialize(generator)
+      @generator = generator
+    end
+
+    def to_s
+      update_excluded_values
+      include, exclude = partition_exclusions
+      as_table(include).tap { |o| o << exclude_output(exclude) }
+    end
+
+    private
+
+    def exclude_output(_exclude)
+      ''
+    end
+
+    def as_table(combos)
+      combos.map(&:hash_row).to_table.to_s
+    end
+
+    def update_excluded_values
+      @generator.combos.each do |combo|
+        if combo.excluded?
+          value = exclude_description(combo.excluded_by_rule)
+          combo.append(:exclude, value)
+        end
+      end
+    end
+
+    def partition_exclusions
+      combos = @generator.combos
+
+      if partition_exclusions?
+        exclude, include = combos.partition(&:excluded?)
+        [include, exclude]
+      else
+        [combos, []]
+      end
+    end
+
+    def partition_exclusions?
+      true
+    end
+
+    def exclude_description(_rule)
+      nil
+    end
+
+    def header
+      ['', 'exclude', '-------']
+    end
+  end
+end
+
+Dir[File.join(__dir__, 'output', '*.rb')].sort.each { |fn| require fn }

data/lib/case_gen/rule_description.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CaseGen
+  module RuleDescription
+    def rule_description(rule)
+      keys = %i[description note reason]
+      key = (rule.keys & keys).first
+      rule[key]
+    end
+  end
+end

data/lib/case_gen/set.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module CaseGen
+  class Set
+    attr_reader :title, :values
+
+    def initialize(title, values)
+      @title = title
+      @values = values
+    end
+
+    def hash_pairs
+      @values.map { |v| {@title => v} }
+    end
+  end
+end

data/lib/casegen.rb

@@ -1,185 +1,17 @@
-require 'singleton'
-
-class String
-  def outdent
-    a = $1 if match(/\A(\s*)(.*\n)(?:\1.*\n|\n)*\z/)
-    gsub(/^#{a}/, '')
-  end
-end
-
-module CLabs
-  module CaseGen
-    class AgentException < Exception
-    end
-
-    class Agent # base class
-      attr_reader :data, :reference_agents
-
-      def initialize(data, agents)
-        @data = data
-        @reference_agents = agents
-      end
-    end
-
-    class Agents
-      include Singleton
-
-      def initialize
-        clear
-      end
-
-      def register(agent)
-        if agent.class == Class && agent.ancestors.include?(Agent)
-          @agents << agent
-        else
-          raise AgentException.new("To register an agent, you must pass in a Class instance that's a subclass of Agent")
-        end
-      end
-
-      def method_missing(methid, *args, &block)
-        @agents.send(methid, *args, &block)
-      end
-
-      def get_agent_by_id(id)
-        @agents.each do |agent|
-          return agent if agent.agent_id =~ /#{id}/i
-        end
-        # rather than return nil and allow the client to get bumfuzzled if 
-        # they forget to check for nil, let's blow up and tell them how to
-        # not let it happen again
-        raise AgentException.new("Requested an agent that does not exist. You can query for existance with .id_registered?")
-      end
-
-      def id_registered?(id)
-        begin
-          get_agent_by_id(id)
-          return true
-        rescue AgentException
-          return false
-        end
-      end
-
-      # removes all registered agents
-      def clear
-        @agents = []
-      end
-    end
-
-    class ParserException < Exception
-    end
-
-    class Parser
-      attr_reader :agents
-
-      def initialize(data)
-        @data = data
-        @agents = []
-        parse
-      end
-
-      def parse
-        lines = @data.split(/\n/)
-        while !lines.empty?
-          line = lines.shift
-          next if line.strip.empty?
-
-          data = nil
-          agent_class, reference_agents = parse_agent(line)
-
-          next_line = lines.shift
-          if next_line =~ /^-+/
-            data = parse_data(lines).join("\n")
-          else
-            raise ParserException.new("Expected hyphen line after the agent declaration for <#{agent_class}>")
-          end
-
-          @agents << agent_class.new(data, reference_agents)
-        end
-      end
-
-      def parse_data(lines)
-        end_index = -1
-        lines.each_with_index do |line, index|
-          if line =~ /^-+/
-            end_index = index - 2
-            return lines.slice!(0, end_index)
-          end
-        end
-        return lines.slice!(0, lines.length)
-      end
-
-      def parse_agent(line)
-        agent_name, *reference_agent_names = line.split(/(?=\()/)
-        raise ParserException.new("Nested agents ( e.g. a(b(c)) ) not supported yet") if reference_agent_names.length > 1
-        if reference_agent_names.length > 0
-          reference_agent_names = reference_agent_names[0].gsub(/\(|\)/, '').split(/,/)
-          reference_agent_names.collect! do |name|
-            name.strip
-          end
-        else
-          reference_agent_names = []
-        end
-
-        [agent_name, reference_agent_names].flatten.each do |a_name|
-          raise ParserException.new("Unregistered agent <#{a_name}> in agent name data <#{line}>") if !Agents.instance.id_registered?(a_name)
-        end
-
-        reference_agents = []
-        reference_agent_names.each do |ref_name|
-          @agents.each do |agent|
-            reference_agents << agent if agent.class.agent_id =~ /#{ref_name}/i
-          end
-        end
-        agent_class = Agents.instance.get_agent_by_id(agent_name)
-        [agent_class, reference_agents]
-      end
-    end
-
-    class CaseGen
-      def CaseGen.version
-        '2.0.0'
-      end
-
-      def initialize(data)
-        load_agents
-        Parser.new(data)
-      end
-
-      def load_agents
-        agent_dir = "#{File.dirname(__FILE__)}/agents"
-        agent_fns = Dir[File.join(agent_dir, '*.rb')]
-        agent_fns.each do |fn|
-          require fn
-        end
-        ObjectSpace.each_object(Class) do |klass|
-          if klass.ancestors.include?(Agent) && (klass != Agent)
-            Agents.instance.register(klass)
-          end
-        end
-      end
-    end
-
-    class Console
-      def initialize
-        put_banner
-
-        if ARGV[0].nil? || !File.exists?(ARGV[0])
-          puts "Case file required: #{File.basename($0)} [case filename]. For example:"
-          puts "  #{File.basename($0)} cases.txt"
-          puts
-          exit
-        end
-
-        CaseGen.new(File.read(ARGV[0]))
-      end
-
-      def put_banner
-        $stderr.puts "cLabs Casegen #{CaseGen.version}"
-      end
-    end
+# frozen_string_literal: true
+
+require_relative 'case_gen/rule_description'
+require_relative 'case_gen/set'
+require_relative 'case_gen/combo_matcher'
+require_relative 'case_gen/exclude_rule'
+require_relative 'case_gen/expect_rule'
+require_relative 'case_gen/combination'
+require_relative 'case_gen/generator'
+require_relative 'case_gen/output'
+
+module CaseGen
+  def self.generate(sets, rules, output_type = :exclude)
+    generator = CaseGen::Generator.new(sets, rules)
+    CaseGen::Output.create(generator, output_type).to_s
   end
 end
-
-if __FILE__ == $0
-  CLabs::CaseGen::Console.new
-end

data/spec/cart_sample_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Cart Sample' do
+  let(:expected) do
+    <<~_
+      +-------------+--------+----------+-----------------+-----------------+
+      |   payment   | amount | shipping | ship_to_country | bill_to_country |
+      +-------------+--------+----------+-----------------+-----------------+
+      | Credit      | 100    | Ground   | US              | US              |
+      | Credit      | 100    | Air      | US              | US              |
+      | Credit      | 100    | Air      | Outside US      | US              |
+      | Credit      | 100    | Air      | Outside US      | Outside US      |
+      | Credit      | 1000   | Ground   | US              | US              |
+      | Credit      | 1000   | Air      | US              | US              |
+      | Credit      | 1000   | Air      | Outside US      | US              |
+      | Credit      | 1000   | Air      | Outside US      | Outside US      |
+      | Credit      | 10000  | Ground   | US              | US              |
+      | Credit      | 10000  | Air      | US              | US              |
+      | Credit      | 10000  | Air      | Outside US      | US              |
+      | Credit      | 10000  | Air      | Outside US      | Outside US      |
+      | Check       | 100    | Ground   | US              | US              |
+      | Check       | 100    | Air      | US              | US              |
+      | Check       | 100    | Air      | Outside US      | US              |
+      | Check       | 1000   | Ground   | US              | US              |
+      | Check       | 1000   | Air      | US              | US              |
+      | Check       | 1000   | Air      | Outside US      | US              |
+      | Check       | 10000  | Ground   | US              | US              |
+      | Check       | 10000  | Air      | US              | US              |
+      | Check       | 10000  | Air      | Outside US      | US              |
+      | Online Bank | 100    | Ground   | US              | US              |
+      | Online Bank | 100    | Air      | US              | US              |
+      | Online Bank | 100    | Air      | Outside US      | US              |
+      | Online Bank | 100    | Air      | Outside US      | Outside US      |
+      +-------------+--------+----------+-----------------+-----------------+
+    _
+  end
+
+  it 'works' do
+    require_relative '../doc/cart'
+
+    fix = Fixtures[:cart]
+    expect(CaseGen.generate(fix[:sets], fix[:rules])).to eq expected
+  end
+end

data/spec/case_gen/combination_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CaseGen::Combination do
+  it 'append' do
+    combo = described_class.new([{a: 1}, {b: 2}])
+    combo.append(:c, 3)
+    expect(combo.hash_row).to eq({a: 1, b: 2, c: 3})
+  end
+end

data/spec/case_gen/exclude_rule_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.describe CaseGen::ExcludeRule do
+  it 'removes expect if excluded inline' do
+    combo = CaseGen::Combination.new([{a: 1}, {b: :expect}])
+    rule = described_class.new({criteria: 'a == 1', note: 'nope'})
+    rule.apply([combo])
+    expect(combo).to be_excluded
+  end
+
+  it 'marks combo as exclude on matching key/values in rule data' do
+    combo = CaseGen::Combination.new([{a: 1}, {b: 2}])
+    rule = described_class.new({b: 2, note: 'nope'})
+    rule.apply([combo])
+    expect(combo).to be_excluded
+  end
+end

data/spec/exclude_as_table_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../doc/bounding_box'
+
+RSpec.describe 'Exclude as table' do
+  let(:expected_combo_table) do
+    <<~_
+      +---------+---------+--------+---------+
+      |  width  | height  | aspect | result  |
+      +---------+---------+--------+---------+
+      | inside  | inside  | wide   | 200x100 |
+      | inside  | inside  | tall   | 100x200 |
+      | inside  | outside | tall   | 100x400 |
+      | outside | inside  | wide   | 400x100 |
+      | outside | outside | wide   | 500x400 |
+      | outside | outside | tall   | 400x500 |
+      +---------+---------+--------+---------+
+    _
+  end
+
+  let(:expected_exclude_as_table) do
+    <<~_
+      +---------+---------+--------+--------+--------------------------------------------+
+      |  width  | height  | aspect | result |                  exclude                   |
+      +---------+---------+--------+--------+--------------------------------------------+
+      | inside  | outside | wide   |        | a narrower image cannot have a wide aspect |
+      | outside | inside  | tall   |        | a shorter image cannot have a tall aspect  |
+      +---------+---------+--------+--------+--------------------------------------------+
+    _
+  end
+
+  let(:fix) { Fixtures[:box] }
+
+  it 'output' do
+    output = CaseGen.generate(fix[:sets], fix[:rules], :exclude_as_table)
+    expect(output.to_s).to eq "#{expected_combo_table}\n#{expected_exclude_as_table}"
+  end
+end

data/spec/exclude_as_text_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../doc/pricing'
+
+RSpec.describe 'Exclude as text' do
+  let(:expected_combo_table) do
+    <<~_
+      +----------+----------+-------+--------+
+      | subtotal | discount | promo | total  |
+      +----------+----------+-------+--------+
+      | 25       | 0%       | none  | 25.00  |
+      | 25       | 0%       | apr   | 17.50  |
+      | 25       | 0%       | fall  | 16.25  |
+      | 75       | 10%      | none  | 67.50  |
+      | 75       | 10%      | apr   | 47.25  |
+      | 75       | 10%      | fall  | 43.88  |
+      | 200      | 20%      | none  | 160.00 |
+      +----------+----------+-------+--------+
+    _
+  end
+
+  let(:expected_exclude_as_text) do
+    <<~_
+      exclude
+      -------
+      subtotal < 100 && discount == '20%'
+        Total must be above $100 to apply the 20% discount
+
+      (subtotal < 50) && discount == '10%'
+        Total must be above $50 to apply the 10% discount
+
+      discount != '20%' && subtotal == 200
+        Orders over 100 automatically get 20% discount
+
+      discount != '10%' && subtotal == 75
+        Orders between 50 and 100 automatically get 10% discount
+
+      discount == '20%' && promo != 'none'
+        20% discount cannot be combined with promo
+    _
+  end
+
+  let(:generator) do
+    fix = Fixtures[:pricing]
+    CaseGen::Generator.new(fix[:sets], fix[:rules])
+  end
+
+  it 'output only combos table' do
+    output = CaseGen::Exclude.new(generator)
+    expect(output.to_s).to eq expected_combo_table
+  end
+
+  it 'outputs with exclude as text' do
+    output = CaseGen::ExcludeAsText.new(generator)
+    expect(output.to_s).to eq "#{expected_combo_table}\n#{expected_exclude_as_text}"
+  end
+end