mendel 1.0.0

data/spec/mendel/combiner_spec.rb

@@ -0,0 +1,256 @@
+require_relative "../spec_helper"
+require "mendel/combiner"
+require "fixtures/example_input"
+require "support/foosball_team"
+
+describe Mendel::Combiner do
+
+  let(:combiner_class) {
+    Class.new do
+      include Mendel::Combiner
+      def score_combination(items)
+        items.reduce(0) { |sum, item| sum += item }
+      end
+    end
+
+  }
+  let(:combiner)       { combiner_class.new(list1, list2) }
+  let(:list1)          { [1.0, 2.0, 3.0] }
+  let(:list2)          { [1.1, 2.1, 3.1] }
+
+  describe "requiring the including class to define `score_combination`" do
+
+    let(:combiner_class) {
+      Class.new do
+        include Mendel::Combiner
+      end
+    }
+
+    it "raises NotImplementedError otherwise" do
+      expect{combiner.take(1)}.to raise_error(NotImplementedError)
+    end
+
+  end
+
+  describe "producing correct output" do
+
+    let(:list1)          { EXAMPLE_INPUT[:incrementing_integers] }
+    let(:all_results)    { combiner.to_a }
+
+    describe "when both lists increment smoothly" do
+      let(:list2) { EXAMPLE_INPUT[:incrementing_decimals] }
+
+      it "has a complete result set that is ordered correctly" do
+        require "fixtures/example_output/inc_integers_w_inc_decimals"
+        expect(all_results).to be_sorted_like($inc_integers_w_inc_decimals)
+      end
+
+    end
+
+    describe "when the second list has repeats" do
+      let(:list2) { EXAMPLE_INPUT[:repeats] }
+
+      it "has a complete result set that is ordered correctly" do
+        require "fixtures/example_output/inc_integers_w_repeats"
+        expect(all_results).to be_sorted_like($inc_integers_w_repeats)
+      end
+
+    end
+
+    describe "when the second list has skips" do
+      let(:list2) { EXAMPLE_INPUT[:skips] }
+
+      it "has a complete result set that is ordered correctly" do
+        require "fixtures/example_output/inc_integers_w_skips"
+        expect(all_results).to be_sorted_like($inc_integers_w_skips)
+      end
+
+    end
+
+    describe "when the second list has repeats AND skips" do
+      let(:list2) { EXAMPLE_INPUT[:repeats_and_skips] }
+
+      it "has a complete result set that is ordered correctly" do
+        require "fixtures/example_output/inc_integers_w_repeats_and_skips"
+        expect(all_results).to be_sorted_like($inc_integers_w_repeats_and_skips)
+      end
+
+    end
+
+    describe "when the lists are different lengths" do
+      let(:list2) { EXAMPLE_INPUT[:short_list] }
+
+      it "has a complete result set that is ordered correctly" do
+        require "fixtures/example_output/different_lengths"
+        expect(all_results).to be_sorted_like($different_lengths)
+      end
+
+    end
+
+    context "when there are more than 2 lists" do
+
+      let(:list3) { [1.2, 2.2, 3.2] }
+      let(:list4) { [1.3, 2.3, 3.3] }
+
+      let(:combiner) { combiner_class.new(list1, list2, list3, list4) }
+
+      it "can produce valid combinations" do
+        expect(combiner.first).to eq([[1.0, 1.1, 1.2, 1.3], 4.6])
+      end
+
+    end
+
+    context "when given lists of non-numeric items" do
+
+      let(:list1) { [{name: 'Jimmy', age: 10}, {name: 'Susan', age: 12}] }
+      let(:list2) { [{name: 'Roger', age: 8},  {name: 'Carla',  age: 14}] }
+      let(:sorted_combos) {
+        combos = []
+        list1.each do |player_1|
+          list2.each do |player_2|
+            combos << [
+              FoosballTeam.new(player_1, player_2),
+              (player_1[:age] + player_2[:age]) / 2.0
+            ]
+          end
+        end
+        combos.sort_by {|c| c.last}
+      }
+
+      context "when the combiner class has custom combination and scoring methods" do
+
+        let(:combiner_class) {
+          Class.new do
+            include Mendel::Combiner
+
+            def build_combination(items)
+              FoosballTeam.new(*items)
+            end
+
+            def score_combination(combination)
+              combination.average_age
+            end
+          end
+        }
+
+        it "has a complete result set that is ordered correctly" do
+          expect(all_results).to be_sorted_like(sorted_combos)
+        end
+
+      end
+
+    end
+
+    context "when the input lists are not sorted in ascending order" do
+
+      let(:list1) { EXAMPLE_INPUT[:incrementing_integers].reverse }
+      let(:list2) { EXAMPLE_INPUT[:incrementing_decimals].shuffle }
+
+      it "does not produce correct output" do
+        require "fixtures/example_output/inc_integers_w_inc_decimals"
+        expect(all_results).not_to be_sorted_like($inc_integers_w_inc_decimals)
+      end
+
+    end
+
+  end
+
+  describe "enumeration" do
+
+    it "is Enumerable" do
+      expect(combiner).to be_a(Enumerable)
+    end
+
+    it "supports normal enumerable operations" do
+      expect(combiner.take(3).map {|c| c[-1] }).to eq([2.1, 3.1, 3.1])
+    end
+
+  end
+
+  describe "dumping and loading state" do
+
+    context "when it has produced some combinations" do
+
+      before :each do
+        combiner.take(3)
+      end
+
+      let(:dumped) {
+        {
+          'input' => [list1, list2], 'seen' => [[0, 0], [1, 0], [0, 1], [2, 0], [1, 1], [0, 2]],
+          'queued' => [
+            [{'combo'=>[2.0, 2.1], "coordinates"=>[1, 1]}, 4.1],
+            [{"combo"=>[3.0, 1.1], "coordinates"=>[2, 0]}, 4.1],
+            [{"combo"=>[1.0, 3.1], "coordinates"=>[0, 2]}, 4.1],
+          ]
+        }
+      }
+
+      it "can dump its state" do
+        expect(combiner.dump).to eq(dumped)
+      end
+
+      it "can dump its state as JSON" do
+        expect(combiner.dump_json).to eq(JSON.dump(dumped))
+      end
+
+      context "when state has been dumped somewhere" do
+
+        context "as a hash" do
+
+          let!(:dumped_data) { combiner.dump }
+
+          it "can load state" do
+            expect(combiner_class.load(dumped_data)).to be_a(combiner_class)
+          end
+
+          it "can begin producing combinations again from that point" do
+            combiner = combiner_class.load(dumped_data)
+            expect(combiner.take(3)).to be_sorted_like([[[2.0, 2.1], 4.1], [[3.0, 1.1], 4.1], [[1.0, 3.1], 4.1]])
+          end
+
+        end
+
+        context "as json" do
+
+          let!(:dumped_json) { combiner.dump_json }
+
+          it "can load state" do
+            expect(combiner_class.load_json(dumped_json)).to be_a(combiner_class)
+          end
+
+          it "can begin producing combinations again from that point" do
+            combiner = combiner_class.load_json(dumped_json)
+            expect(combiner.take(3)).to be_sorted_like([[[2.0, 2.1], 4.1], [[3.0, 1.1], 4.1], [[1.0, 3.1], 4.1]])
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "other methods" do
+
+    it "can return its queue length" do
+      expect(combiner.queue_length).to eq(1) # item at 0,0
+      combiner.take(1)
+      expect(combiner.queue_length).to eq(2) # queued its children
+    end
+
+  end
+
+  describe "when given empty lists" do
+
+    let(:list1) { [] }
+    let(:list2) { [] }
+
+    it "raises an error" do
+      expect{combiner}.to raise_error(Mendel::Combiner::EmptyList)
+    end
+
+  end
+
+end

data/spec/mendel/min_priority_queue_spec.rb

@@ -0,0 +1,70 @@
+require_relative "../spec_helper"
+require "mendel/min_priority_queue"
+
+describe Mendel::MinPriorityQueue do
+
+  let(:queue) { described_class.new }
+
+  describe "basic functionality" do
+
+    it "can add items and pop an item of the lowest priority" do
+      queue.push('b', 2)
+      queue.push('a', 1)
+      queue.push('c', 3)
+      expect(queue.pop).to eq(['a', 1])
+    end
+
+    it "can report its length" do
+      expect(queue.length).to eq(0)
+      queue.push('b', 2)
+      queue.push('a', 1)
+      expect(queue.length).to eq(2)
+      queue.pop
+      expect(queue.length).to eq(1)
+      2.times { queue.pop }
+      expect(queue.length).to eq(0) # not -1
+    end
+
+  end
+
+  describe "dumping and loading" do
+
+    describe "dumping" do
+
+      let(:queue) {
+        described_class.new.tap { |q|
+          q.push('c', 3)
+          q.push('a', 1)
+          q.push('b', 2)
+        }
+      }
+
+      it "can dump its contents as an array" do
+        expect(queue.dump).to eq([['a', 1], ['b', 2], ['c', 3]])
+      end
+
+      it "can dump its contents as json" do
+        expect(queue.dump_json).to eq("[[\"a\",1],[\"b\",2],[\"c\",3]]")
+      end
+
+    end
+
+    describe "loading" do
+
+      it "can load its contents from an array" do
+        queue.load([['a', 1], ['b', 2], ['c', 3]])
+        expect(queue.length).to eq(3)
+        expect(queue.pop).to eq(['a', 1])
+      end
+
+      it "can load its contents from JSON" do
+        queue.load_json("[[\"a\",1],[\"b\",2],[\"c\",3]]")
+        expect(queue.length).to eq(3)
+        expect(queue.pop).to eq(['a', 1])
+      end
+
+    end
+
+  end
+  
+end

data/spec/mendel/observable_combiner_spec.rb

@@ -0,0 +1,42 @@
+require_relative "../spec_helper"
+require "mendel/observable_combiner"
+
+describe Mendel::ObservableCombiner do
+
+  let(:combiner_class) {
+    Class.new(Mendel::ObservableCombiner) do
+      def score_combination(items)
+        items.reduce(0) { |sum, item| sum += item }
+      end
+    end
+  }
+  let(:combiner)       { combiner_class.new(list1, list2) }
+  let(:list1)          { [1.0, 2.0, 3.0] }
+  let(:list2)          { [1.1, 2.1, 3.1] }
+
+  describe "notification of events" do
+
+    describe "when a combination is returned" do
+
+      it "notifies that the combo's children have been scored and that the combo has been returned" do
+        # 2 times because with two lists there are two child coordinates
+        expect(combiner).to receive(:notify).exactly(2).times.with(
+          :scored, a_hash_including(
+            'coordinates' => an_instance_of(Array),
+            'score'       => a_kind_of(Numeric)
+          )
+        )
+        expect(combiner).to receive(:notify).exactly(1).times.with(
+          :returned, a_hash_including(
+            'coordinates' => an_instance_of(Array),
+            'score'       => a_kind_of(Numeric)
+          )
+        )
+        combiner.take(1)
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+File.dirname(__FILE__).tap {|this_dir| $LOAD_PATH << this_dir unless $LOAD_PATH.include?(this_dir) }
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+RSpec::Matchers.define :be_sorted_like do |expected_array|
+  require 'set'
+  # Items with same totals are ordered unpredictably; we only care that
+  # items with different totals are ordered correctly
+  match do |actual_array|
+    same_length         = actual_array.length      == expected_array.length
+    same_uniques        = Set.new(actual_array)    == Set.new(expected_array)
+    same_sort_keys      = actual_array.map(&:last) == expected_array.map(&:last)
+    # puts "#{same_length} && #{same_uniques} && #{same_sort_keys}"
+    same_length && same_uniques && same_sort_keys
+  end
+end
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+def sorted_combos(list1, list2)
+  results = []
+  list1.each do |l1|
+    list2.each do |l2|
+      results << [l1, l2, l1 + l2]
+    end
+  end
+  results.sort_by(&:last)
+end
+

data/spec/support/foosball_team.rb

@@ -0,0 +1,24 @@
+class FoosballTeam
+  attr_accessor :players
+
+  def initialize(*players)
+    self.players = players
+  end
+
+  def average_age
+    players.reduce(0){ |total, player|
+      total += player.fetch(:age)
+    } / 2.0
+  end
+
+  # So that one Set of FoosballTeams will be equal to another
+  # if the teams have the same players
+  def eql?(other)
+    other.class == self.class && other.players == players
+  end
+
+  def hash
+    players.hash
+  end
+
+end

data/visualizer_spec/ascii_spec.rb

@@ -0,0 +1,119 @@
+require_relative "../../spec_helper"
+require "mendel"
+require "mendel/observable_combiner"
+require "mendel/visualizers/ascii"
+
+describe Mendel::Visualizers::ASCII do
+
+  let(:klass) { described_class }
+  let(:combiner_class) {
+    Class.new(Mendel::ObservableCombiner) do
+      def score_combination(items)
+        items.reduce(0) { |sum, item| sum += item }
+      end
+    end
+  }
+
+  let(:combiner)   { combiner_class.new(list1, list2) }
+  let(:list1)      { (1..10).to_a }
+  let(:list2)      { (1..10).map { |i| i + 0.1} }
+  let(:klass)      { described_class }
+  let!(:visualizer) { klass.new(combiner) }
+
+  describe "after initialization" do
+
+    describe "output" do
+
+      describe "axis labels" do
+
+        it "converts the list item to a string" do
+          item = '1'
+          expect(item).to receive(:to_s).and_call_original
+          visualizer.axis_label_for(item)
+        end
+
+        it "pads the output to be 8 characters wide" do
+          item = 1
+          expect(visualizer.axis_label_for(item)).to eq(
+            '       1'
+          )
+        end
+
+        it "limits the output to 8 characters" do
+          item = '0123456789'
+          expect(visualizer.axis_label_for(item)).to eq(
+            '01234567'
+          )
+        end
+
+      end
+
+      describe "grid points" do
+
+        it "represents :unscored as a blank 8 spaces wide" do
+          expect(visualizer.grid_point_for(:unscored)).to eq('        ')
+        end
+
+        it "represents :scored as a blue number" do
+          expect(visualizer.grid_point_for(:scored, 5)).to eq('       5'.blue)
+        end
+
+        it "represents :returned as a green number" do
+          expect(visualizer.grid_point_for(:returned, 873)).to eq('     873'.green)
+        end
+
+      end
+
+      describe "output" do
+
+        let(:empty_grid) {
+          <<-WOO
+      10                                                                                                  
+
+
+       9                                                                                                  
+
+
+       8                                                                                                  
+
+
+       7                                                                                                  
+
+
+       6                                                                                                  
+
+
+       5                                                                                                  
+
+
+       4                                                                                                  
+
+
+       3                                                                                                  
+
+
+       2                                                                                                  
+
+
+       1                                                                                                  
+             1.1       2.1       3.1       4.1       5.1       6.1       7.1       8.1       9.1      10.1
+          WOO
+        }
+
+        it "shows an empty grid when initialized" do
+          expect(visualizer.output).to eq(empty_grid)
+        end
+
+        it "shows something else after enumerating" do
+          combiner.take(3)
+          expect(visualizer.output).not_to eq(empty_grid)
+        end
+
+      end
+
+    end
+
+  end
+
+end
+