oare 0.1.4 → 0.1.6

data/lib/active_resource_override/base.rb

@@ -1,213 +1,187 @@
-module Oare
-  module Resource
-
-    def self.included(base)
-      base.instance_eval <<-RUBY
-
-        alias_method :original_save, :save
-        undef_method :save
-        define_method :save do |options = {}, query_options = nil|
-          begin
-            perform_validation = case options
-              when Hash
-                options.delete(:validate) != false
-              when NilClass
-                true
-              else
-                options
-              end
-
-            # clear the remote validations so they don't interfere with the local
-            # ones. Otherwise we get an endless loop and can never change the
-            # fields so as to make the resource valid
-            @remote_errors = nil
-            if perform_validation && valid? || !perform_validation
-              save_without_validation(options, query_options)
+module Oare::Resource
+  def self.included(base)
+    base.instance_eval <<-RUBY
+
+      alias_method :original_save, :save
+      undef_method :save
+      define_method :save do |options = {}, query_options = nil|
+        begin
+          perform_validation = case options
+            when Hash
+              options.delete(:validate) != false
+            when NilClass
               true
             else
-              false
+              options
             end
-          rescue ActiveResource::ResourceInvalid => error
-            # cache the remote errors because every call to <tt>valid?</tt> clears
-            # all errors. We must keep a copy to add these back after local
-            # validations
-            @remote_errors = error
-            load_remote_errors(@remote_errors, true)
-            false
-          end
-        end
-
-        alias_method :original_save_without_validation, :save_without_validation
-        undef_method :save_without_validation
-        define_method :save_without_validation do |path_options = {}, query_options = nil|
-          new? ? create(path_options, query_options) : update(path_options, query_options)
-        end
-
-        alias_method :original_create, :create
-        undef_method :create
-        define_method :create do |path_options = {}, query_options = nil|
-          connection.post(create_path(path_options, query_options), encode, self.class.headers).tap do |response|
-            self.id = id_from_response(response)
-            load_attributes_from_response(response)
-          end
-        end
-
-        alias_method :original_update, :update
-        undef_method :update
-        define_method :update do |path_options = {}, query_options = nil|
-          connection.put(update_path(path_options, query_options), encode, self.class.headers).tap do |response|
-            load_attributes_from_response(response)
-          end
-        end
-      RUBY
 
-      base.send(:include, InstanceMethods)
-      base.extend(ClassMethods)
-      base.set_default_values
-    end
-
-    module InstanceMethods
-      attr_accessor :nested_attributes_values
-
-      def initialize(attributes = {})
-        @nested_attributes_values ||= {}
-        self.class.instance_variable_get(:@nested_attributes).each do |key, value|
-          @nested_attributes_values[key] = collection = attributes.delete(key)
-          next unless collection
-
-          collection.each do |index, associate_attributes|
-            nested_model = value.to_s
-            collection   = []
-            collection[index.to_i] = nested_model.singularize.camelize.constantize.new(associate_attributes)
-            instance_variable_set("@#{nested_model}", collection)
+          # clear the remote validations so they don't interfere with the local
+          # ones. Otherwise we get an endless loop and can never change the
+          # fields so as to make the resource valid
+          @remote_errors = nil
+          if perform_validation && valid? || !perform_validation
+            save_without_validation(options, query_options)
+            true
+          else
+            false
           end
+        rescue ActiveResource::ResourceInvalid => error
+          # cache the remote errors because every call to <tt>valid?</tt> clears
+          # all errors. We must keep a copy to add these back after local
+          # validations
+          @remote_errors = error
+          load_remote_errors(@remote_errors, true)
+          false
         end
-        super
       end
 
-      def create_path(options = {}, query_options = {})
-        self.class.create_path(prefix_options.merge(options), query_options)
+      alias_method :original_save_without_validation, :save_without_validation
+      undef_method :save_without_validation
+      define_method :save_without_validation do |path_options = {}, query_options = nil|
+        new? ? create(path_options, query_options) : update(path_options, query_options)
       end
 
-      def update_path(options = {}, query_options = {})
-        self.class.update_path(to_param, prefix_options.merge(options), query_options)
+      alias_method :original_create, :create
+      undef_method :create
+      define_method :create do |path_options = {}, query_options = nil|
+        connection.post(create_path(path_options, query_options), encode, self.class.headers).tap do |response|
+          self.id = id_from_response(response)
+          load_attributes_from_response(response)
+        end
       end
 
-      def encode(options={})
-        if new?
-          keys = nested_attributes_values.keys
-          super(options.merge(:methods => keys))
-        else
-          super
+      alias_method :original_update, :update
+      undef_method :update
+      define_method :update do |path_options = {}, query_options = nil|
+        connection.put(update_path(path_options, query_options), encode, self.class.headers).tap do |response|
+          load_attributes_from_response(response)
         end
       end
-    end # Instance Methods
 
-    module ClassMethods
-      attr_accessor :access_token
-      attr_accessor :associations
-      attr_accessor :nested_attributes
+    RUBY
 
-      def set_default_values
-        self.nested_attributes ||= {}
-        self.associations      ||= []
-      end
+    base.send(:include, InstanceMethods)
+    base.extend(ClassMethods)
+    base.set_default_values
+  end
 
-      def has_many(association_id, options = {})
-        class_name = options[:class_name] || association_id.to_s.singularize.camelize
-        associations << class_name.constantize
+  module InstanceMethods
+    attr_accessor :nested_attributes_values
 
-        define_method(association_id) do |*args|
-          current_value = instance_variable_get("@#{association_id}".to_sym)
-          return current_value if current_value
+    def initialize(attributes = {})
+      @nested_attributes_values ||= {}
+      self.class.instance_variable_get(:@nested_attributes).each do |key, value|
+        @nested_attributes_values[key] = collection = attributes.delete(key)
+        next unless collection
 
-          resource = find_or_create_resource_for_collection(class_name)
-          value = if self.new_record? then [resource.new]
-            else
-            # TODO:
-            # Request for users of account
-            # Use an instance variable version of the access token
-            #
-            end
-          instance_variable_set(
-            "@#{association_id}".to_sym, value)
+        collection.each do |index, associate_attributes|
+          nested_model = value.to_s
+          collection   = []
+          collection[index.to_i] = nested_model.singularize.camelize.constantize.new(associate_attributes)
+          instance_variable_set("@#{nested_model}", collection)
         end
       end
+      super
+    end
 
-      def accepts_nested_attributes_for(association_id, options = {})
-        nested_attributes["#{association_id}_attributes"] = association_id
-        define_method("#{association_id}_attributes=") do |*args|
-          # TODO
-        end
+    def create_path(options = {}, query_options = {})
+      self.class.create_path(prefix_options.merge(options), query_options)
+    end
 
-        define_method("#{association_id}_attributes") do
-          nested_attributes_values["#{association_id}_attributes"]
-        end
-      end
+    def update_path(options = {}, query_options = {})
+      self.class.update_path(to_param, prefix_options.merge(options), query_options)
+    end
 
-      def access_token=(token)
-        @access_token = token
-        self.site     = token.consumer.site
+    def encode(options={})
+      if new?
+        keys = nested_attributes_values.keys
+        super(options.merge(:methods => keys))
+      else
+        super
       end
+    end
 
-      def connection(refresh = true)
-        self.access_token ? self.oauth_connection : super
-      end
+    def errors
+      @errors ||= Oare::Errors.new(self)
+    end
+  end # Instance Methods
+
+  module ClassMethods
+    attr_accessor :access_token
+    attr_accessor :associations
+    attr_accessor :nested_attributes
 
-      def oauth_connection(refresh = true)
-        associations.each do |model_constant|
-          model_constant.access_token = self.access_token
-        end if associations
+    def set_default_values
+      self.nested_attributes ||= {}
+      self.associations      ||= []
+    end
 
-        @connection = Oare::Connection.new(self.access_token) if @connection.nil? || refresh
-        @connection.timeout = timeout if timeout
-        @connection
+    def has_many(association_id, options = {})
+      class_name = options[:class_name] || association_id.to_s.singularize.camelize
+      associations << class_name.constantize
+
+      define_method(association_id) do |*args|
+        current_value = instance_variable_get("@#{association_id}".to_sym)
+        return current_value if current_value
+
+        resource = find_or_create_resource_for_collection(class_name)
+        value = if self.new_record? then [resource.new]
+          else
+          # TODO:
+          # Request for users of account
+          # Use an instance variable version of the access token
+          #
+          end
+        instance_variable_set(
+          "@#{association_id}".to_sym, value)
       end
+    end
 
-      def create_path(path_options = {}, query_options = nil)
-        path = path_options.delete(:path)
-        prefix_options = path_options
-        return collection_path(prefix_options, query_options) unless path
-        "/#{path}.#{format.extension}#{query_string(query_options)}"
+    def accepts_nested_attributes_for(association_id, options = {})
+      nested_attributes["#{association_id}_attributes"] = association_id
+      define_method("#{association_id}_attributes=") do |*args|
+        # TODO
       end
 
-      def update_path(id, path_options = {}, query_options = nil)
-        path = path_options.delete(:path)
-        prefix_options = path_options
-        return collection_path(id, prefix_options, query_options) unless path
-        "/#{path}/#{URI.escape id.to_s}.#{format.extension}#{query_string(query_options)}"
+      define_method("#{association_id}_attributes") do
+        nested_attributes_values["#{association_id}_attributes"]
       end
+    end
 
-    end # Class Methods
-  end # Oare Resource
+    def access_token=(token)
+      @access_token = token
+      self.site     = token.consumer.site
+    end
 
-  module Gateway
+    def connection(refresh = true)
+      self.access_token ? self.oauth_connection : super
+    end
 
-    def method_missing(method, *args, &block)
-      collection = ::ActiveResource::Base.oauth_enabled_classes
-      if collection.keys.include? method
-        constant = collection[method].join('::').constantize
-        constant.access_token = self.access_token
-        #Rails.logger.info  constant.access_token.inspect
-        #Rails.logger.info  ::ActiveResource::Base.access_token.inspect
-        #sleep 20
-        constant
-      else
-        super(method, *args, &block)
-      end
+    def oauth_connection(refresh = true)
+      associations.each do |model_constant|
+        model_constant.access_token = self.access_token
+      end if associations
+
+      @connection = Oare::Connection.new(self.access_token) if @connection.nil? || refresh
+      @connection.timeout = timeout if timeout
+      @connection
     end
 
-    def access_token
-      ## This method assumes that the Gateway Model has the fields/methods for:
-      #  oauth_token        : string,
-      #  oauth_token_secret : string,
-      #  consumer           : consumer token
-      #
+    def create_path(path_options = {}, query_options = nil)
+      path = path_options.delete(:path)
+      prefix_options = path_options
+      return collection_path(prefix_options, query_options) unless path
+      "/#{path}.#{format.extension}#{query_string(query_options)}"
+    end
 
-      OAuth::AccessToken.new(consumer, oauth_token, oauth_token_secret)
+    def update_path(id, path_options = {}, query_options = nil)
+      path = path_options.delete(:path)
+      prefix_options = path_options
+      return collection_path(id, prefix_options, query_options) unless path
+      "/#{path}/#{URI.escape id.to_s}.#{format.extension}#{query_string(query_options)}"
     end
 
-  end
+  end # Class Methods
 end
 
 # Monkey Patch Active Resource and Action Controller

data/lib/active_resource_override/errors.rb

@@ -0,0 +1,26 @@
+class Oare::Errors < ActiveResource::Errors
+  def from_array(messages, save_cache = false)
+    clear unless save_cache
+    humanized_nested_attributes = @base.nested_attributes_values.map do |model, v|
+      v.map do |i, v2|
+        v2.keys.map do |k|
+          attribute_name = "#{model.gsub('_attributes','')}_#{k}".underscore
+          [attribute_name.humanize, attribute_name]
+        end
+      end
+    end.flatten
+    humanized_nested_attributes = Hash[*humanized_nested_attributes]
+
+    humanized_attributes = @base.attributes.keys.inject({}) { |h, attr_name| h.update(attr_name.humanize => attr_name) }
+    humanized_attributes.merge!(humanized_nested_attributes)
+    messages.each do |message|
+      attr_message = humanized_attributes.keys.detect do |attr_name|
+        if message[0, attr_name.size + 1] == "#{attr_name} "
+          add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
+        end
+      end
+
+      self[:base] << message if attr_message.nil?
+    end
+  end
+end

data/lib/extensions/gateway.rb

@@ -0,0 +1,27 @@
+module Oare
+  module Gateway
+    def method_missing(method, *args, &block)
+      collection = ::ActiveResource::Base.oauth_enabled_classes
+      if collection.keys.include? method
+        constant = collection[method].join('::').constantize
+        constant.access_token = self.access_token
+        #Rails.logger.info  constant.access_token.inspect
+        #Rails.logger.info  ::ActiveResource::Base.access_token.inspect
+        #sleep 20
+        constant
+      else
+        super(method, *args, &block)
+      end
+    end
+
+    def access_token
+      ## This method assumes that the Gateway Model has the fields/methods for:
+      #  oauth_token        : string,
+      #  oauth_token_secret : string,
+      #  consumer           : consumer token
+      #
+
+      OAuth::AccessToken.new(consumer, oauth_token, oauth_token_secret)
+    end
+  end
+end

data/lib/oare.rb

@@ -2,6 +2,12 @@ module Oare
 end
 
 if defined?(Rails) && Rails::VERSION::MAJOR == 3
+  require 'active_resource'
+  require 'active_resource/base'
+  require 'active_resource/validations'
+
   require File.expand_path('active_resource_override/connection', File.dirname(__FILE__))
+  require File.expand_path('active_resource_override/errors'    , File.dirname(__FILE__))
   require File.expand_path('active_resource_override/base'      , File.dirname(__FILE__))
+  require File.expand_path('extensions/gateway'                 , File.dirname(__FILE__))
 end

data/oare.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |s|
   ## Basic Information
   #
   s.name     = 'oare'
-  s.version  = '0.1.4'
+  s.version  = '0.1.6'
   s.platform = Gem::Platform::RUBY
   s.required_ruby_version     = '~> 1.9'
   s.required_rubygems_version = '>= 1.3.6'

metadata

@@ -2,7 +2,7 @@
 name: oare
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors: 
 - Nelvin Driz
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-19 00:00:00 +08:00
+date: 2011-05-20 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,6 +45,8 @@ files:
 - init.rb
 - lib/active_resource_override/base.rb
 - lib/active_resource_override/connection.rb
+- lib/active_resource_override/errors.rb
+- lib/extensions/gateway.rb
 - lib/oare.rb
 - oare.gemspec
 has_rdoc: true