restly 0.0.1.alpha.16 → 0.0.1.alpha.18

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

@@ -0,0 +1,13 @@
+module Restly::Base::Instance::Comparable
+
+  def ==(object)
+    reload!
+    object.reload!
+
+    this_object = Marshal.dump attributes.except(:id, :created_at, :updated_at)
+    other_object = Marshal.dump object.attributes.except(:id, :created_at, :updated_at)
+
+    Marshal.dump(this_object) == Marshal.dump(other_object) && self.class == object.class
+  end
+
+end

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

@@ -0,0 +1,60 @@
+module Restly::Base::Instance::ErrorHandling
+  extend ActiveSupport::Concern
+
+  private
+
+  def response_has_errors?(response=self.response)
+    @response.status >= 400 ||
+      (parsed_response(response).is_a?(Hash) &&
+        (parsed_response(response)[:errors] || parsed_response(response)[:error]))
+  end
+
+  def set_errors_from_response(response = self.response)
+
+    response_errors = parsed_response(response)[:errors] || parsed_response(response)[:error]
+
+    case response_errors
+
+      when Hash
+        response_errors.each do |name, error|
+          case error
+
+            when Array
+              error.each { |e| self.errors.add(name.to_sym, e) }
+
+            when String
+              self.errors.add(name.to_sym, error)
+
+          end
+        end
+
+      when Array
+        response_errors.each do |error|
+          self.errors.add(:base, error)
+        end
+
+      when String
+        self.errors.add(:base, response_errors)
+
+    end
+
+    self.errors
+  end
+
+  def read_attribute_for_validation(attr)
+    send attr
+  end
+
+  module ClassMethods
+
+    def human_attribute_name(attr, options = {})
+      attr.to_s.humanize
+    end
+
+    def lookup_ancestors
+      [self]
+    end
+
+  end
+
+end

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

@@ -25,7 +25,7 @@ module Restly::Base::Instance::Persistence
   end
 
   def reload!
-    raise Restly::Error::MissingId, "Cannot reload #{resource_name}, either it hasn't been created or it is missing an ID." unless id
+    raise Restly::Error::MissingId, "Cannot reload #{resource_name}, either it hasn't been created or it is missing an ID." unless new_record?
     set_attributes_from_response connection.get(path_with_format, force: true)
     @loaded = true
     self

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

@@ -6,7 +6,7 @@ class Restly::Base::Resource::Specification::Fields < Restly::Proxies::Base
     @spec = spec
     @removed = Set.new
     @added = Set.new
-    super Restly::Base::Fields::FieldSet.new
+    super Restly::Base::Fields::FieldSet.new(spec.model)
   end
 
   def -(field)
@@ -34,7 +34,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
-    __setobj__ Restly::Base::Fields::FieldSet.new(fields)
+    __setobj__ Restly::Base::Fields::FieldSet.new(spec.model, fields)
   end
 
 end

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

@@ -45,7 +45,7 @@ module Restly::Base::Resource::Specification::MassAssignmentSecurity
 
     def reload_specification!
       accepts = spec.actions.map { |action| action['accepts_parameters'] }.flatten if spec.actions.present?
-      __setobj__ ActiveModel::MassAssignmentSecurity::BlackList.new accepts
+      __setobj__ ActiveModel::MassAssignmentSecurity::WhiteList.new accepts
     end
 
   end

data/lib/restly/client.rb

@@ -1,17 +1,30 @@
 class Restly::Client < OAuth2::Client
 
   attr_accessor :id, :secret, :site
-  attr_reader :format
+  attr_reader :format, :resource
 
   def initialize(*args, &block)
     opts = args.extract_options!
-    self.id =     args[0] || Restly::Configuration.oauth_options[:client_id]
-    self.secret = args[1] || Restly::Configuration.oauth_options[:client_secret]
-    self.site = opts.delete(:site) || Restly::Configuration.site
-    self.options = Restly::Configuration.client_options.merge(opts)
-    self.ssl = opts.delete(:ssl) || Restly::Configuration.ssl
-    self.format = @format = opts.delete(:format) || Restly::Configuration.default_format
+    opts.merge!(raise_errors: false)
+
+    self.resource  = opts.delete(:resource) if opts[:resource]
+    self.id        = args[0] || Restly::Configuration.oauth_options[:client_id]
+    self.secret    = args[1] || Restly::Configuration.oauth_options[:client_secret]
+    self.site      = opts.delete(:site) || Restly::Configuration.site
+    self.options   = Restly::Configuration.client_options.merge(opts)
+    self.ssl       = opts.delete(:ssl) || Restly::Configuration.ssl
+    self.format    = @format = opts.delete(:format) || Restly::Configuration.default_format
     self.options[:connection_build] ||= block
+
+  end
+
+  def resource=(resource)
+    raise InvalidObject, "Resource must be a descendant of Restly::Base" unless resource.ancestors.include?(Restly::Base)
+    @resource = resource
+  end
+
+  def resource_name
+    resource.name.parameterize
   end
 
   def ssl=(val)

data/lib/restly/collection.rb

@@ -1,21 +1,28 @@
 class Restly::Collection < Array
   extend ActiveSupport::Autoload
   autoload :Pagination
+  autoload :ErrorHandling
 
   include Restly::Base::Resource::Finders
   include Restly::Base::Resource::BatchActions
   include Restly::Base::GenericMethods
+  include ErrorHandling
 
   delegate :resource_name, :new, :client, to: :resource
 
-  attr_reader :resource
+  attr_reader :resource, :response
 
   def initialize(resource, array=[], opts={})
-    @resource = resource
-    @response = opts[:response]
-    @connection
-    array = items_from_response if @response.is_a?(OAuth2::Response)
-    super(array)
+    ActiveSupport::Notifications.instrument("load_collection.restly", model: resource.name) do
+      @errors = []
+      @resource = resource
+      @connection
+      if opts[:response]
+        set_response(opts[:response])
+      else
+        replace array
+      end
+    end
   end
 
   [:path, :connection, :params].each do |attr|
@@ -52,24 +59,41 @@ class Restly::Collection < Array
     super(instance)
   end
 
+  def replace(array)
+    array.each do |instance|
+      raise Restly::Error::InvalidObject, "Object is not an instance of #{resource}" unless accepts?(instance)
+    end
+    super
+  end
+
   def reload!
     replace collection_from_response(connection.get path)
   end
 
   private
 
+  def set_response(response)
+    raise Restly::Error::InvalidResponse unless response.is_a? OAuth2::Response
+    @response = response
+    if response.try(:body)
+      if response_has_errors?(response)
+        set_errors_from_response
+      else
+        set_items_from_response
+      end
+    end
+  end
+
   def serializable_hash(options = nil)
-    self.collect do |i|
+    self.map do |i|
       i.serializable_hash(options)
     end
   end
 
-  def items_from_response
-    parsed = @response.parsed || {}
-    parsed = parsed[resource_name.pluralize] if parsed.is_a?(Hash) && parsed[resource_name.pluralize]
-    parsed.collect do |instance|
+  def set_items_from_response(response=self.response)
+    parsed_response(response).reduce(self) do |collection, instance|
       instance = instance[resource_name] if instance[resource_name]
-      resource.new(instance, connection: connection)
+      collection << resource.new(instance, connection: connection, loaded: false)
     end
   end
 
@@ -77,4 +101,16 @@ class Restly::Collection < Array
     instance.class.name == resource.name
   end
 
+  def parsed_response(response=self.response)
+    return {} unless response
+    parsed = response.parsed || {}
+    if parsed.is_a?(Hash) && parsed[resource_name.pluralize]
+      parsed[resource_name.pluralize]
+    elsif parsed.is_a?(Hash)
+      parsed.with_indifferent_access
+    else
+      parsed
+    end
+  end
+
 end

data/lib/restly/collection/error_handling.rb

@@ -0,0 +1,17 @@
+module Restly::Collection::ErrorHandling
+  extend ActiveSupport::Concern
+
+  def response_has_errors?(response=self.response)
+    @response.status >= 400 ||
+      (parsed_response(response).is_a?(Hash) &&
+        (parsed_response(response)[:errors] || parsed_response(response)[:error]))
+  end
+
+  def set_errors_from_response(response = self.response)
+    if (error = parsed_response(response)[:errors] || parsed_response(response)[:error])
+      @errors << error
+    end
+    replace []
+  end
+
+end

data/lib/restly/connection.rb

@@ -2,6 +2,8 @@ class Restly::Connection < OAuth2::AccessToken
 
   attr_accessor :cache, :cache_options
 
+  delegate :resource, :resource_name, to: :client
+
   # TODO: Refactor with subclasses that have their own tokenize methods.
   def self.tokenize(client, object)
 
@@ -63,37 +65,79 @@ class Restly::Connection < OAuth2::AccessToken
 
   def request(verb, path, opts={}, &block)
     if cache && !opts[:force]
-      cached_request(verb, path, opts, &block)
+      request_log("Restly::CacheRequest", path, verb) do
+        cached_request(verb, path, opts, &block)
+      end
     else
-      forced_request(verb, path, opts, &block)
+      request_log("Restly::Request", path, verb) do
+        forced_request(verb, path, opts, &block)
+      end
     end
   end
 
-  private
+  def id_from_path(path)
+    capture = path.match /(?<id>[0-9])\.\w*$/
+    capture[:id] if capture
+  end
 
   def cached_request(verb, path, opts={}, &block)
-    options_hash = { verb: verb, token: token, opts: opts, cache_opts: cache_options, block: block }
+    id = id_from_path(path)
+
+    cache_options = self.cache_options.dup
+    options_hash = { path: path, verb: verb, token: token, opts: opts, cache_opts: cache_options, block: block }
     options_packed = [Marshal.dump(options_hash)].pack('m')
     options_hex = Digest::MD5.hexdigest(options_packed)
-    cache_key = [path.parameterize, options_hex].join('_')
+
+    # Keys
+    collection_expire_key = [resource_name, "*"].compact.join('_')
+    instance_expire_key = [id, resource_name, "*"].compact.join('_')
+    cache_key = [id, resource_name, options_hex].compact.join('_')
+
 
     # Force a cache miss for all methods except get
     cache_options[:force] = true unless [:get, :options].include?(verb)
 
     # Set the response
-    response = Rails.cache.fetch cache_key, cache_options.symbolize_keys do
+    unless verb.to_s.upcase =~ /GET|OPTIONS/
 
-      Rails.cache.delete_matched("#{path.parameterize}*") if ![:get, :options].include?(verb)
-      opts.merge!({force: true})
-      request(verb, path, opts, &block)
+      # Expire Collections
+      cache_log("Restly::CacheExpire", instance_expire_key, :yellow) do
+        Rails.cache.delete_matched(collection_expire_key)
+      end
 
+      # Expire Instances
+      cache_log("Restly::CacheExpire", instance_expire_key, :yellow) do
+        Rails.cache.delete_matched(instance_expire_key)
+      end
     end
 
-    # Clear the cache if there is an error
-    Rails.cache.delete(cache_key) and puts "deleted cache for: #{verb} #{path}" if response.error
+    response =  Rails.cache.fetch cache_key, cache_options.symbolize_keys do
+      cache_log("Restly::CacheMiss", cache_key, :red) do
+                    forced_request(verb, path, opts, &block)
+                  end
+                end
+
+    cache_log("Restly::CacheExpire", cache_key, :yellow) { Rails.cache.delete(cache_key) } if response.error
+
+    raise Restly::Error::ConnectionError, "#{response.status}: #{status_string(response.status)}" if response.status >= 500
 
     # Return the response
     response
 
   end
+
+  def request_log(name, path, verb, color=:light_green, &block)
+    site = URI.parse(client.site)
+    formatted_path = ["#{site.scheme}://#{site.host}", path].join("/")
+    ActiveSupport::Notifications.instrument("request.restly", url: formatted_path, method: verb, name: name, color: color, &block)
+  end
+
+  def cache_log(name, key, color=:light_green, &block)
+    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/error.rb

@@ -1,26 +1,22 @@
 module Restly::Error
 
-  class StandardError < ::StandardError
-
-    def message
-      defined?(IRB) ? super.red : super
-    end
-
-  end
-
   errors = %w{
     RecordNotFound
     InvalidClient
     InvalidObject
     InvalidConnection
+    ConnectionError
     MissingId
     InvalidSpec
     InvalidField
+    InvalidAssociation
+    InvalidAttribute
+    InvalidNestedAttribute
     AssociationError
   }
 
   errors.each do |error|
-    const_set(error.to_sym, Class.new(StandardError))
+    const_set error.to_sym, Class.new(StandardError)
   end
 
 end

data/lib/restly/middleware.rb

@@ -8,8 +8,21 @@ class Restly::Middleware
 
   def call(env)
     @env = env
-    Restly::Base.current_token = Restly::Connection.tokenize(Restly::Base.client, self).to_hash
-    self.app.call(self.env)
+
+    Restly::Base.current_token = nil
+
+    token = Restly::Connection.tokenize(Restly::Base.client, self).to_hash
+
+    if token[:access_token].present? && !@env['PATH_INFO'].match(/^\/assets\//)
+      Restly::Base.current_token = token
+    end
+
+    self.app.call(env)
+
+  ensure
+
+    Restly::Base.current_token = nil
+
   end
 
 end

data/lib/restly/nested_attributes.rb

@@ -15,19 +15,21 @@ module Restly::NestedAttributes
   private
 
   # One To One Association
-  def assign_nested_attributes_for_one_to_one_resource_association(association_name, attributes, assignment_opts = {})
-    options = self.nested_attributes_options[association_name]
+  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
+
   end
 
   # Collection Association
-  def assign_nested_attributes_for_collection_resource_association(association_name, attributes_collection, assignment_opts = {})
+  def assign_nested_attributes_for_collection_resource_association(association_name, attributes_collection)
 
     unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
-      raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+      raise ArgumentError,
+            "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
     end
 
     if attributes_collection.is_a? Hash
@@ -46,7 +48,7 @@ module Restly::NestedAttributes
       attributes = attributes.with_indifferent_access
       if attributes[:id].blank?
         send(association_name) << association.build(self, attributes.except(:id))
-      elsif existing_record = existing_records.find{ |record| record.id.to_s == attributes['id'].to_s }
+      elsif (existing_record = existing_records.find{ |record| record.id.to_s == attributes['id'].to_s })
         existing_record.attributes = attributes
       end
     end
@@ -54,13 +56,28 @@ module Restly::NestedAttributes
   end
 
   def set_nested_attributes_for_save
-    @attributes = @attributes.inject(HashWithIndifferentAccess.new) do |hash, (k, v)|
-      k = [resource_nested_attributes_options[k.to_sym][:write_prefix], k, resource_nested_attributes_options[k.to_sym][:write_suffix]].compact.join('_') if resource_nested_attributes_options[k.to_sym].present?
-      hash[k] = v
+    @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
       hash
     end
   end
 
+  def nested_attribute_missing(m, *args)
+    if !!(/(?<attr>\w+)_attributes=$/ =~ m.to_s) && (options = resource_nested_attributes_options[attr])
+      send( "assign_nested_attributes_for_#{options[:association_type]}_resource_association", attr, *args )
+    else
+      raise Restly::Error::InvalidNestedAttribute, "Nested Attribute does not exist!"
+    end
+  end
+
+  def method_missing(m, *args, &block)
+    nested_attribute_missing(m, *args)
+  rescue Restly::Error::InvalidNestedAttribute
+    super
+  end
+
   module ClassMethods
     REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |key, value| key == '_destroy' || value.blank? } }
 
@@ -73,22 +90,11 @@ module Restly::NestedAttributes
       before_save :set_nested_attributes_for_save
 
       attr_names.each do |association_name|
-        if reflection = reflect_on_resource_association(association_name)
-          reflection.options[:autosave] = true
-
-          resource_nested_attributes_options = self.resource_nested_attributes_options.dup
-          resource_nested_attributes_options[association_name.to_sym] = options
-          self.resource_nested_attributes_options = resource_nested_attributes_options
 
-          type = (reflection.collection? ? :collection : :one_to_one)
-
-          if method_defined?("#{association_name}_attributes=")
-              remove_method("#{association_name}_attributes=")
-          end
-
-          define_method "#{association_name}_attributes=" do |attributes|
-            send("assign_nested_attributes_for_#{type}_resource_association", association_name.to_sym, attributes, mass_assignment_options)
-          end
+        if ( reflection = reflect_on_resource_association(association_name) )
+          reflection.options[:autosave] = true
+          options[:association_type] = (reflection.collection? ? :collection : :one_to_one)
+          self.resource_nested_attributes_options[association_name.to_sym] = options
 
         else
           raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"