her5 0.8.1

data/lib/her/model/associations/association.rb

@@ -0,0 +1,107 @@
+module Her
+  module Model
+    module Associations
+      class Association
+        # @private
+        attr_accessor :params
+
+        # @private
+        def initialize(parent, opts = {})
+          @parent = parent
+          @opts = opts
+          @params = {}
+
+          @klass = @parent.class.her_nearby_class(@opts[:class_name])
+          @name = @opts[:name]
+        end
+
+        # @private
+        def self.proxy(parent, opts = {})
+          AssociationProxy.new new(parent, opts)
+        end
+
+        # @private
+        def self.parse_single(association, klass, data)
+          data_key = association[:data_key]
+          return {} unless data[data_key]
+
+          klass = klass.her_nearby_class(association[:class_name])
+          if data[data_key].kind_of?(klass)
+            { association[:name] => data[data_key] }
+          else
+            { association[:name] => klass.new(klass.parse(data[data_key])) }
+          end
+        end
+
+        # @private
+        def assign_single_nested_attributes(attributes)
+          if @parent.attributes[@name].blank?
+            @parent.attributes[@name] = @klass.new(@klass.parse(attributes))
+          else
+            @parent.attributes[@name].assign_attributes(attributes)
+          end
+        end
+
+        # @private
+        def fetch(opts = {})
+          attribute_value = @parent.attributes[@name]
+          return @opts[:default].try(:dup) if @parent.attributes.include?(@name) && (attribute_value.nil? || !attribute_value.nil? && attribute_value.empty?) && @params.empty?
+
+          return @cached_result unless @params.any? || @cached_result.nil?
+          return @parent.attributes[@name] unless @params.any? || @parent.attributes[@name].blank?
+          
+          # No point trying to fetch associates for an object with no id yet.
+          if @parent.persisted?
+            path = build_association_path lambda { "#{@parent.request_path(@params)}#{@opts[:path]}" }
+            @klass.get(path, @params).tap do |result|
+              @cached_result = result unless @params.any?
+            end
+          end
+        end
+
+        # @private
+        def build_association_path(code)
+          begin
+            instance_exec(&code)
+          rescue Her::Errors::PathError
+            return nil
+          end
+        end
+
+        # Add query parameters to the HTTP request performed to fetch the data
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     has_many :comments
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.comments.where(:approved => 1) # Fetched via GET "/users/1/comments?approved=1
+        def where(params = {})
+          return self if params.blank? && @parent.attributes[@name].blank?
+          AssociationProxy.new self.clone.tap { |a| a.params = a.params.merge(params) }
+        end
+        alias all where
+
+        # Fetches the data specified by id
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     has_many :comments
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.comments.find(3) # Fetched via GET "/users/1/comments/3
+        #
+        def find(id)
+          return nil if id.blank?
+          path = build_association_path lambda { "#{@parent.request_path(@params)}#{@opts[:path]}/#{id}" }
+          @klass.get_resource(path, @params)
+        end
+
+      end
+    end
+  end
+end

data/lib/her/model/associations/association_proxy.rb

@@ -0,0 +1,45 @@
+module Her
+  module Model
+    module Associations
+      class AssociationProxy < (ActiveSupport.const_defined?('ProxyObject') ? ActiveSupport::ProxyObject : ActiveSupport::BasicObject)
+
+        # @private
+        def self.install_proxy_methods(target_name, *names)
+          names.each do |name|
+            module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}(*args, &block)
+                #{target_name}.send(#{name.inspect}, *args, &block)
+              end
+            RUBY
+          end
+        end
+
+        install_proxy_methods :association,
+          :build, :create, :where, :find, :all, :assign_nested_attributes
+
+        # @private
+        def initialize(association)
+          @_her_association = association
+        end
+
+        def association
+          @_her_association
+        end
+
+        # @private
+        def method_missing(name, *args, &block)
+          if :object_id == name # avoid redefining object_id
+            return association.fetch.object_id
+          end
+
+          # create a proxy to the fetched object's method
+          AssociationProxy.install_proxy_methods 'association.fetch', name
+
+          # resend message to fetched object
+          __send__(name, *args, &block)
+        end
+
+      end
+    end
+  end
+end

data/lib/her/model/associations/belongs_to_association.rb

@@ -0,0 +1,101 @@
+module Her
+  module Model
+    module Associations
+      class BelongsToAssociation < Association
+
+        # @private
+        def self.attach(klass, name, opts)
+          opts = {
+            :class_name => name.to_s.classify,
+            :name => name,
+            :data_key => name,
+            :default => nil,
+            :foreign_key => "#{name}_id",
+            :path => "/#{name.to_s.pluralize}/:id"
+          }.merge(opts)
+          klass.associations[:belongs_to] << opts
+
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              cached_name = :"@_her_association_#{name}"
+
+              cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+              cached_data || instance_variable_set(cached_name, Her::Model::Associations::BelongsToAssociation.proxy(self, #{opts.inspect}))
+            end
+          RUBY
+        end
+
+        # @private
+        def self.parse(*args)
+          parse_single(*args)
+        end
+
+        # Initialize a new object
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     belongs_to :organization
+        #   end
+        #
+        #   class Organization
+        #     include Her::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   new_organization = user.organization.build(:name => "Foo Inc.")
+        #   new_organization # => #<Organization name="Foo Inc.">
+        def build(attributes = {})
+          @klass.build(attributes)
+        end
+
+        # Create a new object, save it and associate it to the parent
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     belongs_to :organization
+        #   end
+        #
+        #   class Organization
+        #     include Her::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.organization.create(:name => "Foo Inc.")
+        #   user.organization # => #<Organization id=2 name="Foo Inc.">
+        def create(attributes = {})
+          resource = build(attributes)
+          @parent.attributes[@name] = resource if resource.save
+          resource
+        end
+
+        # @private
+        def fetch
+          foreign_key_value = @parent.attributes[@opts[:foreign_key].to_sym]
+          data_key_value = @parent.attributes[@opts[:data_key].to_sym]
+          return @opts[:default].try(:dup) if (@parent.attributes.include?(@name) && @parent.attributes[@name].nil? && @params.empty?) || (foreign_key_value.blank? && data_key_value.blank?)
+
+          return @cached_result unless @params.any? || @cached_result.nil?
+          return @parent.attributes[@name] unless @params.any? || @parent.attributes[@name].blank?
+
+          path_params = @parent.attributes.merge(@params.merge(@klass.primary_key => foreign_key_value))
+          path = build_association_path lambda { @klass.build_request_path(path_params) }
+          begin
+            @klass.get_resource(path, @params).tap do |result|
+              @cached_result = result if @params.blank?
+            end
+          rescue Her::Errors::NotFound => e
+            @opts[:default].try(:dup)
+          end
+        end
+
+        # @private
+        def assign_nested_attributes(attributes)
+          assign_single_nested_attributes(attributes)
+        end
+
+      end
+    end
+  end
+end

data/lib/her/model/associations/has_many_association.rb

@@ -0,0 +1,101 @@
+module Her
+  module Model
+    module Associations
+      class HasManyAssociation < Association
+
+        # @private
+        def self.attach(klass, name, opts)
+          opts = {
+            :class_name     => name.to_s.classify,
+            :name           => name,
+            :data_key       => name,
+            :default        => Her::Collection.new,
+            :path           => "/#{name}",
+            :inverse_of => nil
+          }.merge(opts)
+          klass.associations[:has_many] << opts
+
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              cached_name = :"@_her_association_#{name}"
+
+              cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+              cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasManyAssociation.proxy(self, #{opts.inspect}))
+            end
+          RUBY
+        end
+
+        # @private
+        def self.parse(association, klass, data)
+          data_key = association[:data_key]
+          return {} unless data[data_key]
+
+          klass = klass.her_nearby_class(association[:class_name])
+          { association[:name] => Her::Model::Attributes.initialize_collection(klass, :data => data[data_key]) }
+        end
+
+        # Initialize a new object with a foreign key to the parent
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     has_many :comments
+        #   end
+        #
+        #   class Comment
+        #     include Her::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   new_comment = user.comments.build(:body => "Hello!")
+        #   new_comment # => #<Comment user_id=1 body="Hello!">
+        # TODO: This only merges the id of the parents, handle the case
+        #       where this is more deeply nested
+        def build(attributes = {})
+          @klass.build(attributes.merge(:"#{@parent.singularized_resource_name}_id" => @parent.id))
+        end
+
+        # Create a new object, save it and add it to the associated collection
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     has_many :comments
+        #   end
+        #
+        #   class Comment
+        #     include Her::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.comments.create(:body => "Hello!")
+        #   user.comments # => [#<Comment id=2 user_id=1 body="Hello!">]
+        def create(attributes = {})
+          resource = build(attributes)
+
+          if resource.save
+            @parent.attributes[@name] ||= Her::Collection.new
+            @parent.attributes[@name] << resource
+          end
+
+          resource
+        end
+
+        # @private
+        def fetch
+          (super || []).tap do |o|
+            inverse_of = @opts[:inverse_of] || @parent.singularized_resource_name
+            o.each { |entry| entry.send("#{inverse_of}=", @parent) }
+          end
+        end
+
+        # @private
+        def assign_nested_attributes(attributes)
+          data = attributes.is_a?(Hash) ? attributes.values : attributes
+          @parent.attributes[@name] = Her::Model::Attributes.initialize_collection(@klass, :data => data)
+        end
+        
+      end
+    end
+  end
+end

data/lib/her/model/associations/has_one_association.rb

@@ -0,0 +1,80 @@
+module Her
+  module Model
+    module Associations
+      class HasOneAssociation < Association
+
+        # @private
+        def self.attach(klass, name, opts)
+          opts = {
+            :class_name => name.to_s.classify,
+            :name => name,
+            :data_key => name,
+            :default => nil,
+            :path => "/#{name}"
+          }.merge(opts)
+          klass.associations[:has_one] << opts
+
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              cached_name = :"@_her_association_#{name}"
+
+              cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+              cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasOneAssociation.proxy(self, #{opts.inspect}))
+            end
+          RUBY
+        end
+
+        # @private
+        def self.parse(*args)
+          parse_single(*args)
+        end
+
+        # Initialize a new object with a foreign key to the parent
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     has_one :role
+        #   end
+        #
+        #   class Role
+        #     include Her::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   new_role = user.role.build(:title => "moderator")
+        #   new_role # => #<Role user_id=1 title="moderator">
+        def build(attributes = {})
+          @klass.build(attributes.merge(:"#{@parent.singularized_resource_name}_id" => @parent.id))
+        end
+
+        # Create a new object, save it and associate it to the parent
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     has_one :role
+        #   end
+        #
+        #   class Role
+        #     include Her::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.role.create(:title => "moderator")
+        #   user.role # => #<Role id=2 user_id=1 title="moderator">
+        def create(attributes = {})
+          resource = build(attributes)
+          @parent.attributes[@name] = resource if resource.save
+          resource
+        end
+
+        # @private
+        def assign_nested_attributes(attributes)
+          assign_single_nested_attributes(attributes)
+        end
+
+      end
+    end
+  end
+end

data/lib/her/model/attributes.rb

@@ -0,0 +1,297 @@
+module Her
+  module Model
+    # This module handles all methods related to model attributes
+    module Attributes
+      extend ActiveSupport::Concern
+
+      # Initialize a new object with data
+      #
+      # @param [Hash] attributes The attributes to initialize the object with
+      # @option attributes [Hash,Array] :_metadata
+      # @option attributes [Hash,Array] :_errors
+      # @option attributes [Boolean] :_destroyed
+      #
+      # @example
+      #   class User
+      #     include Her::Model
+      #   end
+      #
+      #  User.new(name: "Tobias") # => #<User name="Tobias">
+      def initialize(attributes={})
+        attributes ||= {}
+        @metadata = attributes.delete(:_metadata) || {}
+        @response_errors = attributes.delete(:_errors) || {}
+        @destroyed = attributes.delete(:_destroyed) || false
+
+        attributes = self.class.default_scope.apply_to(attributes)
+        assign_attributes(attributes)
+        run_callbacks :initialize
+      end
+
+      # Initialize a collection of resources
+      #
+      # @private
+      def self.initialize_collection(klass, parsed_data={})
+        collection_data = klass.extract_array(parsed_data).map do |item_data|
+          if item_data.kind_of?(klass)
+            resource = item_data
+          else
+            resource = klass.new(klass.parse(item_data))
+            resource.run_callbacks :find
+          end
+          resource
+        end
+        Her::Collection.new(collection_data, parsed_data[:metadata], parsed_data[:errors])
+      end
+
+      # Use setter methods of model for each key / value pair in params
+      # Return key / value pairs for which no setter method was defined on the model
+      #
+      # @private
+      def self.use_setter_methods(model, params)
+        params ||= {}
+
+        reserved_keys = [:id, model.class.primary_key] + model.class.association_keys
+        model.class.attributes *params.keys.reject { |k| reserved_keys.include?(k) || reserved_keys.map(&:to_s).include?(k) }
+
+        setter_method_names = model.class.setter_method_names
+        params.inject({}) do |memo, (key, value)|
+          setter_method = key.to_s + '='
+          if setter_method_names.include?(setter_method)
+            model.send(setter_method, value)
+          else
+            key = key.to_sym if key.is_a?(String)
+            memo[key] = value
+          end
+          memo
+        end
+      end
+
+      # Handles missing methods
+      #
+      # @private
+      def method_missing(method, *args, &blk)
+        if method.to_s =~ /[?=]$/ || @attributes.include?(method)
+          # Extract the attribute
+          attribute = method.to_s.sub(/[?=]$/, '')
+
+          # Create a new `attribute` methods set
+          self.class.attributes(*attribute)
+
+          # Resend the method!
+          send(method, *args, &blk)
+        else
+          super
+        end
+      end
+
+      # @private
+      def respond_to_missing?(method, include_private = false)
+        method.to_s.end_with?('=') || method.to_s.end_with?('?') || @attributes.include?(method) || super
+      end
+
+      # Assign new attributes to a resource
+      #
+      # @example
+      #   class User
+      #     include Her::Model
+      #   end
+      #
+      #   user = User.find(1) # => #<User id=1 name="Tobias">
+      #   user.assign_attributes(name: "Lindsay")
+      #   user.changes # => { :name => ["Tobias", "Lindsay"] }
+      def assign_attributes(new_attributes)
+        @attributes ||= attributes
+        # Use setter methods first
+        unset_attributes = Her::Model::Attributes.use_setter_methods(self, new_attributes)
+
+        # Then translate attributes of associations into association instances
+        parsed_attributes = self.class.parse_associations(unset_attributes)
+
+        # Then merge the parsed_data into @attributes.
+        @attributes.merge!(parsed_attributes)
+      end
+      alias attributes= assign_attributes
+
+      def attributes
+        @attributes ||= HashWithIndifferentAccess.new
+      end
+
+      # Handles returning true for the accessible attributes
+      #
+      # @private
+      def has_attribute?(attribute_name)
+        @attributes.include?(attribute_name)
+      end
+
+      # Handles returning data for a specific attribute
+      #
+      # @private
+      def get_attribute(attribute_name)
+        @attributes[attribute_name]
+      end
+      alias attribute get_attribute
+
+      # Return the value of the model `primary_key` attribute
+      def id
+        @attributes[self.class.primary_key]
+      end
+      
+      # Mark as destroyed in order to relay _destroy parameter when nested
+      def _destroy=(value)
+        @destroying = !!value
+      end
+
+      def _destroy
+        @destroying ||= false
+      end
+
+      def destroying?
+        @destroying || false
+      end
+
+      # Return `true` if the other object is also a Her::Model and has matching data
+      #
+      # @private
+      def ==(other)
+        other.is_a?(Her::Model) && @attributes == other.attributes
+      end
+
+      # Delegate to the == method
+      #
+      # @private
+      def eql?(other)
+        self == other
+      end
+
+      # Delegate to @attributes, allowing models to act correctly in code like:
+      #     [ Model.find(1), Model.find(1) ].uniq # => [ Model.find(1) ]
+      # @private
+      def hash
+        @attributes.hash
+      end
+
+      # Assign attribute value (ActiveModel convention method).
+      #
+      # @private
+      def attribute=(attribute, value)
+        @attributes[attribute] = nil unless @attributes.include?(attribute)
+        self.send(:"#{attribute}_will_change!") if @attributes[attribute] != value
+        @attributes[attribute] = value
+      end
+
+      # Check attribute value to be present (ActiveModel convention method).
+      #
+      # @private
+      def attribute?(attribute)
+        @attributes.include?(attribute) && @attributes[attribute].present?
+      end
+
+      module ClassMethods
+        # Initialize a collection of resources with raw data from an HTTP request
+        #
+        # @param [Array] parsed_data
+        # @private
+        def new_collection(parsed_data)
+          Her::Model::Attributes.initialize_collection(self, parsed_data)
+        end
+
+        # Initialize a new object with the "raw" parsed_data from the parsing middleware
+        #
+        # @private
+        def new_from_parsed_data(parsed_data)
+          parsed_data = parsed_data.with_indifferent_access
+          new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
+        end
+
+        # Define attribute method matchers to automatically define them using ActiveModel's define_attribute_methods.
+        #
+        # @private
+        def define_attribute_method_matchers
+          attribute_method_suffix '='
+          attribute_method_suffix '?'
+        end
+
+        # Create a mutex for dynamically generated attribute methods or use one defined by ActiveModel.
+        #
+        # @private
+        def attribute_methods_mutex
+          @attribute_methods_mutex ||= if generated_attribute_methods.respond_to? :mu_synchronize
+                                         generated_attribute_methods
+                                       else
+                                         Mutex.new
+                                       end
+        end
+
+        # Define the attributes that will be used to track dirty attributes and validations
+        #
+        # @param [Array] attributes
+        # @example
+        #   class User
+        #     include Her::Model
+        #     attributes :name, :email
+        #   end
+        def attributes(*attributes)
+          attribute_methods_mutex.synchronize do
+            define_attribute_methods attributes
+          end
+        end
+
+        # Define the accessor in which the API response errors (obtained from the parsing middleware) will be stored
+        #
+        # @param [Symbol] store_response_errors
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     store_response_errors :server_errors
+        #   end
+        def store_response_errors(value = nil)
+          store_her_data(:response_errors, value)
+        end
+
+        # Define the accessor in which the API response metadata (obtained from the parsing middleware) will be stored
+        #
+        # @param [Symbol] store_metadata
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     store_metadata :server_data
+        #   end
+        def store_metadata(value = nil)
+          store_her_data(:metadata, value)
+        end
+
+        # @private
+        def setter_method_names
+          @_her_setter_method_names ||= instance_methods.inject(Set.new) do |memo, method_name|
+            memo << method_name.to_s if method_name.to_s.end_with?('=')
+            memo
+          end
+        end
+
+        private
+        # @private
+        def store_her_data(name, value)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            if @_her_store_#{name} && value.present?
+              remove_method @_her_store_#{name}.to_sym
+              remove_method @_her_store_#{name}.to_s + '='
+            end
+
+            @_her_store_#{name} ||= begin
+              superclass.store_#{name} if superclass.respond_to?(:store_#{name})
+            end
+
+            return @_her_store_#{name} unless value
+            @_her_store_#{name} = value
+
+            define_method(value) { @#{name} }
+            define_method(value.to_s+'=') { |value| @#{name} = value }
+          RUBY
+        end
+      end
+    end
+  end
+end