spyke 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d5dfe590d65f64f97fda8760b3c75ea3900d494
-  data.tar.gz: be9546662e362944f6ea66373c76821e23d1acb1
+  metadata.gz: d8c05691c5a62ac3b717844d0c3f87890ab7c902
+  data.tar.gz: 7edc244c8975b0ec3c5f1887e53866fafb8dde04
 SHA512:
-  metadata.gz: af83b406e410df06ea8fcb0ab4eee9c811ec1a38e3ebaefefd0d83bcac4ced8436130b4f49ed370264795d21a11bdfe32f6abc0bad3443d25d4fcc061f5f68a5
-  data.tar.gz: 10a68a38089bf195ace08b6a9e90010e383113dba3e6c6b11e7bf49079bdbde93fb94367a3e8333400ce269b967b3a096ebab641f038b7a9d30294aeb99c9c49
+  metadata.gz: 05a0f43e35a3411bfab96a7825ad75a9721d3177fc90d1c6b26a29c9d68e43e5476448c14bbba8972ac4d7458efd64a89a04acac929340551d0378f64717b5cb
+  data.tar.gz: e1a53e75a003f0a7dba3c0ecf5151a7b40477b97ab5cc85ddce8e1535ca875ba79c00a04ab679dd3d1904d70049ddf29163a9c2cac6c22ddbd6fffd21ca8a991

data/lib/spyke/associations/association.rb

@@ -15,8 +15,19 @@ module Spyke
         find_one # Override for plural associations that return an association object
       end
 
+      def find_one
+        result = super
+        update_parent(result) if result
+      end
+
+      def find_some
+        result = super
+        update_parent(result) if result.any?
+        result
+      end
+
       def assign_nested_attributes(attributes)
-        parent.attributes[name] = new(attributes).attributes
+        update_parent new(attributes)
       end
 
       def create(attributes = {})
@@ -27,15 +38,12 @@ module Spyke
         add_to_parent super
       end
 
-      def build(*args)
-        new(*args)
-      end
+      alias :build :new
 
       private
 
         def add_to_parent(record)
-          parent.attributes[name] = record.attributes
-          record
+          update_parent record
         end
 
         def foreign_key
@@ -47,15 +55,19 @@ module Spyke
         end
 
         def fetch_embedded
-          if embedded_attributes
-            Result.new(data: embedded_attributes)
+          if embedded_params
+            Result.new(data: embedded_params)
           elsif !uri
             Result.new(data: nil)
           end
         end
 
-        def embedded_attributes
-          parent.attributes[name]
+        def embedded_params
+          @embedded_params ||= parent.attributes.to_params[name]
+        end
+
+        def update_parent(value)
+          parent.attributes[name] = value
         end
     end
   end

data/lib/spyke/associations/has_many.rb

@@ -11,36 +11,44 @@ module Spyke
         self
       end
 
-      def assign_nested_attributes(collection)
-        collection = collection.values if collection.is_a?(Hash)
-        replace_existing! unless primary_keys_present?
-
-        collection.each do |attributes|
-          if existing = find_existing_attributes(attributes.with_indifferent_access[:id])
-            existing.merge!(attributes)
-          else
-            build(attributes)
-          end
+      def assign_nested_attributes(incoming)
+        incoming = incoming.values if incoming.is_a?(Hash)
+        combined_attributes = combine_with_existing(incoming)
+        clear_existing!
+        combined_attributes.each do |attributes|
+          build(attributes)
         end
       end
 
       private
 
-        def find_existing_attributes(id)
-          embedded_attributes.to_a.find { |attr| attr[:id] && attr[:id].to_s == id.to_s }
+        def combine_with_existing(incoming)
+          return incoming unless primary_keys_present_in_existing?
+          combined = embedded_params + incoming
+          group_by_primary_key(combined).flat_map do |primary_key, hashes|
+            if primary_key.present?
+              hashes.reduce(:merge)
+            else
+              hashes
+            end
+          end
+        end
+
+        def group_by_primary_key(array)
+          array.group_by { |h| h.with_indifferent_access[:id].to_s }
         end
 
-        def primary_keys_present?
-          embedded_attributes && embedded_attributes.any? { |attr| attr.has_key?(:id) }
+        def primary_keys_present_in_existing?
+          embedded_params && embedded_params.any? { |attr| attr.has_key?('id') }
         end
 
-        def replace_existing!
-          parent.attributes[name] = []
+        def clear_existing!
+          update_parent []
         end
 
         def add_to_parent(record)
           parent.attributes[name] ||= []
-          parent.attributes[name] << record.attributes
+          parent.attributes[name] << record
           record
         end
     end

data/lib/spyke/attribute_assignment.rb

@@ -0,0 +1,111 @@
+require 'spyke/collection'
+require 'spyke/attributes'
+
+module Spyke
+  module AttributeAssignment
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :attributes
+    end
+
+    module ClassMethods
+      def attributes(*args)
+        args.each do |attr|
+          define_method attr do
+            attribute(attr)
+          end
+        end
+      end
+    end
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+      @uri_template = scope.uri
+    end
+
+    def attributes=(new_attributes)
+      @attributes ||= Attributes.new(scope.params)
+      use_setters(new_attributes) if new_attributes
+    end
+
+    def id
+      attributes[:id]
+    end
+
+    def id=(value)
+      attributes[:id] = value if value.present?
+    end
+
+    def ==(other)
+      other.is_a?(Spyke::Base) && id == other.id
+    end
+
+    def inspect
+      "#<#{self.class}(#{uri}) id: #{id.inspect} #{inspect_attributes}>"
+    end
+
+    private
+
+      def use_setters(attributes)
+        attributes.each do |key, value|
+          send "#{key}=", value
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        case
+        when association?(name) then association(name).load
+        when attribute?(name)   then attribute(name)
+        when predicate?(name)   then predicate(name)
+        when setter?(name)      then set_attribute(name, args.first)
+        else super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        association?(name) || attribute?(name) || predicate?(name) || super
+      end
+
+      def association?(name)
+        associations.has_key?(name)
+      end
+
+      def association(name)
+        options = associations[name]
+        options[:type].new(self, name, options)
+      end
+
+      def attribute?(name)
+        attributes.has_key?(name)
+      end
+
+      def attribute(name)
+        attributes[name]
+      end
+
+      def predicate?(name)
+        name.to_s.end_with?('?')
+      end
+
+      def predicate(name)
+        !!attribute(depredicate(name))
+      end
+
+      def depredicate(name)
+        name.to_s.chomp('?').to_sym
+      end
+
+      def setter?(name)
+        name.to_s.end_with?('=')
+      end
+
+      def set_attribute(name, value)
+        attributes[name.to_s.chomp('=')] = value
+      end
+
+      def inspect_attributes
+        attributes.except(:id).map { |k, v| "#{k}: #{v.inspect}" }.join(' ')
+      end
+  end
+end

data/lib/spyke/attributes.rb

@@ -1,126 +1,20 @@
-require 'spyke/collection'
-
 module Spyke
-  module Attributes
-    extend ActiveSupport::Concern
-
-    included do
-      attr_reader :attributes
-    end
-
-    module ClassMethods
-      def attributes(*args)
-        args.each do |attr|
-          define_method attr do
-            attribute(attr)
-          end
-        end
-      end
-    end
-
-    def initialize(attributes = {})
-      self.attributes = attributes
-      @uri_template = current_scope.uri
-    end
-
-    def attributes=(new_attributes)
-      @attributes ||= current_scope.params.with_indifferent_access
-      use_setters parse(new_attributes) if new_attributes
-    end
-
-    def id
-      attributes[:id]
-    end
-
-    def id=(value)
-      attributes[:id] = value if value.present?
-    end
-
-    def ==(other)
-      other.is_a?(Spyke::Base) && id == other.id
-    end
-
-    def inspect
-      "#<#{self.class}(#{uri}) id: #{id.inspect} #{inspect_attributes}>"
+  class Attributes < HashWithIndifferentAccess
+    def to_params
+      each_with_object({}) do |(key, value), parameters|
+        parameters[key] = parse_value(value)
+      end.with_indifferent_access
     end
 
     private
 
-      def parse(attributes)
-        attributes.each_with_object({}) do |(key, value), parameters|
-          parameters[key] = parse_value(value)
-        end
-      end
-
       def parse_value(value)
         case
-        when value.is_a?(Spyke::Base)         then parse(value.attributes)
-        when value.is_a?(Hash)                then parse(value)
+        when value.is_a?(Spyke::Base)         then value.attributes.to_params
         when value.is_a?(Array)               then value.map { |v| parse_value(v) }
         when value.respond_to?(:content_type) then Faraday::UploadIO.new(value.path, value.content_type)
         else value
         end
       end
-
-      def use_setters(attributes)
-        attributes.each do |key, value|
-          send "#{key}=", value
-        end
-      end
-
-      def method_missing(name, *args, &block)
-        case
-        when association?(name) then association(name).load
-        when attribute?(name)   then attribute(name)
-        when predicate?(name)   then predicate(name)
-        when setter?(name)      then set_attribute(name, args.first)
-        else super
-        end
-      end
-
-      def respond_to_missing?(name, include_private = false)
-        association?(name) || attribute?(name) || predicate?(name) || super
-      end
-
-      def association?(name)
-        associations.has_key?(name)
-      end
-
-      def association(name)
-        options = associations[name]
-        options[:type].new(self, name, options)
-      end
-
-      def attribute?(name)
-        attributes.has_key?(name)
-      end
-
-      def attribute(name)
-        attributes[name]
-      end
-
-      def predicate?(name)
-        name.to_s.end_with?('?')
-      end
-
-      def predicate(name)
-        !!attribute(depredicate(name))
-      end
-
-      def depredicate(name)
-        name.to_s.chomp('?').to_sym
-      end
-
-      def setter?(name)
-        name.to_s.end_with?('=')
-      end
-
-      def set_attribute(name, value)
-        attributes[name.to_s.chomp('=')] = value
-      end
-
-      def inspect_attributes
-        attributes.except(:id).map { |k, v| "#{k}: #{v.inspect}" }.join(' ')
-      end
   end
 end

data/lib/spyke/base.rb

@@ -1,9 +1,10 @@
 require 'active_model'
 require 'spyke/associations'
-require 'spyke/attributes'
+require 'spyke/attribute_assignment'
 require 'spyke/orm'
 require 'spyke/http'
-require 'spyke/scopes'
+require 'spyke/scoping'
+
 
 module Spyke
   class Base
@@ -17,9 +18,9 @@ module Spyke
 
     # Spyke
     include Associations
-    include Attributes
+    include AttributeAssignment
     include Http
     include Orm
-    include Scopes
+    include Scoping
   end
 end

data/lib/spyke/http.rb

@@ -8,9 +8,6 @@ module Spyke
     extend ActiveSupport::Concern
     METHODS = %i{ get post put patch delete }
 
-    included do
-    end
-
     module ClassMethods
       METHODS.each do |method|
         define_method(method) do |path, params = {}|

data/lib/spyke/orm.rb

@@ -50,9 +50,9 @@ module Spyke
 
     def to_params
       if include_root?
-        { self.class.model_name.param_key => attributes.except(*uri.variables) }
+        { self.class.model_name.param_key => attributes.to_params.except(*uri.variables)}
       else
-        attributes.except(*uri.variables)
+        attributes.to_params.except(*uri.variables)
       end
     end
 

data/lib/spyke/relation.rb

@@ -5,19 +5,17 @@ module Spyke
     include Enumerable
 
     attr_reader :klass, :params
+    attr_writer :params
     delegate :to_ary, :[], :empty?, :last, :size, :metadata, to: :find_some
 
     def initialize(klass, options = {})
       @klass, @options, @params = klass, options, {}
     end
 
-    def all
-      where
-    end
-
     def where(conditions = {})
-      @params.merge!(conditions)
-      self
+      relation = clone
+      relation.params = params.merge(conditions)
+      relation
     end
 
     # Overrides Enumerable find
@@ -53,10 +51,10 @@ module Spyke
 
       # Keep hold of current scope while running a method on the class
       def scoping
-        klass.current_scope = self
+        previous, klass.current_scope = klass.current_scope, self
         yield
       ensure
-        klass.current_scope = nil
+        klass.current_scope = previous
       end
   end
 end

data/lib/spyke/{scopes.rb → scoping.rb}

@@ -2,11 +2,15 @@ require 'spyke/relation'
 require 'spyke/scope_registry'
 
 module Spyke
-  module Scopes
+  module Scoping
     extend ActiveSupport::Concern
 
     module ClassMethods
-      delegate :all, :where, to: :current_scope
+      delegate :where, :build, to: :all
+
+      def all
+        current_scope || Relation.new(self, uri: uri)
+      end
 
       def scope(name, code)
         define_singleton_method name, code
@@ -17,14 +21,14 @@ module Spyke
       end
 
       def current_scope
-        ScopeRegistry.value_for(:current_scope, name) || Relation.new(self, uri: uri)
+        ScopeRegistry.value_for(:current_scope, name)
       end
     end
 
     private
 
-      def current_scope
-        self.class.current_scope
+      def scope
+        @scope ||= self.class.all
       end
   end
 end

data/lib/spyke/version.rb

@@ -1,3 +1,3 @@
 module Spyke
-  VERSION = '1.5.0'
+  VERSION = '1.6.0'
 end

data/test/associations_test.rb

@@ -118,12 +118,37 @@ module Spyke
       assert_equal 1, recipe.groups.first.recipe_id
     end
 
+    def test_multiple_builds
+      recipe = Recipe.new
+      recipe.groups.build(name: 'Condiments')
+      recipe.groups.build(name: 'Tools')
+      assert_equal %w{ Condiments Tools }, recipe.groups.map(&:name)
+    end
+
     def test_new_has_many_association
       recipe = Recipe.new(id: 1)
       recipe.groups.new
       assert_equal 1, recipe.groups.first.recipe_id
     end
 
+    def test_changing_attributes_directly_after_build_on_has_many_association
+      recipe = Recipe.new(id: 1)
+      recipe.groups.build(name: 'Dessert')
+      recipe.groups.first.name = 'Starter'
+
+      assert_equal 'Starter', recipe.groups.first.name
+      assert_equal({ 'recipe' => { 'groups' => [{ 'recipe_id' => 1, 'name' => 'Starter' }] } }, recipe.to_params)
+    end
+
+    def test_changing_attributes_on_reference_after_build_on_has_many_association
+      recipe = Recipe.new(id: 1)
+      group = recipe.groups.build(name: 'Dessert')
+      group.name = 'Starter'
+
+      assert_equal 'Starter', recipe.groups.first.name
+      assert_equal({ 'recipe' => { 'groups' => [{ 'recipe_id' => 1, 'name' => 'Starter' }] } }, recipe.to_params)
+    end
+
     def test_deep_build_has_many_association
       recipe = Recipe.new(id: 1)
       recipe.groups.build(ingredients: [Ingredient.new(name: 'Salt')])
@@ -132,6 +157,16 @@ module Spyke
       assert_equal({ 'recipe' => { 'groups' => [{ 'recipe_id' => 1, 'ingredients' => [{ 'name' => 'Salt' }] }] } }, recipe.to_params)
     end
 
+    def test_sequential_deep_build_has_many_association
+      recipe = Recipe.new(id: 1)
+      recipe.groups.build
+      recipe.groups.first.ingredients.build(name: 'Salt')
+
+      assert_equal %w{ Salt }, recipe.ingredients.map(&:name)
+      assert_equal({ 'recipe' => { 'groups' => [{ 'recipe_id' => 1, 'ingredients' => [{ 'group_id' => nil, 'name' => 'Salt' }] }] } }, recipe.to_params)
+      assert_equal({ 'group' => { 'recipe_id' => 1, 'ingredients' => [{ 'group_id' => nil, 'name' => 'Salt' }] } }, recipe.groups.first.to_params)
+    end
+
     def test_deep_build_has_many_association_with_scope
       recipe = User.new(id: 1).recipes.published.build
 
@@ -168,7 +203,7 @@ module Spyke
       assert_equal Image, recipe.background_image.class
     end
 
-    def test_cached_result
+    def test_cached_result_for_associations
       endpoint_1 = stub_request(:get, 'http://sushi.com/recipes/1/groups?per_page=3')
       endpoint_2 = stub_request(:get, 'http://sushi.com/recipes/1/groups')
 
@@ -250,9 +285,15 @@ module Spyke
 
     def test_nested_attributes_merging_with_existing_when_ids_present?
       recipe = Recipe.new(groups_attributes: [{ id: 1, title: 'starter', description: 'nice' }, { id: 2, title: 'sauce', description: 'spicy' }])
-      recipe.attributes = { groups_attributes: [{ 'id' => '2', 'title' => 'flavor' }] }
-      assert_equal %w{ starter flavor }, recipe.groups.map(&:title)
-      assert_equal %w{ nice spicy }, recipe.groups.map(&:description)
+      recipe.attributes = { groups_attributes: [{ 'id' => '2', 'title' => 'flavor' }, { 'title' => 'spices', 'description' => 'lovely' }, { 'title' => 'sweetener', 'description' => 'sweet' }] }
+      assert_equal %w{ starter flavor spices sweetener }, recipe.groups.map(&:title)
+      assert_equal %w{ nice spicy lovely sweet }, recipe.groups.map(&:description)
+    end
+
+    def test_nested_attributes_appending_to_existing_when_ids_present?
+      recipe = Recipe.new(groups_attributes: [{ id: 1, title: 'starter' }, { id: 2, title: 'sauce' }])
+      recipe.attributes = { groups_attributes: [{ title: 'flavor' }] }
+      assert_equal %w{ starter sauce flavor }, recipe.groups.map(&:title)
     end
 
     def test_nested_attributes_has_many_using_hash_syntax
@@ -307,5 +348,14 @@ module Spyke
       assert_equal [], Group.new.ingredients.to_a
       assert_equal [1], Group.new(ingredients: [{ id: 1 }]).ingredients.map(&:id)
     end
+
+    def test_class_methods_for_associations
+      recipe = Recipe.new
+      recipe.groups.build_default
+
+      assert_equal({ 'recipe' => { 'groups' => [{ 'recipe_id' => nil, 'name' => 'Condiments', 'ingredients' => [{ 'group_id' => nil, 'name' => 'Salt' }] }, { 'recipe_id' => nil, 'name' => 'Tools', 'ingredients' => [{ 'group_id' => nil, 'name' => 'Spoon' }] }] } }, recipe.to_params)
+      assert_equal %w{ Condiments Tools }, recipe.groups.map(&:name)
+      assert_equal %w{ Salt Spoon }, recipe.ingredients.map(&:name)
+    end
   end
 end

data/test/attributes_test.rb

@@ -2,6 +2,12 @@ require 'test_helper'
 
 module Spyke
   class AttributesTest < MiniTest::Test
+
+    def test_basics
+      attr = Attributes.new(id: 3, 'title' => 'Fish', groups: [ Group.new(name: 'Starter'), { name: 'Dessert' } ])
+      assert_equal({ 'id' => 3 , 'title' => 'Fish', 'groups' => [{ 'name' => 'Starter' }, { 'name' => 'Dessert' }] }, attr.to_params)
+    end
+
     def test_predicate_methods
       stub_request(:get, 'http://sushi.com/recipes/1').to_return_json(result: { id: 1, title: 'Sushi' })
 

data/test/relation_test.rb

@@ -12,6 +12,32 @@ module Spyke
       assert_equal 'meta', recipes.metadata
     end
 
+    def test_scope_independence
+      endpoint = stub_request(:get, 'http://sushi.com/recipes?query=chicken')
+      wrong_endpoint = stub_request(:get, 'http://sushi.com/recipes?query=chicken&page=1')
+
+      search = Search.new('chicken')
+      variant = search.recipes.where(page: 1)
+      original = search.recipes
+
+      refute_same variant, original
+
+      original.to_a
+
+      assert_not_requested wrong_endpoint
+      assert_requested endpoint, times: 1
+    end
+
+    def test_scope_not_firing_twice_for_duplicate_scope
+      endpoint = stub_request(:get, 'http://sushi.com/recipes?query=chicken')
+
+      search = Search.new('chicken')
+      search.recipes.page.to_a
+      search.suggestions
+
+      assert_requested endpoint, times: 1
+    end
+
     def test_scope_with_find
       endpoint = stub_request(:get, 'http://sushi.com/recipes/1?status=published').to_return_json(result: { id: 1 })
 

data/test/support/fixtures.rb

@@ -15,12 +15,14 @@ class Recipe < Spyke::Base
 
   accepts_nested_attributes_for :image, :user, :groups
 
-  def self.page(number)
-    where(page: number)
+  def self.page(number = nil)
+    result = all
+    result = result.where(page: number) if number
+    result
   end
 
   def ingredients
-    groups.first.ingredients
+    groups.flat_map(&:ingredients)
   end
 
   private
@@ -47,6 +49,13 @@ end
 class Group < Spyke::Base
   has_many :ingredients, uri: nil
   accepts_nested_attributes_for :ingredients
+
+  def self.build_default
+    group_1 = build(name: 'Condiments')
+    group_1.ingredients.build(name: 'Salt')
+    group_2 = build(name: 'Tools')
+    group_2.ingredients.build(name: 'Spoon')
+  end
 end
 
 class Ingredient < Spyke::Base
@@ -64,3 +73,17 @@ end
 class Comment < Spyke::Base
   scope :approved, -> { where(comment_approved: true) }
 end
+
+class Search
+  def initialize(query)
+    @query = query
+  end
+
+  def recipes
+    @recipes ||= Recipe.where(query: @query)
+  end
+
+  def suggestions
+    recipes.metadata[:suggestions]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spyke
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Jens Balvig
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-09 00:00:00.000000000 Z
+date: 2015-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -270,6 +270,7 @@ files:
 - lib/spyke/associations/belongs_to.rb
 - lib/spyke/associations/has_many.rb
 - lib/spyke/associations/has_one.rb
+- lib/spyke/attribute_assignment.rb
 - lib/spyke/attributes.rb
 - lib/spyke/base.rb
 - lib/spyke/collection.rb
@@ -284,7 +285,7 @@ files:
 - lib/spyke/relation.rb
 - lib/spyke/result.rb
 - lib/spyke/scope_registry.rb
-- lib/spyke/scopes.rb
+- lib/spyke/scoping.rb
 - lib/spyke/version.rb
 - spyke.gemspec
 - test/associations_test.rb