her 0.3.3 → 0.3.4

data/lib/her/model/introspection.rb

@@ -11,13 +11,13 @@ module Her
       #
       #   @user = User.find(1)
       #   p @user # => #<User(/users/1) id=1 name="Tobias Fünke">
-      def inspect # {{{
+      def inspect
         "#<#{self.class}(#{request_path}) #{@data.inject([]) { |memo, item| key, value = item; memo << "#{key}=#{attribute_for_inspect(value)}"}.join(" ")}>"
-      end # }}}
+      end
 
       private
       # @private
-      def attribute_for_inspect(value) # {{{
+      def attribute_for_inspect(value)
         if value.is_a?(String) && value.length > 50
           "#{value[0..50]}...".inspect
         elsif value.is_a?(Date) || value.is_a?(Time)
@@ -25,32 +25,32 @@ module Her
         else
           value.inspect
         end
-      end # }}}
+      end
 
       module ClassMethods
         # Finds a class at the same level as this one or at the global level.
         # @private
-        def nearby_class(name) # {{{
+        def nearby_class(name)
           sibling_class(name) || name.constantize rescue nil
-        end # }}}
+        end
 
         protected
         # Looks for a class at the same level as this one with the given name.
         # @private
-        def sibling_class(name) # {{{
+        def sibling_class(name)
           if mod = self.containing_module
-            "#{mod.name}::#{name}".constantize rescue nil
-          else
-            name.constantize rescue nil
+            @sibling_class ||= {}
+            @sibling_class[mod] ||= {}
+            @sibling_class[mod][name] ||= "#{mod.name}::#{name}".constantize rescue nil
           end
-        end # }}}
+        end
 
         # If available, returns the containing Module for this class.
         # @private
-        def containing_module # {{{
+        def containing_module
           return unless self.name =~ /::/
           self.name.split("::")[0..-2].join("::").constantize
-        end # }}}
+        end
       end
     end
   end

data/lib/her/model/orm.rb

@@ -6,31 +6,44 @@ module Her
       attr_accessor :data, :metadata, :errors
 
       # Initialize a new object with data received from an HTTP request
-      # @private
-      def initialize(data={}) # {{{
+      def initialize(params={})
         @data = {}
-        @metadata = data.delete(:_metadata) || {}
-        @errors = data.delete(:_errors) || {}
-
-        # Only keep the keys that don't have corresponding writer methods
-        cleaned_data = data.inject({}) do |memo, item|
-          key, value = item
-          send "#{key}=".to_sym, value unless value.nil?
-          writer_method_defined?(key) ? memo : memo.merge({ key => value })
-        end
-        @data.merge! self.class.parse_relationships(cleaned_data)
-      end # }}}
+        @metadata = params.delete(:_metadata) || {}
+        @errors = params.delete(:_errors) || {}
+
+        # Use setter methods first, then translate attributes of relationships
+        # into relationship instances, then merge the parsed_data into @data.
+        unset_data = Her::Model::ORM.use_setter_methods(self, params)
+        parsed_data = self.class.parse_relationships(unset_data)
+        @data.update(parsed_data)
+      end
 
       # Initialize a collection of resources
       # @private
-      def self.initialize_collection(klass, parsed_data={}) # {{{
+      def self.initialize_collection(klass, parsed_data={})
         collection_data = parsed_data[:data].map { |item_data| klass.new(item_data) }
         Her::Collection.new(collection_data, parsed_data[:metadata], parsed_data[:errors])
-      end # }}}
+      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)
+        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
+            memo[key] = value
+          end
+          memo
+        end
+      end
 
       # Handles missing methods by routing them through @data
       # @private
-      def method_missing(method, *args, &blk) # {{{
+      def method_missing(method, *args, &blk)
         if method.to_s.end_with?('=')
           @data[method.to_s.chomp('=').to_sym] = args.first
         elsif method.to_s.end_with?('?')
@@ -40,49 +53,59 @@ module Her
         else
           super
         end
-      end # }}}
+      end
 
       # Handles returning true for the cases handled by method_missing
-      def respond_to?(method, include_private = false) # {{{
+      def respond_to?(method, include_private = false)
         method.to_s.end_with?('=') || method.to_s.end_with?('?') || @data.include?(method) || super
-      end # }}}
+      end
+
+      # Handles returning true for the accessible attributes
+      def has_key?(attribute_name)
+        @data.include?(attribute_name)
+      end
+
+      # Handles returning attribute value from data
+      def [](attribute_name)
+        @data[attribute_name]
+      end
 
       # Override the method to prevent from returning the object ID (in ruby-1.8.7)
       # @private
-      def id # {{{
+      def id
         @data[:id] || super
-      end # }}}
+      end
 
       # Return `true` if a resource was not saved yet
-      def new? # {{{
+      def new?
         !@data.include?(:id)
-      end # }}}
+      end
 
       # Return `true` if a resource does not contain errors
-      def valid? # {{{
+      def valid?
         @errors.empty?
-      end # }}}
+      end
 
       # Return `true` if a resource contains errors
-      def invalid? # {{{
+      def invalid?
         @errors.any?
-      end # }}}
+      end
 
       # Return `true` if the other object is also a Her::Model and has matching data
-      def ==(other) # {{{
+      def ==(other)
         other.is_a?(Her::Model) && @data == other.data
-      end # }}}
+      end
 
       # Delegate to the == method
-      def eql?(other) # {{{
+      def eql?(other)
         self == other
-      end # }}}
+      end
 
       # Delegate to @data, allowing models to act correctly in code like:
       #     [ Model.find(1), Model.find(1) ].uniq # => [ Model.find(1) ]
-      def hash # {{{
+      def hash
         @data.hash
-      end # }}}
+      end
 
       # Save a resource
       #
@@ -97,7 +120,7 @@ module Her
       #   @user = User.new({ :fullname => "Tobias Fünke" })
       #   @user.save
       #   # Called via POST "/users"
-      def save # {{{
+      def save
         params = to_params
         resource = self
 
@@ -114,10 +137,13 @@ module Her
             self.data = parsed_data[:data]
             self.metadata = parsed_data[:metadata]
             self.errors = parsed_data[:errors]
+
+            return false if self.errors.any?
           end
         end
+
         self
-      end # }}}
+      end
 
       # Destroy a resource
       #
@@ -125,7 +151,7 @@ module Her
       #   @user = User.find(1)
       #   @user.destroy
       #   # Called via DELETE "/users/1"
-      def destroy # {{{
+      def destroy
         resource = self
         self.class.wrap_in_hooks(resource, :destroy) do |resource, klass|
           klass.request(:_method => :delete, :_path => "#{request_path}") do |parsed_data|
@@ -135,32 +161,24 @@ module Her
           end
         end
         self
-      end # }}}
+      end
 
       # Convert into a hash of request parameters
       #
       # @example
       #   @user.to_params
       #   # => { :id => 1, :name => 'John Smith' }
-      def to_params # {{{
+      def to_params
         @data.dup
-      end # }}}
-
-      private
-
-      # @private
-      def writer_method_defined?(key) # {{{
-        self.class.instance_methods.include?("#{key}=".to_sym) || # Ruby 1.9
-          self.class.instance_methods.include?("#{key}=") # Ruby 1.8
-      end # }}}
+      end
 
       module ClassMethods
         # Initialize a collection of resources with raw data from an HTTP request
         #
         # @param [Array] parsed_data
-        def new_collection(parsed_data) # {{{
+        def new_collection(parsed_data)
           Her::Model::ORM.initialize_collection(self, parsed_data)
-        end # }}}
+        end
 
         # Fetch specific resource(s) by their ID
         #
@@ -171,7 +189,7 @@ module Her
         # @example
         #   @users = User.find([1, 2])
         #   # Fetched via GET "/users/1" and GET "/users/2"
-        def find(*ids) # {{{
+        def find(*ids)
           params = ids.last.is_a?(Hash) ? ids.pop : {}
           results = ids.flatten.compact.uniq.map do |id|
             request(params.merge(:_method => :get, :_path => "#{build_request_path(params.merge(:id => id))}")) do |parsed_data|
@@ -183,25 +201,25 @@ module Her
           else
             results.first
           end
-        end # }}}
+        end
 
         # Fetch a collection of resources
         #
         # @example
         #   @users = User.all
         #   # Fetched via GET "/users"
-        def all(params={}) # {{{
+        def all(params={})
           request(params.merge(:_method => :get, :_path => "#{build_request_path(params)}")) do |parsed_data|
             new_collection(parsed_data)
           end
-        end # }}}
+        end
 
         # Create a resource and return it
         #
         # @example
         #   @user = User.create({ :fullname => "Tobias Fünke" })
         #   # Called via POST "/users/1"
-        def create(params={}) # {{{
+        def create(params={})
           resource = new(params)
           wrap_in_hooks(resource, :create, :save) do |resource, klass|
             params = resource.to_params
@@ -214,28 +232,36 @@ module Her
             end
           end
           resource
-        end # }}}
+        end
 
         # Save an existing resource and return it
         #
         # @example
         #   @user = User.save_existing(1, { :fullname => "Tobias Fünke" })
         #   # Called via PUT "/users/1"
-        def save_existing(id, params) # {{{
+        def save_existing(id, params)
           resource = new(params.merge(:id => id))
           resource.save
-        end # }}}
+        end
 
         # Destroy an existing resource
         #
         # @example
         #   User.destroy_existing(1)
         #   # Called via DELETE "/users/1"
-        def destroy_existing(id, params={}) # {{{
+        def destroy_existing(id, params={})
           request(params.merge(:_method => :delete, :_path => "#{build_request_path(params.merge(:id => id))}")) do |parsed_data|
             new(parsed_data[:data])
           end
-        end # }}}
+        end
+
+        # @private
+        def setter_method_names
+          @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
       end
     end
   end

data/lib/her/model/paths.rb

@@ -11,9 +11,9 @@ module Her
       #   end
       #
       #   User.find(1) # Fetched via GET /utilisateurs/1
-      def request_path # {{{
+      def request_path
         self.class.build_request_path(@data.dup)
-      end # }}}
+      end
 
       module ClassMethods
         # Defines a custom collection path for the resource
@@ -23,7 +23,7 @@ module Her
         #    include Her::Model
         #    collection_path "/users"
         #  end
-        def collection_path(path=nil) # {{{
+        def collection_path(path=nil)
           @her_collection_path ||= begin
             superclass.collection_path.dup if superclass.respond_to?(:collection_path)
           end
@@ -31,7 +31,7 @@ module Her
           return @her_collection_path unless path
           @her_resource_path = "#{path}/:id"
           @her_collection_path = path
-        end # }}}
+        end
 
         # Defines a custom resource path for the resource
         #
@@ -40,14 +40,14 @@ module Her
         #    include Her::Model
         #    resource_path "/users/:id"
         #  end
-        def resource_path(path=nil) # {{{
+        def resource_path(path=nil)
           @her_resource_path ||= begin
             superclass.resource_path.dup if superclass.respond_to?(:resource_path)
           end
 
           return @her_resource_path unless path
           @her_resource_path = path
-        end # }}}
+        end
 
         # Return a custom path based on the collection path and variable parameters
         #
@@ -58,7 +58,7 @@ module Her
         #   end
         #
         #   User.all # Fetched via GET /utilisateurs
-        def build_request_path(path=nil, parameters={}) # {{{
+        def build_request_path(path=nil, parameters={})
           unless path.is_a?(String)
             parameters = path || {}
             path = parameters.include?(:id) ? resource_path : collection_path
@@ -68,7 +68,7 @@ module Her
             # Look for :key or :_key, otherwise raise an exception
             parameters.delete($1.to_sym) || parameters.delete("_#{$1}".to_sym) || raise(Her::Errors::PathError.new("Missing :_#{$1} parameter to build the request path (#{path})."))
           end
-        end # }}}
+        end
       end
     end
   end

data/lib/her/model/relationships.rb

@@ -4,8 +4,9 @@ module Her
     module Relationships
       # Return @her_relationships, lazily initialized with copy of the
       # superclass' her_relationships, or an empty hash.
+      #
       # @private
-      def relationships # {{{
+      def relationships
         @her_relationships ||= begin
           if superclass.respond_to?(:relationships)
             superclass.relationships.dup
@@ -13,16 +14,17 @@ module Her
             {}
           end
         end
-      end # }}}
+      end
 
       # Parse relationships data after initializing a new object
+      #
       # @private
-      def parse_relationships(data) # {{{
+      def parse_relationships(data)
         relationships.each_pair do |type, definitions|
           definitions.each do |relationship|
             name = relationship[:name]
+            next unless data[name]
             klass = self.nearby_class(relationship[:class_name])
-            next if !data.include?(name) or data[name].nil?
             data[name] = case type
               when :has_many
                 Her::Model::ORM.initialize_collection(klass, :data => data[name])
@@ -34,7 +36,7 @@ module Her
           end
         end
         data
-      end # }}}
+      end
 
       # Define an *has_many* relationship.
       #
@@ -54,7 +56,7 @@ module Her
       #   @user = User.find(1)
       #   @user.articles # => [#<Article(articles/2) id=2 title="Hello world.">]
       #   # Fetched via GET "/users/1/articles"
-      def has_many(name, attrs={}) # {{{
+      def has_many(name, attrs={})
         attrs = {
           :class_name => name.to_s.classify,
           :name => name,
@@ -71,7 +73,7 @@ module Her
             @data[name] ||= klass.get_collection("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
           end
         end
-      end # }}}
+      end
 
       # Define an *has_one* relationship.
       #
@@ -91,7 +93,7 @@ module Her
       #   @user = User.find(1)
       #   @user.organization # => #<Organization(organizations/2) id=2 name="Foobar Inc.">
       #   # Fetched via GET "/users/1/organization"
-      def has_one(name, attrs={}) # {{{
+      def has_one(name, attrs={})
         attrs = {
           :class_name => name.to_s.classify,
           :name => name,
@@ -108,7 +110,7 @@ module Her
             @data[name] ||= klass.get_resource("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
           end
         end
-      end # }}}
+      end
 
       # Define a *belongs_to* relationship.
       #
@@ -128,7 +130,7 @@ module Her
       #   @user = User.find(1)
       #   @user.team # => #<Team(teams/2) id=2 name="Developers">
       #   # Fetched via GET "/teams/2"
-      def belongs_to(name, attrs={}) # {{{
+      def belongs_to(name, attrs={})
         attrs = {
           :class_name => name.to_s.classify,
           :name => name,
@@ -146,17 +148,17 @@ module Her
             @data[name] ||= klass.get_resource("#{klass.build_request_path(:id => @data[attrs[:foreign_key].to_sym])}")
           end
         end
-      end # }}}
+      end
 
       # @private
-      def relationship_accessor(type, attrs) # {{{
+      def relationship_accessor(type, attrs)
         name = attrs[:name]
         class_name = attrs[:class_name]
         define_method(name) do
           klass = self.class.nearby_class(attrs[:class_name])
           @data[name] ||= klass.get_resource("#{klass.build_request_path(attrs[:path], :id => @data[attrs[:foreign_key].to_sym])}")
         end
-      end # }}}
+      end
     end
   end
 end