restly 0.0.1.beta.3 → 0.0.1.beta.4

data/lib/restly/base/instance/actions.rb

@@ -25,13 +25,13 @@ module Restly::Base::Instance::Actions
 
   def update
     run_callbacks :update do
-      set_response(connection.put path_with_format, body: @request_body, params: params)
+      set_response(connection.put path_with_format, body: formatted_for_request, params: params)
     end
   end
 
   def create
     run_callbacks :create do
-      set_response(connection.post path_with_format, body: @request_body, params: params)
+      set_response(connection.post path_with_format, body: formatted_for_request, params: params)
     end
   end
 

data/lib/restly/base/instance/error_handling.rb

@@ -1,6 +1,14 @@
 module Restly::Base::Instance::ErrorHandling
   extend ActiveSupport::Concern
 
+  def append_error(field, error)
+    self.errors.add field.to_sym, error
+    if /(?<association>\w+)\.(?<attr>.+)/ =~ field && respond_to_association?(association)
+      instance_eval(&association.to_sym).append_error(attr, error)
+    end
+
+  end
+
   private
 
   def response_has_errors?(response=self.response)
@@ -20,21 +28,23 @@ module Restly::Base::Instance::ErrorHandling
           case error
 
             when Array
-              error.each { |e| self.errors.add(name.to_sym, e) }
+              error.each { |e| append_error name, e }
 
             when String
-              self.errors.add(name.to_sym, error)
+              append_error name, error
 
           end
+
         end
 
       when Array
-        response_errors.each do |error|
-          self.errors.add(:base, error)
-        end
+        response_errors.each { |error| append_error :base, error }
 
       when String
-        self.errors.add(:base, response_errors)
+        append_error :base, response_errors
+
+      when NilClass
+        append_error :base, connection.status_string(response.status)
 
     end
 

data/lib/restly/base/instance/persistence.rb

@@ -4,7 +4,7 @@ module Restly::Base::Instance::Persistence
     return false unless id
 
     begin
-      @response ||= connection.get(path, force: true)
+      @response = connection.get(path, force: true) unless @response.status.to_i < 400
 
     rescue OAuth2::Error => e
       @response = e.response
@@ -12,7 +12,7 @@ module Restly::Base::Instance::Persistence
     end
 
     status = @response.status.to_i
-    status < 300 && status >= 200
+    status < 400 && status >= 200
 
   end
 

data/lib/restly/base/instance/write_callbacks.rb

@@ -2,47 +2,63 @@ module Restly::Base::Instance::WriteCallbacks
   extend ActiveSupport::Concern
 
   included do
-    before_save :format_request
-  end
+    extend ClassMethods
 
-  private
-
-  def format_request
-    @request_body = case format.to_sym
-                      when :json
-                        savable_resource.to_json
-                      when :xml
-                        savable_resource.to_xml
-                      else
-                        savable_resource.to_param
-                    end
-  end
+    class_attribute :request_builders
+    self.request_builders = []
+
+    build_request :attributes
 
-  def savable_resource
-    {resource_name => attributes_with_present_values(writable_attributes)}
   end
 
-  def attributes_with_present_values(attributes=self.attributes)
-    attributes.as_json.reduce({}) do |hash, (key, val)|
-      if val.is_a?(Hash)
-        hash[key] = attributes_with_present_values(val)
-      elsif val.present? && key.to_sym != :id
-        hash[key] = val
-      end
-      hash
+  def formatted_for_request
+
+    case format.to_sym
+      when :json
+        built_for_request.to_json
+
+      when :xml
+        built_for_request.to_xml
+
+      else
+        built_for_request.to_param
+
     end
+
   end
 
-  def writable_attributes(attributes=self.attributes)
+  def built_for_request(resource_key=resource_name)
+
+    attributes = request_builders.reduce(HashWithIndifferentAccess.new) do |attributes, builder|
+      attributes.merge! builder.is_a?(Symbol) ? send(builder) : instance_eval(&builder)
+    end
+
     maa = mass_assignment_authorizer(:default)
 
     if maa.is_a? ActiveModel::MassAssignmentSecurity::BlackList
-      attributes.reject{ |key, val| maa.map(&:to_sym).include?(key.to_sym) }
+      attributes.except! *maa.map(&:to_sym)
 
     elsif maa.is_a? ActiveModel::MassAssignmentSecurity::WhiteList
-      attributes.select{ |key, val| maa.map(&:to_sym).include?(key.to_sym) }
+      attributes.slice! *maa.map(&:to_sym)
+
+    end
+
+    if resource_key
+      { resource_key.to_sym => attributes.select { |k,v| v.present? } }
+    else
+      attributes.select { |k,v| v.present? }
+    end
 
+  end
+
+  module ClassMethods
+
+    private
+
+    def build_request(symbol=nil, &block)
+      self.request_builders << symbol || block
     end
+
   end
 
 

data/lib/restly/base/resource/finders.rb

@@ -24,6 +24,7 @@ module Restly::Base::Resource::Finders
   end
 
   def instance_from_response(response)
+    raise Restly::Error::RecordNotFound, "Could not find a #{name} at the specified path." unless response.status < 400
     new(nil, response: response, connection: connection)
   end
 

data/lib/restly/base/resource/specification/fields.rb

@@ -10,12 +10,12 @@ class Restly::Base::Resource::Specification::Fields < Restly::Proxies::Base
   end
 
   def - field
-    @removed << field
+    @removed += field
     replace(__getobj__.send __method__, field)
   end
 
   def + field
-    @added << field
+    @added += field
     replace(__getobj__.send __method__, field)
   end
 
@@ -38,7 +38,7 @@ class Restly::Base::Resource::Specification::Fields < Restly::Proxies::Base
 
   def reload_specification!
     from_spec = spec[:attributes] || []
-    fields = (from_spec - @removed.to_a) + @added.to_a
+    fields = (from_spec.map(&:to_sym) - @removed.map(&:to_sym)) + @added.map(&:to_sym)
     __setobj__ Restly::Base::Fields::FieldSet.new(spec.model, fields)
   end
 

data/lib/restly/connection.rb

@@ -61,10 +61,15 @@ class Restly::Connection < OAuth2::AccessToken
     }
   end
 
+  def status_string(int)
+    Rack::Utils::HTTP_STATUS_CODES[int.to_i]
+  end
+
   alias_method :forced_request, :request
 
   def request(verb, path, opts={}, &block)
-    path = [base_path.gsub(/\/?$/, ''), path.gsub(/^\/?/, '')].join('/')
+
+    path = [base_path.gsub(/\/?$/, ''), path.gsub(/^\/?/, '')].join('/') unless /#{base_path}/.match path
 
     if cache && !opts[:force]
       request_log("Restly::CacheRequest", path, verb) do
@@ -77,6 +82,8 @@ class Restly::Connection < OAuth2::AccessToken
     end
   end
 
+  private
+
   def id_from_path(path)
     capture = path.match /(?<id>[0-9])\.\w*$/
     capture[:id] if capture
@@ -123,7 +130,7 @@ class Restly::Connection < OAuth2::AccessToken
 
     if response.status >= 500
       site = URI.parse(client.site)
-      formatted_path = ["#{site.scheme}://#{site.host}", "#{site.port}", path].join
+      formatted_path = ["#{site.scheme}://#{site.host}", ":#{site.port}", path].join
       raise Restly::Error::ConnectionError, "#{response.status}: #{status_string(response.status)}\nurl: #{formatted_path}"
     end
 
@@ -142,8 +149,4 @@ class Restly::Connection < OAuth2::AccessToken
     ActiveSupport::Notifications.instrument("cache.restly", key: key, name: name, color: color, &block)
   end
 
-  def status_string(int)
-    Rack::Utils::HTTP_STATUS_CODES[int.to_i]
-  end
-
 end

data/lib/restly/embedded_associations/class_methods.rb

@@ -4,7 +4,7 @@ module Restly::EmbeddedAssociations::ClassMethods
 
   # Embeds One
   def embeds_resource(name, options = {})
-    exclude_field(name) if ancestors.include?(Restly::Base)
+    exclude_field(name)
     self.resource_associations[name] = association = Restly::EmbeddedAssociations::EmbedsOne.new(self, name, options)
 
     define_method name do |options={}|
@@ -20,7 +20,7 @@ module Restly::EmbeddedAssociations::ClassMethods
 
   # Embeds Many
   def embeds_resources(name, options = {})
-    exclude_field(name) if ancestors.include?(Restly::Base)
+    exclude_field(name)
     self.resource_associations[name] = association = Restly::EmbeddedAssociations::EmbedsMany.new(self, name, options)
 
     define_method name do |options={}|
@@ -43,6 +43,13 @@ module Restly::EmbeddedAssociations::ClassMethods
     define_method "#{name}=" do |value|
       set_association name, value
     end
+
+    [:save, :delete, :destroy].each do |method|
+      define_method method do
+        raise NotImplemented, "Embedded actions have not been implemented."
+      end
+    end
+
   end
 
 end

data/lib/restly/nested_attributes.rb

@@ -6,23 +6,28 @@ module Restly::NestedAttributes
 
   included do
     class_attribute :resource_nested_attributes_options, :instance_writer => false
-    self.resource_nested_attributes_options = {}
+    self.resource_nested_attributes_options = HashWithIndifferentAccess.new
 
     inherited do
       self.resource_nested_attributes_options = resource_nested_attributes_options.dup
     end
 
+    if ancestors.include?(Restly::Base)
+      include Restly::Base::Instance::WriteCallbacks
+      build_request :nested_attributes_for_request
+    else
+      before_save :save_nested_attributes_associations
+    end
+
   end
 
   private
 
   # One To One Association
-  def assign_nested_attributes_for_one_to_one_resource_association( association_name, attributes )
+  def assign_nested_attributes_for_one_to_one_resource_association( association_name, attributes={} )
 
-    association_attributes[association_name] = attributes.delete("#{association_name}_attributes") || {}
-    associated_instance = send(association_name) ||
-      self.class.reflect_on_resource_association(association_name).build(self)
-    associated_instance.attributes = association_attributes
+    associated_instance = send(association_name) || self.class.reflect_on_resource_association(association_name).build(self)
+    associated_instance.attributes = attributes
 
   end
 
@@ -57,15 +62,40 @@ module Restly::NestedAttributes
 
   end
 
-  def set_nested_attributes_for_save
-    @attributes = @attributes.reduce(HashWithIndifferentAccess.new) do |hash, (key, v)|
-      options = resource_nested_attributes_options[key.to_sym]
-      key = [ options[:write_prefix], key, options[:write_suffix] ].compact.join('_') if options.present?
-      hash[key] = v
+  def nested_attributes_for_request
+    resource_nested_attributes_options.reduce(HashWithIndifferentAccess.new) do |hash, (association_name, options)|
+      association = self.class.reflect_on_resource_association association_name.to_sym
+      next unless association.options[:autosave]
+
+      associated_object = instance_eval(&association_name.to_sym)
+      built_for_request = if associated_object.is_a? Array
+                            associated_object.map { |instance| instance.built_for_request(nil) if instance.changed? }.compact
+                          else
+                            associated_object.built_for_request(nil) if associated_object.changed?
+                          end
+
+      key = [ options[:write_prefix], association_name, options[:write_suffix] ].compact.join('_')
+      hash[key] = built_for_request if built_for_request.present?
       hash
     end
   end
 
+  def save_nested_attributes_associations
+    resource_nested_attributes_options.each do |association_name, options|
+      association = self.class.reflect_on_resource_association association_name.to_sym
+      next unless association.options[:autosave]
+
+      associated_object = instance_eval(&association_name.to_sym)
+      if associated_object.is_a? Array
+        associated_object.each do |instance|
+          instance.save && instance.changed?
+        end
+      else
+        associated_object.save if associated_object.changed?
+      end
+    end
+  end
+
   def nested_attribute_missing(m, *args)
     if !!(matched = ATTR_MATCHER.match m) && (options = resource_nested_attributes_options[(attr = matched[:attr])])
       send( "assign_nested_attributes_for_#{options[:association_type]}_resource_association", attr, *args )
@@ -80,6 +110,14 @@ module Restly::NestedAttributes
     super
   end
 
+  def respond_to_nested_attributes?(m)
+    (matched = ATTR_MATCHER.match m) && resource_nested_attributes_options.has_key?(matched[:attr].to_sym)
+  end
+
+  def respond_to?(m, include_private = false)
+    respond_to_nested_attributes?(m) || super
+  end
+
   module ClassMethods
     REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |key, value| key == '_destroy' || value.blank? } }
 
@@ -89,8 +127,6 @@ module Restly::NestedAttributes
       options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only, :write_prefix, :write_suffix)
       options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
 
-      before_save :set_nested_attributes_for_save
-
       attr_names.each do |association_name|
 
         if ( reflection = reflect_on_resource_association(association_name) )

data/lib/restly/version.rb

@@ -1,3 +1,3 @@
 module Restly
-  VERSION = "0.0.1.beta.3"
+  VERSION = "0.0.1.beta.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: restly
 version: !ruby/object:Gem::Version
-  version: 0.0.1.beta.3
+  version: 0.0.1.beta.4
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-22 00:00:00.000000000 Z
+date: 2012-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oauth2