kelredd-resourceful 0.7.24 → 0.7.25

data/lib/resourceful/model/embedded_associations.rb

@@ -1,63 +1,62 @@
-module Resourceful
-  module Model
-    module EmbeddedAssociations
-      
-      module ClassMethods
-
-        protected
-        
-        def contains_one(name, config={})
-          clean_name = cleanup_name(name)
-          config ||= {}
-          config[:path] ||= clean_name
-          raise ArgumentError, "contains_one requires a :class option to be specified" unless config[:class]
-          class_name = config.delete(:class).to_s
-          define_method(name) do
-            klass = self.class.get_namespaced_klass(class_name)
-            raise ArgumentError, "contains_one :class '#{class_name}' is not defined in any given namespaces" if klass.nil?
-            instance_variable_get("@#{clean_name}") || \
-              instance_variable_set("@#{clean_name}", \
-                if (c = child(config))
-                  klass.new(c) rescue c
-                else
-                  c
-                end
-              )
-          end
-        end
-
-        def contains_many(name, config={})
-          clean_name = cleanup_name(name)
-          config ||= {}
-          config[:path] ||= clean_name
-          raise ArgumentError, "contains_many requires a :class option to be specified" unless config[:class]
-          class_name = config.delete(:class).to_s
-          define_method(name) do
-            klass = self.class.get_namespaced_klass(class_name)
-            raise ArgumentError, "contains_many :class '#{class_name}' is not defined in any given namespaces" if klass.nil?
-            instance_variable_get("@#{clean_name}") || \
-              instance_variable_set("@#{clean_name}", \
-                if ((c = child(config)) && c.respond_to?(:collect))
-                  c.collect do |item|
-                    klass.new(item) rescue item
-                  end
-                else
-                  c
-                end
-              )
-          end
-        end
+module Resourceful; end
+module Resourceful::Model; end
 
-      end
+module Resourceful::Model::EmbeddedAssociations
       
-      module InstanceMethods
+  module ClassMethods
+
+    protected
+    
+    def contains_one(name, config={})
+      clean_name = cleanup_name(name)
+      config ||= {}
+      config[:path] ||= clean_name
+      raise ArgumentError, "contains_one requires a :class option to be specified" unless config[:class]
+      class_name = config.delete(:class).to_s
+      define_method(name) do
+        klass = self.class.get_namespaced_klass(class_name)
+        raise ArgumentError, "contains_one :class '#{class_name}' is not defined in any given namespaces" if klass.nil?
+        instance_variable_get("@#{clean_name}") || \
+          instance_variable_set("@#{clean_name}", \
+            if (c = child(config))
+              klass.new(c) rescue c
+            else
+              c
+            end
+          )
       end
-      
-      def self.included(receiver)
-        receiver.extend         ClassMethods
-        receiver.send :include, InstanceMethods
+    end
+
+    def contains_many(name, config={})
+      clean_name = cleanup_name(name)
+      config ||= {}
+      config[:path] ||= clean_name
+      raise ArgumentError, "contains_many requires a :class option to be specified" unless config[:class]
+      class_name = config.delete(:class).to_s
+      define_method(name) do
+        klass = self.class.get_namespaced_klass(class_name)
+        raise ArgumentError, "contains_many :class '#{class_name}' is not defined in any given namespaces" if klass.nil?
+        instance_variable_get("@#{clean_name}") || \
+          instance_variable_set("@#{clean_name}", \
+            if ((c = child(config)) && c.respond_to?(:collect))
+              c.collect do |item|
+                klass.new(item) rescue item
+              end
+            else
+              c
+            end
+          )
       end
-      
     end
+
+  end
+  
+  module InstanceMethods
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
   end
-end
+  
+end

data/lib/resourceful/model/external_associations.rb

@@ -1,88 +1,87 @@
-module Resourceful
-  module Model
-    module ExternalAssociations
+module Resourceful; end
+module Resourceful::Model; end
+
+module Resourceful::Model::ExternalAssociations
       
-      module ClassMethods
+  module ClassMethods
 
-        protected
-        
-        def has_many(name, config={})
-          clean_name = cleanup_name(name)
-          config ||= {}
-          raise ArgumentError, "has_many requires a :class option to be specified" unless config[:class]
-          class_name = config.delete(:class).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 = self.class.get_namespaced_klass(class_name)
-              raise ArgumentError, "has_many :class '#{class_name}' is not defined in any given namespaces" if klass.nil?
-              unless klass.respond_to?(find_method_name)
-                raise NotImplementedError, "has_many 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(name, config={})
+      clean_name = cleanup_name(name)
+      config ||= {}
+      raise ArgumentError, "has_many requires a :class option to be specified" unless config[:class]
+      class_name = config.delete(:class).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 = self.class.get_namespaced_klass(class_name)
+          raise ArgumentError, "has_many :class '#{class_name}' is not defined in any given namespaces" if klass.nil?
+          unless klass.respond_to?(find_method_name)
+            raise NotImplementedError, "has_many 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(name, config={})
-          clean_name = cleanup_name(name)
-          config ||= {}
-          raise ArgumentError, "belongs_to requires a :class option to be specified" unless config[:class]
-          class_name = config.delete(:class).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 = self.class.get_namespaced_klass(class_name)
-              raise ArgumentError, "belongs_to :class '#{class_name}' is not defined in any given namespaces" if klass.nil?
-              unless self.respond_to?(foreign_key_method)
-                raise ArgumentError, "belongs_to requires a '#{foreign_key_method}' method defined to return the foreign_key"
-              end
-              unless klass.respond_to?(find_method_name)
-                raise NotImplementedError, "belongs_to 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(name, config={})
+      clean_name = cleanup_name(name)
+      config ||= {}
+      raise ArgumentError, "belongs_to requires a :class option to be specified" unless config[:class]
+      class_name = config.delete(:class).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 = self.class.get_namespaced_klass(class_name)
+          raise ArgumentError, "belongs_to :class '#{class_name}' is not defined in any given namespaces" if klass.nil?
+          unless self.respond_to?(foreign_key_method)
+            raise ArgumentError, "belongs_to requires a '#{foreign_key_method}' method defined to return the foreign_key"
+          end
+          unless klass.respond_to?(find_method_name)
+            raise NotImplementedError, "belongs_to 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/findable.rb

@@ -1,102 +1,101 @@
-module Resourceful
-  module Model
-    module Findable
+module Resourceful; end
+module Resourceful::Model; end
+
+module Resourceful::Model::Findable
       
-      module ClassMethods
+  module ClassMethods
 
-        def find(id, opts={}, force=false)
-          opts ||= {}
-          opts = findable_default_opts.merge(opts) if respond_to?(:findable_default_opts)
-          case id
-          when :all
-            self.get_collection("#{findable_index}.#{format}", opts, findable_search, force)
-          when :first
-            self.get_collection("#{findable_index}.#{format}", opts, findable_search, force).first
-          when :last
-            self.get_collection("#{findable_index}.#{format}", opts, findable_search, force).last
-          else
-            self.get("#{findable_index}/#{id}.#{format}", opts, findable_search, force)
-          end
-        end
-        
-        def all
-          find(:all)
-        end
-        def first
-          find(:first)
-        end
-        def last
-          find(:last)
-        end
-        
-        def findable_index
-          raise NotImplementedError, "Findable expects a public class method 'findable_index'"
-        end
-        
-        def findable_search
-          # defaults to non namespaced downcased name of the class
-          self.name.demodulize.underscore.to_s.gsub(/^.*::/, '')
-        end
-        
+    def find(id, opts={}, force=false)
+      opts ||= {}
+      opts = findable_default_opts.merge(opts) if respond_to?(:findable_default_opts)
+      case id
+      when :all
+        self.get_collection("#{findable_index}.#{format}", opts, findable_search, force)
+      when :first
+        self.get_collection("#{findable_index}.#{format}", opts, findable_search, force).first
+      when :last
+        self.get_collection("#{findable_index}.#{format}", opts, findable_search, force).last
+      else
+        self.get("#{findable_index}/#{id}.#{format}", opts, findable_search, force)
       end
-      
-      module InstanceMethods
-        
-        def save
-          super do |attribute_hash|
-            if new_record?
-              self.push_data('post', \
-                "#{self.class.findable_index}.#{self.class.format}", \
-                {:params => self.class.findable_default_opts.merge(push_data_params)}, \
-                nested_attr_hash(attribute_hash), \
-                self.class.findable_search \
-              )
-            else
-              self.push_data('put', \
-                "#{self.class.findable_index}/#{self.id}.#{self.class.format}", \
-                {:params => self.class.findable_default_opts.merge(push_data_params)}, \
-                nested_attr_hash(attribute_hash), \
-                self.class.findable_search \
-              )
-            end
-          end
-        end
-        
-        def destroy
-          super do |attribute_hash|
-            unless new_record?
-              self.push_data('delete', \
-                "#{self.class.findable_index}/#{self.id}.#{self.class.format}", \
-                {:params => self.class.findable_default_opts.merge(push_data_params)}, \
-                {} \
-              )
-            end
-          end
-        end
-        
-        def push_data_params
-          # override to customize save url params
-          {}
-        end
-        
-        def push_data_nesting
-          # default, override to customize, set to nil for push data hash style nesting
-          self.class.name.demodulize.underscore
-        end
-        
-        private
-        
-        def nested_attr_hash(attr_hash)
-          push_data_nesting ? {push_data_nesting => attr_hash} : attr_hash
+    end
+    
+    def all
+      find(:all)
+    end
+    def first
+      find(:first)
+    end
+    def last
+      find(:last)
+    end
+    
+    def findable_index
+      raise NotImplementedError, "Findable expects a public class method 'findable_index'"
+    end
+    
+    def findable_search
+      # defaults to non namespaced downcased name of the class
+      self.name.demodulize.underscore.to_s.gsub(/^.*::/, '')
+    end
+    
+  end
+  
+  module InstanceMethods
+    
+    def save
+      super do |attribute_hash|
+        if new_record?
+          self.push_data('post', \
+            "#{self.class.findable_index}.#{self.class.format}", \
+            {:params => self.class.findable_default_opts.merge(push_data_params)}, \
+            nested_attr_hash(attribute_hash), \
+            self.class.findable_search \
+          )
+        else
+          self.push_data('put', \
+            "#{self.class.findable_index}/#{self.id}.#{self.class.format}", \
+            {:params => self.class.findable_default_opts.merge(push_data_params)}, \
+            nested_attr_hash(attribute_hash), \
+            self.class.findable_search \
+          )
         end
-        
       end
-      
-      def self.included(receiver)
-        receiver.extend         ClassMethods
-        receiver.send :include, InstanceMethods
+    end
+    
+    def destroy
+      super do |attribute_hash|
+        unless new_record?
+          self.push_data('delete', \
+            "#{self.class.findable_index}/#{self.id}.#{self.class.format}", \
+            {:params => self.class.findable_default_opts.merge(push_data_params)}, \
+            {} \
+          )
+        end
       end
-      
     end
+    
+    def push_data_params
+      # override to customize save url params
+      {}
+    end
+    
+    def push_data_nesting
+      # default, override to customize, set to nil for push data hash style nesting
+      self.class.name.demodulize.underscore
+    end
+    
+    private
+    
+    def nested_attr_hash(attr_hash)
+      push_data_nesting ? {push_data_nesting => attr_hash} : attr_hash
+    end
+    
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
   end
-end
+  
+end