casegen 2.0.0 → 3.0.0

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

data/spec/exclude_inline_footnotes_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../doc/pricing'
+
+RSpec.describe 'Exclude inline with footnotes' do
+  let(:expected_table) do
+    <<~_
+      +----------+----------+-------+--------+---------+
+      | subtotal | discount | promo | total  | exclude |
+      +----------+----------+-------+--------+---------+
+      | 25       | 0%       | none  | 25.00  |         |
+      | 25       | 0%       | apr   | 17.50  |         |
+      | 25       | 0%       | fall  | 16.25  |         |
+      | 25       | 10%      | none  |        | [2]     |
+      | 25       | 10%      | apr   |        | [2]     |
+      | 25       | 10%      | fall  |        | [2]     |
+      | 25       | 20%      | none  |        | [1]     |
+      | 25       | 20%      | apr   |        | [1]     |
+      | 25       | 20%      | fall  |        | [1]     |
+      | 75       | 0%       | none  |        | [4]     |
+      | 75       | 0%       | apr   |        | [4]     |
+      | 75       | 0%       | fall  |        | [4]     |
+      | 75       | 10%      | none  | 67.50  |         |
+      | 75       | 10%      | apr   | 47.25  |         |
+      | 75       | 10%      | fall  | 43.88  |         |
+      | 75       | 20%      | none  |        | [1]     |
+      | 75       | 20%      | apr   |        | [1]     |
+      | 75       | 20%      | fall  |        | [1]     |
+      | 200      | 0%       | none  |        | [3]     |
+      | 200      | 0%       | apr   |        | [3]     |
+      | 200      | 0%       | fall  |        | [3]     |
+      | 200      | 10%      | none  |        | [3]     |
+      | 200      | 10%      | apr   |        | [3]     |
+      | 200      | 10%      | fall  |        | [3]     |
+      | 200      | 20%      | none  | 160.00 |         |
+      | 200      | 20%      | apr   |        | [5]     |
+      | 200      | 20%      | fall  |        | [5]     |
+      +----------+----------+-------+--------+---------+
+
+      exclude
+      -------
+      [1] Total must be above $100 to apply the 20% discount
+      [2] Total must be above $50 to apply the 10% discount
+      [3] Orders over 100 automatically get 20% discount
+      [4] Orders between 50 and 100 automatically get 10% discount
+      [5] 20% discount cannot be combined with promo
+    _
+  end
+
+  let(:sets) { Fixtures[:pricing][:sets] }
+  let(:rules) { Fixtures[:pricing][:rules] }
+
+  it 'output' do
+    result = CaseGen.generate(sets, rules, :exclude_inline_footnotes)
+    expect(result).to eq expected_table.chomp
+  end
+end