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

data/README.md

@@ -16,118 +16,8 @@ Or install it yourself as:
 
     $ gem install restly
 
-## Configuration
-In order for restly to funciton it will need some configuration. This can be done by placing restly.yml in your config directory. We have added a generator to make this easier.
-
-```sh
-$ rails generate restly:configuration
-```
-
-This will generate a file like so:
-
-```yaml
-development: &development
-  site: http://example.com # Change This
-  default_format: json # defaults to: json
-
-  ## Would you like requests to be cached?
-  # cache: true
-  # cache_options:
-  #   expires_in: 3600
-
-  ## Enable Oauth?
-  # use_oauth: true
-  # oauth_options:
-  #   client_id: %client_id%
-  #   client_secret: %client_secret%
-
-test:
-  <<: *development
-
-production:
-  site: http://example.com # Change This
-  default_format: json # defaults to: json
-
-  # Would you like requests to be cached?
-  cache: true
-  cache_options:
-     expires_in: 3600
-
-  ## Enable Oauth?
-  # use_oauth: true
-  # oauth_options:
-  #   client_id: %client_id%
-  #   client_secret: %client_secret%
-
-```
-
-=======
-*__Restly ships with OAuth2 support, allowing you to authorize requests before making them.__*
-
-## Creating a Restly Model
-
-### Using the generator
-
-```
-$ rails generate restly:model MyModel
-```
-
-This will generate a model that looks like this:
-
-```ruby
-class MyModel < Restly::Base
-
-  # self.resource_name = 'my_model'
-  # self.path = 'some_path/to_resource' # defaults to: 'resource_name.pluralized'
-
-end
-```
-=======
-Generates:
-
-```
-class MyModel < Restly::Base
-
-    field :id # implied
-    field :my_attr
-
-end
-```
-
-## Interacting With Objects
-
-In restly interacting with objects is familiar.
-
-__Getting the Collection:__
-
-```ruby
-MyModel.all
-```
-
-__Finding an Instance:__
-
-```ruby
-my_instance = MyModel.find(1)
-```
-
-__Updating an Instance:__
-
-```ruby
-my_instance.update_attributes({my_attr: 'val'})
-```
-
-or
-
-```ruby
-my_instance.my_attr = 'val'
-my_instance.save
-```
-
-__Creating an Instance__
-
-```
-my_instance
-```
+## Getting Started
+For information on how to use restly and how to get started, head over to the [Documentation](http://jwaldrip.github.com/restly).
 
 ## Contributing
 

data/lib/restly.rb

@@ -30,4 +30,29 @@ module Restly
 
 end
 
-require 'restly/railtie' if Object.const_defined?('Rails')
+require 'restly/railtie' if Object.const_defined?('Rails')
+require 'restly/notifications'
+
+class Object
+
+  @@__method_calls ||= {}
+
+  def current_method(index=0)
+    /`(?<curr_method>.*?)'/ =~ caller[index]
+    curr_method
+  end
+
+  def method_called(enum, *args)
+    count = enum.count
+    method = Digest::MD5.hexdigest( current_method(1) + args.to_sentence )
+
+    @@__method_calls.delete_if { |k, v| v[:timestamp] < Time.now - 10 }
+    @@__method_calls[method.to_sym] ||= {}
+    @@__method_calls[method.to_sym][:count] ||= 0
+    @@__method_calls[method.to_sym][:count] += 1
+    @@__method_calls[method.to_sym][:timestamp] = Time.now
+
+    @@__method_calls[method.to_sym][:count] >= count
+  end
+
+end

data/lib/restly/associations.rb

@@ -56,7 +56,11 @@ module Restly::Associations
   private
 
   def association_attributes
-    @association_attributes ||= {}.with_indifferent_access
+    @association_attributes ||= HashWithIndifferentAccess.new
+  end
+
+  def loaded_associations
+    @loaded_associations ||= HashWithIndifferentAccess.new
   end
 
   def set_association(attr, val)
@@ -66,19 +70,22 @@ module Restly::Associations
   end
 
   def get_association(attr, options={})
-    association = self.class.reflect_on_resource_association(attr)
-    if (stubbed = association.stub self, association_attributes[attr]).present?
-      stubbed
-    elsif (loaded = association.load self, options).present?
-      loaded
-    else
-      association.build(self)
+    return loaded_associations[attr] if loaded_associations[attr].present?
+    ActiveSupport::Notifications.instrument("load_association.restly", model: self.class.name, association: attr) do
+      association = self.class.reflect_on_resource_association(attr)
+
+      loaded_associations[attr] = if (stubbed = association.stub self, association_attributes[attr]).present?
+                                    stubbed
+                                  elsif (loaded = association.load self, options).present?
+                                    loaded
+                                  else
+                                    association.build(self)
+                                  end
     end
-
   end
 
-  def method_missing(m, *args, &block)
-    if !!(/(?<attr>\w+)(?<setter>=)?$/ =~ m.to_s) && associations.include?(m)
+  def association_missing(m, *args)
+    if !!(/(?<attr>\w+)(?<setter>=)?$/ =~ m.to_s) && respond_to_association?(m)
       attr = attr.to_sym
       case !!setter
         when true
@@ -87,8 +94,14 @@ module Restly::Associations
           get_association(attr)
       end
     else
-      super(m, *args, &block)
+      raise Restly::Error::InvalidAssociation, "Association is invalid"
     end
   end
 
+  def method_missing(m, *args, &block)
+    association_missing(m, *args)
+  rescue Restly::Error::InvalidAssociation
+    super
+  end
+
 end

data/lib/restly/associations/base/conditionals.rb

@@ -2,8 +2,8 @@ module Restly::Associations::Base::Conditionals
 
   # Conditionals
   def valid?(val)
-    valid_instances = Array.wrap(val).reject{ |item| item.resource_name == association_class.resource_name }.empty?
-    raise Restly::Error::InvalidObject, "#{val} is not a #{association_class}" unless valid_instances
+    #valid_instances = Array.wrap(val).reject{ |item| item.resource_name == association_class.resource_name }.empty?
+    #raise Restly::Error::InvalidObject, "#{val} is not a #{association_class}" unless valid_instances
   end
 
   def collection?

data/lib/restly/base.rb

@@ -65,6 +65,7 @@ module Restly
       self.resource_name      = name.gsub(/.*::/,'').underscore if name.present?
       self.path               = resource_name.pluralize
       self.params             = params.dup
+      self.client             = client.dup
     end
 
     # Run Active Support Load Hooks

data/lib/restly/base/fields.rb

@@ -5,7 +5,7 @@ module Restly::Base::Fields
     extend  ClassMethods
 
     class_attribute :fields
-    self.fields = FieldSet.new
+    self.fields = FieldSet.new(self)
     field :id
 
     inherited do
@@ -20,45 +20,49 @@ module Restly::Base::Fields
 
     def field(attr)
       if attr.is_a?(Symbol) || attr.is_a?(String)
-        unless instance_method_already_implemented? attr
-          define_attribute_method attr
-          self.fields += [attr]
-        end
+        define_attribute_method attr unless instance_method_already_implemented? attr
+        self.fields += [attr]
       else
         raise Restly::Error::InvalidField, "field must be a symbol or string."
       end
     end
 
     def exclude_field(name)
-
-      # Remove from the class
       self.fields -= [name]
-
-      # Remove from the instance
-      before_initialize do
-        self.fields -= [name]
-      end
-
     end
 
   end
 
   class FieldSet < Set
 
+    attr_reader :owner
+
+    def initialize(owner, fields=[])
+      @owner = owner
+      super(fields)
+
+      self.each { |value| owner.send(:define_attribute_method, value) unless owner.send(:instance_method_already_implemented?, value.to_sym) }
+    end
+
     def include?(value)
       super(value.to_sym) || super(value.to_s)
     end
 
     def <<(value)
+      owner.send(:define_attribute_method, value) unless owner.send(:instance_method_already_implemented?, value.to_sym)
       super(value.to_sym)
     end
 
-    def +(other_arry)
-      super(other_arry.map(&:to_sym))
+    def +(other_array)
+      other_array.map!(&:to_sym)
+      other_array.each { |value| owner.send(:define_attribute_method, value) unless owner.send(:instance_method_already_implemented?, value.to_sym) }
+      super(other_array)
     end
 
-    def -(other_arry)
-      super(other_arry.map(&:to_sym))
+    def -(other_array)
+      other_array.map!(&:to_sym)
+      other_array.each { |value| owner.send(:define_attribute_method, value) if owner.send(:instance_method_already_implemented?, value.to_sym) }
+      super(other_array)
     end
 
   end

data/lib/restly/base/includes.rb

@@ -11,12 +11,17 @@ module Restly::Base::Includes
     delegate :site, :site=, :format, :format=, to: :client
 
     def client
-      @client ||= Restly::Client.new
+      return @client if @client
+      @client = Restly::Client.new(nil, nil)
+      @client.resource = self
+      @client
     end
 
     def client=(client)
-      raise Restly::Error::InvalidClient, "Client is invalid!"
+      raise Restly::Error::InvalidClient, "Client is invalid!" unless client.is_a?(Restly::Client)
       @client = client
+      @client.resource = self
+      @client
     end
 
     def has_specification

data/lib/restly/base/instance.rb

@@ -5,15 +5,19 @@ module Restly::Base::Instance
   autoload :Attributes
   autoload :Persistence
   autoload :WriteCallbacks
+  autoload :Comparable
+  autoload :ErrorHandling
 
   include Restly::Base::GenericMethods
   include Actions
   include Attributes
   include Persistence
   include WriteCallbacks
+  include Comparable
+  include ErrorHandling
 
   included do
-    attr_reader :init_options, :response
+    attr_reader :init_options, :response, :errors
     delegate :spec, to: :resource
   end
 
@@ -22,25 +26,30 @@ module Restly::Base::Instance
     @init_options = options
     @attributes = HashWithIndifferentAccess.new
     @association_cache = {}
-    @association_attributes = {}.with_indifferent_access
+    @association_attributes = HashWithIndifferentAccess.new
     @aggregation_cache = {}
     @attributes_cache = {}
     @previously_changed = {}
     @changed_attributes = {}
+    @errors = ActiveModel::Errors.new(self)
 
-    run_callbacks :initialize do
-      @readonly = options[:readonly] || false
-      set_response options[:response] if options[:response]
-      @loaded = options.has_key?(:loaded) ? options[:loaded] : true
-      self.attributes = attributes if attributes
-      self.connection = options[:connection] if options[:connection].is_a?(OAuth2::AccessToken)
+    ActiveSupport::Notifications.instrument("load_instance.restly", instance: self) do
 
-    end
+      run_callbacks :initialize do
+
+        @readonly = options[:readonly] || false
+        set_response options[:response] if options[:response]
+        @loaded = options.has_key?(:loaded) ? options[:loaded] : true
+        self.attributes = attributes if attributes
+        self.connection = options[:connection] if options[:connection].is_a?(OAuth2::AccessToken)
+
+      end
 
+    end
   end
 
   def loaded?
-    @loaded
+    !!@loaded
   end
 
   def connection
@@ -66,13 +75,21 @@ module Restly::Base::Instance
     end
   end
 
+  def to_param
+    id.to_s
+  end
+
   private
 
   def set_response(response)
     raise Restly::Error::InvalidResponse unless response.is_a? OAuth2::Response
     @response = response
     if response.try(:body)
-      set_attributes_from_response
+      if response_has_errors?(response)
+        set_errors_from_response
+      else
+        set_attributes_from_response
+      end
     end
   end
 
@@ -80,7 +97,9 @@ module Restly::Base::Instance
     return {} unless response
     parsed = response.parsed || {}
     if parsed.is_a?(Hash) && parsed[resource_name]
-      parsed[resource_name]
+      parsed[resource_name].with_indifferent_access
+    elsif parsed.is_a?(Hash)
+      parsed.with_indifferent_access
     else
       parsed
     end

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

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

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

@@ -1,5 +1,3 @@
-require "colorize"
-
 module Restly::Base::Instance::Attributes
 
   def update_attributes(attributes)
@@ -9,49 +7,35 @@ module Restly::Base::Instance::Attributes
 
   def attributes=(attributes)
     attributes.each do |k, v|
-      write_attribute k, v
+      self[k] = v
     end
   end
 
   def attributes
     fields.reduce(HashWithIndifferentAccess.new) do |hash, key|
-      hash[key] = read_attribute key, autoload: false
+      hash[key] = read_attribute(key, autoload: false)
       hash
     end
   end
 
-  def write_attribute(attr, val)
-    if fields.include?(attr)
-      send("#{attr}_will_change!".to_sym) unless val == @attributes[attr.to_sym] || !@loaded
-      @attributes[attr.to_sym] = Attribute.new(val)
-
-    elsif (association = self.class.reflect_on_resource_association attr).present?
-      set_association attr, association.stub(self, val) unless (@association_attributes ||= {}.with_indifferent_access)[attr].present?
-
-    else
-      puts "WARNING: Attribute `#{attr}` not written. ".colorize(:yellow) +
-               "To fix this add the following the the model. -- field :#{attr}"
-    end
+  def attribute(key, options={})
+    read_attribute(key)
   end
 
-  def read_attribute(attr, options={})
-    options.reverse_merge!({autoload: true})
-    if @attributes[attr.to_sym].nil? && !!options[:autoload] && !loaded?
-      load!
-      read_attribute(attr)
-    else
-      @attributes[attr.to_sym]
-    end
+  def []=(key, value)
+    send "#{key}=", value
   end
 
-  alias :attribute :read_attribute
+  def [](key)
+    send key
+  end
 
   def has_attribute?(attr)
-    attribute(attr)
+    fields.include?(attr) && attribute(attr)
   end
 
   def respond_to_attribute?(m)
-    !!(/(?<attr>\w+)(?<setter>=)?$/ =~ m.to_s) && associations.include?(attr)
+    !!(/(?<attr>\w+)(?<setter>=)?$/ =~ m.to_s) && fields.include?(attr)
   end
 
   def respond_to?(m, include_private = false)
@@ -71,6 +55,41 @@ module Restly::Base::Instance::Attributes
 
   private
 
+  def attribute_missing(m, *args)
+    if !!(/(?<attr>\w+)(?<setter>=)?$/ =~ m.to_s) && fields.include?(attr)
+      case !!setter
+        when true
+          write_attribute(attr, *args)
+        when false
+          read_attribute(attr, *args)
+      end
+    else
+      raise Restly::Error::InvalidAttribute, "Attribute does not exist!"
+    end
+  end
+
+  def method_missing(m, *args, &block)
+    attribute_missing(m, *args)
+  rescue Restly::Error::InvalidAttribute
+    super
+  end
+
+  def write_attribute(attr, val)
+    if fields.include?(attr)
+      send("#{attr}_will_change!".to_sym) unless val == @attributes[attr.to_sym] || !@loaded
+      @attributes[attr.to_sym] = Attribute.new(val)
+
+    else
+      ActiveSupport::Notifications.instrument("missing_attribute.restly", attr: attr)
+    end
+  end
+
+  def read_attribute(attr, options={})
+    options.reverse_merge!({ autoload: true })
+    load! if (key = attr.to_sym) != :id && @attributes[key].nil? && !!options[:autoload] && !loaded? && !exists?
+    @attributes[attr.to_sym]
+  end
+
   def attribute_for_inspect(attr_name)
     value = attribute(attr_name, autoload: false)
     if value.is_a?(String) && value.length > 50
@@ -84,19 +103,6 @@ module Restly::Base::Instance::Attributes
     self.attributes = parsed_response(response)
   end
 
-  def method_missing(m, *args, &block)
-    if !!(/(?<attr>\w+)(?<setter>=)?$/ =~ m.to_s) && fields.include?(attr)
-      case !!setter
-        when true
-          write_attribute(attr, *args)
-        when false
-          read_attribute(attr)
-      end
-    else
-      super(m, *args, &block)
-    end
-  end
-
   class Attribute < Restly::Proxies::Base
 
     def initialize(attr)