restly 0.0.1.alpha.4 → 0.0.1.alpha.6

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

@@ -0,0 +1,27 @@
+module Restly::Associations::Base::Builders
+
+  # Build
+  def build(parent, attributes = nil, options = {})
+
+    # Merge Options
+    options.reverse_merge!(self.options)
+
+    # Authorize and Set Path
+    association = authorize(options[:authorize]).with_path(parent, options[:path])
+
+    collection? ? association.build_collection(parent) : association.build_instance(parent, attributes)
+  end
+
+  private
+
+  def build_instance(parent, attributes)
+    instance = association_class.new(attributes, options)
+    instance.write_attribute("#{@owner.resource_name}_id", parent.id) if association_class.method_defined?("#{@owner.resource_name}_id")
+    Restly::Proxies::Associations::Instance.new(instance, parent)
+  end
+
+  def build_collection(parent)
+    Restly::Proxies::Associations::Collection.new(Restly::Collection.new(association_class), parent)
+  end
+
+end

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

@@ -0,0 +1,23 @@
+module Restly::Associations::Base::Conditionals
+
+  private
+
+  # 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
+  end
+
+  def collection?
+    false
+  end
+
+  def embedded?
+    false
+  end
+
+  def nested?
+    false
+  end
+
+end

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

@@ -0,0 +1,41 @@
+module Restly::Associations::Base::Loaders
+
+  def load(parent, options)
+
+    # Merge Options
+    options.reverse_merge!(self.options)
+
+    # Authorize and Set Path
+    association = authorize(options[:authorize]).with_path(parent, options[:path])
+
+    # Load Collection or Instance
+    collection? ? association.load_collection(parent) : association.load_instance(parent)
+  end
+
+  private
+
+  def load_collection(parent, association_class = self.association_class)
+    raise Restly::Error::AssociationError, "Not a collection" unless collection?
+    collection = if embedded?
+                   []
+                 else
+                   association_class.all
+                 end
+
+    Restly::Proxies::Associations::Collection.new(collection, parent)
+  end
+
+  def load_instance(parent, association_class = self.association_class)
+    raise Restly::Error::AssociationError, "Not an instance" if collection?
+    return nil if embedded?
+    instance = if parent.attributes.has_key? "#{name}_id"
+                 foreign_key = parent.attributes["#{name}_id"]
+                 return nil unless foreign_key
+                 association_class.find(foreign_key)
+               else
+                 association_class.instance_from_response association_class.connection.get(association_class.path)
+               end
+    Restly::Proxies::Associations::Instance.new(instance, parent)
+  end
+
+end

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

@@ -0,0 +1,24 @@
+module Restly::Associations::Base::Modifiers
+
+  # Modifiers
+  def authorize(authorization = nil, association_class=self.association_class)
+    duplicate = self.dup
+    duplicate.instance_variable_set :@association_class, if (!association_class.authorized? && @owner.respond_to?(:authorized?) && @owner.authorized?) || authorization
+                                                           association_class.authorize(authorization || @owner.connection)
+                                                         else
+                                                           association_class
+                                                         end
+    duplicate
+  end
+
+  def with_path(parent, path = nil, association_class=self.association_class)
+    duplicate = self.dup
+    duplicate.instance_variable_set :@association_class, if path
+                                                           association_class.with_path(path)
+                                                         else
+                                                           association_class.with_path(association_resource_name, prepend: parent.path)
+                                                         end
+    duplicate
+  end
+
+end

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

@@ -0,0 +1,21 @@
+module Restly::Associations::Base::Stubs
+
+  # Stubs
+  def stub(parent, attributes)
+    return nil if !parent.is_a?(Restly::Base) || !attributes.present?
+    collection? ? stub_collection(parent, attributes) : stub_instance(parent, attributes)
+  end
+
+  private
+
+  def stub_collection(parent, attributes)
+    collection = attributes.map{ |item_attrs| association_class.new(item_attrs, loaded: embedded?) }
+    Restly::Proxies::Associations::Collection.new(collection, parent)
+  end
+
+  def stub_instance(parent, attributes)
+    instance = association_class.new(attributes, loaded: embedded?)
+    Restly::Proxies::Associations::Instance.new(instance, parent)
+  end
+
+end

data/lib/restly/associations/base.rb

@@ -1,4 +1,17 @@
 class Restly::Associations::Base
+  extend ActiveSupport::Autoload
+
+  autoload :Loaders
+  autoload :Stubs
+  autoload :Builders
+  autoload :Modifiers
+  autoload :Conditionals
+
+  include Loaders
+  include Stubs
+  include Builders
+  include Modifiers
+  include Conditionals
 
   attr_reader :name, :association_class, :namespace, :polymorphic, :options
 
@@ -12,97 +25,8 @@ class Restly::Associations::Base
     @options = options
   end
 
-  def load(parent, options)
-
-    # Merge Options
-    options.reverse_merge!(self.options)
-
-    # Authorize and Set Path
-    association = authorize(options[:authorize]).with_path(parent, options[:path])
-
-    # Load Collection or Instance
-    collection? ? association.load_collection(parent) : association.load_instance(parent)
-  end
-
-  def load_collection(parent, association_class = self.association_class)
-    raise Restly::Error::AssociationError, "Not a collection" unless collection?
-    return [] if embedded?
-    Restly::Proxies::Associations::Collection.new(association_class.all, parent)
-  end
-
-  def load_instance(parent, association_class = self.association_class)
-    raise Restly::Error::AssociationError, "Not an instance" if collection?
-    return nil if embedded?
-    instance = if parent.attributes.has_key? "#{name}_id"
-                 foreign_key = parent.attributes["#{name}_id"]
-                 return nil unless foreign_key
-                 association_class.find(foreign_key)
-               else
-                 association_class.instance_from_response association_class.connection.get(association_class.path)
-               end
-    Restly::Proxies::Associations::Instance.new(instance, parent)
-  end
-
-  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
-  end
-
-  # Stubs
-  def stub(parent, attributes)
-    return nil if !parent.is_a?(Restly::Base) || !attributes.present?
-    collection? ? stub_collection(parent, attributes) : stub_instance(parent, attributes)
-  end
-
-  def stub_collection(parent, attributes)
-    collection = attributes.map{ |item_attrs| association_class.new(item_attrs, loaded: embedded?) }
-    Restly::Proxies::Associations::Collection.new(collection, parent)
-  end
-
-  def stub_instance(parent, attributes)
-    instance = association_class.new(attributes, loaded: embedded?)
-    Restly::Proxies::Associations::Instance.new(instance, parent)
-  end
-
-  # Build
-  def build(parent, attributes = nil, options = {})
-    raise NoMethodError, "Build not available for collection." if collection?
-    instance = association_class.new(attributes, options)
-    instance.write_attribute("#{@owner.resource_name}_id", parent.id) if association_class.method_defined?("#{@owner.resource_name}_id")
-    Restly::Proxies::Associations::Instance.new(instance, parent)
-  end
-
-  # Modifiers
-  def authorize(authorization = nil, association_class=self.association_class)
-    duplicate = self.dup
-    duplicate.instance_variable_set :@association_class, if (!association_class.authorized? && @owner.respond_to?(:authorized?) && @owner.authorized?) || authorization
-                                                           association_class.authorize(authorization || @owner.connection)
-                                                         else
-                                                           association_class
-                                                         end
-    duplicate
-  end
-
-  def with_path(parent, path = nil, association_class=self.association_class)
-    duplicate = self.dup
-    duplicate.instance_variable_set :@association_class, if path
-                                                           association_class.with_path(path)
-                                                         else
-                                                           association_class.with_path(association_resource_name, prepend: parent.path)
-                                                         end
-    duplicate
-  end
-
   private
 
-  def collection?
-    false
-  end
-
-  def embedded?
-    false
-  end
-
   def association_resource_name
     collection? ? association_class.resource_name.pluralize : association_class.resource_name
   end

data/lib/restly/associations/belongs_to.rb

@@ -8,6 +8,8 @@ class Restly::Associations::BelongsTo < Restly::Associations::Base
     end
   end
 
+  private
+
   def set_polymorphic_class(parent)
     duplicate = self.dup
     duplicate.instance_variable_set(:@association_class, parent.send("#{name}_type"))
@@ -15,18 +17,4 @@ class Restly::Associations::BelongsTo < Restly::Associations::Base
     duplicate
   end
 
-  def with_path(parent, path = nil, association_class=self.association_class)
-    duplicate = self.dup
-    duplicate.instance_variable_set :@association_class, if path
-                                                           association_class.with_path(path)
-                                                         else
-                                                           association_class
-                                                         end
-    duplicate
-  end
-
-  def collection?
-    false
-  end
-
 end

data/lib/restly/associations/class_methods.rb

@@ -0,0 +1,62 @@
+module Restly::Associations::ClassMethods
+
+  def resource_name
+    name.gsub(/.*::/,'').underscore
+  end
+
+  def reflect_on_resource_association(association_name)
+    reflect_on_all_resource_associations[association_name]
+  end
+
+  def reflect_on_all_resource_associations
+    resource_associations
+  end
+
+  private
+
+  # Belongs to
+  def belongs_to_resource(name, options = {})
+    exclude_field(name) if ancestors.include?(Restly::Base)
+    self.resource_associations[name] = Restly::Associations::BelongsTo.new(self, name, options)
+
+    define_method name do |options={}|
+      get_association(name, options)
+    end
+
+    define_method "#{name}=" do |value|
+      set_association name, value
+    end
+
+  end
+
+  # Has One
+  def has_one_resource(name, options = {})
+    exclude_field(name) if ancestors.include?(Restly::Base)
+    self.resource_associations[name] = Restly::Associations::HasOne.new(self, name, options)
+
+    define_method name do |options={}|
+      get_association(name, options)
+    end
+
+    define_method "#{name}=" do |value|
+      set_association name, value
+    end
+
+  end
+
+  # Has One
+  def has_many_resources(name, options = {})
+    exclude_field(name) if ancestors.include?(Restly::Base)
+    self.resource_associations[name] = Restly::Associations::HasMany.new(self, name, options)
+
+    define_method name do |options={}|
+      get_association(name, options)
+    end
+
+    define_method "#{name}=" do |value|
+      set_association name, value
+    end
+
+  end
+
+end

data/lib/restly/associations/has_one.rb

@@ -7,8 +7,4 @@ class Restly::Associations::HasOne < Restly::Associations::Base
     super
   end
 
-  def collection?
-    true
-  end
-
 end

data/lib/restly/associations.rb

@@ -8,9 +8,9 @@ module Restly::Associations
   autoload :HasManyThrough
   autoload :HasOne
   autoload :HasOneThrough
-  autoload :EmbeddableResources
+  autoload :ClassMethods
 
-  class AssociationsSet < HashWithIndifferentAccess
+  class AssociationsHash < HashWithIndifferentAccess
   end
 
   class IndifferentSet < Set
@@ -25,15 +25,13 @@ module Restly::Associations
   included do
 
     include Restly::ConcernedInheritance
-    extend  EmbeddableResources if self == Restly::Base
     include Restly::NestedAttributes
 
-    delegate :resource_name, to: :klass
     class_attribute :resource_associations, instance_reader: false, instance_writer: false
 
     attr_reader :association_attributes
 
-    self.resource_associations = AssociationsSet.new
+    self.resource_associations = AssociationsHash.new
 
     inherited do
       self.resource_associations = resource_associations.dup
@@ -41,19 +39,12 @@ module Restly::Associations
 
   end
 
-  def associations
-    IndifferentSet.new klass.reflect_on_all_resource_associations.keys.map(&:to_sym)
+  def resource_name
+    self.class.resource_name
   end
 
-  def set_association(attr, val)
-    association = klass.reflect_on_resource_association(attr)
-    association.valid?(val)
-    @association_attributes[attr] = val
-  end
-
-  def get_association(attr, options={})
-    association = klass.reflect_on_resource_association(attr)
-    (@association_attributes ||= {}.with_indifferent_access)[attr] || set_association(attr, association.load(self, options))
+  def associations
+    IndifferentSet.new self.class.reflect_on_all_resource_associations.keys.map(&:to_sym)
   end
 
   def respond_to_association?(m)
@@ -66,6 +57,25 @@ module Restly::Associations
 
   private
 
+  def set_association(attr, val)
+    association = self.class.reflect_on_resource_association(attr)
+    association.valid?(val)
+    @association_attributes[attr] = val
+  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)
+    end
+
+  end
+
   def method_missing(m, *args, &block)
     if !!(/(?<attr>\w+)(?<setter>=)?$/ =~ m.to_s) && associations.include?(m)
       attr = attr.to_sym
@@ -80,71 +90,4 @@ module Restly::Associations
     end
   end
 
-  def klass
-    self.class
-  end
-
-  module ClassMethods
-
-    def resource_name
-      name.gsub(/.*::/,'').underscore
-    end
-
-    def reflect_on_resource_association(association_name)
-      reflect_on_all_resource_associations[association_name]
-    end
-
-    def reflect_on_all_resource_associations
-      resource_associations
-    end
-
-    private
-
-    # Belongs to
-    def belongs_to_resource(name, options = {})
-      exclude_field(name) if ancestors.include?(Restly::Base)
-      self.resource_associations[name] = association = BelongsTo.new(self, name, options)
-
-      define_method name do |options={}|
-        get_association(name, options)
-      end
-
-      define_method "#{name}=" do |value|
-        set_association name, value
-      end
-
-    end
-
-    # Has One
-    def has_one_resource(name, options = {})
-      exclude_field(name) if ancestors.include?(Restly::Base)
-      self.resource_associations[name] = association = HasOne.new(self, name, options)
-
-      define_method name do |options={}|
-        get_association(name, options)
-      end
-
-      define_method "#{name}=" do |value|
-        set_association name, value
-      end
-
-    end
-
-    # Has One
-    def has_many_resources(name, options = {})
-      exclude_field(name) if ancestors.include?(Restly::Base)
-      self.resource_associations[name] = association = HasMany.new(self, name, options)
-
-      define_method name do |options={}|
-        get_association(name, options)
-      end
-
-      define_method "#{name}=" do |value|
-        set_association name, value
-      end
-
-    end
-
-  end
-
 end

data/lib/restly/base/fields.rb

@@ -18,6 +18,8 @@ module Restly::Base::Fields
 
   module SharedMethods
 
+    private
+
     def set_field(attr)
       base = self.is_a?(Class) ? self : singleton_class
       unless base.send :instance_method_already_implemented?, attr
@@ -30,6 +32,8 @@ module Restly::Base::Fields
 
   module ClassMethods
 
+    private
+
     def field(attr)
       if attr.is_a?(Hash) && attr[:from_spec]
         before_initialize do

data/lib/restly/base/generic_methods.rb

@@ -26,7 +26,7 @@ module Restly::Base::GenericMethods
   end
 
   def proxied?
-    true
+    false
   end
 
 end

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

@@ -10,14 +10,17 @@ module Restly::Base::Instance::Actions
   end
 
   def delete
-    run_callbacks :delete do
-      response = connection.delete(path_with_format, params: params)
-      false
-      freeze
-    end
+    response = connection.delete(path_with_format, params: params)
+    freeze
     response.status < 300
   end
 
+  def destroy
+    run_callbacks :destroy do
+      delete
+    end
+  end
+
   private
 
   def update

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

@@ -21,9 +21,9 @@ module Restly::Base::Instance::Attributes
   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] = val
+      @attributes[attr.to_sym] = Attribute.new(val)
 
-    elsif (association = klass.reflect_on_resource_association attr).present?
+    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
@@ -44,17 +44,6 @@ module Restly::Base::Instance::Attributes
 
   alias :attribute :read_attribute
 
-  def inspect
-    inspection = if @attributes
-                   fields.collect { |name|
-                     "#{name}: #{attribute_for_inspect(name)}"
-                   }.compact.join(", ")
-                 else
-                   "not initialized"
-                 end
-    "#<#{self.class} #{inspection}>"
-  end
-
   def has_attribute?(attr)
     attribute(attr)
   end
@@ -67,6 +56,17 @@ module Restly::Base::Instance::Attributes
     respond_to_attribute?(m) || super
   end
 
+  def inspect
+    inspection = if @attributes
+                   fields.collect { |name|
+                     "#{name}: #{attribute_for_inspect(name)}"
+                   }.compact.join(", ")
+                 else
+                   "not initialized"
+                 end
+    "#<#{self.class} #{inspection}>"
+  end
+
   private
 
   def attribute_for_inspect(attr_name)
@@ -83,7 +83,7 @@ module Restly::Base::Instance::Attributes
   end
 
   def method_missing(m, *args, &block)
-    if !!(/(?<attr>\w+)(?<setter>=)?$/ =~ m.to_s) && fields.include?(m)
+    if !!(/(?<attr>\w+)(?<setter>=)?$/ =~ m.to_s) && fields.include?(attr)
       case !!setter
         when true
           write_attribute(attr, *args)
@@ -95,4 +95,37 @@ module Restly::Base::Instance::Attributes
     end
   end
 
+  class Attribute < Restly::Proxies::Base
+
+    def initialize(attr)
+      @attr = attr
+      case @attr
+        when String
+          type_convert_string
+        end
+      super(@attr)
+    end
+
+    private
+
+    def type_convert_string
+      time =    (@attr.to_time rescue nil)
+      date =    (@attr.to_date rescue nil)
+      # int  =    (@attr.to_i    rescue nil)
+      # flt  =    (@attr.to_f    rescue nil)
+      @attr = if time.try(:iso8601) == @attr
+                time
+              elsif date.try(:to_s) == @attr
+                date
+              #elsif int.try (:to_s) == @attr
+              #  int
+              #elsif flt.try (:to_s) == @attr
+              #  flt
+              else
+                @attr
+      end
+    end
+
+  end
+
 end

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

@@ -1,8 +1,19 @@
 module Restly::Base::Instance::Persistence
 
   def exists?
-    status = @response.try(:status).to_i
+    return false unless id
+
+    begin
+      @response ||= connection.get(path, force: true)
+
+    rescue OAuth2::Error => e
+      @response = e.response
+
+    end
+
+    status = @response.status.to_i
     status < 300 && status >= 200
+
   end
 
   def persisted?

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

@@ -19,7 +19,7 @@ module Restly::Base::Instance::WriteCallbacks
   end
 
   def savable_resource
-    {resource_name => attributes_with_present_values}
+    {resource_name => attributes_with_present_values(writeable_attributes)}
   end
 
   def attributes_with_present_values(attributes=self.attributes)
@@ -33,5 +33,13 @@ module Restly::Base::Instance::WriteCallbacks
     end
   end
 
+  def writeable_attributes(attributes=self.attributes)
+    if (maa = mass_assignment_authorizer :default).is_a? ActiveModel::MassAssignmentSecurity::BlackList
+      attributes.reject{ |key, val| maa.map(&:to_sym).include?(key.to_sym) }
+    elsif mass_assignment_authorizer.is_a? ActiveModel::MassAssignmentSecurity::BlackList
+      attributes.select{ |key, val| maa.map(&:to_sym).include?(key.to_sym) }
+    end
+  end
+
 
 end