predictable 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NjNkNTE5YTc1NjA5MDEyNjc4YTk1NDViMThmYjBiZjY5ZDkzNTQ3Ng==
+  data.tar.gz: !binary |-
+    MmY0YmRmMjgxZDhhMjU1OTBjMjhkYmMwMjc2YjM3YmMyYjA3MGQ2NA==
+SHA512:
+  metadata.gz: !binary |-
+    NWI0NGUzYjkyZThjMzY5ZWEwODA1YmIzMTg3ZjQ4NDUzZGM1OWExOWRmNzVm
+    NzhlOTJjNWYxMjAxMWU1MTk2NzY2YmQ2NzExMDM1OWIyYjFiYTExYzcwMWYz
+    M2RjODllNDRjMjBkZGNmZDFmODlmMzdhYzQxY2I0OTJiMmYyNDc=
+  data.tar.gz: !binary |-
+    YjBkZjExNGRhYzU2NjU3NjUxYTMzMmY4NzYzYzAyNDE1MzY4OGYxYjlhMjM2
+    MzY3MDViYTkyYWMyMzJmYzZkZTI0NTc4MDBmMTJiMTEzYzRjYmExYzRmOTgw
+    NTk3NGU5MWEyMjY3MjY1YmNmZjJjODY2NDU1ZTJmMzA2OWE4ZDY=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--colour --require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in predictable.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 JS Boulanger
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# Predictable
+
+Predictable is a Ruby DSL for Prediction.io, an open source machine learning server built on top of Hadoop. It makes it easy to implement predictive features such as personalization, recommendations, and content discovery in your Ruby/Rails application.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'predictable'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install predictable
+
+## Usage
+
+Include Predictable::User in your application's User model.
+
+    class User < ActiveRecord::Base
+      include Predictable::User
+
+      ...
+    end
+
+    user = User.create(email: "js@perkhub.com")
+    user.add_to_recommender
+
+Include the Predictable::Item in the models of the items you want to recommend.
+
+    class Offer < ActiveRecord::Base
+      include Predictable::Item
+
+      after_create { add_to_recommender }
+      after_destroy { delete_from_recommender }
+
+      ...
+    end
+
+Get 10 recommended items for a user.
+
+    Offer.recommended_for(user)
+    current_user.recommended_offers.where("created_at > ?", 1.week.ago).limit(10)
+
+ Get 10 items most similar to an existing item.
+
+    Offer.similar_to(offer)
+
+
+  current_user.recommended_offers.limit(10)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/predictable.rb

@@ -0,0 +1,40 @@
+require "predictable/item"
+require "predictable/recommender"
+require "predictable/user"
+require "predictable/version"
+
+module Predictable
+  class << self
+    def default_config
+      {
+        :api_url     => "http://localhost:8000",
+        :threads     => 10,
+        :api_version => ""
+      }.dup
+    end
+
+    def client
+      @client ||= PredictionIO::Client.new(
+        config[:app_key],
+        config[:threads],
+        config[:api_url],
+        config[:api_version]
+      )
+    end
+
+    def config
+      @config ||= default_config
+    end
+
+    def config=(new_config)
+      config.merge!(new_config)
+    end
+
+    def engines
+      {
+        :recommendation_engine => config[:recommendation_engine],
+        :similarity_engine => config[:similarity_engine]
+      }
+    end
+  end
+end

data/lib/predictable/item.rb

@@ -0,0 +1,97 @@
+require 'active_support/concern'
+require 'active_support/inflector'
+
+module Predictable
+  # == Predictable Item Role
+  #
+  # Defines the Item role for the recommender. This module should
+  # be included in any model that represents items that will
+  # be recommended.
+  #
+  #   class Offer < ActiveRecord::Base
+  #     include Predictable::Item
+  #     ...
+  #   end
+  #
+  #   class Article < ActiveRecord::Base
+  #     include Predictable::Item
+  #     ...
+  #   end
+  #
+  module Item
+    extend ActiveSupport::Concern
+
+    included do
+      # if active_record? defined?(ActiveRecord::Base) && ancestors.include?(ActiveRecord::Base)
+      after_create { add_to_recommender }
+      after_destroy { delete_from_recommender }
+    end
+
+    # Returns the item id
+    def pio_iid
+      "#{self.class.pio_itype}-#{id}"
+    end
+
+    # Returns the item types
+    def pio_itypes
+      [self.class.pio_itype]
+    end
+
+    # Creates or updates the item in prediction.io
+    # When the item already exists, it updates it.
+    # The operation is done asynchronously.
+    def add_to_recommender(attrs={})
+      recommender.create_item(self, attrs)
+      nil
+    end
+
+    # Removes the item from prediction.io
+    # The operation is done asynchronously.
+    def delete_from_recommender
+      recommender.delete_item(self)
+      nil
+    end
+
+    protected
+
+    def recommender
+      self.class.recommender
+    end
+
+    module ClassMethods
+      attr_writer :pio_engines, :recommender
+
+      def pio_engines
+        @pio_engines || Predictable.engines
+      end
+
+      def recommender
+        @recommender ||= Recommender.new(Predictable.client, pio_engines)
+      end
+
+      def pio_itype
+        to_s.underscore
+      end
+
+      def recommended_for(user, opts = {})
+        options = { "itypes" => [pio_itype] }.merge(opts)
+        limit = options.delete("limit") || 10
+
+        item_ids = recommender.recommended_items(user, limit, options)
+        item_ids = item_ids.map { |id| id.gsub! /[^\d]/, '' }
+        where(:id => item_ids)
+      end
+
+      def similar_to(item, opts={})
+        options = opts.stringify_keys
+        options["pio_itypes"] ||= [pio_itype]
+        limit = options.delete("limit") || 10
+
+        item_ids = recommender.similar_items(item, limit, options)
+        item_ids = item_ids.map { |id| id.gsub! /[^\d]/, '' }
+        where(:id => item_ids)
+      end
+
+    end
+  end
+end

data/lib/predictable/recommender.rb

@@ -0,0 +1,72 @@
+require 'active_support/core_ext/hash/keys'
+require 'predictionio'
+
+module Predictable
+  # == Recommender
+  #
+  # Defines the Recommender interface and implements it using
+  # the Prediction.io API.
+  #
+  #   recommender = Recommender.new(client)
+  #   recommender.create_item(item)
+  #   recommender.create_user(user)
+  #   recommender.record_action(user, "conversion", item)
+  #   recommender.recommended_items(user, 10)
+  #
+  class Recommender
+    attr_reader :client
+    attr_accessor :recommendation_engine, :similarity_engine
+
+    def initialize(client, engines={})
+      @client = client
+      @recommendation_engine = engines[:recommendation_engine]
+      @similarity_engine = engines[:similarity_engine]
+    end
+
+    def create_item(item, attrs = {})
+      client.acreate_item(item.pio_iid, item.pio_itypes, attrs)
+    end
+
+    def delete_item(item)
+      client.adelete_item(item.pio_iid)
+    end
+
+    def create_user(user, attrs = {})
+      client.acreate_user(user.pio_uid, attrs)
+    end
+
+    def delete_user(user)
+      client.adelete_user(user.pio_uid)
+    end
+
+    def record_action(user, action, item, opts = {})
+      client.identify(user.pio_uid)
+      client.arecord_action_on_item(action.to_s, item.pio_iid, opts)
+    end
+
+    def recommended_items(user, n, opts = {})
+      options = opts.stringify_keys
+      client.identify(user.pio_uid)
+      begin
+        client.get_itemrec_top_n(recommendation_engine, n, opts)
+      rescue PredictionIO::Client::ItemRecNotFoundError => e
+        []
+      end
+    end
+
+    def similar_items(item, n, opts = {})
+      begin
+        client.get_itemsim_top_n(similarity_engine, item.pio_iid, n, opts)
+      rescue PredictionIO::Client::ItemSimNotFoundError
+        []
+      end
+    end
+
+  end
+end
+
+
+
+
+
+

data/lib/predictable/user.rb

@@ -0,0 +1,78 @@
+require 'active_support/concern'
+
+module Predictable
+  # == Predictable User Role
+  #
+  # Defines the User role for the recommender. This module should
+  # be included in the User model of the appliation.
+  #
+  #   class User < ActiveRecord::Base
+  #     include Predictable::User
+  #     ...
+  #   end
+  #
+  module User
+    extend ActiveSupport::Concern
+
+    included do
+      # if active_record? defined?(ActiveRecord::Base) && ancestors.include?(ActiveRecord::Base)
+      after_create { add_to_recommender }
+      after_destroy { delete_from_recommender }
+    end
+
+    # Returns the user id
+    def pio_uid
+      self.id
+    end
+
+    # Record a user action in the recommender.
+    # Actions cannot be overwritten or deleted in prediction.io
+    # The operation is done asynchronously.
+    #
+    #   user.record_action(:conversion, item)
+    #
+    def record_action(action, item, opts={})
+      recommender.record_action(self, action, item, opts)
+      nil
+    end
+
+    def record_conversion(item, opts={})
+      record_action(:conversion, item, opts)
+      nil
+    end
+
+    # Creates or updates a user in prediction.io
+    # When the user id already exists it updates the user.
+    # The operation is done asynchronously.
+    def add_to_recommender(attrs={})
+      recommender.create_user(self, attrs)
+      nil
+    end
+
+    # Removes the user from prediction.io.
+    # The operation is done asynchronously.
+    def delete_from_recommender
+      recommender.delete_user(self)
+      nil
+    end
+
+    protected
+
+    def recommender
+      self.class.recommender
+    end
+
+    module ClassMethods
+      attr_writer :pio_engines, :recommender
+
+      def pio_engines
+        @pio_engines || Predictable.engines
+      end
+
+      def recommender
+        @recommender ||= Recommender.new(Predictable.client, pio_engines)
+      end
+    end
+  end
+end
+

data/lib/predictable/version.rb

@@ -0,0 +1,3 @@
+module Predictable
+  VERSION = "0.0.1"
+end

data/predictable.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'predictable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "predictable"
+  spec.version       = Predictable::VERSION
+  spec.authors       = ["JS Boulanger"]
+  spec.email         = ["jsboulanger@gmail.com"]
+  spec.description   = "Ruby/Rails DSL for PredictionIO, an open source machine learning server."
+  spec.summary       = "Ruby/Rails DSL for PredictionIO"
+  spec.homepage      = "https://github.com/jsboulanger/predictable"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency('activerecord')
+  spec.add_dependency('predictionio')
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/predictable/item_spec.rb

@@ -0,0 +1,105 @@
+require 'ostruct'
+
+describe Predictable::Item do
+  let(:recommender) { Predictable::Recommender.new(double("Client").as_null_object) }
+
+  # TODO: Test with ActiveRecord::Base
+  class MyItem < OpenStruct # ActiveRecord::Base
+    include Predictable::Item
+
+    def self.where(args)
+      args[:id].map do |i|
+        self.new(:id => i.to_i)
+      end
+    end
+  end
+
+  let(:item) { MyItem.new(:id => 1) }
+  let(:user) { double("User", :pio_uid => 2) }
+
+  before do
+    MyItem.recommender = recommender
+  end
+  subject { item }
+
+  its(:pio_iid) { should == "my_item-#{item.id}" }
+  its(:pio_itypes) { should == ['my_item'] }
+
+  describe "#add_to_recommender" do
+    it "should create the item in the recommender" do
+      recommender.should_receive(:create_item).with(item, {})
+      item.add_to_recommender
+    end
+
+    it "should return nil" do
+      item.add_to_recommender.should be_nil
+    end
+  end
+
+  describe "#delete_from_recommender" do
+    it "should delete the item from the recommender" do
+      recommender.should_receive(:delete_item).with(item)
+      item.delete_from_recommender
+    end
+
+    it "should return nil" do
+      item.delete_from_recommender.should be_nil
+    end
+  end
+
+  describe ".recommended_for" do
+    it "should get recommended items from the recommender" do
+      recommender.should_receive(:recommended_items).with(user, 10, {"itypes" => ["my_item"] }).and_return []
+      MyItem.recommended_for(user, 10)
+    end
+
+    context "when there are recommendations" do
+      before do
+        recommender.stub(:recommended_items).and_return [item.pio_iid]
+      end
+
+      it "should return the recommended items" do
+        MyItem.recommended_for(user, 1).should == [item]
+      end
+    end
+
+    context "when there are no recommendations" do
+      before do
+        recommender.stub(:recommended_items).and_return []
+      end
+
+      it "should return an empty array" do
+        MyItem.recommended_for(user, 1).should == []
+      end
+    end
+  end
+
+  describe ".similar_to" do
+    let(:similar_item) { MyItem.new(:id => 1) }
+
+    it "should get similar items from the recommender" do
+      recommender.should_receive(:similar_items).with(item, 10, {"pio_itypes"=>["my_item"]}).and_return []
+      MyItem.similar_to(item, 10)
+    end
+
+    context "when there are similar items" do
+      before do
+        recommender.stub(:similar_items).and_return [similar_item.pio_iid]
+      end
+
+      it "should return the similar items" do
+        MyItem.similar_to(item, 10).should == [similar_item]
+      end
+    end
+
+    context "when there are no similar items" do
+      before do
+        recommender.stub(:similar_items).and_return []
+      end
+
+      it "should an empty array" do
+        MyItem.similar_to(item, 10).should == []
+      end
+    end
+  end
+end

data/spec/predictable/recommender_spec.rb

@@ -0,0 +1,122 @@
+describe Predictable::Recommender do
+  let(:client) { double("PredictionIO Client") }
+  let(:recommender) { Predictable::Recommender.new(client) }
+
+  let(:item) { double("Item", :pio_iid => "item-123", :pio_itypes => ["item"]) }
+
+  # TODO: item should behave as an item
+
+  describe "#create_item" do
+    it "should call the api" do
+      client.should_receive(:acreate_item)
+        .with("item-123", ["item"], {})
+      recommender.create_item(item)
+    end
+  end
+
+  describe "#delete_item" do
+    it "should call the api" do
+      client.should_receive(:adelete_item)
+        .with("item-123")
+      recommender.delete_item(item)
+    end
+  end
+
+  let(:user) { double("User", :pio_uid => "user-1") }
+  # TODO: user should behave as a user
+
+  describe "#create_user" do
+    it "should call the api" do
+      client.should_receive(:acreate_user)
+        .with("user-1", {})
+      recommender.create_user(user)
+    end
+  end
+
+  describe "#delete_user" do
+    it "should call the api" do
+      client.should_receive(:adelete_user)
+        .with("user-1")
+      recommender.delete_user(user)
+    end
+  end
+
+  describe "#record_action" do
+    it "should call the api" do
+      client.should_receive(:identify).with("user-1")
+      client.should_receive(:arecord_action_on_item)
+        .with("conversion", "item-123", {})
+      recommender.record_action(user, :conversion, item)
+    end
+  end
+
+  describe "#recommended_items" do
+    before do
+      client.stub(:identify)
+      recommender.recommendation_engine = "itemrec"
+    end
+
+    it "should call the api" do
+      client.should_receive(:identify).with("user-1")
+      client.should_receive(:get_itemrec_top_n)
+        .with("itemrec", 10, {})
+        .and_return([])
+      recommender.recommended_items(user, 10)
+    end
+
+    context "when items are found" do
+      before do
+        client.stub(:get_itemrec_top_n).and_return(["item-1", "item-2"])
+      end
+
+      it "should return an array of item ids" do
+        recommender.recommended_items(user, 10).should == ["item-1", "item-2"]
+      end
+    end
+
+    context "when no items are found" do
+      before do
+        client.stub(:get_itemrec_top_n).and_raise(PredictionIO::Client::ItemRecNotFoundError)
+      end
+
+      it "should return an empty array" do
+        recommender.recommended_items(user, 10).should == []
+      end
+    end
+  end # recommended_items
+
+  describe "#similar_items" do
+    before do
+      client.stub(:identify)
+      recommender.similarity_engine = "itemsim"
+    end
+
+    it "should call the api" do
+      client.should_receive(:get_itemsim_top_n)
+        .with("itemsim", "item-123", 10, {})
+        .and_return([])
+
+      recommender.similar_items(item, 10)
+    end
+
+    context "when items are found" do
+      before do
+        client.stub(:get_itemsim_top_n).and_return(["item-1", "item-2"])
+      end
+
+      it "should return an array of item ids" do
+        recommender.similar_items(item, 10).should == ["item-1", "item-2"]
+      end
+    end
+
+    context "when no items are found" do
+      before do
+        client.stub(:get_itemsim_top_n).and_raise(PredictionIO::Client::ItemSimNotFoundError)
+      end
+
+      it "should return an empty array" do
+        recommender.similar_items(item, 10).should == []
+      end
+    end
+  end # similar_items
+end

data/spec/predictable/user_spec.rb

@@ -0,0 +1,55 @@
+require 'ostruct'
+
+describe Predictable::User do
+  let(:recommender) { Predictable::Recommender.new(double("Client").as_null_object) }
+
+  # TODO: Test with ActiveRecord::Base
+  class MyUser < OpenStruct
+    include Predictable::User
+  end
+
+  before do
+    MyUser.recommender = recommender
+  end
+
+  let(:user) { MyUser.new(:id => 1) }
+  let(:item) { double("Item", :pio_iid => 2) }
+  subject { user }
+
+  its(:pio_uid) { should == 1 }
+
+  describe "#record_action" do
+    it "should record an action with the recommender" do
+      recommender.should_receive(:record_action)
+        .with(user, :rate, item, :rating => 4)
+
+      user.record_action(:rate, item, :rating => 4)
+    end
+
+    it "should return nil" do
+      user.record_action(:rate, item).should be_nil
+    end
+  end
+
+  describe "#add_to_recommender" do
+    it "should create a user in the recommender" do
+      recommender.should_receive(:create_user).with(user, {})
+      user.add_to_recommender
+    end
+
+    it "should return nil" do
+      user.add_to_recommender.should be_nil
+    end
+  end
+
+  describe "#delete_from_recommender" do
+    it "should delete the user from the recommender" do
+      recommender.should_receive(:delete_user).with(user)
+      user.delete_from_recommender
+    end
+
+    it "should return nil" do
+      user.delete_from_recommender.should be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'predictable'

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: predictable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- JS Boulanger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: predictionio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby/Rails DSL for PredictionIO, an open source machine learning server.
+email:
+- jsboulanger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/predictable.rb
+- lib/predictable/item.rb
+- lib/predictable/recommender.rb
+- lib/predictable/user.rb
+- lib/predictable/version.rb
+- predictable.gemspec
+- spec/predictable/item_spec.rb
+- spec/predictable/recommender_spec.rb
+- spec/predictable/user_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jsboulanger/predictable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Ruby/Rails DSL for PredictionIO
+test_files:
+- spec/predictable/item_spec.rb
+- spec/predictable/recommender_spec.rb
+- spec/predictable/user_spec.rb
+- spec/spec_helper.rb