likes 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6148191736d05b2de8dce7c05ad3ec5781a70735
-  data.tar.gz: fdc47aec630718afa84d9c79f25e7a82bf71e8e5
+  metadata.gz: ec87d59328fd9af20cf8ac632d146dbfa8d62479
+  data.tar.gz: 26d0b83be096dc1150ac797545abdbf6170de08e
 SHA512:
-  metadata.gz: 6f3b0458b662807a8ba0558be63846421a8d95a1bb0d64729419aeb08b58d0f6dfafa0fe4ff91fd3fae464833152d7ef8827fdea901106bf69dc360d0bee7033
-  data.tar.gz: 6e8d085e9022c1ead5877416f48b250bcd2036e62ce442d345156556bb2cfc461961efecf78cc0a89f181511983b071783f29087b20df26fd91a4f0726b37c8d
+  metadata.gz: fd78634d24a31e845a6f08ac785d2a8698be63e82f6fc6822a2c8011fcb61f526b37582b53e7b3cad7136f49b585e9d41375b150ea0d8bf943abb29214b92f3a
+  data.tar.gz: aaf4af28de77e664cce38e5cd06973c2b6dfafa9a1066e48c5874e605a3184ac0b2f438a1061d81dd5d8e0069476d6b44b24272345ffd4b6b51571b9eea50747

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - 2.2
+  - jruby-18mode
+  - jruby-19mode
+  - rbx
+
+script: bundle exec rspec
+bundler_args: --without development

data/Gemfile

@@ -4,4 +4,8 @@ source 'https://rubygems.org'
 gemspec
 
 gem "rspec"
-gem "yard"
+
+group :development do
+  gem "yard"
+  gem "reek"
+end

data/README.md

@@ -1,5 +1,7 @@
 # Likes
 
+[![Build Status](https://travis-ci.org/waterlink/likes.svg?branch=master)](https://travis-ci.org/waterlink/likes)
+
 Give it a list of people and their likings and it will tell what else could these people like.
 
 This is a ruby gem.

data/lib/likes.rb

@@ -1,4 +1,6 @@
 require "likes/version"
+require "likes/support"
+require "likes/engines"
 require "likes/like"
 require "likes/set"
 

data/lib/likes/engines.rb

@@ -0,0 +1,9 @@
+require "likes/engines/protocol"
+require "likes/engines/best_intersection_size"
+require "likes/engines/best_relative_intersection_size"
+require "likes/engines/fast_jaccard_similarity"
+
+module Links
+  module Engines
+  end
+end

data/lib/likes/engines/best_intersection_size.rb

@@ -0,0 +1,151 @@
+module Likes
+  module Engines
+    # Job: Understands which items could be recommended
+    #
+    # Calculates intersection sizes to all other person likings and
+    # chooses maximum
+    #
+    # Worst approximation of execution time:
+    #
+    # Given K = how much likes target person has, in reasonable
+    # situations it is not very big number. But in theory can be as
+    # high as P
+    #
+    # Given N = how much distinct people we have
+    #
+    # Given P = how much distinct items we have
+    #
+    # Complexity: O(NK) * O(hash operations ~ log N + log P)
+    #
+    # @see BestRelativeIntersectionSize
+    class BestIntersectionSize
+
+      # Creates new instance of BestIntersectionSize engine
+      #
+      # @param [Person#==] person The person to provide
+      #   recommendations for
+      # @param [Hash<Person, Array<Item>>] likes_of Input data in form
+      #   of map person => [item]
+      # @param [Hash<Item, Array<Person>>] liked Input data in form of
+      #   map item => [person]
+      #
+      # @param [Factory<Intersections>#new(Person)]
+      #   intersections_factory Knows how to find best intersection
+      #   candidates
+      def initialize(person, likes_of, liked, intersections_factory=Intersections)
+        @intersections = intersections_factory.build(person)
+        @likes_of = likes_of
+        @liked = liked
+        @its_likes = likes_of.fetch(person)
+        add_similar_tastes
+      end
+
+      # Solves the problem and returns recommendation list
+      #
+      # @return [Array<Item>] Returns list of recommended items
+      def solve
+        solution_candidate(intersections.next_people_with_similar_tastes)
+      end
+
+      private
+
+      attr_reader :intersections, :likes_of, :liked, :its_likes
+
+      def solution_candidate(candidates)
+        return [] if candidates.empty?
+        non_empty_solution(_solution_candidate(candidates))
+      end
+
+      def _solution_candidate(candidates)
+        candidates.map { |other_person, _|
+          likes_of.fetch(other_person) - its_likes
+        }.flatten.uniq
+      end
+
+      def non_empty_solution(solution)
+        return solve if solution.empty?
+        solution
+      end
+
+      def add_similar_tastes
+        its_likes.each do |item|
+          intersections.add_similar_tastes(liked.fetch(item))
+        end
+      end
+
+      # @private
+      # Job: Null object for size transformation logic
+      class NullSizeTransform
+        def call(_, size)
+          size
+        end
+
+        alias_method :[], :call
+      end
+
+      # @private
+      # Job: Understands similar tastes
+      class Intersections
+        NO_LIMIT = Object.new.freeze
+
+        def self.build(person)
+          new(person, NullSizeTransform.new)
+        end
+
+        def initialize(person, size_transform)
+          @sizes = {}
+          @person = person
+          @best_size = NO_LIMIT
+          @size_transform = size_transform
+        end
+
+        def add_similar_tastes(people)
+          people.each do |other_person|
+            next if person == other_person
+            sizes[other_person] = sizes.fetch(other_person, 0) + 1
+          end
+        end
+
+        def next_people_with_similar_tastes
+          candidates_with(next_best_size)
+        end
+
+        private
+
+        attr_reader :sizes, :person, :best_size, :size_transform
+
+        def candidates_with(intersection_size)
+          return [] if no_limit?(intersection_size)
+          transformed_sizes.select { |_, size|
+            Support::FloatWithError.new(intersection_size) == size
+          }
+        end
+
+        def next_best_size
+          @best_size = get_best_size(best_size)
+        end
+
+        def get_best_size(limit)
+          transformed_sizes.
+            select { |_, size| in_limit?(size, limit) }.
+            map { |_, size| size }.max || NO_LIMIT
+        end
+
+        def transformed_sizes
+          @_transformed_sizes ||= Hash[sizes.map { |person, size|
+            [person, size_transform[person, size]]
+          }]
+        end
+
+        def in_limit?(size, limit)
+          return true if no_limit?(limit)
+          size < limit
+        end
+
+        def no_limit?(limit)
+          NO_LIMIT == limit
+        end
+      end
+    end
+  end
+end

data/lib/likes/engines/best_relative_intersection_size.rb

@@ -0,0 +1,106 @@
+require "likes/engines/best_intersection_size"
+
+module Likes
+  module Engines
+    # Job: Understands which items could be recommended
+    #
+    # Calculates relative intersection sizes to all other person
+    # likings and chooses maximum. This is Jaccard Similarity of Sets
+    # algorithm implementation
+    #
+    # Relative intersection size = intersection size / union size
+    #
+    # Worst approximation of execution time:
+    #
+    # Given K = how much likes target person has, in reasonable
+    # situations it is not very big number. But in theory can be as
+    # high as P
+    #
+    # Given P = how much distinct items we have
+    #
+    # Given N = how much distinct people we have
+    #
+    # Complexity: O(NK) * O(hash operations ~ log N + log P)
+    #
+    # @see BestIntersectionSize
+    class BestRelativeIntersectionSize
+
+      # Creates new instance of BestRelativeIntersectionSize engine
+      #
+      # @param [Person#==] person The person to provide
+      #   recommendations for
+      # @param [Hash<Person, Array<Item>>] likes_of Input data in form
+      #   of map person => [item]
+      # @param [Hash<Item, Array<Person>>] liked Input data in form of
+      #   map item => [person]
+      def initialize(person, likes_of, liked)
+        @delegatee = BestIntersectionSize.new(
+          person,
+          likes_of,
+          liked,
+          RelativeIntersectionsFactory.new(likes_of)
+        )
+      end
+
+      # Solves the problem and returns recommendation list
+      #
+      # @return [Array<Item>] Returns list of recommended items
+      def solve
+        delegatee.solve
+      end
+
+      private
+
+      attr_reader :delegatee
+
+      # @private
+      # Job: Understands how needs of Intersections with relative
+      # logic
+      class RelativeIntersectionsFactory
+        def initialize(likes_of)
+          @sets_sizes = Hash[likes_of.map { |person, items| [person, items.size] }]
+        end
+
+        def build(person)
+          BestIntersectionSize::Intersections.new(person, size_transform(person))
+        end
+
+        private
+
+        attr_reader :sets_sizes
+
+        def size_transform(person)
+          RelativeSizeTransform.new(person, sets_sizes)
+        end
+      end
+
+      # @private
+      # Job: Understands conversion between absolute and relative
+      # intersection sizes
+      class RelativeSizeTransform
+        def initialize(person, sets_sizes)
+          @person = person
+          @sets_sizes = sets_sizes
+        end
+
+        def call(other_person, intersection_size)
+          1.0 * intersection_size / union_size(other_person)
+        end
+
+        alias_method :[], :call
+
+        private
+
+        attr_reader :person, :sets_sizes
+
+        def union_size(other_person)
+          sets_sizes[other_person] + own_size
+        end
+
+        def own_size
+          @_own_size ||= sets_sizes[person]
+        end
+      end
+    end
+  end
+end

data/lib/likes/engines/fast_jaccard_similarity.rb

@@ -0,0 +1,159 @@
+module Likes
+  module Engines
+    # Job: Understands which items could be recommended
+    #
+    # Calculates Minhash Signatures and uses them to give approximate
+    # relative intersection size. Returns recommendations from best
+    # approximate relative intersection sizes
+    #
+    # Relative intersection size = intersection size / union size
+    #
+    # Worst approximation of execution time:
+    #
+    # Given P = how much distinct items we have
+    #
+    # Given N = how much distinct people we have
+    #
+    # Given D = depth of this implementation - maximum count of hash functions (~100)
+    #
+    # Complexity: O(ND + PD) * O(hash operations ~ log N + log P) ~ O(N * log N)
+    # @ignore has a lot of memoization :reek:TooManyInstanceVariables
+    class FastJaccardSimilarity
+
+      MAX_HASH_FUNCTIONS_COUNT = 200
+      ALLOW_FLUCTUATION = 1.075
+      INFINITY = 1.0 / 0
+
+      # Creates new instance of FastJaccardSimilarity engine
+      #
+      # @param [Person#==] person The person to provide
+      #   recommendations for
+      # @param [Hash<Person, Array<Item>>] likes_of Input data in form
+      #   of map person => [item]
+      # @param [Hash<Item, Array<Person>>] liked Input data in form of
+      #   map item => [person]
+      def initialize(person, likes_of, liked)
+        @person = person
+        @likes_of = likes_of
+        @liked = liked
+        @items = liked.keys
+        @people = likes_of.keys
+      end
+
+      # Solves the problem and returns recommendation list
+      #
+      # @return [Array<Item>] Returns list of recommended items
+      def solve
+        init_signature
+        compute_hashes
+        compute_signature
+        recommendations
+      end
+
+      private
+
+      attr_reader :person, :likes_of, :liked, :items, :people,
+        :signature, :hash_functions, :hashes
+
+      def init_signature
+        @signature = (0...MAX_HASH_FUNCTIONS_COUNT).map {
+          Array.new(people.count, INFINITY)
+        }
+      end
+
+      def own_column
+        @_own_column ||= people.index(person)
+      end
+
+      def similarities
+        @_similarities ||= people.
+                         each_with_index.
+                         inject({person => -1}) do |similarities, (other_person, column)|
+          if person != other_person
+            similarities[other_person] = relative_similarity(similarity_for(column), other_person)
+          end
+          similarities
+        end
+      end
+
+      def similarity_for(column)
+        signature.each_with_index.select { |signature_row, index|
+          signature_row[column] == signature_row[own_column]
+        }.count
+      end
+
+      def relative_similarity(similarity, other_person)
+        1.0 * similarity / union_size(other_person)
+      end
+
+      def union_size(other_person)
+        own_likes_count + likes_of.fetch(other_person).count
+      end
+
+      def own_likes
+        @_own_likes ||= likes_of.fetch(person)
+      end
+
+      def own_likes_count
+        @_own_likes_count ||= own_likes.count
+      end
+
+      def best_similarity
+        similarities.values.max
+      end
+
+      def candidates
+        Hash[similarities.select { |_, similarity|
+          best_similarity <= similarity * ALLOW_FLUCTUATION
+        }].keys
+      end
+
+      def recommendations
+        candidates.map { |other_person, _|
+          likes_of.fetch(other_person) - own_likes
+        }.flatten.uniq
+      end
+
+      # Full complexity: D * O(likeset size * log N) ~ O(N log N) with big constant
+      def compute_signature
+        each_like do |_, _, row, column|
+          signature_step(row, column)
+        end
+      end
+
+      # Complexity: O(likeset size) * O(log N) ~ O(N log N)
+      def each_like(&blk)
+        items.each_with_index do |item, row|
+          each_column_of_likes(item, row, &blk)
+        end
+      end
+
+      def each_column_of_likes(item, row, &blk)
+        # only columns with 1 in matrix:
+        liked.fetch(item).each_with_index do |person, column|
+          blk[item, person, row, column]
+        end
+      end
+
+      # Complexity: D * O(1)
+      def signature_step(row, column)
+        signature.each_with_index do |signature_row, index|
+          signature_row[column] = [signature_row[column], hashes[index][row]].min
+        end
+      end
+
+      def compute_hashes
+        @hashes = hash_functions.map { |function|
+          function.map(0...items.count)
+        }
+      end
+
+      def hash_functions
+        @_hash_functions ||= Support::HashFunction.sample(
+          MAX_HASH_FUNCTIONS_COUNT,
+          items.count
+        )
+      end
+    end
+  end
+end

data/lib/likes/engines/protocol.rb

@@ -0,0 +1,34 @@
+module Likes
+  module Engines
+    # @abstract
+    # Defines protocol which any Engine should support
+    class Protocol
+
+      # @ignore :reek:UnusedParameters
+      # Creates new instance of engine
+      #
+      # @param [Person#==] person The person to provide
+      #   recommendations for
+      # @param [Hash<Person, Array<Item>>] likes_of Input data in form
+      #   of map person => [item]
+      # @param [Hash<Item, Array<Person>>] liked Input data in form of
+      #   map item => [person]
+      def initialize(person, likes_of, liked)
+        abstract
+      end
+
+      # Solves the problem and returns recommendation list
+      #
+      # @return [Array<Item>] Returns list of recommended items
+      def solve
+        abstract
+      end
+
+      private
+
+      def abstract
+        raise NotImplementedError.new("Likes::Engines::Protocol is abstract")
+      end
+    end
+  end
+end

data/lib/likes/set.rb

@@ -1,11 +1,20 @@
 module Likes
   # Job: Understands patterns in people likings
   class Set
+    # Default engine - simplest one
+    #
+    # @see Engines::BestIntersectionSize
+    DEFAULT_ENGINE = Engines::BestIntersectionSize
+
     # Creates new instance of Set
     #
     # @param [Array<Like>] likes List of likes
-    def initialize(likes)
+    # @param [Engines::Protocol] engine Recommendation engine to use
+    #
+    # @see Engines
+    def initialize(likes, engine=DEFAULT_ENGINE)
       @likes = likes
+      @engine = engine
       build_likes_of
       build_liked
     end
@@ -13,29 +22,20 @@ module Likes
     # Provides list of recommendations for person based on this
     # likeset
     #
-    # Should handle amount of distinct persons <= 10**6 and amount of
+    # Should handle amount of distinct people <= 10**6 and amount of
     # distinct items <= 10**6, but likeset length is <= 10**7, ie it
     # is advised to use only recent likes (couple of weeks or month)
     #
-    # Worst approximation of execution time:
-    #
-    # Given K = how much likes target person has, in reasonable
-    #   situations it is not very big number
-    #
-    # Given N = how much distinct persons we have
-    #
-    # Complexity: O(NK)
-    #
     # @param [Person#==] person The person to provide recommendations
     #   for
     # @return [Array<Item>] List of recommendations for the person
     def recommendations_for(person)
-      Recommendations.new(person, likes_of, liked).solve
+      engine.new(person, likes_of, liked).solve
     end
 
     private
 
-    attr_accessor :likes, :likes_of, :liked
+    attr_accessor :likes, :engine, :likes_of, :liked
 
     def build_likes_of
       @likes_of = {}
@@ -50,98 +50,5 @@ module Likes
         like.add_person_to_map(liked)
       end
     end
-
-    # @private
-    # Job: Understands which items could be recommended
-    class Recommendations
-      def initialize(person, likes_of, liked)
-        @intersections = Intersections.new(person)
-        @likes_of = likes_of
-        @liked = liked
-        @its_likes = likes_of.fetch(person)
-        add_similar_tastes
-      end
-
-      def solve
-        solution_candidate(intersections.next_people_with_similar_tastes)
-      end
-
-      private
-
-      attr_reader :intersections, :likes_of, :liked, :its_likes
-
-      def solution_candidate(candidates)
-        return [] if candidates.empty?
-        non_empty_solution(_solution_candidate(candidates))
-      end
-
-      def _solution_candidate(candidates)
-        candidates.map { |other_person, _|
-          likes_of.fetch(other_person) - its_likes
-        }.flatten.uniq
-      end
-
-      def non_empty_solution(solution)
-        return solve if solution.empty?
-        solution
-      end
-
-      def add_similar_tastes
-        its_likes.each do |item|
-          intersections.add_similar_tastes(liked.fetch(item))
-        end
-      end
-    end
-
-    # @private
-    # Job: Understands similar tastes
-    class Intersections
-      NO_LIMIT = Object.new.freeze
-
-      def initialize(person)
-        @sizes = {}
-        @person = person
-        @best_size = NO_LIMIT
-      end
-
-      def add_similar_tastes(people)
-        people.each do |other_person|
-          next if person == other_person
-          sizes[other_person] = sizes.fetch(other_person, 0) + 1
-        end
-      end
-
-      def next_people_with_similar_tastes
-        candidates_with(next_best_size)
-      end
-
-      private
-
-      attr_reader :sizes, :person
-
-      def candidates_with(intersection_size)
-        return [] if no_limit?(intersection_size)
-        sizes.select { |_, size| intersection_size == size }
-      end
-
-      def next_best_size
-        @best_size = get_best_size(@best_size)
-      end
-
-      def get_best_size(limit)
-        sizes
-          .select { |_, size| in_limit?(size, limit) }
-          .map { |_, size| size }.max || NO_LIMIT
-      end
-
-      def in_limit?(size, limit)
-        return true if no_limit?(limit)
-        size < limit
-      end
-
-      def no_limit?(limit)
-        NO_LIMIT == limit
-      end
-    end
   end
 end

data/lib/likes/support.rb

@@ -0,0 +1,68 @@
+PrimeFactory = if RUBY_VERSION.to_f > 1.8
+  require "prime"
+  Prime
+else
+  require "mathn"
+  Prime.new
+end
+
+module Likes
+  module Support
+    # @private
+    # Job: Understands float comparision in computer world
+    class FloatWithError
+      ALLOWED_ERROR = 1e-9
+
+      def self.lift(value)
+        return value if FloatWithError === value
+        FloatWithError.new(value)
+      end
+
+      def initialize(value)
+        @value = value
+      end
+
+      def ==(other)
+        (self.value - FloatWithError.lift(other).value).abs < ALLOWED_ERROR
+      end
+
+      protected
+
+      attr_accessor :value
+    end
+
+    # @private
+    # Job: Understands random hash function generation
+    class HashFunction
+      PRIMES = PrimeFactory.first(3200)[-250..-1]
+
+      def self.sample(count, modulo)
+        (0...count).map { new(*(sample_primes(2) + [modulo])) }
+      end
+
+      def initialize(factor, constant, modulo)
+        @factor, @constant, @modulo = factor, constant, modulo
+      end
+
+      def call(value)
+        (factor * value + constant) % modulo
+      end
+
+      def map(values)
+        values.map { |value| call(value) }
+      end
+
+      private
+
+      attr_accessor :factor, :constant, :modulo
+
+      def self.sample_primes(count)
+        if RUBY_VERSION.to_f > 1.8
+          PRIMES.sample(count)
+        else
+          (0...count).map { PRIMES.choice }
+        end
+      end
+    end
+  end
+end

data/lib/likes/version.rb

@@ -1,3 +1,3 @@
 module Likes
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/fixtures.rb

@@ -0,0 +1,107 @@
+# @ignore :reek:UtilityFunction
+module Fixtures
+  class << self
+    def small_likeset
+      [
+        Likes::Like.new(:person => 1, :item => 5),
+
+        Likes::Like.new(:person => 3, :item => 5),
+        Likes::Like.new(:person => 3, :item => 4),
+      ]
+    end
+
+    def small_likeset_likes_of
+      {
+        1 => [5],
+        3 => [5, 4],
+      }
+    end
+
+    def small_likeset_liked
+      {
+        5 => [1, 3],
+        4 => [3],
+      }
+    end
+
+    def regular_likeset
+      [
+        Likes::Like.new(:person => 1, :item => 1),
+        Likes::Like.new(:person => 1, :item => 5),
+        Likes::Like.new(:person => 1, :item => 4),
+        Likes::Like.new(:person => 1, :item => 7),
+        Likes::Like.new(:person => 1, :item => 19),
+
+        Likes::Like.new(:person => 2, :item => 1),
+        Likes::Like.new(:person => 2, :item => 3),
+        Likes::Like.new(:person => 2, :item => 5),
+        Likes::Like.new(:person => 2, :item => 4),
+
+        Likes::Like.new(:person => 3, :item => 3),
+        Likes::Like.new(:person => 3, :item => 2),
+        Likes::Like.new(:person => 3, :item => 5),
+        Likes::Like.new(:person => 3, :item => 4),
+        Likes::Like.new(:person => 3, :item => 9),
+      ]
+    end
+
+    def best_intersection_candidate_has_no_other_likings
+      [
+        Likes::Like.new(:person => 1, :item => 1),
+        Likes::Like.new(:person => 1, :item => 5),
+        Likes::Like.new(:person => 1, :item => 4),
+        Likes::Like.new(:person => 1, :item => 7),
+
+        Likes::Like.new(:person => 2, :item => 1),
+        Likes::Like.new(:person => 2, :item => 3),
+        Likes::Like.new(:person => 2, :item => 5),
+        Likes::Like.new(:person => 2, :item => 4),
+
+        Likes::Like.new(:person => 4, :item => 1),
+        Likes::Like.new(:person => 4, :item => 5),
+        Likes::Like.new(:person => 4, :item => 4),
+        Likes::Like.new(:person => 4, :item => 7),
+
+        Likes::Like.new(:person => 3, :item => 3),
+        Likes::Like.new(:person => 3, :item => 2),
+        Likes::Like.new(:person => 3, :item => 5),
+        Likes::Like.new(:person => 3, :item => 4),
+        Likes::Like.new(:person => 3, :item => 9),
+      ]
+    end
+
+    def there_is_nothing_to_recommend
+      [
+        Likes::Like.new(:person => 1, :item => 1),
+        Likes::Like.new(:person => 1, :item => 5),
+        Likes::Like.new(:person => 1, :item => 4),
+        Likes::Like.new(:person => 1, :item => 7),
+
+        Likes::Like.new(:person => 4, :item => 1),
+        Likes::Like.new(:person => 4, :item => 5),
+        Likes::Like.new(:person => 4, :item => 7),
+      ]
+    end
+
+    def somebody_likes_literally_everything
+      [
+        Likes::Like.new(:person => 1, :item => 1),
+        Likes::Like.new(:person => 1, :item => 5),
+
+        Likes::Like.new(:person => 2, :item => 1),
+        Likes::Like.new(:person => 2, :item => 3),
+        Likes::Like.new(:person => 2, :item => 5),
+        Likes::Like.new(:person => 2, :item => 4),
+        Likes::Like.new(:person => 2, :item => 17),
+        Likes::Like.new(:person => 2, :item => 6),
+        Likes::Like.new(:person => 2, :item => 19),
+        Likes::Like.new(:person => 2, :item => 7),
+        Likes::Like.new(:person => 2, :item => 9),
+
+        Likes::Like.new(:person => 3, :item => 5),
+        Likes::Like.new(:person => 3, :item => 4),
+        Likes::Like.new(:person => 3, :item => 9),
+      ]
+    end
+  end
+end

data/spec/likes/engines/best_intersection_size_spec.rb

@@ -0,0 +1,44 @@
+module Likes
+  RSpec.describe "Set with Likes::Engines::BestIntersectionSize" do
+    let(:engine) { Engines::BestIntersectionSize }
+
+    let(:raw_likeset) { Fixtures.regular_likeset }
+    let(:likeset) { Set.new(raw_likeset, engine) }
+
+    describe "#recommendations_for" do
+      it "returns a list of items" do
+        expect(likeset.recommendations_for(1)).to be_a(Array)
+      end
+
+      it "returns right recommendations" do
+        expect(likeset.recommendations_for(1).sort).to eq([3])
+        expect(likeset.recommendations_for(2).sort).to eq([2, 7, 9, 19])
+        expect(likeset.recommendations_for(3).sort).to eq([1])
+      end
+
+      context "when somebody literally likes everything" do
+        let(:raw_likeset) { Fixtures.somebody_likes_literally_everything }
+
+        it "chooses this person as a candidate for recommendations" do
+          expect(likeset.recommendations_for(1).sort).to eq([3, 4, 6, 7, 9, 17, 19])
+        end
+      end
+
+      context "when there is an identic match with other person" do
+        let(:raw_likeset) { Fixtures.best_intersection_candidate_has_no_other_likings }
+
+        it "ignores identical candidates" do
+          expect(likeset.recommendations_for(1).sort).to eq([3])
+        end
+      end
+
+      context "when there is nothing to recommend" do
+        let(:raw_likeset) { Fixtures.there_is_nothing_to_recommend }
+
+        it "returns an empty solution" do
+          expect(likeset.recommendations_for(1).sort).to eq([])
+        end
+      end
+    end
+  end
+end

data/spec/likes/engines/best_relative_intersection_size_spec.rb

@@ -0,0 +1,44 @@
+module Likes
+  RSpec.describe "Set with Likes::Engines::BestRelativeIntersectionSize" do
+    let(:engine) { Engines::BestRelativeIntersectionSize }
+
+    let(:raw_likeset) { Fixtures.regular_likeset }
+    let(:likeset) { Set.new(raw_likeset, engine) }
+
+    describe "#recommendations_for" do
+      it "returns a list of items" do
+        expect(likeset.recommendations_for(1)).to be_a(Array)
+      end
+
+      it "returns right recommendations" do
+        expect(likeset.recommendations_for(1).sort).to eq([3])
+        expect(likeset.recommendations_for(2).sort).to eq([2, 7, 9, 19])
+        expect(likeset.recommendations_for(3).sort).to eq([1])
+      end
+
+      context "when somebody literally likes everything" do
+        let(:raw_likeset) { Fixtures.somebody_likes_literally_everything }
+
+        it "doesn't choose this person as a candidate for recommendations" do
+          expect(likeset.recommendations_for(1).sort).to eq([4, 9])
+        end
+      end
+
+      context "when there is an identic match with other person" do
+        let(:raw_likeset) { Fixtures.best_intersection_candidate_has_no_other_likings }
+
+        it "ignores identical candidates" do
+          expect(likeset.recommendations_for(1).sort).to eq([3])
+        end
+      end
+
+      context "when there is nothing to recommend" do
+        let(:raw_likeset) { Fixtures.there_is_nothing_to_recommend }
+
+        it "returns an empty solution" do
+          expect(likeset.recommendations_for(1).sort).to eq([])
+        end
+      end
+    end
+  end
+end

data/spec/likes/engines/fast_jaccard_similarity_spec.rb

@@ -0,0 +1,44 @@
+module Likes
+  RSpec.describe "Set with Likes::Engines::FastJaccardSimilarity" do
+    let(:engine) { Engines::FastJaccardSimilarity }
+
+    let(:raw_likeset) { Fixtures.regular_likeset }
+    let(:likeset) { Set.new(raw_likeset, engine) }
+
+    describe "#recommendations_for" do
+      it "returns a list of items" do
+        expect(likeset.recommendations_for(1)).to be_a(Array)
+      end
+
+      it "returns right recommendations" do
+        expect(likeset.recommendations_for(1).sort).to eq([3])
+        expect(likeset.recommendations_for(2).sort).to eq([2, 7, 9, 19]).or eq([7, 19]).or eq([2, 9])
+        expect(likeset.recommendations_for(3).sort).to eq([1])
+      end
+
+      context "when somebody literally likes everything" do
+        let(:raw_likeset) { Fixtures.somebody_likes_literally_everything }
+
+        it "possibly can choose this person as a candidate for recommendations" do
+          expect(likeset.recommendations_for(1).sort).to eq([4, 9]).or eq([3, 4, 6, 7, 9, 17, 19])
+        end
+      end
+
+      context "when there is an identic match with other person" do
+        let(:raw_likeset) { Fixtures.best_intersection_candidate_has_no_other_likings }
+
+        it "ignores identical candidates" do
+          expect(likeset.recommendations_for(1).sort).to eq([3])
+        end
+      end
+
+      context "when there is nothing to recommend" do
+        let(:raw_likeset) { Fixtures.there_is_nothing_to_recommend }
+
+        it "returns an empty solution" do
+          expect(likeset.recommendations_for(1).sort).to eq([])
+        end
+      end
+    end
+  end
+end

data/spec/likes/like_spec.rb

@@ -2,44 +2,44 @@ module Likes
   RSpec.describe Like do
     describe "creation" do
       it "can be created with person and item" do
-        expect(Like.new(person: 1, item: 2)).to be_a(Like)
+        expect(Like.new(:person => 1, :item => 2)).to be_a(Like)
       end
 
       it "cannot be created without person and/or item" do
-        expect { Like.new(person: 1) }.to raise_error(ArgumentError, /item is required/)
-        expect { Like.new(item: 2) }.to raise_error(ArgumentError, /person is required/)
+        expect { Like.new(:person => 1) }.to raise_error(ArgumentError, /item is required/)
+        expect { Like.new(:item => 2) }.to raise_error(ArgumentError, /person is required/)
         expect { Like.new }.to raise_error(ArgumentError, /is required/)
       end
 
       it "ignores excessive attributes" do
-        expect(Like.new(person: 1, item: 3, hello: "world")).to eq(Like.new(person: 1, item: 3))
+        expect(Like.new(:person => 1, :item => 3, :hello => "world")).to eq(Like.new(:person => 1, :item => 3))
       end
     end
 
     describe "encapsulation" do
       it "does not allow to access its data" do
-        expect { Like.new(person: 1, item: 2).person }.to raise_error(NoMethodError)
-        expect { Like.new(person: 1, item: 2).person = 3 }.to raise_error(NoMethodError)
+        expect { Like.new(:person => 1, :item => 2).person }.to raise_error(NoMethodError)
+        expect { Like.new(:person => 1, :item => 2).person = 3 }.to raise_error(NoMethodError)
 
-        expect { Like.new(person: 1, item: 2).item }.to raise_error(NoMethodError)
-        expect { Like.new(person: 1, item: 2).item = 3 }.to raise_error(NoMethodError)
+        expect { Like.new(:person => 1, :item => 2).item }.to raise_error(NoMethodError)
+        expect { Like.new(:person => 1, :item => 2).item = 3 }.to raise_error(NoMethodError)
       end
     end
 
     describe "equality" do
       it "is equal to another like with same person and item" do
-        expect(Like.new(person: 1, item: 2)).to eq(Like.new(person: 1, item: 2))
+        expect(Like.new(:person => 1, :item => 2)).to eq(Like.new(:person => 1, :item => 2))
       end
 
       it "is not equal to another like with different person and/or item" do
-        expect(Like.new(person: 1, item: 2)).not_to eq(Like.new(person: 3, item: 2))
-        expect(Like.new(person: 1, item: 2)).not_to eq(Like.new(person: 1, item: 5))
-        expect(Like.new(person: 1, item: 2)).not_to eq(Like.new(person: 2, item: 4))
+        expect(Like.new(:person => 1, :item => 2)).not_to eq(Like.new(:person => 3, :item => 2))
+        expect(Like.new(:person => 1, :item => 2)).not_to eq(Like.new(:person => 1, :item => 5))
+        expect(Like.new(:person => 1, :item => 2)).not_to eq(Like.new(:person => 2, :item => 4))
       end
 
       it "is not equal to different objects" do
-        expect(Like.new(person: 1, item: 2)).not_to eq(nil)
-        expect(Like.new(person: 1, item: 2)).not_to eq(Object.new)
+        expect(Like.new(:person => 1, :item => 2)).not_to eq(nil)
+        expect(Like.new(:person => 1, :item => 2)).not_to eq(Object.new)
       end
     end
   end

data/spec/likes/set_spec.rb

@@ -1,84 +1,27 @@
 module Likes
   RSpec.describe Set do
-    let(:likeset) {
-      Likes::Set.new([
-        Likes::Like.new(person: 1, item: 1),
-        Likes::Like.new(person: 1, item: 5),
-        Likes::Like.new(person: 1, item: 4),
-        Likes::Like.new(person: 1, item: 7),
+    let(:engine) { class_double(Engines::Protocol) }
+    let(:engine_instance) { instance_double(Engines::Protocol) }
 
-        Likes::Like.new(person: 2, item: 1),
-        Likes::Like.new(person: 2, item: 3),
-        Likes::Like.new(person: 2, item: 5),
-        Likes::Like.new(person: 2, item: 4),
+    let(:raw_likeset) { Fixtures.small_likeset }
+    let(:likeset) { Set.new(raw_likeset, engine) }
 
-        Likes::Like.new(person: 3, item: 3),
-        Likes::Like.new(person: 3, item: 2),
-        Likes::Like.new(person: 3, item: 5),
-        Likes::Like.new(person: 3, item: 4),
-        Likes::Like.new(person: 3, item: 9),
-      ])
-    }
+    let(:proper_likes_of) { Fixtures.small_likeset_likes_of }
+    let(:proper_liked) { Fixtures.small_likeset_liked }
 
     describe "#recommendations_for" do
-      it "returns a list of items" do
-        expect(likeset.recommendations_for(1)).to be_a(Array)
-      end
-
-      it "returns right recommendations" do
-        expect(likeset.recommendations_for(1).sort).to eq([3])
-        expect(likeset.recommendations_for(2).sort).to eq([2, 7, 9])
-        expect(likeset.recommendations_for(3).sort).to eq([1])
-      end
-
-      context "when there is an identic match with other person" do
-        let(:likeset) {
-          Likes::Set.new([
-            Likes::Like.new(person: 1, item: 1),
-            Likes::Like.new(person: 1, item: 5),
-            Likes::Like.new(person: 1, item: 4),
-            Likes::Like.new(person: 1, item: 7),
-
-            Likes::Like.new(person: 2, item: 1),
-            Likes::Like.new(person: 2, item: 3),
-            Likes::Like.new(person: 2, item: 5),
-            Likes::Like.new(person: 2, item: 4),
-
-            Likes::Like.new(person: 4, item: 1),
-            Likes::Like.new(person: 4, item: 5),
-            Likes::Like.new(person: 4, item: 4),
-            Likes::Like.new(person: 4, item: 7),
-
-            Likes::Like.new(person: 3, item: 3),
-            Likes::Like.new(person: 3, item: 2),
-            Likes::Like.new(person: 3, item: 5),
-            Likes::Like.new(person: 3, item: 4),
-            Likes::Like.new(person: 3, item: 9),
-          ])
-        }
-
-        it "ignores identical candidates" do
-          expect(likeset.recommendations_for(1).sort).to eq([3])
-        end
-      end
+      let(:person) { double("Person") }
+      let(:solution) { double("Solution") }
 
-      context "when there is nothing to recommend" do
-        let(:likeset) {
-          Likes::Set.new([
-            Likes::Like.new(person: 1, item: 1),
-            Likes::Like.new(person: 1, item: 5),
-            Likes::Like.new(person: 1, item: 4),
-            Likes::Like.new(person: 1, item: 7),
+      it "builds proper likes_of and liked and delegates solution to engine instance" do
+        expect(engine).
+          to receive(:new).
+          with(person, proper_likes_of, proper_liked).
+          and_return(engine_instance)
 
-            Likes::Like.new(person: 4, item: 1),
-            Likes::Like.new(person: 4, item: 5),
-            Likes::Like.new(person: 4, item: 7),
-          ])
-        }
+        expect(engine_instance).to receive(:solve).and_return(solution)
 
-        it "returns an empty solution" do
-          expect(likeset.recommendations_for(1).sort).to eq([])
-        end
+        expect(likeset.recommendations_for(person)).to eq(solution)
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 require "likes"
+require "./spec/fixtures"
 
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: likes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alexey Fedorov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-18 00:00:00.000000000 Z
+date: 2015-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -48,15 +48,26 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/likes.rb
+- lib/likes/engines.rb
+- lib/likes/engines/best_intersection_size.rb
+- lib/likes/engines/best_relative_intersection_size.rb
+- lib/likes/engines/fast_jaccard_similarity.rb
+- lib/likes/engines/protocol.rb
 - lib/likes/like.rb
 - lib/likes/set.rb
+- lib/likes/support.rb
 - lib/likes/version.rb
 - likes.gemspec
+- spec/fixtures.rb
+- spec/likes/engines/best_intersection_size_spec.rb
+- spec/likes/engines/best_relative_intersection_size_spec.rb
+- spec/likes/engines/fast_jaccard_similarity_spec.rb
 - spec/likes/like_spec.rb
 - spec/likes/set_spec.rb
 - spec/spec_helper.rb
@@ -86,6 +97,10 @@ specification_version: 4
 summary: Give it a list of people and their likings and it will tell what else could
   these people like.
 test_files:
+- spec/fixtures.rb
+- spec/likes/engines/best_intersection_size_spec.rb
+- spec/likes/engines/best_relative_intersection_size_spec.rb
+- spec/likes/engines/fast_jaccard_similarity_spec.rb
 - spec/likes/like_spec.rb
 - spec/likes/set_spec.rb
 - spec/spec_helper.rb