the_array_comparator 0.1.1

data/lib/the_array_comparator/strategies/base.rb

@@ -0,0 +1,41 @@
+#encoding: utf-8
+
+# the main module
+module TheArrayComparator
+  # the available strategies
+  module Strategies
+    #base class for strategies
+    class Base
+
+      # Create a new instance of strategy
+      #
+      # @param [Sample] sample
+      #    the probe which should be used for the check
+      #
+      # @return [Object] 
+      #   the strategy
+      def initialize(sample=Sample.new)
+        @data = sample.data
+        @keywords = sample.keywords
+        @exceptions = sample.exceptions
+        @tag = sample.tag
+      end
+
+      # Check the keywords with the data
+      #
+      # @note
+      #   needs to be implemented by the concrete strategy
+      # @raise [RuntimeError]
+      #   error when not implemented by strategy
+      def success?
+        raise Exceptions::IncompatibleComparator, "The chosen comparator is incompatible, Please check the documentation for comparator strategies on how to build a compatible one."
+      end
+
+      private 
+
+      def warning_unsupported_exceptions
+        warn "Exceptions are not supported by this strategy." unless @exceptions.blank?
+      end
+    end
+  end
+end

data/lib/the_array_comparator/strategies/contains_all.rb

@@ -0,0 +1,35 @@
+#encoding: utf-8
+
+# the main module
+module TheArrayComparator
+  # the available strategies
+  module Strategies
+    #strategy contains
+    class ContainsAll < Base
+      
+      # Create a new instance of strategy
+      #
+      # @see Base
+      def initialize(sample=Sample.new)
+        super
+
+        warning_unsupported_exceptions
+      end
+
+      # Check the keywords with the data
+      #
+      # @return [Boolean]
+      #   The result of the check
+      def success?
+        return true if @keywords.blank? and @data.blank?
+        return false if @keywords.blank? or @data.blank?
+
+        if ( @keywords - @data ).blank?
+          return true
+        else
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/the_array_comparator/strategies/contains_all_with_substring_search.rb

@@ -0,0 +1,39 @@
+#encoding: utf-8
+
+# the main module
+module TheArrayComparator
+  # the available strategies
+  module Strategies
+    # strategy contains substring
+    class ContainsAllWithSubstringSearch < Base
+
+      # Create a new instance of strategy
+      #
+      # @see Base
+      def initialize(sample=Sample.new)
+        super
+      end
+
+      # Check the keywords with the data
+      #
+      # @return [Boolean]
+      #   The result of the check
+      def success?
+        return true if @keywords.blank? and @data.blank?
+
+        #return true if @data.all? do |line| 
+        #  #does a keyword match and it is not an the exception list
+        #  binding.pry
+        #  @keywords.all?{ |k| line[k] } and not @exceptions.any?{ |e| line[e] }
+        #end
+
+        return true if @keywords.all? do |word| 
+          #does a keyword match and it is not an the exception list
+          @data.any?{ |line| line[word] and not @exceptions.any?{ |e| line[e] } }
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/the_array_comparator/strategies/contains_any.rb

@@ -0,0 +1,34 @@
+#encoding: utf-8
+
+# the main module
+module TheArrayComparator
+  # the available strategies
+  module Strategies
+    #strategy contains
+    class ContainsAny < Base
+      
+      # Create a new instance of strategy
+      #
+      # @see Base
+      def initialize(sample=Sample.new)
+        super
+
+        warning_unsupported_exceptions
+      end
+
+      # Check the keywords with the data
+      #
+      # @return [Boolean]
+      #   The result of the check
+      def success?
+        return true if @keywords.blank? and @data.blank?
+
+        if ( @keywords & @data ).blank?
+          return false
+        else
+          return true
+        end
+      end
+    end
+  end
+end

data/lib/the_array_comparator/strategies/contains_any_with_substring_search.rb

@@ -0,0 +1,33 @@
+#encoding: utf-8
+
+# the main module
+module TheArrayComparator
+  # the available strategies
+  module Strategies
+    # strategy contains substring
+    class ContainsAnyWithSubstringSearch < Base
+
+      # Create a new instance of strategy
+      #
+      # @see Base
+      def initialize(sample=Sample.new)
+        super
+      end
+
+      # Check the keywords with the data
+      #
+      # @return [Boolean]
+      #   The result of the check
+      def success?
+        return true if @keywords.blank? and @data.blank?
+
+        return true if @data.any? do |line| 
+          #does a keyword match and it is not an the exception list
+          @keywords.any?{ |k| line[k] } and not @exceptions.any?{ |e| line[e] }
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/the_array_comparator/strategies/contains_not.rb

@@ -0,0 +1,32 @@
+#encoding: utf-8
+
+# the main module
+module TheArrayComparator
+  # the available strategies
+  module Strategies
+    #strategy contains
+    class ContainsNot < Base
+      
+      # Create a new instance of strategy
+      #
+      # @see Base
+      def initialize(sample=Sample.new)
+        super
+      end
+
+      # Check the keywords with the data
+      #
+      # @return [Boolean]
+      #   The result of the check
+      def success?
+        return false if @keywords.blank? and @data.blank?
+
+        if ( @keywords & @data ).blank?
+          return true
+        else
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/the_array_comparator/strategies/contains_not_with_substring_search.rb

@@ -0,0 +1,33 @@
+#encoding: utf-8
+
+# the main module
+module TheArrayComparator
+  # the available strategies
+  module Strategies
+    # strategy not contains substring
+    class ContainsNotWithSubstringSearch < Base
+
+      # Create a new instance of strategy
+      #
+      # @see Base
+      def initialize(sample=Sample.new)
+        super
+      end
+
+      # Check the keywords with the data
+      #
+      # @return [Boolean]
+      #   The result of the check
+      def success?
+        return false if @keywords.blank? and @data.blank?
+
+        return true if @data.all? do |line| 
+          #if a keyword is found, check if there's an exception
+          @keywords.none?{ |k| line[k] } or @exceptions.any?{ |e| line[e] }
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/the_array_comparator/strategies/is_equal.rb

@@ -0,0 +1,30 @@
+#encoding: utf-8
+
+# the main module
+module TheArrayComparator
+  # the available strategies
+  module Strategies
+    #strategy is equal
+    class IsEqual < Base
+      
+      # Create a new instance of strategy
+      #
+      # @see Base
+      def initialize(sample=Sample.new)
+        super
+
+        warning_unsupported_exceptions
+      end
+
+      # Check the keywords with the data
+      #
+      # @return [Boolean]
+      #   The result of the check
+      def success?
+        return true if @keywords.to_a == @data
+
+        false
+      end
+    end
+  end
+end

data/lib/the_array_comparator/strategies/is_not_equal.rb

@@ -0,0 +1,30 @@
+#encoding: utf-8
+
+# the main module
+module TheArrayComparator
+  # the available strategies
+  module Strategies
+    #strategy is not equal
+    class IsNotEqual < Base
+      
+      # Create a new instance of strategy
+      #
+      # @see Base
+      def initialize(sample=Sample.new)
+        super
+
+        warning_unsupported_exceptions
+      end
+
+      # Check the keywords with the data
+      #
+      # @return [Boolean]
+      #   The result of the check
+      def success?
+        return true if @keywords.to_a != @data
+
+        false
+      end
+    end
+  end
+end

data/lib/the_array_comparator/testing_helper/data_set.rb

@@ -0,0 +1,63 @@
+module TheArrayComparator
+  module TestingHelper
+    # Keywords only make sense together with the raw data
+    class DataSet
+      #@!attribute [rw] keywords
+      #  keywords which need to be hidden in the raw data
+      #
+      #@!attribute [rw] raw_data
+      #  the raw data which should be used to hide the keywords
+      attr_accessor :keywords, :raw_data
+
+      # Create new instance
+      #
+      # @return [DataSet]
+      #   the object holding the data
+      def initialize(keywords=[],raw_data=[])
+        @keywords = keywords
+        @raw_data = raw_data
+      end
+
+      # A stripe of data
+      #
+      # @return [Array]
+      #   a pice of raw data
+      def stripe_of_data
+        raw_data.shift(stripe_size)
+      end
+
+      # A tripe of the keywords
+      #
+      # @return [String,Integer]
+      #   one keyword
+      def stripe_of_keywords
+        keywords.shift unless keywords.blank?
+      end
+
+      # The count of the keywords
+      # @return [Integer]
+      #   How many key words are available
+      def count_of_keywords
+        keywords.size
+      end
+
+      private
+
+      def divisor
+        if count_of_keywords > 0 and count_of_keywords <= count_of_rawdata
+          return count_of_keywords
+        else
+          return 1
+        end
+      end
+
+      def stripe_size
+        raw_data.size / divisor
+      end
+
+      def count_of_rawdata
+        raw_data.size
+      end
+    end
+  end
+end

data/lib/the_array_comparator/testing_helper/test_data.rb

@@ -0,0 +1,33 @@
+module TheArrayComparator
+  module TestingHelper
+    class TestData
+
+      # Create test data instance
+      #
+      # @return [TestData]
+      #   the test data object used to generate the test data
+      def initialize(dataset)
+        @dataset = dataset
+        @data = []
+      end
+
+      # Generate the test data
+      #
+      # @return [Array]
+      #   the test data
+      def generate
+        if @data.blank?
+          @dataset.count_of_keywords.times do
+            @data.concat @dataset.stripe_of_data
+            @data << @dataset.stripe_of_keywords
+          end
+
+          #put the rest into the output
+          @data.concat @dataset.raw_data
+        end
+
+        @data
+      end
+    end
+  end
+end

data/lib/the_array_comparator/testing_helper.rb

@@ -0,0 +1,55 @@
+#the main module
+module TheArrayComparator
+  # helper for tests
+  module TestingHelper
+
+    # Generate data for the tests
+    #
+    # @param [Hash] options
+    #
+    # @option options [Array] :keywords
+    #   the keywords which should be hidden in the data
+    # 
+    # @option options [Array] :raw_data
+    #   the data which should be used to hide the keywords
+    #
+    # @option options [Integer] :count_of_data
+    #   how much raw data should be generated if none is given
+    #
+    # @return [Array]
+    #   the testdata (raw_data + keywords)
+    def generate_testdata(options)
+      opts = {
+        keywords: [],
+        raw_data: [],
+        count_of_data: 100,
+      }.merge options
+
+      raw_data = options[:raw_data] || Faker::Lorem.sentences(opts[:count_of_data])
+      dataset = DataSet.new(options[:keywords],raw_data)
+
+      testdata = TestData.new(dataset)
+      testdata.generate
+    end
+  end
+end
+
+module Kernel
+  #
+  # Captures the given stream and returns it:
+  #
+  #   stream = capture(:stdout) { puts 'Cool' }
+  #   stream # => "Cool\n"
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+
+    result
+  end
+end

data/lib/the_array_comparator/version.rb

@@ -0,0 +1,6 @@
+#encoding: utf-8
+
+#main TheArrayComparator
+module TheArrayComparator
+  VERSION = '0.1.1'
+end

data/lib/the_array_comparator.rb

@@ -0,0 +1,34 @@
+#encoding: utf-8
+
+require 'active_support/core_ext/object/blank'
+require 'set'
+require 'forwardable'
+
+require 'the_array_comparator/version'
+require 'the_array_comparator/exceptions'
+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/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

data/script/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'the_array_comparator'
+require 'pry'
+
+Pry.start

data/script/terminal

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'tmrb'
+
+tmux = TmRb::Multiplexer.new
+#creates an empty window
+tmux.new_session(session_name: 'the_array_comparator')
+
+tmux.new_window(:name => 'code', :command => "zsh -c 'vim -p lib/**/*.rb'")
+tmux.new_window(:name => 'spec', :command => "zsh -c 'vim -p spec/**/*.rb'")
+tmux.new_window(:name => 'features', :command => "zsh -c 'vim -p features/**/*.{rb,feature}'")
+tmux.start

data/spec/benchmark/benchmark_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+
+describe "benchmark for strategies" do
+  let(:count_of_lines) { 100000 }
+
+  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)
+      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)
+      time_taken = Benchmark.realtime { comparator.success? }
+      expect(time_taken).to be < 1
+    end
+  end
+end

data/spec/check_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Check do
+  strategy_klass = Class.new do
+    def success?
+      true
+    end
+
+    def initialize(sample=nil)
+    end
+  end
+
+  sample_klass = Class.new do; end
+
+  it "add a sample and a comparator" do
+    Check.new(strategy_klass,sample_klass.new)
+  end
+
+  it "is true if the check is successfull" do
+    check = Check.new(strategy_klass,sample_klass.new)
+    result = check.success?
+    expect(result).to eq(true)
+  end
+
+  it "is able to return the sample of the check" do
+    sample = sample_klass.new
+    check = Check.new(strategy_klass,sample)
+    expect(check.sample).to eq(sample)
+  end
+end

data/spec/comparator/base_spec.rb

@@ -0,0 +1,16 @@
+#enconding: utf-8
+require 'spec_helper'
+require 'strategies_helper'
+
+describe Strategies::Base do
+
+  it "raise an exception if api is not implemented" do
+    class TestStrategy < Strategies::Base
+    end
+
+    expect {
+      test_strategy = TestStrategy.new
+      test_strategy.success?
+    }.to raise_error Exceptions::IncompatibleComparator
+  end
+end