kelredd-resourceful 0.7.24 → 0.7.25

data/lib/resourceful/model/activerecord_associations.rb

@@ -1,88 +1,87 @@
-module Resourceful
-  module Model
-    module ActiverecordAssociations
+module Resourceful; end
+module Resourceful::Model; end
+
+module Resourceful::Model::ActiverecordAssociations
       
-      module ClassMethods
+  module ClassMethods
 
-        protected
-        
-        def has_many_resourceful(name, config={})
-          clean_name = Resourceful::Model::Base.cleanup_name(name)
-          config ||= {}
-          raise ArgumentError, "has_many_resourceful requires a :class_name option to be specified" unless config[:class_name]
-          class_name = config.delete(:class_name).to_s
-          find_method_name = (config.delete(:method) || 'find').to_s
-          force = config.delete(:force) || false
-          foreign_key_name = config.delete(:foreign_key) || "#{self.name.demodulize.underscore}_id"
-          foreign_key_method = config.delete(:foreign_key_method) || 'id'
-          Resourceful.add_to_associations(self.name, clean_name, {
-            :type => :has_many,
-            :class_name => class_name,
-            :foreign_key_name => foreign_key_name,
-            :foreign_key_method => foreign_key_method,
-            :find_method_name => find_method_name
-          })
-          define_method(name) do |*args|
-            reload = args.first || false
-            if reload || (assoc_val = instance_variable_get("@#{clean_name}")).nil?
-              klass = class_name.resourceful_constantize
-              raise ArgumentError, "has_many_resourceful :class_name '#{class_name}' is not defined" if klass.nil?
-              unless klass.respond_to?(find_method_name)
-                raise NotImplementedError, "has_many_resourceful expects #{klass} to implement a Findable method named '#{find_method_name}'"
-              end
-              config[foreign_key_name] = self.send(foreign_key_method)
-              instance_variable_set("@#{clean_name}", klass.send(find_method_name, :all, config, reload || force))
-            else
-              assoc_val
-            end
+    protected
+    
+    def has_many_resourceful(name, config={})
+      clean_name = Resourceful::Model::Base.cleanup_name(name)
+      config ||= {}
+      raise ArgumentError, "has_many_resourceful requires a :class_name option to be specified" unless config[:class_name]
+      class_name = config.delete(:class_name).to_s
+      find_method_name = (config.delete(:method) || 'find').to_s
+      force = config.delete(:force) || false
+      foreign_key_name = config.delete(:foreign_key) || "#{self.name.demodulize.underscore}_id"
+      foreign_key_method = config.delete(:foreign_key_method) || 'id'
+      Resourceful.add_to_associations(self.name, clean_name, {
+        :type => :has_many,
+        :class_name => class_name,
+        :foreign_key_name => foreign_key_name,
+        :foreign_key_method => foreign_key_method,
+        :find_method_name => find_method_name
+      })
+      define_method(name) do |*args|
+        reload = args.first || false
+        if reload || (assoc_val = instance_variable_get("@#{clean_name}")).nil?
+          klass = class_name.resourceful_constantize
+          raise ArgumentError, "has_many_resourceful :class_name '#{class_name}' is not defined" if klass.nil?
+          unless klass.respond_to?(find_method_name)
+            raise NotImplementedError, "has_many_resourceful expects #{klass} to implement a Findable method named '#{find_method_name}'"
           end
+          config[foreign_key_name] = self.send(foreign_key_method)
+          instance_variable_set("@#{clean_name}", klass.send(find_method_name, :all, config, reload || force))
+        else
+          assoc_val
         end
+      end
+    end
 
-        def belongs_to_resourceful(name, config={})
-          clean_name = Resourceful::Model::Base.cleanup_name(name)
-          config ||= {}
-          raise ArgumentError, "belongs_to_resourceful requires a :class_name option to be specified" unless config[:class_name]
-          class_name = config.delete(:class_name).to_s
-          find_method_name = (config.delete(:method) || 'find').to_s
-          force = config.delete(:force) || false
-          foreign_key_name = config.delete(:foreign_key_name) || 'id'
-          foreign_key_method = config.delete(:foreign_key) || "#{clean_name}_id"
-          Resourceful.add_to_associations(self.name, clean_name, {
-            :type => :belongs_to,
-            :class_name => class_name,
-            :foreign_key_name => foreign_key_name,
-            :foreign_key_method => foreign_key_method,
-            :find_method_name => find_method_name
-          })
-          define_method(name) do |*args|
-            reload = args.first || false
-            if reload || (assoc_val = instance_variable_get("@#{clean_name}")).nil?
-              klass = class_name.resourceful_constantize
-              raise ArgumentError, "belongs_to_resourceful :class_name '#{class_name}' is not defined" if klass.nil?
-              unless self.respond_to?(foreign_key_method)
-                raise ArgumentError, "belongs_to_resourceful requires a '#{foreign_key_method}' method defined to return the foreign_key"
-              end
-              unless klass.respond_to?(find_method_name)
-                raise NotImplementedError, "belongs_to_resourceful expects #{klass} to implement a Findable method named '#{find_method_name}'"
-              end
-              fk = self.send(foreign_key_method)
-              instance_variable_set("@#{clean_name}", fk.nil? || (fk.respond_to?('empty?') && fk.empty?) ? nil : klass.send(find_method_name, fk, config, reload || force))
-            else
-              assoc_val
-            end
+    def belongs_to_resourceful(name, config={})
+      clean_name = Resourceful::Model::Base.cleanup_name(name)
+      config ||= {}
+      raise ArgumentError, "belongs_to_resourceful requires a :class_name option to be specified" unless config[:class_name]
+      class_name = config.delete(:class_name).to_s
+      find_method_name = (config.delete(:method) || 'find').to_s
+      force = config.delete(:force) || false
+      foreign_key_name = config.delete(:foreign_key_name) || 'id'
+      foreign_key_method = config.delete(:foreign_key) || "#{clean_name}_id"
+      Resourceful.add_to_associations(self.name, clean_name, {
+        :type => :belongs_to,
+        :class_name => class_name,
+        :foreign_key_name => foreign_key_name,
+        :foreign_key_method => foreign_key_method,
+        :find_method_name => find_method_name
+      })
+      define_method(name) do |*args|
+        reload = args.first || false
+        if reload || (assoc_val = instance_variable_get("@#{clean_name}")).nil?
+          klass = class_name.resourceful_constantize
+          raise ArgumentError, "belongs_to_resourceful :class_name '#{class_name}' is not defined" if klass.nil?
+          unless self.respond_to?(foreign_key_method)
+            raise ArgumentError, "belongs_to_resourceful requires a '#{foreign_key_method}' method defined to return the foreign_key"
+          end
+          unless klass.respond_to?(find_method_name)
+            raise NotImplementedError, "belongs_to_resourceful expects #{klass} to implement a Findable method named '#{find_method_name}'"
           end
+          fk = self.send(foreign_key_method)
+          instance_variable_set("@#{clean_name}", fk.nil? || (fk.respond_to?('empty?') && fk.empty?) ? nil : klass.send(find_method_name, fk, config, reload || force))
+        else
+          assoc_val
         end
-
-      end
-      
-      module InstanceMethods
       end
-      
-      def self.included(receiver)
-        receiver.extend         ClassMethods
-        receiver.send :include, InstanceMethods
-      end
-      
     end
+
+  end
+  
+  module InstanceMethods
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
   end
-end
+  
+end

data/lib/resourceful/model/attribute_types.rb

@@ -1,39 +1,38 @@
-module Resourceful
-  module Model
-    module AttributeTypes
-      
-      module ClassMethods
-        
-        ATTRIBUTE_TYPES = {
-          :string   => { :method => 'to_s',                   :kind => ::String   },
-          :text     => { :method => 'to_s',                   :kind => ::String   },
-          :integer  => { :method => 'to_i',                   :kind => ::Fixnum   },
-          :float    => { :method => 'to_f',                   :kind => ::Float    },
-          :currency => { :method => 'from_currency_to_f',     :kind => ::Float    },
-          :date     => { :method => 'to_date',                :kind => ::Date     },
-          :datetime => { :method => 'to_datetime',            :kind => ::DateTime },
-          :boolean  => { :method => 'to_resourceful_boolean', :kind => ::Object   },
-          :other    => { :method => 'to_s',                   :kind => ::String   }
-        }
-        
-        def attribute_type_to_method(type)
-          (ATTRIBUTE_TYPES.has_key?(type.to_sym) ? ATTRIBUTE_TYPES[type.to_sym] : ATTRIBUTE_TYPES[:other])[:method]
-        end
-
-        def attribute_type_to_kind(type)
-          (ATTRIBUTE_TYPES.has_key?(type.to_sym) ? ATTRIBUTE_TYPES[type.to_sym] : ATTRIBUTE_TYPES[:other])[:kind]
-        end
+module Resourceful; end
+module Resourceful::Model; end
 
-      end
-      
-      module InstanceMethods
-      end
-      
-      def self.included(receiver)
-        receiver.extend         ClassMethods
-        receiver.send :include, InstanceMethods
-      end
+module Resourceful::Model::AttributeTypes
       
+  module ClassMethods
+    
+    ATTRIBUTE_TYPES = {
+      :string   => { :method => 'to_s',               :kind => ::String   },
+      :text     => { :method => 'to_s',               :kind => ::String   },
+      :integer  => { :method => 'to_i',               :kind => ::Fixnum   },
+      :float    => { :method => 'to_f',               :kind => ::Float    },
+      :currency => { :method => 'from_currency_to_f', :kind => ::Float    },
+      :date     => { :method => 'to_date',            :kind => ::Date     },
+      :datetime => { :method => 'to_datetime',        :kind => ::DateTime },
+      :boolean  => { :method => 'to_boolean',         :kind => ::Object   },
+      :other    => { :method => 'to_s',               :kind => ::String   }
+    }
+    
+    def attribute_type_to_method(type)
+      (ATTRIBUTE_TYPES.has_key?(type.to_sym) ? ATTRIBUTE_TYPES[type.to_sym] : ATTRIBUTE_TYPES[:other])[:method]
     end
+
+    def attribute_type_to_kind(type)
+      (ATTRIBUTE_TYPES.has_key?(type.to_sym) ? ATTRIBUTE_TYPES[type.to_sym] : ATTRIBUTE_TYPES[:other])[:kind]
+    end
+
+  end
+  
+  module InstanceMethods
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
   end
-end
+  
+end

data/lib/resourceful/model/base.rb

@@ -1,187 +1,187 @@
 require 'resourceful/model/attribute_types'
 
-module Resourceful
-  module Model
+module Resourceful; end
 
-    class Base
-      include Resourceful::Model::AttributeTypes
-      
-      @@agent ||= {}
-      def self.agent(&block)
-        @@agent[self.name.to_s] = block;
-      end
-      
-      @@namespaces = [""]
-      def self.namespaces
-        @@namespaces.dup
-      end
-      def self.add_namespace(ns)
-        @@namespaces.unshift(ns)
-      end
-      def self.get_namespaced_klass(class_name)
-        klass = nil
-        @@namespaces.each do |ns|
-          begin
-            klass = "#{ns}::#{class_name}".resourceful_constantize
-            break;
-          rescue Exception => err
-          end
+module Resourceful::Model
+
+  class Base
+    include Resourceful::Model::AttributeTypes
+    
+    @@agent ||= {}
+    def self.agent(&block)
+      @@agent[self.name.to_s] = block;
+    end
+    
+    @@namespaces = [""]
+    def self.namespaces
+      @@namespaces.dup
+    end
+    def self.add_namespace(ns)
+      @@namespaces.unshift(ns)
+    end
+    def self.get_namespaced_klass(class_name)
+      klass = nil
+      @@namespaces.each do |ns|
+        begin
+          klass = "#{ns}::#{class_name}".resourceful_constantize
+          break;
+        rescue Exception => err
         end
-        klass
       end
-      
-      def self.get(path, opts={})
-        block = opts.delete(:on_response)
-        set_agent.get(path, opts, &block)
-      end
-      def self.get_collection(path, opts={})
-        block = opts.delete(:on_response)
-        (yield set_agent.get(path, opts, &block)).collect{|data| new(data)}
-      end
-      def self.find(id, opts, force)
-        raise NotImplementedError, "no find method has been defined"
-      end
-      
-      def initialize(data)
-      end
-      
-      def data
-        @data
-      end
-      
-      def new_record?
-        @data.nil?
-      end
-      
-      def attributes(force=false)
-        if @attributes.nil? || force
-          @attributes = {}
-          self.class.ancestors.each do |anc|
-            if @@attributes[anc.to_s]
-              @attributes.merge!(@@attributes[anc.to_s].inject({}) { |hsh, key| hsh[key] = self.send("_#{key}"); hsh })
-            end
+      klass
+    end
+    
+    def self.get(path, opts={})
+      block = opts.delete(:on_response)
+      set_agent.get(path, opts, &block)
+    end
+    def self.get_collection(path, opts={})
+      block = opts.delete(:on_response)
+      (yield set_agent.get(path, opts, &block)).collect{|data| new(data)}
+    end
+    def self.find(id, opts, force)
+      raise NotImplementedError, "no find method has been defined"
+    end
+    
+    def initialize(data)
+    end
+    
+    def data
+      @data
+    end
+    
+    def new_record?
+      @data.nil?
+    end
+    
+    def attributes(force=false)
+      if @attributes.nil? || force
+        @attributes = {}
+        self.class.ancestors.each do |anc|
+          if @@attributes[anc.to_s]
+            @attributes.merge!(@@attributes[anc.to_s].inject({}) { |hsh, key| hsh[key] = self.send("_#{key}"); hsh })
           end
         end
-        @attributes
       end
-      
-      def update_attributes(attr_hash={})
-        attr_hash.each do |k,v|
-          self.send("#{k}=", v)
-        end
-        attributes(true)
-      end
-      
-      def save
-        @data = yield attributes(true)
-        reset_attributes
-      end
-      
-      def destroy
-        yield attributes(true)
-        @data = nil
+      @attributes
+    end
+    
+    def update_attributes(attr_hash={})
+      attr_hash.each do |k,v|
+        self.send("#{k}=", v)
       end
+      attributes(true)
+    end
+    
+    def save
+      @data = yield attributes(true)
+      reset_attributes
+    end
+    
+    def destroy
+      yield attributes(true)
+      @data = nil
+    end
 
-      def self.cleanup_name(name)
-        name.to_s.gsub(/\W/,'')
-      end
-      
-      protected
-      
-      def push_data(verb, path, opts, data)
-        block = opts.delete(:on_response)
-        ['id', :id].each { |a| data.delete(a) } if data.kind_of?(::Hash)
-        self.class.set_agent.send(verb.to_s, path, opts, data, &block)
-      end
-      
-      def self.attribute(name, type, config={})
-        clean_name = cleanup_name(name)
-        add_to_attributes(name.to_s)
-        config ||= {}
-        config[:path] ||= clean_name
-        content_method = attribute_type_to_method(type)
-        # method to get the raw attribute variable data (not intended to be overridden)
-        define_method("_#{clean_name}") do
-          fetch_attribute(clean_name, config, content_method)
-        end
-        # method to read the attribute value (intended to be overridden when necessary)
-        define_method(name) do |*args|
-          reload = args.first || false
-          instance_variable_set("@#{clean_name}", nil) if reload
-          fetch_attribute(clean_name, config, content_method)
-        end
-        # method to write the attribute value
-        define_method("#{name}=") do |value|
-          instance_variable_set("@#{clean_name}", value)
-        end
+    def self.cleanup_name(name)
+      name.to_s.gsub(/\W/,'')
+    end
+    
+    protected
+    
+    def push_data(verb, path, opts, data)
+      block = opts.delete(:on_response)
+      ['id', :id].each { |a| data.delete(a) } if data.kind_of?(::Hash)
+      self.class.set_agent.send(verb.to_s, path, opts, data, &block)
+    end
+    
+    def self.attribute(name, type, config={})
+      clean_name = cleanup_name(name)
+      add_to_attributes(name.to_s)
+      config ||= {}
+      config[:path] ||= clean_name
+      content_method = attribute_type_to_method(type)
+      # method to get the raw attribute variable data (not intended to be overridden)
+      define_method("_#{clean_name}") do
+        fetch_attribute(clean_name, config, content_method)
+      end
+      # method to read the attribute value (intended to be overridden when necessary)
+      define_method(name) do |*args|
+        reload = args.first || false
+        instance_variable_set("@#{clean_name}", nil) if reload
+        fetch_attribute(clean_name, config, content_method)
+      end
+      # method to write the attribute value
+      define_method("#{name}=") do |value|
+        instance_variable_set("@#{clean_name}", value)
       end
+    end
 
-      private
-      
-      def fetch_attribute(clean_name, config, content_method)
-        instance_variable_get("@#{clean_name}") || \
-          instance_variable_set("@#{clean_name}", \
-            if (a = attribute(config))
-              begin
-                self.class.get_value(a, config).send(content_method)
-              rescue Exception => err
-                a
-              end
-            else
+    private
+    
+    def fetch_attribute(clean_name, config, content_method)
+      instance_variable_get("@#{clean_name}") || \
+        instance_variable_set("@#{clean_name}", \
+          if (a = attribute(config))
+            begin
+              self.class.get_value(a, config).send(content_method)
+            rescue Exception => err
               a
             end
-          )
-      end
-      
-      def reset_attributes
-        clear_attributes
-        attributes(true)
-      end
-      
-      def clear_attributes
-        @@attributes ||= {}
-        klass_name = self.class.name
-        @@attributes[klass_name] ||= []
-        @@attributes[klass_name].each do |a|
-          instance_variable_set("@#{a.to_s.gsub(/\W/,'')}", nil)
-        end
-      end
-      
-      def self.add_to_attributes(name)
-        @@attributes ||= {}
-        klass_name = self.name
-        @@attributes[klass_name] ||= []
-        @@attributes[klass_name] << name
+          else
+            a
+          end
+        )
+    end
+    
+    def reset_attributes
+      clear_attributes
+      attributes(true)
+    end
+    
+    def clear_attributes
+      @@attributes ||= {}
+      klass_name = self.class.name
+      @@attributes[klass_name] ||= []
+      @@attributes[klass_name].each do |a|
+        instance_variable_set("@#{a.to_s.gsub(/\W/,'')}", nil)
       end
+    end
+    
+    def self.add_to_attributes(name)
+      @@attributes ||= {}
+      klass_name = self.name
+      @@attributes[klass_name] ||= []
+      @@attributes[klass_name] << name
+    end
 
-      def self.get_value(attribute, opts={})
-        if opts[:value]
-          (attribute =~ opts[:value]) ? ($1 || $&) : nil
-        else
-          attribute
-        end
+    def self.get_value(attribute, opts={})
+      if opts[:value]
+        (attribute =~ opts[:value]) ? ($1 || $&) : nil
+      else
+        attribute
       end
-      
-      def self.set_agent
-        klass_name = ""
-        self.ancestors.each do |anc|
-          if @@agent[anc.to_s]
-            klass_name = anc.to_s 
-            break
-          end
-        end
-        
-        unless @@agent[klass_name].kind_of?(Resourceful::Agent::Base)
-          @@agent[klass_name] = @@agent[klass_name].call 
+    end
+    
+    def self.set_agent
+      klass_name = ""
+      self.ancestors.each do |anc|
+        if @@agent[anc.to_s]
+          klass_name = anc.to_s 
+          break
         end
-        @@agent[klass_name]
-      end
-
-      def self.add_namespace(ns)
-        @@namespaces.unshift(ns)
       end
       
+      unless @@agent[klass_name].kind_of?(Resourceful::Agent::Base)
+        @@agent[klass_name] = @@agent[klass_name].call 
+      end
+      @@agent[klass_name]
     end
 
+    def self.add_namespace(ns)
+      @@namespaces.unshift(ns)
+    end
+    
   end
-end
+
+end