kelredd-resourceful 0.7.24 → 0.7.25

data/Rakefile

@@ -24,6 +24,7 @@ spec = Gem::Specification.new do |s|
   s.add_dependency('rest-client')
   s.add_dependency('mechanize')
   s.add_dependency('log4r')
+  s.add_dependency('kelredd-useful', '>= 0.2.4')
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|

data/lib/resourceful.rb

@@ -1,4 +1,4 @@
-%w(nokogiri json log4r).each do |lib|
+%w(nokogiri json log4r useful/ruby_extensions).each do |lib|
   require lib
 end
 

data/lib/resourceful/agent/base.rb

@@ -1,73 +1,73 @@
 require 'log4r'
 require "resourceful/resource/cache"
 
-module Resourceful
-  module Agent
-    class Base
-      
-      attr_reader :logger, :cache, :expiration, :log_prefix
+module Resourceful; end
 
-      ATTRS = [:host, :user, :password, :expiration, :log_prefix]
-      ATTRS.each { |a| attr_reader a }
-      
-      def initialize(args={})
-        ATTRS.each { |a| instance_variable_set("@#{a.to_s}", args.delete(a)) }
-        @cache = Resourceful::Resource::Cache.new @expiration
-        @logger = Log4r::Logger.new('[Resourceful]')
-        @logger.add(Log4r::StdoutOutputter.new('console'))
-      end
-      
-      protected
+module Resourceful::Agent
+  class Base
+    
+    attr_reader :logger, :cache, :expiration, :log_prefix
 
-      def call_resource(verb, path, opts={}, &block)
-        path, opts = check_config(path, opts)
-        format = Resourceful::Resource::Format.get(opts[:format])
-        
-        full_resource_path = self.class.resource_path(path, format, opts[:params])
-        resource_summary = summary(verb.to_s, full_resource_path)
-        cache_key = Resourceful::Resource::Cache.key(@host, verb.to_s, full_resource_path)
-        
-        if opts[:force] || (resp = cache.read(cache_key)).nil?
-          log "#{resource_summary}"
-          resp = cache.write(cache_key, block.call(full_resource_path))
-        else
-          log "[CACHE] #{resource_summary}"
-        end
-        format.build(resp)
-      end
+    ATTRS = [:host, :user, :password, :expiration, :log_prefix]
+    ATTRS.each { |a| attr_reader a }
     
-      def check_config(path, opts) # :nodoc:
-        raise Resourceful::Exceptions::ConfigurationError, "invalid agent" unless agent && agent_url && !agent_url.empty?
-        opts ||= {}
-        opts[:force] ||= false
-        if path =~ /^(.+)\.(.+)$/
-          opts[:format] ||= $2
-        end
-        opts[:format] ||= Resourceful::Resource::Json.to_s
-        opts[:params] ||= {}
-        [path, opts]
-      end
+    def initialize(args={})
+      ATTRS.each { |a| instance_variable_set("@#{a.to_s}", args.delete(a)) }
+      @cache = Resourceful::Resource::Cache.new @expiration
+      @logger = Log4r::Logger.new('[Resourceful]')
+      @logger.add(Log4r::StdoutOutputter.new('console'))
+    end
+    
+    protected
+
+    def call_resource(verb, path, opts={}, &block)
+      path, opts = check_config(path, opts)
+      format = Resourceful::Resource::Format.get(opts[:format])
       
-      def self.resource_path(path, format, params) # :nodoc:
-        "#{path}#{params.to_http_query_str unless params.empty?}"
-      end
+      full_resource_path = self.class.resource_path(path, format, opts[:params])
+      resource_summary = summary(verb.to_s, full_resource_path)
+      cache_key = Resourceful::Resource::Cache.key(@host, verb.to_s, full_resource_path)
       
-      def summary(verb, full_resource_path) # :nodoc:
-        "#{verb.upcase} #{agent_url}#{full_resource_path}"
-      end
-        
-      def agent_url
-        @host
+      if opts[:force] || (resp = cache.read(cache_key)).nil?
+        log "#{resource_summary}"
+        resp = cache.write(cache_key, block.call(full_resource_path))
+      else
+        log "[CACHE] #{resource_summary}"
       end
-      
-      def log(msg, level = :info) # :nodoc:
-        @logger.send(level.to_s, "#{"[#{@log_prefix.to_s}]" if @log_prefix} #{msg}") if msg
+      format.build(resp)
+    end
+  
+    def check_config(path, opts) # :nodoc:
+      raise Resourceful::Exceptions::ConfigurationError, "invalid agent" unless agent && agent_url && !agent_url.empty?
+      opts ||= {}
+      opts[:force] ||= false
+      if path =~ /^(.+)\.(.+)$/
+        opts[:format] ||= $2
       end
+      opts[:format] ||= Resourceful::Resource::Json.to_s
+      opts[:params] ||= {}
+      [path, opts]
+    end
+    
+    def self.resource_path(path, format, params) # :nodoc:
+      "#{path}#{params.to_http_query_str unless params.empty?}"
+    end
+    
+    def summary(verb, full_resource_path) # :nodoc:
+      "#{verb.upcase} #{agent_url}#{full_resource_path}"
+    end
       
-      def log=(file)
-        @logger.add(Log4r::FileOutputter.new('fileOutputter', :filename => file, :trunc => false, :formatter => Log4r::PatternFormatter.new(:pattern => "[%l] %d :: %m"))) rescue nil
-      end
-
+    def agent_url
+      @host
+    end
+    
+    def log(msg, level = :info) # :nodoc:
+      @logger.send(level.to_s, "#{"[#{@log_prefix.to_s}]" if @log_prefix} #{msg}") if msg
     end
+    
+    def log=(file)
+      @logger.add(Log4r::FileOutputter.new('fileOutputter', :filename => file, :trunc => false, :formatter => Log4r::PatternFormatter.new(:pattern => "[%l] %d :: %m"))) rescue nil
+    end
+
   end
 end

data/lib/resourceful/agent/mechanize.rb

@@ -1,44 +1,44 @@
 require 'mechanize'
 require "resourceful/agent/base"
 
-module Resourceful
-  module Agent
-    class Mechanize < Resourceful::Agent::Base
-      
-      ATTRS = [:agent_alias, :verbose]
-      ATTRS.each { |a| attr_reader a }
-      
-      def initialize(args={})
-        @verbose ||= false
-        ATTRS.each { |a| instance_variable_set("@#{a.to_s}", args.delete(a)) if args[a] }
-        super(args)
-        self.log = yield if block_given?
-        @mechanize = ::WWW::Mechanize.new do |obj|
-          obj.log = @logger && @verbose ? @logger : nil
-          obj.user_agent_alias = @agent_alias unless @agent_alias.nil?
-        end
-      end
+module Resourceful; end
 
-      def get(path, opts={}, &block)
-        call_resource(:get, path, opts, block)
+module Resourceful::Agent
+  class Mechanize < Resourceful::Agent::Base
+    
+    ATTRS = [:agent_alias, :verbose]
+    ATTRS.each { |a| attr_reader a }
+    
+    def initialize(args={})
+      @verbose ||= false
+      ATTRS.each { |a| instance_variable_set("@#{a.to_s}", args.delete(a)) if args[a] }
+      super(args)
+      self.log = yield if block_given?
+      @mechanize = ::WWW::Mechanize.new do |obj|
+        obj.log = @logger && @verbose ? @logger : nil
+        obj.user_agent_alias = @agent_alias unless @agent_alias.nil?
       end
+    end
+
+    def get(path, opts={}, &block)
+      call_resource(:get, path, opts, block)
+    end
+  
+    protected
     
-      protected
-      
-      def call_resource(verb, path, opts, block)
-        super(verb, path, opts) do |path|
-          resp = ""
-          @mechanize.send(verb.to_s, "#{@host}#{path}") do |page|
-            resp = block ? block.call(page) : page
-          end
-          resp.body
+    def call_resource(verb, path, opts, block)
+      super(verb, path, opts) do |path|
+        resp = ""
+        @mechanize.send(verb.to_s, "#{@host}#{path}") do |page|
+          resp = block ? block.call(page) : page
         end
+        resp.body
       end
-      
-      def agent
-        @mechanize
-      end
-      
     end
+    
+    def agent
+      @mechanize
+    end
+    
   end
 end

data/lib/resourceful/agent/rest_client.rb

@@ -1,56 +1,56 @@
 require 'rest_client'
 require "resourceful/agent/base"
 
-module Resourceful
-  module Agent
-    class RestClient < Resourceful::Agent::Base
-      
-     def initialize(args={})
-        super(args)
-        self.log = ::RestClient.log = yield if block_given?
-        @rest_client = ::RestClient::Resource.new(@host, :user => @user, :password => @password)
-      end
+module Resourceful; end
 
-      def get(path, opts={}, &block)
-        call_resource(:get, path, opts, block)
-      end
-      
-      def post(path, opts={}, body=nil, &block)
-        push_resource(:post, path, opts, body, block)
-      end
-      
-      def put(path, opts={}, body=nil, &block)
-        push_resource(:put, path, opts, body, block)
-      end
-      
-      def delete(path, opts={}, body=nil, &block)
-        push_resource(:delete, path, opts, body, block)
-      end
-      
-      protected
-      
-      def push_resource(verb, path, opts, body, block)
-        opts[:body] = body
-        opts[:force] = true
-        call_resource(verb, path, opts, block)
-      end
-      
-      def call_resource(verb, path, opts, block)
-        super(verb, path, opts) do |path|
-          result = case verb.to_sym 
-          when :get
-            @rest_client[path].get
-          when :post, :put, :delete
-            @rest_client[path].send(verb, opts[:body])
-          end
-          block ? block.call(result) : result
+module Resourceful::Agent
+  class RestClient < Resourceful::Agent::Base
+    
+   def initialize(args={})
+      super(args)
+      self.log = ::RestClient.log = yield if block_given?
+      @rest_client = ::RestClient::Resource.new(@host, :user => @user, :password => @password)
+    end
+
+    def get(path, opts={}, &block)
+      call_resource(:get, path, opts, block)
+    end
+    
+    def post(path, opts={}, body=nil, &block)
+      push_resource(:post, path, opts, body, block)
+    end
+    
+    def put(path, opts={}, body=nil, &block)
+      push_resource(:put, path, opts, body, block)
+    end
+    
+    def delete(path, opts={}, body=nil, &block)
+      push_resource(:delete, path, opts, body, block)
+    end
+    
+    protected
+    
+    def push_resource(verb, path, opts, body, block)
+      opts[:body] = body
+      opts[:force] = true
+      call_resource(verb, path, opts, block)
+    end
+    
+    def call_resource(verb, path, opts, block)
+      super(verb, path, opts) do |path|
+        result = case verb.to_sym 
+        when :get
+          @rest_client[path].get
+        when :post, :put, :delete
+          @rest_client[path].send(verb, opts[:body])
         end
+        block ? block.call(result) : result
       end
-      
-      def agent
-        @rest_client
-      end
-      
     end
+    
+    def agent
+      @rest_client
+    end
+    
   end
 end

data/lib/resourceful/exceptions.rb

@@ -1,23 +1,23 @@
-module Resourceful
-  module Exceptions
+module Resourceful; end
+
+module Resourceful::Exceptions
+
+  class ResourcefulError < ::StandardError
+  end
   
-    class ResourcefulError < ::StandardError
-    end
-    
-    class ResourceError < ResourcefulError
-    end
-    
-    class ConfigurationError < ResourceError
-    end
-    
-    class FormatError < ResourceError
-    end
-    
-    class ModelError < ResourcefulError
-    end
-    
-    class AttributeError < ModelError
-    end
-    
+  class ResourceError < ResourcefulError
+  end
+  
+  class ConfigurationError < ResourceError
+  end
+  
+  class FormatError < ResourceError
+  end
+  
+  class ModelError < ResourcefulError
+  end
+  
+  class AttributeError < ModelError
   end
+    
 end

data/lib/resourceful/extensions.rb

@@ -1,198 +1,50 @@
-module Resourceful
-  module Extensions   
-    module NilClass
-      
-      module ClassMethods; end
-      def self.included(klass)
-        klass.extend(ClassMethods) if klass.kind_of?(Class)
-      end
-
-      module ClassMethods
-      end
+module Resourceful; end
+module Resourceful::Extensions; end
 
-      unless nil.respond_to?(:to_resourceful_boolean) 
-        def to_resourceful_boolean
-          !!self
-        end
-      end
-      
-    end
+module Resourceful::Extensions::String
+  
+  module ClassMethods
   end
-end
-
-module Resourceful
-  module Extensions   
-    module String
-      
-      module ClassMethods; end
-      def self.included(klass)
-        klass.extend(ClassMethods) if klass.kind_of?(Class)
-      end
-
-      module ClassMethods
-      end
-
-      unless "".respond_to?(:to_datetime) 
-        def to_datetime
-          ::DateTime.civil(*::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 }) rescue nil
-        end
-      end
-
-      unless "".respond_to?(:to_date) 
-        def to_date
-          ::Date.civil(*::Date._parse(self, false).values_at(:year, :mon, :mday).map { |arg| arg || 0 }) rescue nil
-        end
-      end
-      
-      unless "".respond_to?(:to_resourceful_boolean) 
-        def to_resourceful_boolean
-          self.nil? || self.empty? || self =~ /^(false|0)$/i ? false : true
-        end
-      end
-      
-      unless "".respond_to?(:from_currency_to_f) 
-        def from_currency_to_f
-          self.gsub(/[^0-9.-]/,'').to_f
-        end
-      end
-      
-      unless "".respond_to?(:resourceful_constantize) 
-        if Module.method(:const_get).arity == 1
-          def resourceful_constantize #:nodoc:
-            names = self.split('::')
-            names.shift if names.empty? || names.first.empty?
-
-            constant = ::Object
-            names.each do |name|
-              constant = constant.const_defined?(name) ? constant.const_get(name) : raise(NameError.new("uninitialized constant #{self}"))
-            end
-            constant
-          end
-        else # Ruby 1.9 version
-          def resourceful_constantize #:nodoc:
-            names = self.split('::')
-            names.shift if names.empty? || names.first.empty?
-
-            constant = ::Object
-            names.each do |name|
-              constant = constant.const_get(name, false) || raise(NameError.new("uninitialized constant #{self}"))
-            end
-            constant
+  
+  module InstanceMethods
+
+    # Had to use a custom version of constantize to get around rails enhancements of 'const_missing'
+    # => instead, I just raise an uninitialized constant NameError manually
+    unless "".respond_to?(:resourceful_constantize) 
+      if Module.method(:const_get).arity == 1
+        def resourceful_constantize #:nodoc:
+          names = self.split('::')
+          names.shift if names.empty? || names.first.empty?
+
+          constant = ::Object
+          names.each do |name|
+            constant = constant.const_defined?(name) ? constant.const_get(name) : raise(NameError.new("uninitialized constant #{self}"))
           end
+          constant
         end
-      end
+      else # Ruby 1.9 version
+        def resourceful_constantize #:nodoc:
+          names = self.split('::')
+          names.shift if names.empty? || names.first.empty?
 
-      unless "".respond_to?(:camelize)
-        #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
-        def camelize(first_letter_in_uppercase = true)
-          if first_letter_in_uppercase
-            self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-          else
-            self[0..0].downcase + camelize(self)[1..-1]
+          constant = ::Object
+          names.each do |name|
+            constant = constant.const_get(name, false) || raise(NameError.new("uninitialized constant #{self}"))
           end
+          constant
         end
-        
       end
-      
-      unless "".respond_to?(:underscore)
-        #   "ActiveRecord::Errors".underscore # => active_record/errors
-        def underscore
-          self.to_s.gsub(/::/, '/').
-            gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-            gsub(/([a-z\d])([A-Z])/,'\1_\2').
-            tr("-", "_").
-            downcase
-        end
-      end
-      
-      unless "".respond_to?(:demodulize)
-        #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
-        def demodulize
-          self.to_s.gsub(/^.*::/, '')
-        end
-      end
-      
     end
-  end
-end
-
-module Resourceful
-  module Extensions
-    module Hash
 
-      module ClassMethods; end
-      def self.included(klass)
-        klass.extend(ClassMethods) if klass.kind_of?(Class)
-      end
-
-      module ClassMethods
-      end
-
-      # Returns string formatted for HTTP URL encoded name-value pairs.
-      # For example,
-      #  {:id => 'thomas_hardy'}.to_http_query_str 
-      #  # => "?id=thomas_hardy"
-      #  {:id => 23423, :since => Time.now}.to_http_query_str
-      #  # => "?since=Thu,%2021%20Jun%202007%2012:10:05%20-0500&id=23423"
-      #  {:id => [1,2]}.to_http_query_str
-      #  # => "?id[]=1&id[]=2"
-      #  {:poo => {:foo => 1, :bar => 2}}.to_http_query_str
-      #  # => "?poo[bar]=2&poo[foo]=1"
-      #  {:poo => {:foo => 1, :bar => {:bar1 => 1, :bar2 => "nasty"}}}.to_http_query_str
-      #  "?poo[bar][bar1]=1&poo[bar][bar2]=nasty&poo[foo]=1"
-      unless {}.respond_to?(:to_http_query_str) 
-        def to_http_query_str(opts = {})
-          require 'cgi' unless defined?(::CGI) && defined?(::CGI::escape)
-          opts[:prepend] ||= '?'
-          opts[:append] ||= ''
-          opts[:key_ns] ||= nil
-          opt_strings = self.collect do |key, val|
-            key_s = opts[:key_ns] ? "#{opts[:key_ns]}[#{key.to_s}]" : key.to_s
-            if val.kind_of?(::Array)
-              val.collect{|i| "#{key_s}[]=#{::CGI.escape(i.to_s)}"}.join('&')
-            elsif val.kind_of?(::Hash)
-              val.to_http_query_str({
-                :prepend => '',
-                :key_ns => key_s,
-                :append => ''
-              })
-            else
-              "#{key_s}=#{::CGI.escape(val.to_s)}"
-            end
-          end 
-          self.empty? ? '' : "#{opts[:prepend]}#{opt_strings.join('&')}#{opts[:append]}"
-        end
-      end
-      
-      # Returns the value for the provided key(s).  Allows searching in nested hashes
-      unless {}.respond_to?(:get_value) 
-        def get_value(*keys)
-          val = self[keys.first] || self[keys.first.to_s]
-          val = self[keys.first.to_s.intern] unless val || keys.first.to_s.empty? || keys.first.kind_of?(Symbol) 
-          val.kind_of?(Hash) && keys.length > 1 ? val.get_value?(keys[1..-1]) : val
-        end
-      end
-
-      # Determines if a value exists for the provided key(s).  Allows searching in nested hashes
-      unless {}.respond_to?('check_value?') 
-        def check_value?(*keys)
-          val = self.get_value(keys)
-          val && !val.empty? ? true : false
-        end
-      end
-
-    end
   end
-end
-
-class NilClass
-  include Resourceful::Extensions::NilClass
-end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+end      
 
 class String
   include Resourceful::Extensions::String
 end
 
-class Hash
-  include Resourceful::Extensions::Hash
-end