her 0.6.2 → 0.6.3

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

@@ -12,20 +12,59 @@ module Her
           }.merge(attrs)
           klass.associations[:has_one] << attrs
 
-          klass.instance_eval do
-            define_method(name) do
+          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.new(self, attrs))
+              cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasOneAssociation.new(self, #{attrs.inspect}))
             end
-          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] => klass.new(data[data_key]) }
         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.new(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
@@ -48,6 +87,15 @@ module Her
             @parent.attributes[@name]
           end
         end
+
+        # @private
+        def assign_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
       end
     end
   end

data/lib/her/model/attributes.rb

@@ -3,22 +3,33 @@ module Her
     # This module handles all methods related to model attributes
     module Attributes
       extend ActiveSupport::Concern
-
       attr_accessor :attributes
-      alias :data :attributes
-      alias :data= :attributes=
 
       # 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)
       end
 
       # Initialize a collection of resources
+      #
       # @private
       def self.initialize_collection(klass, parsed_data={})
         collection_data = parsed_data[:data].map do |item_data|
@@ -31,6 +42,7 @@ module Her
 
       # 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)
         setter_method_names = model.class.setter_method_names
@@ -48,6 +60,7 @@ module Her
       end
 
       # Handles missing methods
+      #
       # @private
       def method_missing(method, *args, &blk)
         if method.to_s =~ /[?=]$/ || attributes.include?(method)
@@ -74,8 +87,16 @@ module Her
         method.to_s.end_with?('=') || method.to_s.end_with?('?') || @attributes.include?(method) || @attributes.include?(method) || super
       end
 
-      # Assign new attributes
-      # @private
+      # 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(raw_data)
         @attributes ||= {}
         # Use setter methods first, then translate attributes of associations
@@ -84,36 +105,37 @@ module Her
         parsed_attributes = self.class.parse_associations(unset_attributes)
         attributes.update(parsed_attributes)
       end
-      alias :update_attributes :assign_attributes
-      alias :assign_data :assign_attributes
 
       # Handles returning true for the accessible attributes
+      #
       # @private
       def has_attribute?(attribute_name)
         attributes.include?(attribute_name)
       end
-      alias :has_data? :has_attribute?
 
       # Handles returning data for a specific attribute
+      #
       # @private
       def get_attribute(attribute_name)
         attributes[attribute_name]
       end
-      alias :get_data :get_attribute
 
       # Override the method to prevent from returning the object ID
+      #
       # @private
       def id
         attributes[self.class.primary_key]
       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
@@ -137,28 +159,44 @@ module Her
         # 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)
           define_attribute_methods attributes
 
           attributes.each do |attribute|
             attribute = attribute.to_sym
 
-            define_method attribute do
-              @attributes.include?(attribute) ? @attributes[attribute] : nil
-            end
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{attribute}
+                @attributes.include?(:'#{attribute}') ? @attributes[:'#{attribute}'] : nil
+              end
 
-            define_method :"#{attribute}=" do |value|
-              self.send(:"#{attribute}_will_change!") if @attributes[attribute] != value
-              @attributes[attribute] = value
-            end
+              def #{attribute}=(value)
+                self.send(:"#{attribute}_will_change!") if @attributes[:'#{attribute}'] != value
+                @attributes[:'#{attribute}'] = value
+              end
 
-            define_method :"#{attribute}?" do
-              @attributes.include?(attribute) && @attributes[attribute].present?
-            end
+              def #{attribute}?
+                @attributes.include?(:'#{attribute}') && @attributes[:'#{attribute}'].present?
+              end
+            RUBY
           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)
           if @_her_store_response_errors
             remove_method @_her_store_response_errors
@@ -172,11 +210,21 @@ module Her
           return @_her_store_response_errors unless value
           @_her_store_response_errors = value
 
-          define_method(@_her_store_response_errors) { @response_errors }
-          define_method(:"#{@_her_store_response_errors}=") { |value| @response_errors = value }
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{@_her_store_response_errors}; @response_errors; end
+            def #{@_her_store_response_errors}=(value); @response_errors = value; end
+          RUBY
         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)
           if @_her_store_metadata
             remove_method @_her_store_metadata
@@ -190,8 +238,10 @@ module Her
           return @_her_store_metadata unless value
           @_her_store_metadata = value
 
-          define_method(@_her_store_metadata) { @metadata }
-          define_method(:"#{@_her_store_metadata}=") { |value| @metadata = value }
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{@_her_store_metadata}; @metadata; end
+            def #{@_her_store_metadata}=(value); @metadata = value; end
+          RUBY
         end
 
         # @private

data/lib/her/model/base.rb

@@ -7,6 +7,8 @@ module Her
       # Returns true if attribute_name is
       # * in resource attributes
       # * an association
+      #
+      # @private
       def has_key?(attribute_name)
         has_attribute?(attribute_name) ||
         has_association?(attribute_name)
@@ -15,6 +17,8 @@ module Her
       # Returns
       # * the value of the attribute_name attribute if it's in orm data
       # * the resource/collection corrsponding to attribute_name if it's an association
+      #
+      # @private
       def [](attribute_name)
         get_attribute(attribute_name) ||
         get_association(attribute_name)

data/lib/her/model/deprecated_methods.rb

@@ -0,0 +1,61 @@
+module Her
+  module Model
+    # @private
+    module DeprecatedMethods
+      extend ActiveSupport::Concern
+
+      def self.deprecate!(old, new, object, *args)
+        line = begin
+          raise StandardError
+        rescue StandardError => e
+          e.backtrace[2]
+        end
+
+        warn "#{line} - The `#{old}` method is deprecated and may be removed soon. Please update your code with `#{new}` instead."
+        object.send(new, *args)
+      end
+
+      def data(*args)
+        Her::Model::DeprecatedMethods.deprecate! :data, :attributes, self, *args
+      end
+
+      def data=(*args)
+        Her::Model::DeprecatedMethods.deprecate! :data=, :attributes=, self, *args
+      end
+
+      def update_attributes(*args)
+        Her::Model::DeprecatedMethods.deprecate! :update_attributes, :assign_attributes, self, *args
+      end
+
+      def assign_data(*args)
+        Her::Model::DeprecatedMethods.deprecate! :assign_data, :assign_attributes, self, *args
+      end
+
+      def has_data?(*args)
+        Her::Model::DeprecatedMethods.deprecate! :has_data?, :has_attribute?, self, *args
+      end
+
+      def get_data(*args)
+        Her::Model::DeprecatedMethods.deprecate! :get_data, :get_attribute, self, *args
+      end
+
+      module ClassMethods
+        def has_relationship?(*args)
+          Her::Model::DeprecatedMethods.deprecate! :has_relationship?, :has_association?, self, *args
+        end
+
+        def get_relationship(*args)
+          Her::Model::DeprecatedMethods.deprecate! :get_relationship, :get_association, self, *args
+        end
+
+        def relationships(*args)
+          Her::Model::DeprecatedMethods.deprecate! :relationships, :associations, self, *args
+        end
+
+        def her_api(*args)
+          Her::Model::DeprecatedMethods.deprecate! :her_api, :use_api, self, *args
+        end
+      end
+    end
+  end
+end

data/lib/her/model/http.rb

@@ -7,6 +7,17 @@ module Her
 
       module ClassMethods
         # Change which API the model will use to make its HTTP requests
+        #
+        # @example
+        #   secondary_api = Her::API.new :url => "https://api.example" do |connection|
+        #     connection.use Faraday::Request::UrlEncoded
+        #     connection.use Her::Middleware::DefaultParseJSON
+        #   end
+        #
+        #   class User
+        #     include Her::Model
+        #     use_api secondary_api
+        #   end
         def use_api(value = nil)
           @_her_use_api ||= begin
             superclass.use_api if superclass.respond_to?(:use_api)
@@ -15,10 +26,11 @@ module Her
           return @_her_use_api unless value
           @_her_use_api = value
         end
-        alias :her_api :use_api
-        alias :uses_api :use_api
+        alias her_api use_api
+        alias uses_api use_api
 
         # Main request wrapper around Her::API. Used to make custom request to the API.
+        #
         # @private
         def request(attrs={})
           request = her_api.request(attrs)
@@ -38,52 +50,49 @@ module Her
         # - <method>_resource(path, attrs, &block)
         # - custom_<method>(path, attrs)
         METHODS.each do |method|
-          define_method method do |path, *attrs|
-            attrs = attrs.first || {}
-            path = build_request_path_from_string_or_symbol(path, attrs)
-            send(:"#{method}_raw", path, attrs) do |parsed_data, response|
-              if parsed_data[:data].is_a?(Array)
-                new_collection(parsed_data)
-              else
-                new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(path, attrs={})
+              path = build_request_path_from_string_or_symbol(path, attrs)
+              send(:'#{method}_raw', path, attrs) do |parsed_data, response|
+                if parsed_data[:data].is_a?(Array)
+                  new_collection(parsed_data)
+                else
+                  new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
+                end
               end
             end
-          end
 
-          define_method :"#{method}_raw" do |path, *attrs, &block|
-            attrs = attrs.first || {}
-            path = build_request_path_from_string_or_symbol(path, attrs)
-            request(attrs.merge(:_method => method, :_path => path), &block)
-          end
+            def #{method}_raw(path, attrs={}, &block)
+              path = build_request_path_from_string_or_symbol(path, attrs)
+              request(attrs.merge(:_method => #{method.to_sym.inspect}, :_path => path), &block)
+            end
 
-          define_method :"#{method}_collection" do |*args|
-            path  = args.first
-            attrs = args[1] || {}
-            path = build_request_path_from_string_or_symbol(path, attrs)
-            send(:"#{method}_raw", build_request_path_from_string_or_symbol(path, attrs), attrs) do |parsed_data, response|
-              new_collection(parsed_data)
+            def #{method}_collection(path, attrs={})
+              path = build_request_path_from_string_or_symbol(path, attrs)
+              send(:'#{method}_raw', build_request_path_from_string_or_symbol(path, attrs), attrs) do |parsed_data, response|
+                new_collection(parsed_data)
+              end
             end
-          end
 
-          define_method :"#{method}_resource" do |path, *attrs|
-            attrs = attrs.first || {}
-            path = build_request_path_from_string_or_symbol(path, attrs)
-            send(:"#{method}_raw", path, attrs) do |parsed_data, response|
-              new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
+            def #{method}_resource(path, attrs={})
+              path = build_request_path_from_string_or_symbol(path, attrs)
+              send(:"#{method}_raw", path, attrs) do |parsed_data, response|
+                new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
+              end
             end
-          end
 
-          define_method :"custom_#{method}" do |*paths|
-            metaclass = (class << self; self; end)
-            opts = paths.last.is_a?(Hash) ? paths.pop : Hash.new
+            def custom_#{method}(*paths)
+              metaclass = (class << self; self; end)
+              opts = paths.last.is_a?(Hash) ? paths.pop : Hash.new
 
-            paths.each do |path|
-              metaclass.send(:define_method, path) do |*attrs|
-                attrs = attrs.first || Hash.new
-                send(method, path, attrs)
+              paths.each do |path|
+                metaclass.send(:define_method, path) do |*attrs|
+                  attrs = attrs.first || Hash.new
+                  send(#{method.to_sym.inspect}, path, attrs)
+                end
               end
             end
-          end
+          RUBY
         end
       end
     end