the_array_comparator 0.2.0 → 0.3.0

data/spec/comparator/contains_all_with_substring_search_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 require 'strategies_helper'
 
-describe Strategies::ContainsAllWithSubstringSearch do
+describe SearchingStrategies::ContainsAllWithSubstringSearch do
   let(:data) { %w{ ab c e} }
   let(:exceptions) { %w{ b } }
   let(:keywords_overlap) { %w{ a } }
@@ -11,31 +11,31 @@ describe Strategies::ContainsAllWithSubstringSearch do
 
   it "is successfull when there's a data overlap" do
     sample = SampleDouble.new(data,keywords_overlap)
-    comparator = Strategies::ContainsAllWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsAllWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "doesn't find something if there's no overlap" do
     sample = SampleDouble.new(data,keywords_no_overlap)
-    comparator = Strategies::ContainsAllWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsAllWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "doesn't find something if there's an exception defined" do
     sample = SampleDouble.new(data,keywords_overlap, exceptions)
-    comparator = Strategies::ContainsAllWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsAllWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "doesn't find something if there's an exception defined" do
     sample = SampleDouble.new(data,multiple_keywords_with_one_no_overlap, exceptions)
-    comparator = Strategies::ContainsAllWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsAllWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "fails if not all keywords can be found within the data" do
     sample = SampleDouble.new(data,multiple_keywords_with_one_no_overlap)
-    comparator = Strategies::ContainsAllWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsAllWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(false)
   end
 end

data/spec/comparator/contains_any_spec.rb

@@ -2,38 +2,38 @@
 require 'spec_helper'
 require 'strategies_helper'
 
-describe Strategies::ContainsAny do
+describe SearchingStrategies::ContainsAny do
   let(:data) { %w{ a b c e} }
   let(:keywords_overlap) { %w{ a } }
   let(:keywords_no_overlap) { %w{ d } }
 
   it "fails if keywords are empty" do
     sample = SampleDouble.new(data,[])
-    comparator = Strategies::ContainsAny.new(sample)
+    comparator = SearchingStrategies::ContainsAny.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "fails if data is empty" do
     sample = SampleDouble.new([],keywords_no_overlap)
-    comparator = Strategies::ContainsAny.new(sample)
+    comparator = SearchingStrategies::ContainsAny.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "is successfull if both keywords and data are empty" do
     sample = SampleDouble.new([],[])
-    comparator = Strategies::ContainsAny.new(sample)
+    comparator = SearchingStrategies::ContainsAny.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "is successfull when there's a data overlap" do
     sample = SampleDouble.new(data,keywords_overlap)
-    comparator = Strategies::ContainsAny.new(sample)
+    comparator = SearchingStrategies::ContainsAny.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "doesn't find something if there's no overlap" do
     sample = SampleDouble.new(data,keywords_no_overlap)
-    comparator = Strategies::ContainsAny.new(sample)
+    comparator = SearchingStrategies::ContainsAny.new(sample)
     expect(comparator.success?).to eq(false)
   end
 

data/spec/comparator/contains_any_with_substring_search_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 require 'strategies_helper'
 
-describe Strategies::ContainsAnyWithSubstringSearch do
+describe SearchingStrategies::ContainsAnyWithSubstringSearch do
   let(:data) { %w{ ab c e} }
   let(:exceptions) { %w{ b} }
   let(:keywords_overlap) { %w{ a } }
@@ -11,25 +11,25 @@ describe Strategies::ContainsAnyWithSubstringSearch do
 
   it "is successfull when there's a data overlap (at least one element)" do
     sample = SampleDouble.new(data,keywords_overlap)
-    comparator = Strategies::ContainsAnyWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsAnyWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "doesn't find something if there's no overlap" do
     sample = SampleDouble.new(data,keywords_no_overlap)
-    comparator = Strategies::ContainsAnyWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsAnyWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "doesn't find something if there's an exception defined" do
     sample = SampleDouble.new(data,keywords_overlap, exceptions)
-    comparator = Strategies::ContainsAnyWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsAnyWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "is successfull, if there's a least one match (second match 'c' -> exception -> no match) " do
     sample = SampleDouble.new(data,multiple_overlap, exceptions)
-    comparator = Strategies::ContainsAnyWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsAnyWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(true)
   end
 end

data/spec/comparator/contains_not_spec.rb

@@ -2,38 +2,38 @@
 require 'spec_helper'
 require 'strategies_helper'
 
-describe Strategies::ContainsNot do
+describe SearchingStrategies::ContainsNot do
   let(:data) { %w{ a b c e} }
   let(:keywords_overlap) { %w{ a } }
   let(:keywords_no_overlap) { %w{ d } }
 
   it "is successfull if keywords are empty" do
     sample = SampleDouble.new(data,[])
-    comparator = Strategies::ContainsNot.new(sample)
+    comparator = SearchingStrategies::ContainsNot.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "is successfull if data is empty" do
     sample = SampleDouble.new([],keywords_no_overlap)
-    comparator = Strategies::ContainsNot.new(sample)
+    comparator = SearchingStrategies::ContainsNot.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "fails if both keywords and data are empty" do
     sample = SampleDouble.new([],[])
-    comparator = Strategies::ContainsNot.new(sample)
+    comparator = SearchingStrategies::ContainsNot.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "is successfull if there's a data overlap" do
     sample = SampleDouble.new(data,keywords_overlap)
-    comparator = Strategies::ContainsNot.new(sample)
+    comparator = SearchingStrategies::ContainsNot.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "doesn't find something if there's no overlap" do
     sample = SampleDouble.new(data,keywords_no_overlap)
-    comparator = Strategies::ContainsNot.new(sample)
+    comparator = SearchingStrategies::ContainsNot.new(sample)
     expect(comparator.success?).to eq(true)
   end
 

data/spec/comparator/contains_not_with_substring_search_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 require 'strategies_helper'
 
-describe Strategies::ContainsNotWithSubstringSearch do
+describe SearchingStrategies::ContainsNotWithSubstringSearch do
   let(:data) { %w{ ab c e } }
   let(:exceptions) { %w{ a } }
   let(:keywords_overlap) { %w{ ab } }
@@ -10,19 +10,19 @@ describe Strategies::ContainsNotWithSubstringSearch do
 
   it "is successfull when there's a no overlap" do
     sample = SampleDouble.new(data,keywords_no_overlap)
-    comparator = Strategies::ContainsNotWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsNotWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "doesn't find something if there's an overlap" do
     sample = SampleDouble.new(data,keywords_overlap)
-    comparator = Strategies::ContainsNotWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsNotWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "is successfull although there's an overlap, but an exception defined" do
     sample = SampleDouble.new(data,keywords_overlap, exceptions)
-    comparator = Strategies::ContainsNotWithSubstringSearch.new(sample)
+    comparator = SearchingStrategies::ContainsNotWithSubstringSearch.new(sample)
     expect(comparator.success?).to eq(true)
   end
 end

data/spec/comparator/is_equal_spec.rb

@@ -2,38 +2,38 @@
 require 'spec_helper'
 require 'strategies_helper'
 
-describe Strategies::IsEqual do
+describe SearchingStrategies::IsEqual do
   let(:data) { %w{ a } }
   let(:keywords_overlap) { %w{ a } }
   let(:keywords_no_overlap) { %w{ d } }
 
   it "fails if keywords are empty" do
     sample = SampleDouble.new(data,[])
-    comparator = Strategies::IsEqual.new(sample)
+    comparator = SearchingStrategies::IsEqual.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "fails if data is empty" do
     sample = SampleDouble.new([],keywords_no_overlap)
-    comparator = Strategies::IsEqual.new(sample)
+    comparator = SearchingStrategies::IsEqual.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "is successfull if both keywords and data are empty" do
     sample = SampleDouble.new([],[])
-    comparator = Strategies::IsEqual.new(sample)
+    comparator = SearchingStrategies::IsEqual.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "is successfull if data and keywords are equal" do
     sample = SampleDouble.new(data,keywords_overlap)
-    comparator = Strategies::IsEqual.new(sample)
+    comparator = SearchingStrategies::IsEqual.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "fails if data and keywords are different" do
     sample = SampleDouble.new(data,keywords_no_overlap)
-    comparator = Strategies::IsEqual.new(sample)
+    comparator = SearchingStrategies::IsEqual.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
@@ -43,7 +43,7 @@ describe Strategies::IsEqual do
     sample = SampleDouble.new(data,keywords_no_overlap,%w{a})
 
     msg = capture(:stderr) do
-      Strategies::IsEqual.new(sample)
+      SearchingStrategies::IsEqual.new(sample)
     end
 
     expect(msg).to eq(needed_msg)

data/spec/comparator/is_not_equal_spec.rb

@@ -2,38 +2,38 @@
 require 'spec_helper'
 require 'strategies_helper'
 
-describe Strategies::IsNotEqual do
+describe SearchingStrategies::IsNotEqual do
   let(:data) { %w{ a } }
   let(:keywords_overlap) { %w{ a } }
   let(:keywords_no_overlap) { %w{ d } }
 
   it "is successfull if keywords are empty" do
     sample = SampleDouble.new(data,[])
-    comparator = Strategies::IsNotEqual.new(sample)
+    comparator = SearchingStrategies::IsNotEqual.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "is successfull if data is empty" do
     sample = SampleDouble.new([],keywords_no_overlap)
-    comparator = Strategies::IsNotEqual.new(sample)
+    comparator = SearchingStrategies::IsNotEqual.new(sample)
     expect(comparator.success?).to eq(true)
   end
 
   it "fails if both keywords and data are empty" do
     sample = SampleDouble.new([],[])
-    comparator = Strategies::IsNotEqual.new(sample)
+    comparator = SearchingStrategies::IsNotEqual.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "fails if data and keywords are equal" do
     sample = SampleDouble.new(data,keywords_overlap)
-    comparator = Strategies::IsNotEqual.new(sample)
+    comparator = SearchingStrategies::IsNotEqual.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "is successfull if data and keywords are different" do
     sample = SampleDouble.new(data,keywords_no_overlap)
-    comparator = Strategies::IsNotEqual.new(sample)
+    comparator = SearchingStrategies::IsNotEqual.new(sample)
     expect(comparator.success?).to eq(true)
   end
 end

data/spec/spec_helper.rb

@@ -28,7 +28,7 @@ require 'the_array_comparator/testing_helper/test_data'
 require 'the_array_comparator/testing_helper'
 
 RSpec.configure do |c|
-  c.treat_symbols_as_metadata_keys_with_true_values = true
+#  c.treat_symbols_as_metadata_keys_with_true_values = true
 #  c.filter_run_including :focus => true
 end
 

data/spec/strategy_dispatcher/strategy_dispatcher_spec.rb

@@ -0,0 +1,159 @@
+#enconding: utf-8
+require 'spec_helper'
+
+describe StrategyDispatcher do
+  let(:dispatcher_klass) do
+    Class.new(StrategyDispatcher) do
+      def initialize; end
+
+      def class_must_have_methods
+        [
+          :success?
+        ]
+      end
+
+      def exception_to_raise_for_invalid_strategy; end
+    end
+  end
+
+  let(:strategy_klass) do
+    Class.new do
+      def success?
+        true
+      end
+    end
+  end
+
+  it "let you define must have methods" do
+    dispatcher_klass = Class.new(StrategyDispatcher) do
+      def class_must_have_methods; end
+    end
+
+    expect {
+      dispatcher_klass.new.class_must_have_methods
+    }.to_not raise_error
+  end
+
+  it "expects that must have methods are defined" do
+    dispatcher_klass = Class.new(StrategyDispatcher) do; end
+
+    expect {
+      dispatcher_klass.new.class_must_have_methods
+    }.to raise_error Exceptions::MustHaveMethodNotImplemented
+
+    expect {
+      dispatcher_klass.new.exception_to_raise_for_invalid_strategy
+    }.to raise_error Exceptions::MustHaveMethodNotImplemented
+  end
+
+  it "let you register classes" do
+    invalid_strategy_exception = Class.new(Exception)
+
+    dispatcher_klass = Class.new(StrategyDispatcher) do
+      def class_must_have_methods; end
+
+      def exception_to_raise_for_invalid_strategy
+        invalid_strategy_exception
+      end
+    end
+
+    expect {
+      dispatcher_klass.new.register(:is_eqal_new, strategy_klass) 
+    }.to_not raise_error invalid_strategy_exception
+  end
+
+  it "fails when you did not set a strategy reader but defined your own initializer" do
+    expect {
+      dispatcher_klass.new.register(:is_eqal_new, strategy_klass) 
+    }.to raise_error Exceptions::WrongUsageOfLibrary
+  end
+
+  it "is happy if you define a strategy reader" do
+    dispatcher_klass = Class.new(StrategyDispatcher) do
+      strategy_reader :avail_strategies
+
+      def class_must_have_methods
+        [
+          :success?
+        ]
+      end
+
+      def exception_to_raise_for_invalid_strategy; end
+    end
+
+    expect {
+      dispatcher_klass.new.register(:is_eqal_new, strategy_klass) 
+    }.to_not raise_error Exceptions::WrongUsageOfLibrary
+  end
+
+  it "gives you access to the defined strategies via the reader" do
+    dispatcher_klass = Class.new(StrategyDispatcher) do
+      strategy_reader :strategies
+
+      def class_must_have_methods
+        [
+          :success?
+        ]
+      end
+
+      def exception_to_raise_for_invalid_strategy; end
+    end
+
+    d = dispatcher_klass.new
+    d.register(:is_eqal_new, strategy_klass) 
+    s = d.strategies[:is_eqal_new]
+    expect(s).to be(strategy_klass)
+  end
+
+  it "fails if you try to register an internal keyword" do
+    forbidden_keywords = [ 
+      :initialize,
+      :strategy_reader,
+      :register,
+      :exception_to_raise_for_invalid_strategy,
+      :class_must_have_methods,
+      :each,
+      :interal_keywords,
+      :valid_strategy?,
+      :exception_if_not_implemented,
+    ]
+
+    def dispatcher_klass(reader)
+      Class.new(StrategyDispatcher) do
+        strategy_reader reader.to_sym
+
+        def class_must_have_methods
+          [
+            :success?
+          ]
+        end
+
+        def exception_to_raise_for_invalid_strategy; end
+      end
+    end
+
+    forbidden_keywords.each do |w|
+      expect{ dispatcher_klass(w) }.to raise_error Exceptions::UsedInternalKeyword
+    end
+  end
+
+  it "fails when registering a not suitable class" do
+    Invalid_strategy_exception = Class.new(Exception)
+
+    dispatcher_klass = Class.new(StrategyDispatcher) do
+      def class_must_have_methods
+        [ 
+          :wow_what_a_method
+        ]
+      end
+
+      def exception_to_raise_for_invalid_strategy
+        Invalid_strategy_exception
+      end
+    end
+
+    expect {
+      dispatcher_klass.new.register(:is_eqal_new, strategy_klass) 
+    }.to raise_error Invalid_strategy_exception
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: the_array_comparator
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-10 00:00:00.000000000 Z
+date: 2013-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_support
@@ -52,20 +52,23 @@ files:
 - gemfiles/Gemfile.travis
 - lib/the_array_comparator.rb
 - lib/the_array_comparator/cache.rb
+- lib/the_array_comparator/caching_strategies/anonymous_cache.rb
+- lib/the_array_comparator/caching_strategies/single_value_cache.rb
 - lib/the_array_comparator/check.rb
 - lib/the_array_comparator/comparator.rb
 - lib/the_array_comparator/exceptions.rb
 - lib/the_array_comparator/result.rb
 - lib/the_array_comparator/sample.rb
-- lib/the_array_comparator/strategies/base.rb
-- lib/the_array_comparator/strategies/contains_all.rb
-- lib/the_array_comparator/strategies/contains_all_with_substring_search.rb
-- lib/the_array_comparator/strategies/contains_any.rb
-- lib/the_array_comparator/strategies/contains_any_with_substring_search.rb
-- lib/the_array_comparator/strategies/contains_not.rb
-- lib/the_array_comparator/strategies/contains_not_with_substring_search.rb
-- lib/the_array_comparator/strategies/is_equal.rb
-- lib/the_array_comparator/strategies/is_not_equal.rb
+- lib/the_array_comparator/searching_strategies/base.rb
+- lib/the_array_comparator/searching_strategies/contains_all.rb
+- lib/the_array_comparator/searching_strategies/contains_all_with_substring_search.rb
+- lib/the_array_comparator/searching_strategies/contains_any.rb
+- lib/the_array_comparator/searching_strategies/contains_any_with_substring_search.rb
+- lib/the_array_comparator/searching_strategies/contains_not.rb
+- lib/the_array_comparator/searching_strategies/contains_not_with_substring_search.rb
+- lib/the_array_comparator/searching_strategies/is_equal.rb
+- lib/the_array_comparator/searching_strategies/is_not_equal.rb
+- lib/the_array_comparator/strategy_dispatcher.rb
 - lib/the_array_comparator/testing_helper.rb
 - lib/the_array_comparator/testing_helper/data_set.rb
 - lib/the_array_comparator/testing_helper/test_data.rb
@@ -73,6 +76,8 @@ files:
 - script/console
 - script/terminal
 - spec/benchmark/benchmark_spec.rb
+- spec/cache/anonymous_cache_spec.rb
+- spec/cache/single_value_cache_spec.rb
 - spec/cache_spec.rb
 - spec/check_spec.rb
 - spec/comparator/base_spec.rb
@@ -89,6 +94,7 @@ files:
 - spec/sample_spec.rb
 - spec/spec_helper.rb
 - spec/strategies_helper.rb
+- spec/strategy_dispatcher/strategy_dispatcher_spec.rb
 - spec/testing_helper/testing_helper_spec.rb
 - the_array_comparator.gemspec
 homepage: https://www.github.com/max_meyer/the_array_comparator
@@ -117,6 +123,8 @@ specification_version: 3
 summary: you need to compare arrays? then this gem is very suitable for you.
 test_files:
 - spec/benchmark/benchmark_spec.rb
+- spec/cache/anonymous_cache_spec.rb
+- spec/cache/single_value_cache_spec.rb
 - spec/cache_spec.rb
 - spec/check_spec.rb
 - spec/comparator/base_spec.rb
@@ -133,5 +141,6 @@ test_files:
 - spec/sample_spec.rb
 - spec/spec_helper.rb
 - spec/strategies_helper.rb
+- spec/strategy_dispatcher/strategy_dispatcher_spec.rb
 - spec/testing_helper/testing_helper_spec.rb
 has_rdoc: