arusarka-dynamic-active-resource 0.2.2 → 0.2.3

data/lib/dynamic_active_resource.rb

@@ -0,0 +1,21 @@
+begin
+  require 'active_resource'
+rescue LoadError
+  require 'rubygems'
+  require 'active_resource'
+end
+
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'dynamic_active_resource/associations'
+require 'dynamic_active_resource/common_dynamic_class_instance_methods'
+require 'dynamic_active_resource/common_class_methods'
+require 'dynamic_active_resource/helpers'
+require 'dynamic_active_resource/version'
+require 'dynamic_active_resource/base'
+
+module DynamicActiveResource
+end
+
+# shorter name
+DynAR = DynamicActiveResource

data/lib/dynamic_active_resource/associations.rb

@@ -0,0 +1,21 @@
+require 'dynamic_active_resource/associations/base'
+require 'dynamic_active_resource/associations/has_many'
+require 'dynamic_active_resource/associations/belongs_to'
+
+module DynamicActiveResource
+  module Associations
+    def has_many(assosiation_sym, options = {})
+      h_m_association = HasMany.new(assosiation_sym, options)
+      associations = self.instance_variable_get(:@associations) || []
+      associations << h_m_association
+      self.instance_variable_set(:@associations, associations)
+    end
+    
+    def belongs_to(association_sym, options = {})
+      b_t_association = BelongsTo.new(association_sym, options)
+      associations = self.instance_variable_get(:@associations) || []
+      associations << b_t_association
+      self.instance_variable_set(:@associations, associations)
+    end
+  end
+end

data/lib/dynamic_active_resource/associations/base.rb

@@ -0,0 +1,23 @@
+module DynamicActiveResource
+  module Associations
+    class Base
+      attr_reader :method_name
+      def initialize(method_name, options = {})
+        @method_name = method_name.to_s
+        class_name = options[:through] || @method_name.singularize.camelize
+        @associated_class_name = class_name
+      end
+
+      # fetches the resources for the association. requires the caller to be
+      # passed through self.
+      def resources_for(caller)
+        raise 'Not Implemented'
+      end
+
+      private
+      def associated_class
+        eval(@associated_class_name)
+      end
+    end
+  end
+end

data/lib/dynamic_active_resource/associations/belongs_to.rb

@@ -0,0 +1,11 @@
+module DynamicActiveResource
+  module Associations
+    class BelongsTo < Associations::Base
+      def resources_for(caller)
+        site_elements = caller.class.site.path.split('/')
+        associated_resource_id = site_elements[-1]
+        associated_class.find(associated_resource_id)
+      end
+    end
+  end
+end

data/lib/dynamic_active_resource/associations/has_many.rb

@@ -0,0 +1,17 @@
+module DynamicActiveResource
+  module Associations
+    class HasMany < Base
+      def set_associated_class_attributes(caller)
+        associated_class_site = File.join(caller.class.site.to_s, caller.class.collection_name, caller.resource_identifier)
+        associated_class.site = associated_class_site
+        associated_class.user = caller.class.user
+        associated_class.password = caller.class.password
+      end
+
+      def resources_for(caller)
+        set_associated_class_attributes(caller)
+        associated_class.find(:all)
+      end
+    end
+  end
+end

data/lib/dynamic_active_resource/base.rb

@@ -0,0 +1,210 @@
+module DynamicActiveResource
+  # ActiveResource makes connecting to rest resources very easy. However it has one problem 
+  # and a big one at that. If you try setting the authentication credentials or the site or
+  # collection name, element name for the class for the second time it doesn't work. E.g.
+  #
+  # class Person < ActiveResource::Base
+  #   self.site = 'http://localhost:9090/'
+  # end
+  #
+  # After sometime you change it to 
+  #
+  # Person.site = 'https://org-server/my_proj/'
+  # Person.user = 'admin'
+  # Person.password = 'secret'
+  #
+  # Then you do
+  #
+  # Person.find(:all) => It bombs
+  #
+  # This class provides a mechanism by which you can get rid of this problem. Extend DynamicActiveResource::Base
+  # class in the actual class itself. Do not extend the extended class from ActiveResource::Base.
+  # 
+  # E.g.
+  #
+  # class Person < DynamicActiveResource::Base
+  # end
+  #
+  # set the credentials
+  #
+  # Person.site = 'http://localhost:8080'
+  # Person.user = 'foo'
+  # Person.password = 'bar'
+  # 
+  # Thats it. Now create some objects
+  #
+  # asur = Person.new(:name => 'Asur', :job => 'fooling around', :status => 'Single and ready 2 mingle')
+  # asur.save
+  # 
+  # Now change the class attributes
+  #
+  # Person.site = 'https://org-server/mingle'
+  # Person.collection_name = 'boring_people'
+  # 
+  # Now instantiate an object
+  #
+  # rakhshas = Person.new(:name => 'Rakhshas', :job => 'eating people', :status => 'just woke up and hungry')
+  # rakhshas.save => Voila !!!!!!! it works
+  # 
+  # CUSTOMIZATIONS
+  # --------------
+  # 
+  # No amount of wrapping can provide very detailed customizations. Either you have a lot of methods
+  # that are not being used or there is hardly anything at all. To oversome this problem this module
+  # was written to provide only those methods which are common to most active resource objects.
+  # However if you want to have a little more control over your active resource objects its very easy.
+  # Here's how you would do it normally
+  # 
+  # class Person < ActiveResource::Base
+  #   def self.count
+  #     find(:all).size
+  #   end
+  #
+  #   def occupation
+  #     return job if job
+  #     'Unemployed' 
+  #   end
+  # end
+  #
+  # To do the same thing, here's how you do it using this library
+  #
+  # class Person < DynamicActiveResource::Base
+  #   module DynamicClassSingletonMethods
+  #     def count
+  #       find(:all).size
+  #     end
+  #   end
+  #
+  #   module DynamicClassInstanceMethods
+  #     def occupation
+  #       return job if job
+  #       'Unemployed' 
+  #     end
+  #   end
+  # end
+  #
+  # The DynamicClassInstanceMethods will be available as instance methods in the objects created,
+  # DynamicClassSingletonMethods will be available as class methods in the class of the object. Also
+  # active resource associations are sometimes paginated. So even if you use find(:all), you get 
+  # only the first few results. To overcome this, include in your DynamicClassSingletonMethods module
+  # a method called find_without_pagination. In that method route it to acitve resource find with 
+  # proper parameters. An example of the method implementation is 
+  #
+  # module DynamicClassSingletonMethods
+  #   def find_without_pagination(*args)
+  #     scope = args.slice!(0)
+  #     options = args.slice!(0) || {}
+  #     options[:params] ||= {}
+  #     options[:params].merge!({:page => 'all'})
+  #     # call ActiveResource::Base::find with proper options
+  #     find(scope, options)
+  #   end
+  # end
+  # 
+  # The class level find method will automatically pick up this method if defined as a method in the
+  # DynamicClassSingeletonMethod module else it will pass it to find. 
+  #
+  # ASSOCIATIONS
+  # ------------
+  #
+  # This gem also provides active record like associations(highly experimental). Right now it provides only two
+  # associations - 1) has_many, 2) belongs_to.
+  #
+  # 1) has_many 
+  # -----------
+  #
+  # Taking the example from above the way it should be done
+  #
+  # class Person < DynamicActiveResource::Base
+  #   has_many :cars
+  #
+  #   module DynamicClassSingletonMethods
+  #     def count
+  #       find(:all).size
+  #     end
+  #   end
+  #
+  #   module DynamicClassInstanceMethods
+  #     def occupation
+  #       return job if job
+  #       'Unemployed' 
+  #     end
+  #     
+  #     def resource_identifier
+  #      name()
+  #    end
+  #   end
+  # end
+  # 
+  # Next a car class has to be initialized
+  # 
+  # class Car < DynARBase (alias for DynamicActiveResource::Base, inbuilt in the gem)
+  # end
+  # 
+  # set resource options only at the top level( Person in this case)
+  #
+  # Person.site = 'http://localhost:8080/'
+  # Person.user = 'test'
+  # Person.password = 'secret'
+  #
+  # associations take care of setting the site in the children classes automatically
+  # you will notice that an additional method resource_identifier() has been defined
+  # in the parent class. It would be discussed shortly.
+  # 
+  # The way associations work is if you do something like
+  # 
+  # person = Person.find('asur').cars it will hit the url http://localhost:8080/people/asur/cars.xml
+  # 
+  # You would notice that its getting the cars for the person with name 'asur'. It does so because
+  # in the Person class a method called resource_identifier has been defined which says that the id
+  # is actually name instead of the database id. If the id attribute in the xml is set appropriately
+  # (to 'name' in this case) then you do not need to define the method.
+  # 
+  # 2) belongs_to
+  # -------------
+  # 
+  # Again, referring to the example above
+  # 
+  # class Person < DynamicActiveResource::Base
+  #   has_many :cars
+  #
+  #   module DynamicClassSingletonMethods
+  #     def count
+  #       find(:all).size
+  #     end
+  #   end
+  #
+  #   module DynamicClassInstanceMethods
+  #     def occupation
+  #       return job if job
+  #       'Unemployed' 
+  #     end
+  #     
+  #     def resource_identifier
+  #      name()
+  #    end
+  #   end
+  # end
+  # 
+  # Next a car class has to be initialized
+  # 
+  # class Car < DynARBase (alias for DynamicActiveResource::Base)
+  #   belongs_to :person
+  # end
+  #
+  # Right now belongs_to supports only assocation with a single class. After defining this you 
+  # automatically have a method 'person' available.
+  #
+  # car = Car.find('WB1234I')
+  # owner = car.person
+  
+  class Base < ActiveResource::Base
+    def self.inherited(subclass)
+      subclass.extend(DynamicActiveResource::CommonClassMethods)
+      subclass.extend(DynamicActiveResource::Associations)
+    end
+  end
+end
+
+# shorter name
+DynARBase = DynamicActiveResource::Base

data/lib/dynamic_active_resource/common_class_methods.rb

@@ -0,0 +1,131 @@
+module DynamicActiveResource
+  module CommonClassMethods
+    attr_reader :site, :user, :password
+
+    # creates an object of the class in which this module is extended
+    def new(args = {})
+      # @resource_class = create_resource_class() # should this be commented
+      @resource_class.new(args)
+    end
+
+    # sets the site for the class in which this module is extended
+    def site=(site)
+      if site != self.site
+        @site = site
+        uri = URI.parse(site)
+        @user = URI.decode(uri.user) if(uri.user)
+        @password = URI.decode(uri.password) if(uri.password)
+        @resource_class = self.send(:create_resource_class)
+      end
+      @site
+    end
+
+    # sets the user for the class in which this module is extended
+    def user=(user)
+      if user != self.user
+        @user = user
+        @resource_class = self.send(:create_resource_class) if(site)
+      end
+      @user
+    end
+
+    # sets the password for the class in which this module is extended
+    def password=(password)
+      if password != self.password
+        @password = password
+        @resource_class = self.send(:create_resource_class) if(site)
+      end
+      @password
+    end
+
+    # sets the collection name for the class in which this module is extended
+    def collection_name=(collection_name)
+      if collection_name != self.collection_name
+        @collection_name = collection_name
+      end
+      @collection_name
+    end
+
+    # sets the elment name for the class in which this module is extended
+    def element_name=(element_name)
+      if element_name != self.element_name
+        @element_name = element_name
+      end
+      @element_name
+    end
+
+    # collection name for the class in which this module is extended
+    def collection_name
+      @collection_name || class_name.underscore.pluralize
+    end
+
+    # element name for the class in which this module is extended
+    def element_name
+      @element_name || class_name.underscore
+    end
+
+    # routes to active resource find
+    def find(*args)
+      return @resource_class.find_without_pagination(*args) if(@resource_class.respond_to?(:find_without_pagination))
+      scope = args.slice!(0)
+      options = args.slice!(0) || {}
+      obj = @resource_class.find(scope, options)
+      obj
+    end
+
+    private
+    # creates an active resource class dynamically. All the attributes are set automatically. Avoid calling
+    # this method directly                                                  
+    def create_resource_class
+      # raise exceptions if any of site is not set
+      raise "Please set the site for #{self} class before using create_resource_class()." unless(self.site)
+
+      created_class = Class.new(ActiveResource::Base)
+
+      # set the resource options
+      created_class.site = self.site
+      created_class.user = self.user
+      created_class.password = self.password
+      created_class.collection_name = self.collection_name
+      created_class.element_name = self.element_name
+
+      created_class_name = "#{self}::#{class_name}#{Helpers.fast_token()}"
+      eval "#{created_class_name} = created_class"
+
+      # include the common dynamic methods 
+      created_class.send(:include, DynamicActiveResource::CommonDynamicClassInstanceMethods)
+      
+      # includes a module called InstanceMethods in the class created dynamically
+      # if it is defined inside the wrapper class
+      inst_meth_mod_name = instance_methods_module_name()
+      created_class.send(:include, self.const_get(inst_meth_mod_name.to_sym)) if inst_meth_mod_name
+
+      # extends the class created dynamically with a module called ClassMethods if
+      # it is defined inside the wrapper class
+      class_meth_mod_name = class_methods_module_name()
+      created_class.extend(self.const_get(class_meth_mod_name)) if class_meth_mod_name
+      # put the associations in the created class also
+      created_class.instance_variable_set(:@associations, @associations)
+
+      created_class
+    end
+
+    def class_name
+      self.name.split('::')[-1]
+    end
+
+    def instance_methods_module_name
+      inst_meth_mod_name = 'DynamicClassInstanceMethods'
+      self.constants.detect { |const| const.split('::')[-1] =~ /#{inst_meth_mod_name}/ }
+    end
+
+    def class_methods_module_name
+      class_meth_mod_name = 'DynamicClassSingletonMethods'
+      self.constants.detect { |const| const.split('::')[-1] =~ /#{class_meth_mod_name}/ }
+    end
+
+    def method_missing(meth_id, *args, &block)
+      @resource_class.send(meth_id, *args, &block)
+    end
+  end
+end

data/lib/dynamic_active_resource/common_dynamic_class_instance_methods.rb

@@ -0,0 +1,38 @@
+module DynamicActiveResource
+  module CommonDynamicClassInstanceMethods
+    def method_missing(method_symbol, *arguments) #:nodoc:
+      method_name = method_symbol.to_s
+      # dynamic setters and getters
+      case method_name.last
+      when "="
+        return attributes[method_name.first(-1)] = arguments.first
+      when "?"
+        return attributes[method_name.first(-1)]
+      else
+        # return attributes
+        return attributes[method_name] if(attributes.has_key?(method_name))
+        # return the association if it is a association method
+        return get_association(method_name) if(association_method?(method_name))
+        super
+      end
+    end
+    
+    def resource_identifier
+      id()
+    end
+    
+    private
+    def association_method?(method_name)
+      @associations ||= self.class.instance_variable_get(:@associations)
+      return false unless @associations
+      association = @associations.detect { |association| association.method_name.to_s == method_name.to_s }
+      association ? true : false
+    end
+    
+    def get_association(method_name)
+      @associations ||= self.class.instance_variable_get(:@associations)
+      association = @associations.detect { |association| association.method_name.to_s == method_name.to_s }
+      association.resources_for(self)
+    end
+  end
+end

data/lib/dynamic_active_resource/helpers.rb

@@ -0,0 +1,33 @@
+module DynamicActiveResource
+  module Helpers
+    def Helpers.fast_token
+      values = [
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x1000000),
+        rand(0x1000000),
+      ]
+      "%04x%04x%04x%04x%04x%06x%06x" % values
+    end
+
+    def Helpers.encode2html(string)
+      html_char_map = {
+        '[' => '%5B', ']' => '%5D',
+        '(' => '%28', ')' => '%29',
+        ',' => '%2C', ' ' => '%20',
+        '=' => '%3D', '\'' => '%27',
+        '<' => '%3C', '>' => '%3E',
+      }
+
+      string.strip! if string
+      encoded_string = ''
+      string.each_char do |char|
+        encoded_string << (html_char_map[char] || char)
+      end
+      encoded_string
+    end
+  end
+end

data/lib/dynamic_active_resource/version.rb

@@ -0,0 +1,11 @@
+module DynamicActiveResource
+  module Version
+    Major = '0'
+    Minor = '2'
+    Tiny  = '1'
+    
+    def self.to_s
+      [Major, Minor, Tiny].join('.')
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: arusarka-dynamic-active-resource
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors: 
 - asur
@@ -31,6 +31,16 @@ extensions: []
 extra_rdoc_files: 
 - README
 files: 
+- lib/dynamic_active_resource/associations/base.rb
+- lib/dynamic_active_resource/associations/belongs_to.rb
+- lib/dynamic_active_resource/associations/has_many.rb
+- lib/dynamic_active_resource/associations.rb
+- lib/dynamic_active_resource/base.rb
+- lib/dynamic_active_resource/common_class_methods.rb
+- lib/dynamic_active_resource/common_dynamic_class_instance_methods.rb
+- lib/dynamic_active_resource/helpers.rb
+- lib/dynamic_active_resource/version.rb
+- lib/dynamic_active_resource.rb
 - README
 - History.txt
 - init.rb