attune 1.0.5 → 1.0.6

data/lib/attune/models/customer.rb

@@ -1,40 +1,37 @@
 module Attune
   module Model
-    # customer associated with an anonymous user
+    # Customer associated with an anonymous user
+    #
+    # @attr [String] customer
     class Customer
       attr_accessor :customer
       
 
-      # :internal => :external
-      def self.attribute_map
-        {
-          :customer => :customer
-
-        }
-      end
-
       def initialize(attributes = {})
         return if attributes.empty?
-        # Morph attribute keys into undescored rubyish style
-        if self.class.attribute_map[:"customer"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @customer = attributes["customer"] || attributes[:"customer"]
-        end
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @customer = attributes["customer"] || attributes[:"customer"]
         
 
       end
 
       def to_body
-        body = {}
-        self.class.attribute_map.each_pair do |key, value|
-          body[value] = self.send(key) unless self.send(key).nil?
-        end
-        body
+        Hash[ATTRIBUTE_MAP.map do |internal, external|
+          next unless value = send(internal)
+          [external, value]
+        end.compact]
       end
 
       def to_json(options = {})
         to_body.to_json
       end
+
+      private
+      # :internal => :external
+      ATTRIBUTE_MAP = {
+          :customer => :customer
+
+        }
     end
   end
 end

data/lib/attune/models/ranked_entities.rb

@@ -0,0 +1,55 @@
+module Attune
+  module Model
+    # List of ids in ranked order. If an error occurs, returns message and status code.
+    #
+    # @attr [String] message
+    # @attr [Integer] status
+    # @attr [Array<String>] ranking
+    class RankedEntities
+      attr_accessor :message
+      
+
+      attr_accessor :status
+      
+
+      attr_accessor :ranking
+      
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @message = attributes["message"] || attributes[:"message"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @status = attributes["status"] || attributes[:"status"]
+        value = attributes["ranking"] || attributes[:"ranking"]
+        if value.is_a?(Array)
+          @ranking = value
+
+        end
+        
+
+      end
+
+      def to_body
+        Hash[ATTRIBUTE_MAP.map do |internal, external|
+          next unless value = send(internal)
+          [external, value]
+        end.compact]
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+
+      private
+      # :internal => :external
+      ATTRIBUTE_MAP = {
+          :message => :message,
+          :status => :status,
+          :ranking => :ranking
+
+        }
+    end
+  end
+end
+

data/lib/attune/models/ranking_params.rb

@@ -0,0 +1,93 @@
+module Attune
+  module Model
+    # Inputs for ranking a set of ids for a particular user.
+    #
+    # @attr [Array<Attune::Model::ScopeEntry>] scope
+    # @attr [String] anonymous
+    # @attr [String] customer
+    # @attr [String] user_agent
+    # @attr [String] entity_type
+    # @attr [Array<String>] ids
+    # @attr [String] ip
+    # @attr [String] view
+    class RankingParams
+      attr_accessor :scope
+      
+
+      attr_accessor :anonymous
+      
+
+      attr_accessor :customer
+      
+
+      attr_accessor :user_agent
+      
+
+      attr_accessor :entity_type
+      
+
+      attr_accessor :ids
+      
+
+      attr_accessor :ip
+      
+
+      attr_accessor :view
+      
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        value = attributes["scope"] || attributes[:"scope"]
+        if value.is_a?(Array)
+          @scope = value.map{ |v| ScopeEntry.new(v) }
+
+        end
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @anonymous = attributes["anonymous"] || attributes[:"anonymous"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @customer = attributes["customer"] || attributes[:"customer"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @user_agent = attributes["userAgent"] || attributes[:"user_agent"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @entity_type = attributes["entityType"] || attributes[:"entity_type"]
+        value = attributes["ids"] || attributes[:"ids"]
+        if value.is_a?(Array)
+          @ids = value
+
+        end
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @ip = attributes["ip"] || attributes[:"ip"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @view = attributes["view"] || attributes[:"view"]
+        
+
+      end
+
+      def to_body
+        Hash[ATTRIBUTE_MAP.map do |internal, external|
+          next unless value = send(internal)
+          [external, value]
+        end.compact]
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+
+      private
+      # :internal => :external
+      ATTRIBUTE_MAP = {
+          :scope => :scope,
+          :anonymous => :anonymous,
+          :customer => :customer,
+          :user_agent => :userAgent,
+          :entity_type => :entityType,
+          :ids => :ids,
+          :ip => :ip,
+          :view => :view
+
+        }
+    end
+  end
+end
+

data/lib/attune/models/scope_entry.rb

@@ -0,0 +1,45 @@
+module Attune
+  module Model
+    # Name value pairs indicating the context where a ranking will be displayed.
+    #
+    # @attr [String] name
+    # @attr [String] value
+    class ScopeEntry
+      attr_accessor :name
+      
+
+      attr_accessor :value
+      
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @name = attributes["name"] || attributes[:"name"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @value = attributes["value"] || attributes[:"value"]
+        
+
+      end
+
+      def to_body
+        Hash[ATTRIBUTE_MAP.map do |internal, external|
+          next unless value = send(internal)
+          [external, value]
+        end.compact]
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+
+      private
+      # :internal => :external
+      ATTRIBUTE_MAP = {
+          :name => :name,
+          :value => :value
+
+        }
+    end
+  end
+end
+

data/lib/attune/version.rb

@@ -1,4 +1,4 @@
 module Attune
-  VERSION = "1.0.5"
+  VERSION = "1.0.6"
 end
 

data/spec/attune/client_spec.rb

@@ -72,35 +72,28 @@ describe Attune::Client do
         result = client.get_auth_token("id", "secret")
         expect(result).to match(/^[a-z0-9\-]+$/)
       end
-      it "mocks create_anonymous with an id" do
-        result = client.anonymous.create(id: '12345', user_agent: 'Mozilla/5.0')
-        expect(result).to eq('12345')
-      end
+
       it "mocks create_anonymous with no id" do
-        result = client.anonymous.create(user_agent: 'Mozilla/5.0')
-        expect(result).to match(/^[a-z0-9\-]+$/)
+        result = client.anonymous.create
+        expect(result.id).to match(/^[a-z0-9\-]+$/)
       end
       describe "mocks get_rankings" do
         let(:entities) { %w[1001 1002 1003 1004] }
-        let(:expected) do
-          {
-            headers: {"attune-cell"=>"mock", "attune-ranking"=>"mock"},
-            entities: entities.map { |e| e.to_s }
-          }
-        end
+        let(:expected) { entities.map { |e| e.to_s } }
 
         before(:each) do
-          @result = client.entities.get_rankings(
-            id: 'abcd123',
+          params = Attune::Model::RankingParams.new(
+            anonymous: 'abcd123',
             view: 'b/mens-pants',
-            collection: 'products',
-            entities: entities
+            entity_type: 'products',
+            ids: entities
           )
+          @result = client.entities.get_rankings(params)
         end
 
         context "with entities sent as strings" do
           it "returns entities in order sent" do
-            expect(@result).to eq expected
+            expect(@result.ranking).to eq expected
           end
         end
 
@@ -108,31 +101,30 @@ describe Attune::Client do
           let(:entities) { [1001, 1002, 1003, 1004] }
 
           it "returns entities in order sent as strings" do
-            expect(@result).to eq expected
+            expect(@result.ranking).to eq expected
           end
         end
       end
       describe "mocks multi_get_rankings" do
         let(:entities) { %w[1001 1002 1003 1004] }
-        let(:expected) do
-          {
-            headers: {"attune-cell"=>"mock", "attune-ranking"=>"mock"},
-            entities: [ entities.map { |e| e.to_s } ]
-          }
-        end
+        let(:expected) { [entities.map { |e| e.to_s }] }
 
         before(:each) do
-          @result = client.multi_get_rankings([
-            id: 'abcd123',
+          params = Attune::Model::RankingParams.new(
+            anonymous: 'abcd123',
             view: 'b/mens-pants',
-            collection: 'products',
-            entities: entities
-          ])
+            entity_type: 'products',
+            ids: entities
+          )
+          batch_request = Attune::Model::BatchRankingRequest.new
+          batch_request.requests = [params]
+          @result = client.entities.batch_get_rankings(batch_request)
         end
 
         context "with entities sent as strings" do
           it "returns entities in order sent" do
-            expect(@result).to eq expected
+            rankings = @result.results.map(&:ranking)
+            expect(rankings).to eq expected
           end
         end
 
@@ -140,7 +132,8 @@ describe Attune::Client do
           let(:entities) { [1001, 1002, 1003, 1004] }
 
           it "returns entities in order sent as strings" do
-            expect(@result).to eq expected
+            rankings = @result.results.map(&:ranking)
+            expect(rankings).to eq expected
           end
         end
       end

data/spec/attune_spec.rb

@@ -6,7 +6,7 @@ describe Attune do
   end
   describe 'defaults' do
     subject { Attune::Default }
-    specify { expect(subject.endpoint).to eq 'http://localhost/' }
+    specify { expect(subject.endpoint).to eq 'https://api.attune-staging.co' }
     specify { expect(subject.disabled).to eq false }
   end
   describe 'configure' do

data/spec/remote_spec.rb

@@ -11,7 +11,7 @@ describe "remote requests" do
     pending "REMOTE_ENDPOINT required for remote spec" unless endpoint
     pending "AUTH_TOKEN required for remote spec" unless auth_token
   end
-  let!(:client){ Attune::Client.new(endpoint: endpoint, auth_token: auth_token) }
+  let!(:client){ Attune::Client.new(endpoint: endpoint, auth_token: auth_token, timeout: 2) }
 
   it "can request an auth_token given a client id and secret" do
     pending "CLIENT_ID required for get_auth_token spec" unless client_id

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attune
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
 platform: ruby
 authors:
 - John Hawthorn
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-03 00:00:00.000000000 Z
+date: 2014-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -148,17 +148,18 @@ files:
 - lib/attune/configurable.rb
 - lib/attune/default.rb
 - lib/attune/json_logger.rb
-- lib/attune/models/anonymousresult.rb
-- lib/attune/models/batchrankingrequest.rb
-- lib/attune/models/batchrankingresult.rb
+- lib/attune/mocks.rb
+- lib/attune/models/anonymous_result.rb
+- lib/attune/models/batch_ranking_request.rb
+- lib/attune/models/batch_ranking_result.rb
 - lib/attune/models/blacklist.rb
-- lib/attune/models/blacklistgetresponse.rb
-- lib/attune/models/blacklistparams.rb
-- lib/attune/models/blacklistsaveresponse.rb
+- lib/attune/models/blacklist_get_response.rb
+- lib/attune/models/blacklist_params.rb
+- lib/attune/models/blacklist_save_response.rb
 - lib/attune/models/customer.rb
-- lib/attune/models/rankedentities.rb
-- lib/attune/models/rankingparams.rb
-- lib/attune/models/scopeentry.rb
+- lib/attune/models/ranked_entities.rb
+- lib/attune/models/ranking_params.rb
+- lib/attune/models/scope_entry.rb
 - lib/attune/net_http_persistent.rb
 - lib/attune/param_flattener.rb
 - lib/attune/version.rb

data/lib/attune/models/anonymousresult.rb

@@ -1,41 +0,0 @@
-module Attune
-  module Model
-    # 
-    class AnonymousResult
-      attr_accessor :id
-      
-
-      # :internal => :external
-      def self.attribute_map
-        {
-          :id => :id
-
-        }
-      end
-
-      def initialize(attributes = {})
-        return if attributes.empty?
-        # Morph attribute keys into undescored rubyish style
-        if self.class.attribute_map[:"id"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @id = attributes["id"] || attributes[:"id"]
-        end
-        
-
-      end
-
-      def to_body
-        body = {}
-        self.class.attribute_map.each_pair do |key, value|
-          body[value] = self.send(key) unless self.send(key).nil?
-        end
-        body
-      end
-
-      def to_json(options = {})
-        to_body.to_json
-      end
-    end
-  end
-end
-