casegen 2.0.0 → 3.0.0

data/doc/cart.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../lib/casegen'
+
+sets = {
+  payment: ['Credit', 'Check', 'Online Bank'],
+  amount: [100, 1_000, 10_000],
+  shipping: ['Ground', 'Air'],
+  ship_to_country: ['US', 'Outside US'],
+  bill_to_country: ['US', 'Outside US']
+}
+
+rules = {
+  exclude: [
+    {
+      criteria: %(shipping == "Ground" && ship_to_country == "Outside US" ),
+      description: 'Our ground shipper will only ship things within the US',
+    },
+    {
+      criteria: -> { payment == 'Check' && bill_to_country == 'Outside US' },
+      description: 'Our bank will not accept checks written from banks outside the US.',
+    },
+    {
+      criteria: -> { payment == 'Online Bank' && amount >= 1_000 },
+      description: <<~_,
+        While the online bank will process amounts > $1,000, we've experienced
+        occasional problems with their services and have had to write off some
+        transactions, so we no longer allow this payment option for amounts
+        greater than $1,000.
+      _
+    },
+    {
+      criteria: -> { ship_to_country == 'US' && bill_to_country == 'Outside US' },
+      description: "If we're shipping to the US, billing party cannot be outside US"
+    },
+  ]
+}
+
+if __FILE__ == $PROGRAM_NAME
+  puts CaseGen.generate(sets, rules, :exclude_as_text).to_s
+else
+  Fixtures.add(:cart, sets, rules)
+end

data/doc/expect_only.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../lib/casegen'
+
+sets = {
+  duration: [12, 24, 36, 60],
+  unit: [60, 3600],
+  result: [:expect]
+}
+
+rules = {
+  expect: [
+    {duration: 12, unit: 60, result: '12m'},
+    {duration: 12, unit: 3600, result: '12h'},
+    {duration: 24, unit: 60, result: '24m'},
+    {duration: 24, unit: 3600, result: '1d'},
+    {duration: 36, unit: 60, result: '36m'},
+    {duration: 36, unit: 3600, result: '1d 12h'},
+    {duration: 60, unit: 60, result: '1h'},
+    {duration: 60, unit: 3600, result: '2d 12h'},
+  ]
+}
+
+if __FILE__ == $PROGRAM_NAME
+  puts CaseGen.generate(sets, rules, :exclude_inline).to_s
+else
+  Fixtures.add(:duration, sets, rules)
+end

data/doc/pricing.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../lib/casegen'
+
+sets = {
+  subtotal: [25, 75, 200],
+  discount: %w[0% 10% 20%],
+  promo: %w[none apr fall],
+  total: [:expect]
+}
+
+rules = {
+  exclude: [
+    {
+      criteria: %(subtotal < 100 && discount == '20%'),
+      description: 'Total must be above $100 to apply the 20% discount',
+    },
+    {
+      criteria: %((subtotal < 50) && discount == '10%'),
+      note: 'Total must be above $50 to apply the 10% discount',
+    },
+    {
+      criteria: %(discount != '20%' && subtotal == 200),
+      reason: 'Orders over 100 automatically get 20% discount',
+    },
+    {
+      criteria: %(discount != '10%' && subtotal == 75),
+      reason: 'Orders between 50 and 100 automatically get 10% discount',
+    },
+    {
+      criteria: %(discount == '20%' && promo != 'none'),
+      reason: '20% discount cannot be combined with promo',
+    },
+  ],
+  expect: [
+    {subtotal: 25, promo: 'none', total: '25.00'},
+    {subtotal: 25, promo: 'apr', total: '17.50', reason: 'apr promo is 30%'},
+    {subtotal: 25, promo: 'fall', total: '16.25', note: 'fall promo is 35%'},
+    {subtotal: 75, promo: 'none', total: '67.50', note: '10% discount'},
+    {subtotal: 75, promo: 'apr', total: '47.25', reason: '10% + apr promo is 30%'},
+    {subtotal: 75, promo: 'fall', total: '43.88', note: '10% + fall promo is 35%'},
+    {subtotal: 200, promo: 'none', total: '160.00', note: '20% discount'},
+  ]
+}
+
+if __FILE__ == $PROGRAM_NAME
+  puts CaseGen.generate(sets, rules, :exclude_as_text)
+else
+  Fixtures.add(:pricing, sets, rules)
+end

data/doc/ruby_array.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../lib/case_gen'
+
+raise "This doesn't currently work. Do I even want to keep it?"
+
+# CLabs::CaseGen::CaseGen.new(DATA.read)
+
+# Outputs
+#
+# DataSubmitCase = Struct.new(:role, :authorization_code, :submit_enabled)
+#
+# cases = [DataSubmitCase.new("admin", "none", "true"),
+#          DataSubmitCase.new("admin", "invalid", "true"),
+#          DataSubmitCase.new("admin", "valid", "true"),
+#          DataSubmitCase.new("standard", "none", "false"),
+#          DataSubmitCase.new("standard", "invalid", "false"),
+#          DataSubmitCase.new("standard", "valid", "true")]
+
+__END__
+
+sets
+----
+role: admin, standard
+authorization code: none, invalid, valid
+submit enabled: true, false
+
+rules(sets)
+-----------
+exclude role = admin AND submit enabled = false
+  Admin role can always submit
+
+exclude role = standard AND authorization code = none AND submit enabled = true
+exclude role = standard AND authorization code = invalid AND submit enabled = true
+exclude role = standard AND authorization code = valid AND submit enabled = false
+  Standard role can only submit when authorization code is valid
+
+
+ruby_array(rules)
+-------------
+DataSubmitCase

data/lib/case_gen/combination.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module CaseGen
+  class Combination
+    attr_reader :names, :excluded_by_rule
+
+    def initialize(hash_pairs)
+      @names = hash_pairs.map do |h|
+        k = h.first.first
+        v = h.first.last
+        append(k, v)
+        k
+      end
+    end
+
+    def hash_row
+      {}.tap do |h|
+        @names.each do |ivar|
+          h[ivar] = instance_variable_get("@#{ivar}")
+        end
+      end
+    end
+
+    def append(key, value)
+      @names << key if defined?(@names)
+      instance_variable_set("@#{key}", value)
+      self.class.attr_accessor key
+    end
+
+    def exclude_with(rule)
+      @excluded_by_rule = rule
+    end
+
+    def excluded?
+      !@excluded_by_rule.nil?
+    end
+  end
+end

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 }