the_array_comparator 0.2.0 → 0.3.0

data/lib/the_array_comparator/strategy_dispatcher.rb

@@ -0,0 +1,110 @@
+#encoding: utf-8
+
+# the main module
+module TheArrayComparator
+  # the main comparator shell class
+  class StrategyDispatcher
+
+    # Create strategy dispatcher
+    def initialize
+      @available_strategies = {}
+    end
+
+    class << self
+      # Define a reader for the available strategies
+      #
+      # @param [String, Symbol] name
+      #   the name for the reader
+      def strategy_reader(name)
+        raise Exceptions::UsedInternalKeyword,  "You tried to define a reader using an internal name , which is forbidden (your reader name: #{name}). Please choose another name. Thank you very much." if internal_keywords.include? name
+
+        define_method name.to_sym do
+          instance_variable_get :@available_strategies
+        end
+      end
+
+      private
+
+      def internal_keywords
+        [
+          :initialize,
+          :strategy_reader,
+          :register,
+          :exception_to_raise_for_invalid_strategy,
+          :class_must_have_methods,
+          :each,
+          :interal_keywords,
+          :valid_strategy?,
+          :exception_if_not_implemented,
+        ]
+      end
+    end
+
+
+    # Register a new comparator strategy
+    #
+    # @param [String,Symbol] name
+    #   The name which can be used to refer to the registered strategy
+    #
+    # @param [Comparator] klass
+    #   The strategy class which should be registered
+    #
+    # @raise user defined exception
+    #   Raise exception if an incompatible strategy class is given. Please
+    #   see #exception_to_raise_for_invalid_strategy for more information
+    def register(name,klass)
+      if valid_strategy? klass
+        available_strategies[name.to_sym] = klass
+      else
+        raise exception_to_raise_for_invalid_strategy, "Registering #{klass} failed. It does not support \"#{class_must_have_methods.join("-, ")}\"-method"
+      end
+    end
+
+    # Returns the exception used in registration check
+    #
+    # @note
+    #   has to be implemented by concrete dispatcher -> otherwise exception
+    def exception_to_raise_for_invalid_strategy
+      exception_if_not_implemented __method__
+    end
+
+    # Return all must have methods
+    #
+    # @note
+    #   has to be implemented by concrete dispatcher -> otherwise exception
+    def class_must_have_methods
+      exception_if_not_implemented __method__
+    end
+
+    # Iterate over all strategies
+    #
+    # @param [Block] block
+    #   the block to be executed for each strategy
+    #
+    # @return [Enumerator]
+    #   enumerator over all available strategies
+    def each(&block)
+      available_strategies.each(block)
+    end
+
+    private
+
+    #internal reader
+    def available_strategies
+      @available_strategies or raise Exceptions::WrongUsageOfLibrary, "You forgot to call \"super()\" in your \"initialize\"-method of your strategy dispatcher #{self.class.name}"
+    end
+
+    # Check if given klass is a valid
+    def valid_strategy?(klass)
+      class_must_have_methods.all? { |m| klass.new.respond_to?(m) }
+    end
+
+    # There are methods to be
+    # implemented, raise an exception 
+    # if one forgot to implement them
+    def exception_if_not_implemented(m)
+      raise Exceptions::MustHaveMethodNotImplemented, "You forgot to implement the must have method \"#{m}\" in your strategy dispatcher #{self.class.name}"
+    end
+
+  end
+end

data/lib/the_array_comparator/version.rb

@@ -1,4 +1,4 @@
 #main TheArrayComparator
 module TheArrayComparator
-  VERSION = '0.2.0'
-end
+  VERSION = '0.3.0'
+end

data/lib/the_array_comparator.rb

@@ -6,30 +6,22 @@ require 'forwardable'
 
 require 'the_array_comparator/version'
 require 'the_array_comparator/exceptions'
-require 'the_array_comparator/cache'
 require 'the_array_comparator/sample'
 require 'the_array_comparator/check'
 require 'the_array_comparator/result'
-require 'the_array_comparator/strategies/base'
-require 'the_array_comparator/strategies/contains_all_with_substring_search'
-require 'the_array_comparator/strategies/contains_any_with_substring_search'
-require 'the_array_comparator/strategies/contains_all'
-require 'the_array_comparator/strategies/contains_any'
-require 'the_array_comparator/strategies/contains_not_with_substring_search'
-require 'the_array_comparator/strategies/contains_not'
-require 'the_array_comparator/strategies/is_equal'
-require 'the_array_comparator/strategies/is_not_equal'
+require 'the_array_comparator/strategy_dispatcher'
+require 'the_array_comparator/cache'
+require 'the_array_comparator/searching_strategies/base'
+require 'the_array_comparator/searching_strategies/contains_all_with_substring_search'
+require 'the_array_comparator/searching_strategies/contains_any_with_substring_search'
+require 'the_array_comparator/searching_strategies/contains_all'
+require 'the_array_comparator/searching_strategies/contains_any'
+require 'the_array_comparator/searching_strategies/contains_not_with_substring_search'
+require 'the_array_comparator/searching_strategies/contains_not'
+require 'the_array_comparator/searching_strategies/is_equal'
+require 'the_array_comparator/searching_strategies/is_not_equal'
 require 'the_array_comparator/comparator'
 
 
 # main module
-module TheArrayComparator
-  Comparator.register :contains_all, Strategies::ContainsAll
-  Comparator.register :contains_any, Strategies::ContainsAny
-  Comparator.register :not_contains, Strategies::ContainsNot
-  Comparator.register :contains_all_as_substring, Strategies::ContainsAllWithSubstringSearch
-  Comparator.register :contains_any_as_substring, Strategies::ContainsAnyWithSubstringSearch
-  Comparator.register :not_contains_substring, Strategies::ContainsNotWithSubstringSearch
-  Comparator.register :is_equal, Strategies::IsEqual
-  Comparator.register :is_not_equal, Strategies::IsNotEqual
-end
+module TheArrayComparator; end

data/spec/benchmark/benchmark_spec.rb

@@ -1,28 +1,69 @@
 require 'spec_helper'
-
+require 'strategies_helper'
 
 describe "benchmark for strategies" do
   let(:count_of_lines) { 100000 }
+  let(:keywords) { %w{a c d} }
+  let(:data) { generate_testdata(keywords: keywords, count_of_data: count_of_lines) }
 
   describe "strategy contains with substring search" do
-    let(:keywords) { %w{ab c d} }
-    let(:data) { generate_testdata(keywords: keywords, count_of_data: count_of_lines) }
-
     it "is fast", :bm => true do
-      comparator = Strategies::ContainsWithSubstringSearch.add_check(data,keywords)
+      keywords = %w{ab c d}
+      data = generate_testdata(keywords: keywords, count_of_data: count_of_lines)
+      sample = SampleDouble.new(data,keywords)
+
+      comparator = SearchingStrategies::ContainsAllWithSubstringSearch.new(sample)
       time_taken = Benchmark.realtime { comparator.success? }
       expect(time_taken).to be < 1
     end
   end
 
   describe "strategy contains" do
-    let(:keywords) { %w{a c d} }
-    let(:data) { generate_testdata(keywords: keywords, count_of_data: count_of_lines) }
-
     it "is fast", :bm => true do
-      comparator = Strategies::Contains.add_check(data,keywords)
+      sample = SampleDouble.new(data,keywords)
+      comparator = SearchingStrategies::ContainsAll.new(sample)
       time_taken = Benchmark.realtime { comparator.success? }
       expect(time_taken).to be < 1
     end
   end
+
+  describe "caching behaviour" do
+    it "the cache reduces delay", :bm => true do
+      comparator = Comparator.new
+      keyword = %w{ a }
+
+      100.times do
+        comparator.add_check data , :contains_all , keyword
+      end
+
+      time_taken_cold_cache = Benchmark.realtime { comparator.success? }
+      time_taken_warm_cache = Benchmark.realtime { comparator.success? }
+
+      expect(time_taken_warm_cache).to be < time_taken_cold_cache
+    end
+
+    it "will be reseted when a new element was added after first access to cache", :bm => true do
+      comparator = Comparator.new
+      keyword = %w{ a }
+
+      #cold cache 1
+      100.times do
+        comparator.add_check data , :contains_all , keyword
+      end
+      time_taken_cold_cache_1 = Benchmark.realtime { comparator.success? }
+
+      #cold cache 2
+      comparator.add_check data , :contains_all , keyword
+      time_taken_cold_cache_2 = Benchmark.realtime { comparator.success? }
+
+      #there should be no large difference between those values
+      # cold: ~8s
+      # warm: <1s
+      #
+      # therefor all difference larger than 1 should be treated as error
+      difference = time_taken_cold_cache_1 - time_taken_cold_cache_2
+
+      expect(difference).to be < 1
+    end
+  end
 end

data/spec/cache/anonymous_cache_spec.rb

@@ -0,0 +1,89 @@
+#enconding: utf-8
+require 'spec_helper'
+
+describe CachingStrategies::AnonymousCache do
+
+  let(:cache) { CachingStrategies::AnonymousCache.new }
+
+  it "adds abitrary objects to cache" do
+    expect {
+      cache.add %w{obj}
+      cache.add('obj')
+    }.to_not raise_error
+  end
+
+  it "returns all cached objects" do
+    objects = []
+
+    objects << cache.add('obj')
+    objects << cache.add('obj')
+    objects << cache.add('obj')
+
+    expect(cache.stored_objects).to eq(objects)
+  end
+
+  it "clears cache" do
+    cache.add('obj')
+    cache.add('obj')
+    cache.add('obj')
+    expect(cache.stored_objects.size).to eq(3) 
+
+    cache.clear
+    expect(cache.stored_objects.size).to eq(0) 
+  end
+
+  it "tells the requester if there are new objects" do
+    cache.add('obj')
+    expect(cache.new_objects?).to eq(true) 
+  end
+
+  it "tells the requester if there __no__ new objects" do
+    cache.add('obj')
+    cache.stored_objects
+    expect(cache.new_objects?).to eq(false) 
+  end
+
+  it "works with sub-sequent requests to the cache as well" do
+    cache.add('obj')
+    cache.stored_objects
+    cache.add('obj')
+    expect(cache.new_objects?).to eq(true) 
+
+    cache.add('obj')
+    cache.stored_objects
+    cache.add('obj')
+    cache.stored_objects
+    expect(cache.new_objects?).to eq(false) 
+  end
+
+  it "returns the same objecs if requested multiple times" do
+    cache.add('obj')
+    cache.add('obj')
+    run1 = cache.stored_objects
+    run2 = cache.stored_objects
+
+    expect(run1).to be(run2) 
+    expect(run1).to eq(run2) 
+  end
+
+  it "deletes specific objects from cache (by number)" do
+    cache.add('obj')
+    c_created = cache.add('obj')
+    cache.add('obj')
+
+    c_deleted = cache.delete_object(1) 
+
+    expect(c_created).to eq(c_deleted)
+  end
+
+  it "gets you a specific object" do
+    cache.add('obj')
+    c_created = cache.add('obj')
+    cache.add('obj')
+
+    c_fetched = cache.fetch_object(1) 
+
+    expect(c_created).to eq(c_fetched)
+  end
+
+end

data/spec/cache/single_value_cache_spec.rb

@@ -0,0 +1,77 @@
+#enconding: utf-8
+require 'spec_helper'
+
+describe CachingStrategies::SingleValueCache do
+
+  let(:cache) { CachingStrategies::SingleValueCache.new }
+
+  it "adds abitrary objects to cache" do
+    expect {
+      cache.add %w{obj}
+    }.to_not raise_error
+  end
+
+  it "returns one and only object" do
+    objects = []
+
+    objects << cache.add('obj')
+    objects << cache.add('obj')
+
+    expect(cache.stored_objects).to eq([ objects.last ])
+  end
+
+  it "clears cache" do
+    cache.add('obj')
+    expect(cache.stored_objects.size).to eq(1) 
+
+    cache.clear
+    expect(cache.stored_objects.size).to eq(0) 
+  end
+
+  it "tells the requester if there are new objects" do
+    cache.add('obj')
+    expect(cache.new_objects?).to eq(true) 
+  end
+
+  it "tells the requester if there __no__ new objects" do
+    cache.add('obj')
+    cache.stored_objects
+    expect(cache.new_objects?).to eq(false) 
+  end
+
+  it "works with sub-sequent requests to the cache as well" do
+    cache.add('obj')
+    cache.stored_objects
+    cache.add('obj')
+    expect(cache.new_objects?).to eq(true) 
+
+    cache.add('obj')
+    cache.stored_objects
+    cache.add('obj')
+    cache.stored_objects
+    expect(cache.new_objects?).to eq(false) 
+  end
+
+  it "returns the same objecs if requested multiple times" do
+    cache.add('obj')
+    run1 = cache.stored_objects
+    run2 = cache.stored_objects
+
+    expect(run1).to be(run2) 
+    expect(run1).to eq(run2) 
+  end
+
+  it "deletes specific objects from cache (by number)" do
+    c_created = cache.add('obj')
+    c_deleted = cache.delete_object
+
+    expect(c_deleted).to eq(c_created)
+  end
+
+  it "gets you a specific object" do
+    c_created = cache.add('obj')
+    c_fetched = cache.fetch_object
+
+    expect(c_fetched).to eq(c_created)
+  end
+end

data/spec/cache_spec.rb

@@ -1,89 +1,40 @@
-#enconding: utf-8
 require 'spec_helper'
 
 describe Cache do
 
-  let(:cache) { Cache.new }
+  it "let you add a cache" do
+    cache = Cache.new
+    cache.add(:test, :anonymous_cache)
+    data = %w{ a b c d}
 
-  it "adds abitrary objects to cache" do
     expect {
-      cache.add %w{obj}
-      cache.add('obj')
+      cache[:test].add data
     }.to_not raise_error
   end
 
-  it "returns all cached objects" do
-    objects = []
+  it "fails if an unknown cache strategy is given" do
+    cache = Cache.new
+    data = %w{ a b c d}
 
-    objects << cache.add('obj')
-    objects << cache.add('obj')
-    objects << cache.add('obj')
-
-    expect(cache.stored_objects).to eq(objects)
-  end
-
-  it "clears cache" do
-    cache.add('obj')
-    cache.add('obj')
-    cache.add('obj')
-    expect(cache.stored_objects.size).to eq(3) 
-
-    cache.clear
-    expect(cache.stored_objects.size).to eq(0) 
-  end
-
-  it "tells the requester if there are new objects" do
-    cache.add('obj')
-    expect(cache.new_objects?).to eq(true) 
-  end
-
-  it "tells the requester if there __no__ new objects" do
-    cache.add('obj')
-    cache.stored_objects
-    expect(cache.new_objects?).to eq(false) 
-  end
-
-  it "works with sub-sequent requests to the cache as well" do
-    cache.add('obj')
-    cache.stored_objects
-    cache.add('obj')
-    expect(cache.new_objects?).to eq(true) 
-
-    cache.add('obj')
-    cache.stored_objects
-    cache.add('obj')
-    cache.stored_objects
-    expect(cache.new_objects?).to eq(false) 
-  end
-
-  it "returns the same objecs if requested multiple times" do
-    cache.add('obj')
-    cache.add('obj')
-    run1 = cache.stored_objects
-    run2 = cache.stored_objects
-
-    expect(run1).to be(run2) 
-    expect(run1).to eq(run2) 
+    expect {
+      cache.add(:test, :anonymous_cache_abc)
+    }.to raise_error Exceptions::UnknownCachingStrategy 
   end
 
-  it "deletes specific objects from cache (by number)" do
-    cache.add('obj')
-    c_created = cache.add('obj')
-    cache.add('obj')
-
-    c_deleted = cache.delete_object(1) 
+  it "fails if an unknown cache is given" do
+    data = %w{ a b c d}
 
-    expect(c_created).to eq(c_deleted)
+    expect {
+      cache[:test123].add data
+    }.to raise_error
   end
 
-  it "gets you a specific object" do
-    cache.add('obj')
-    c_created = cache.add('obj')
-    cache.add('obj')
-
-    c_fetched = cache.fetch_object(1) 
+  it "returns the cache after adding it" do
+    cache = Cache.new
+    cache.add(:test, :anonymous_cache)
+    data = %w{ a b c d}
 
-    expect(c_created).to eq(c_fetched)
+    expect( cache[:test].class ).to be(CachingStrategies::AnonymousCache)
   end
 
 end

data/spec/comparator/base_spec.rb

@@ -2,10 +2,10 @@
 require 'spec_helper'
 require 'strategies_helper'
 
-describe Strategies::Base do
+describe SearchingStrategies::Base do
 
   it "raise an exception if api is not implemented" do
-    class TestStrategy < Strategies::Base
+    class TestStrategy < SearchingStrategies::Base
     end
 
     expect {

data/spec/comparator/comparator_spec.rb

@@ -2,29 +2,15 @@
 require 'spec_helper'
 
 describe Comparator do
-  it "let you register classes" do
-    comparator_instance = double('TestComparatorInstance')
-    comparator_instance.stub(:success?).and_return(true)
+  cache_klass = Class.new do
+    def success?
+      true
+    end
 
-    comparator_klass = double('TestComparatorClass')
-    comparator_klass.stub(:new).and_return(comparator_instance)
-
-    expect {
-      Comparator.register(:is_eqal_new, comparator_klass) 
-    }.to_not raise_error Exceptions::IncompatibleComparator
+    def initialize(sample=nil)
+    end
   end
 
-  it "fails when registering a not suitable class" do
-    comparator_instance = double('TestComparatorInstance')
-    comparator_instance.stub(:successasdf?).and_return(true)
-
-    comparator_klass = double('TestComparatorClass')
-    comparator_klass.stub(:new).and_return(comparator_instance)
-    expect {
-      Comparator.register(:is_eqal_new, comparator_klass) 
-    }.to raise_error Exceptions::IncompatibleComparator
-  end
-  
   it "let you add check to check for" do
     testrun = Comparator.new
     data = %w{ a b c d}
@@ -45,22 +31,6 @@ describe Comparator do
     }.to raise_error Exceptions::UnknownCheckType
   end
 
-  it "let you register and use classes" do
-    comparator_instance = double('TestComparatorInstance')
-    comparator_instance.stub(:success?).and_return(true)
-
-    comparator_klass = double('TestComparatorClass')
-    comparator_klass.stub(:new).and_return(comparator_instance)
-
-    Comparator.register(:new_comp, comparator_klass) 
-
-    comparator = Comparator.new
-    comparator.add_check %w{a}, :new_comp , %{a}
-    result = comparator.success?
-
-    expect(result).to eq(true)
-  end
-
   it "support some comparators by default" do
     testrun = Comparator.new
     data = %w{ a b c d}
@@ -182,7 +152,7 @@ describe Comparator do
     expect(result.of_checks).to eq(true)
   end
 
-  it "tells you which check has failed and made the whole thing failed" , :test => true do
+  it "tells you which check has failed and made the whole thing failed" do
     comparator = Comparator.new
     data = %w{ a b c d }
     keyword_successfull = %w{ a b }

data/spec/comparator/contains_all_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 require 'strategies_helper'
 
-describe Strategies::ContainsAll do
+describe SearchingStrategies::ContainsAll do
   let(:data) { %w{ a b c e} }
   let(:keywords_overlap) { %w{ a } }
   let(:keywords_no_overlap) { %w{ d } }
@@ -10,37 +10,37 @@ describe Strategies::ContainsAll do
 
   it "fails if keywords are empty" do
     sample = SampleDouble.new(data,[])
-    comparator = Strategies::ContainsAll.new(sample)
+    comparator = SearchingStrategies::ContainsAll.new(sample)
     expect(comparator.success?).to eq(false)
   end
 
   it "fails if data is empty" do
     sample = SampleDouble.new([],keywords_no_overlap)
-    comparator = Strategies::ContainsAll.new(sample)
+    comparator = SearchingStrategies::ContainsAll.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::ContainsAll.new(sample)
+    comparator = SearchingStrategies::ContainsAll.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::ContainsAll.new(sample)
+    comparator = SearchingStrategies::ContainsAll.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::ContainsAll.new(sample)
+    comparator = SearchingStrategies::ContainsAll.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::ContainsAll.new(sample)
+    comparator = SearchingStrategies::ContainsAll.new(sample)
     expect(comparator.success?).to eq(false)
   end