kelredd-resourceful 0.2.0 → 0.3.0

data/Rakefile

@@ -37,7 +37,7 @@ Rake::TestTask.new do |t|
 end
 
 desc 'Generate the gemspec to serve this Gem from Github'
-task :github do
+task :gemspec do
   file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
   File.open(file, 'w') {|f| f << spec.to_ruby }
   puts "Created gemspec: #{file}"

data/features/{resource_models.feature → models.feature}

@@ -1,26 +1,22 @@
-Feature: Resource Models
+Feature:  Models
   In order to consume rest based resources
   As an object
-  I want to define and initialize a model class from xml resource data
+  I want to define and initialize a model class from resource data
   
   Scenario: Get JSON user
-    Given I have a configured resource host
-    And I am user with the screen_name "kelredd"
+    Given I am user with the screen_name "kelredd"
     When I load my "Json" user model
     Then the result should be a valid User model
     
   Scenario: Get XML user
-    Given I have a configured resource host
-    And I am user with the screen_name "kelredd"
+    Given I am user with the screen_name "kelredd"
     When I load my "Xml" user model
     Then the result should be a valid User model
 
   Scenario: Get JSON status collection
-    Given I have a configured resource host
     When I load the "Json" status "public_timeline"
     Then the result should be a collection of valid Status models
     
   Scenario: Get XML status collection
-    Given I have a configured resource host
     When I load the "Xml" status "public_timeline"
     Then the result should be a collection of valid Status models

data/features/{get_resource.feature → rest_client.feature}

@@ -3,6 +3,33 @@ Feature: Get Resource
   As an object
   I want to get data from a web resource as a formatted object
   
+  Scenario: JSON Format definition
+    Given I want to use the json resource format
+    Then the format should be .json
+  
+  Scenario: XML Format definition
+    Given I want to use the xml resource format
+    Then the format should be .xml
+  
+  Scenario: Host not configured
+    Given I have no host server configured
+    Then resourceful should complain about a configuration error
+
+  Scenario: Host configured
+    Given I have a configured resource host
+    Then the host should be set
+
+  Scenario: Resource logger
+    Given I have a configured resource host set to log
+    Then verify the log settings
+
+  Scenario: Resource logging
+    Given I have a configured resource host set to log
+    When I get a json formatted resource
+    Then the set log file should exist
+
+
+
   Scenario: Get JSON resource
     Given I have a configured resource host
     When I get a json formatted resource

data/features/step_definitions/rest_client_steps.rb

@@ -0,0 +1,84 @@
+Given /^I want to use the (.+) resource format$/ do |format|
+  @format = Resourceful::Resource::Format.get(format)
+end
+
+Given /^I have no host server configured$/ do
+  @agent = Resourceful::Agent::RestClient.new
+end
+
+Given /^I have a configured resource host$/ do
+  @agent = Resourceful::Agent::RestClient.new(:host => RESOURCE_CONFIG[:host])
+end
+
+Given /^I have a configured resource host set to log$/ do
+  log_file = File.expand_path(RESOURCE_CONFIG[:log])
+  FileUtils.rm(log_file) if File.exists?(log_file)
+  @agent = Resourceful::Agent::RestClient.new(:host => RESOURCE_CONFIG[:host]) {
+    RESOURCE_CONFIG[:log]
+  }
+end
+
+Then /^the format should be \.(.+)$/ do |format|
+  assert_equal @format.to_s, format
+end
+
+Then /^the host should be set$/ do
+  assert_equal @agent.host, RESOURCE_CONFIG[:host]
+end
+
+Then /^resourceful should complain about a configuration error$/ do
+  assert_raise Resourceful::Exceptions::ConfigurationError do
+    @agent.get RESOURCE_CONFIG[:resource], :format => 'json', :params => RESOURCE_CONFIG[:params]
+  end
+end
+
+Then /^verify the log settings$/ do
+  assert_equal @agent.logger.outputters.detect{|out| out.respond_to?('filename')}.filename, RESOURCE_CONFIG[:log]
+end
+
+Then /^the set log file should exist$/ do
+  log_file = File.expand_path(RESOURCE_CONFIG[:log])  
+  assert File.exists?(log_file)
+  FileUtils.rm(log_file) if File.exists?(log_file)
+end
+
+
+
+
+When /^I get a[n]* (.+) formatted resource$/ do |format|
+  @result = ResourcefulFeature::Helpers.safe_run_get do
+    @agent.get RESOURCE_CONFIG[:resource], :format => format, :params => RESOURCE_CONFIG[:params]
+  end
+end
+
+When /^I get a[n]* (.+) formatted implicitly resource$/ do |format|
+  @result = ResourcefulFeature::Helpers.safe_run_get do
+    @agent.get RESOURCE_CONFIG[:resource]+".#{format}", :params => RESOURCE_CONFIG[:params]
+  end
+end
+
+When /^I get a resource that does not exist$/ do
+  @result = ResourcefulFeature::Helpers.safe_run_get do
+    @agent.get '/unknown', :format => 'xml', :params => RESOURCE_CONFIG[:params]
+  end
+end
+
+Then /^the result should be a hash object$/ do
+  assert_kind_of Hash, @result.first
+end
+
+Then /^the result should be an xml object$/ do
+  assert_kind_of Nokogiri::XML::Document, @result
+end
+
+Then /^resourceful should complain about a format error$/ do
+  assert @result
+  assert_kind_of Resourceful::Exceptions::FormatError, @result
+  assert @result.message.length > 0
+end
+
+Then /^resourceful should complain about the resource not being found$/ do
+  assert @result
+  assert_kind_of RestClient::ResourceNotFound, @result
+  assert @result.message.length > 0
+end

data/features/step_definitions/support/env.rb

@@ -2,10 +2,13 @@ require 'test/unit/assertions'
 World(Test::Unit::Assertions)
 
 RESOURCE_CONFIG = {
-  :host => 'twitter.com',
+  :host => 'http://twitter.com',
   :resource => '/statuses/public_timeline',
   :params => {},
   :log => "./test.log"
 }
 
 require File.dirname(__FILE__) + '/../../../lib/resourceful'
+
+REST_CLIENT_TWITTER = Resourceful::Agent::RestClient.new(:host => RESOURCE_CONFIG[:host])
+

data/features/step_definitions/support/models.rb

@@ -1,5 +1,7 @@
 class UserXml < Resourceful::Model::Xml
   
+  agent REST_CLIENT_TWITTER
+  
   def self.find(screen_name, force=false)
     get("/users/#{screen_name}", {}, "//user")
   end
@@ -22,6 +24,8 @@ end
 
 class UserJson < Resourceful::Model::Json
   
+  agent REST_CLIENT_TWITTER
+  
   def self.find(screen_name, force=false)
     get("/users/#{screen_name}", {})
   end
@@ -44,6 +48,8 @@ end
 
 class StatusXml < Resourceful::Model::Xml
   
+  agent REST_CLIENT_TWITTER
+  
   def self.find(collection, force=false)
     get_collection("/statuses/#{collection}", {}, "//statuses/status")
   end
@@ -67,6 +73,8 @@ end
 
 class StatusJson < Resourceful::Model::Json
   
+  agent REST_CLIENT_TWITTER
+  
   def self.find(collection, force=false)
     get_collection("/statuses/#{collection}", {})
   end

data/lib/resourceful/agent/base.rb

@@ -0,0 +1,34 @@
+require 'log4r'
+require File.join(File.dirname(__FILE__), '..', 'resource', 'cache.rb')
+
+module Resourceful
+  module Agent
+    class Base
+      
+      attr_reader :logger, :cache
+      
+      def initialize(args={})
+        @cache = Resourceful::Resource::Cache.new
+        @logger = Log4r::Logger.new('Resourceful Base')
+        @logger.add(Log4r::StdoutOutputter.new('console'))
+      end
+      
+      protected
+
+      def log(msg, level = :info) # :nodoc:
+        if(msg)
+          if @logger && @logger.respond_to?(level)
+            @logger.send(level.to_s, msg) 
+          else
+            puts "** [#{level.to_s.upcase}]: #{msg}"
+          end
+        end
+      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
+end

data/lib/resourceful/agent/rest_client.rb

@@ -0,0 +1,61 @@
+require 'rest_client'
+require File.join(File.dirname(__FILE__), '..', 'resource', 'format.rb')
+require File.join(File.dirname(__FILE__), 'base.rb')
+
+module Resourceful
+  module Agent
+    class RestClient < Resourceful::Agent::Base
+      
+      ATTRS = [:host, :user, :password]
+      ATTRS.each { |a| attr_reader a }
+      
+      def initialize(args={})
+        ATTRS.each { |a| instance_variable_set("@#{a.to_s}", args.delete(a)) }
+        super(args)
+        self.log = ::RestClient.log = yield if block_given?
+        @agent = ::RestClient::Resource.new(@host, :user => @user, :password => @password)
+      end
+
+      def get(path, opts={})
+        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('get', full_resource_path)
+        cache_key = Resourceful::Resource::Cache.key(@host, 'get', full_resource_path)
+        
+        if opts[:force] || (resp = cache.read(cache_key)).nil?
+          log "Resource call: #{resource_summary}"
+          resp = cache.write(cache_key, @agent[full_resource_path].get)
+        else
+          log "Resource call: [CACHE] #{resource_summary}"
+        end
+        format.build(resp)
+      end
+    
+      protected
+    
+      def check_config(path, opts)
+        raise Resourceful::Exceptions::ConfigurationError, "invalid RestClient agent" unless @agent && @agent.url
+        opts ||= {}
+        opts[:force] ||= false
+        if path =~ /^(.+)\.(.+)$/
+          path = $1
+          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}.#{format}#{params.to_http_query_str unless params.empty?}"
+      end
+      
+      def summary(verb, full_resource_path) # :nodoc:
+        "#{verb.upcase} #{@agent.url}#{full_resource_path}"
+      end
+        
+    end
+  end
+end

data/lib/resourceful/agent.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__), "agent" ,"*.rb")].each do |file|
+  require file
+end

data/lib/resourceful/model/base.rb

@@ -3,17 +3,16 @@ module Resourceful
 
     class Base
       
-      # KDR: override this to have a per model Resource handler
-      # => TODO: need to support creating resource instances first though
-      def self.resource
-        Resourceful::Resource
+      @@agent = nil
+      def self.agent(a)
+        @@agent = a
       end
       
-      def self.get(path, opts={}, force=false)
-        resource.get(path, opts, force)
+      def self.get(path, opts={})
+        @@agent.get(path, opts)
       end
-      def self.get_collection(path, opts={}, force=false)
-        (yield resource.get(path, opts, force)).collect{|data| new(data)}
+      def self.get_collection(path, opts={})
+        (yield @@agent.get(path, opts)).collect{|data| new(data)}
       end
 
       def initialize(data)

data/lib/resourceful/model/json.rb

@@ -8,16 +8,18 @@ module Resourceful
       def self.get(path, params, force=false)
         opts = {
           :format => 'json',
-          :params => params || {}
+          :params => params || {},
+          :force => force
         }
-        new(super(path, opts, force))
+        new(super(path, opts))
       end
       def self.get_collection(path, params, force=false)
         opts = {
           :format => 'json',
-          :params => params || {}
+          :params => params || {},
+          :force => force
         }
-        super(path, opts, force) do |data|
+        super(path, opts) do |data|
           data
         end
       end
@@ -35,10 +37,7 @@ module Resourceful
       
       def attribute(config)
         paths = config[:path].to_s.split('/')
-        paths.inject(@json) do |val,path|
-          #raise Resourceful::Exceptions::AttributeError, "no matching attribute data for'#{config[:path]}'" if val.nil?
-          val.fetch(path, nil) rescue nil
-        end
+        paths.inject(@json) { |val,path| val.fetch(path, nil) rescue nil }
       end
         
 

data/lib/resourceful/model/xml.rb

@@ -8,16 +8,18 @@ module Resourceful
       def self.get(path, params, xpath, force=false)
         opts = {
           :format => 'xml',
-          :params => params || {}
+          :params => params || {},
+          :force => force
         }
-        new(super(path, opts, force).xpath(xpath))
+        new(super(path, opts).xpath(xpath))
       end
       def self.get_collection(path, params, xpath, force=false)
         opts = {
           :format => 'xml',
-          :params => params || {}
+          :params => params || {},
+          :force => force
         }
-        super(path, opts, force) do |data|
+        super(path, opts) do |data|
           data.xpath(xpath)
         end
       end
@@ -35,7 +37,6 @@ module Resourceful
       
       def attribute(config)
         node = get_node("./#{config[:path]}")
-        #raise Resourceful::Exceptions::AttributeError, "no matching attribute data for'#{config[:path]}'" unless node
         node.content rescue nil
       end
         

data/lib/resourceful/resource/cache.rb

@@ -2,44 +2,30 @@ module Resourceful
   module Resource
     class Cache
 
-      @@cache = {}
-
-      def self.clear(key=nil)
-        if key
-          @@cache[key] = nil
-        else
-          @@cache = {}
-        end
-      end
-      
-      def self.read(key)
-        @@cache[key]
-      end
+      attr_reader :store
       
-      def self.write(key, value)
-        @@cache[key] = value
+      def self.key(host, verb, resource)
+        "#{host}_#{verb}_#{resource}"
       end
 
-      def self.key(server, verb, path, format, params)
-        "#{server}_#{verb}_#{path}_#{format.to_s}_#{params.to_s}"
+      def initialize
+        @store = {}
       end
-      
-      attr_reader :key
-      
-      def initialize(server, verb, path, format, params)
-        @key = self.class.key(server, verb, path, format, params)
-      end
-      
-      def read
-        self.class.read(@key)
+
+      def clear(key=nil)
+        if key
+          @store[key] = nil
+        else
+          @store = {}
+        end
       end
       
-      def write(value)
-        self.class.write(@key, value)
+      def read(key)
+        @store[key]
       end
       
-      def clear
-        self.class.clear(@key)
+      def write(key, value)
+        @store[key] = value
       end
 
     end

data/lib/resourceful/resource.rb

@@ -1,25 +1,3 @@
 Dir[File.join(File.dirname(__FILE__), "resource" ,"*.rb")].each do |file|
   require file
 end
-
-module Resourceful
-  module Resource
-    
-    def self.configure(opts={}, &block)
-      Resourceful::Resource::Base.configure(opts, &block)
-    end
-
-    def self.get(resource, opts={}, force=false)
-      Resourceful::Resource::Base.get(resource, opts, force)
-    end
-
-    def self.host
-      Resourceful::Resource::Base.host
-    end
-
-    def self.logger
-      Resourceful::Resource::Base.logger
-    end
-
-  end
-end

data/lib/resourceful/version.rb

@@ -2,7 +2,7 @@ module Resourceful
   module Version
     
     MAJOR = 0
-    MINOR = 2
+    MINOR = 3
     TINY  = 0
     
     def self.to_s # :nodoc:

data/lib/resourceful.rb

@@ -1,7 +1,7 @@
-%w(rubygems nokogiri json rest_client log4r).each do |lib|
+%w(rubygems nokogiri json log4r).each do |lib|
   require lib
 end
 
-%w(exceptions extensions resource model).each do |file|
+%w(exceptions extensions resource agent model).each do |file|
   require File.join(File.dirname(__FILE__), 'resourceful', "#{file}.rb")
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kelredd-resourceful
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -73,19 +73,20 @@ extra_rdoc_files:
 files: 
 - README.rdoc
 - Rakefile
-- features/config_resource.feature
-- features/get_resource.feature
-- features/resource_models.feature
+- features/models.feature
+- features/rest_client.feature
 - features/step_definitions
-- features/step_definitions/resource_config_steps.rb
-- features/step_definitions/resource_get_steps.rb
-- features/step_definitions/resource_models_steps.rb
+- features/step_definitions/model_steps.rb
+- features/step_definitions/rest_client_steps.rb
 - features/step_definitions/support
 - features/step_definitions/support/env.rb
 - features/step_definitions/support/helpers.rb
 - features/step_definitions/support/models.rb
-- features/step_definitions/support/resources.rb
 - lib/resourceful
+- lib/resourceful/agent
+- lib/resourceful/agent/base.rb
+- lib/resourceful/agent/rest_client.rb
+- lib/resourceful/agent.rb
 - lib/resourceful/exceptions.rb
 - lib/resourceful/extensions.rb
 - lib/resourceful/model
@@ -94,7 +95,6 @@ files:
 - lib/resourceful/model/xml.rb
 - lib/resourceful/model.rb
 - lib/resourceful/resource
-- lib/resourceful/resource/base.rb
 - lib/resourceful/resource/cache.rb
 - lib/resourceful/resource/format.rb
 - lib/resourceful/resource.rb

data/features/config_resource.feature

@@ -1,29 +0,0 @@
-Feature: Config Resource
-  In order to consume rest based resources
-  As an user
-  I want to configure Resourceful for a particular resource format and host
-  
-  Scenario: JSON Format definition
-    Given I want to use the json resource format
-    Then the format should be .json
-  
-  Scenario: XML Format definition
-    Given I want to use the xml resource format
-    Then the format should be .xml
-  
-  Scenario: Host not configured
-    Given I have no host server configured
-    Then resourceful should complain about a configuration error
-
-  Scenario: Host configured
-    Given I have a configured resource host
-    Then the host should be set
-
-  Scenario: Resource logger
-    Given I have a configured resource host set to log
-    Then verify the log settings
-
-  Scenario: Resource logging
-    Given I have a configured resource host set to log
-    When I get a json formatted resource
-    Then the set log file should exist

data/features/step_definitions/resource_config_steps.rb

@@ -1,23 +0,0 @@
-Then /^the format should be \.(.+)$/ do |format|
-  assert_equal @format.to_s, format
-end
-
-Then /^the host should be set$/ do
-  assert_equal Resourceful::Resource.host, RESOURCE_CONFIG[:host]
-end
-
-Then /^resourceful should complain about a configuration error$/ do
-  assert_raise Resourceful::Exceptions::ConfigurationError do
-    Resourceful::Resource::Base.get RESOURCE_CONFIG[:resource], :format => 'json', :params => RESOURCE_CONFIG[:params]
-  end
-end
-
-Then /^verify the log settings$/ do
-  assert_equal Resourceful::Resource.logger.outputters.detect{|out| out.respond_to?('filename')}.filename, RESOURCE_CONFIG[:log]
-end
-
-Then /^the set log file should exist$/ do
-  log_file = File.expand_path(RESOURCE_CONFIG[:log])  
-  assert File.exists?(log_file)
-  FileUtils.rm(log_file) if File.exists?(log_file)
-end

data/features/step_definitions/resource_get_steps.rb

@@ -1,37 +0,0 @@
-When /^I get a[n]* (.+) formatted resource$/ do |format|
-  @result = ResourcefulFeature::Helpers.safe_run_get do
-    Resourceful::Resource::Base.get RESOURCE_CONFIG[:resource], :format => format, :params => RESOURCE_CONFIG[:params]
-  end
-end
-
-When /^I get a[n]* (.+) formatted implicitly resource$/ do |format|
-  @result = ResourcefulFeature::Helpers.safe_run_get do
-    Resourceful::Resource::Base.get RESOURCE_CONFIG[:resource]+".#{format}", :params => RESOURCE_CONFIG[:params]
-  end
-end
-
-When /^I get a resource that does not exist$/ do
-  @result = ResourcefulFeature::Helpers.safe_run_get do
-    Resourceful::Resource::Base.get '/unknown', :format => 'xml', :params => RESOURCE_CONFIG[:params]
-  end
-end
-
-Then /^the result should be a hash object$/ do
-  assert_kind_of Hash, @result.first
-end
-
-Then /^the result should be an xml object$/ do
-  assert_kind_of Nokogiri::XML::Document, @result
-end
-
-Then /^resourceful should complain about a format error$/ do
-  assert @result
-  assert_kind_of Resourceful::Exceptions::FormatError, @result
-  assert @result.message.length > 0
-end
-
-Then /^resourceful should complain about the resource not being found$/ do
-  assert @result
-  assert_kind_of RestClient::ResourceNotFound, @result
-  assert @result.message.length > 0
-end

data/features/step_definitions/support/resources.rb

@@ -1,20 +0,0 @@
-Given /^I want to use the (.+) resource format$/ do |format|
-  @format = Resourceful::Resource::Format.get(format)
-end
-
-Given /^I have no host server configured$/ do
-  Resourceful::Resource::Base.configure
-end
-
-Given /^I have a configured resource host$/ do
-  Resourceful::Resource::Base.configure(:host => RESOURCE_CONFIG[:host])
-end
-
-Given /^I have a configured resource host set to log$/ do
-  log_file = File.expand_path(RESOURCE_CONFIG[:log])
-  FileUtils.rm(log_file) if File.exists?(log_file)
-  Resourceful::Resource::Base.configure(:host => RESOURCE_CONFIG[:host]) {
-    RESOURCE_CONFIG[:log]
-  }
-end
-

data/lib/resourceful/resource/base.rb

@@ -1,84 +0,0 @@
-require 'rest_client'
-require 'log4r'
-require File.join(File.dirname(__FILE__), 'cache.rb')
-require File.join(File.dirname(__FILE__), 'format.rb')
-require File.join(File.dirname(__FILE__), '..', 'exceptions.rb')
-
-module Resourceful
-  module Resource
-    class Base
-      
-      @@host = nil
-      @@logger = nil
-      
-      def self.configure(opts={})
-        Resourceful::Resource::Cache.clear
-        @@logger = Log4r::Logger.new('Resourceful Base')
-        @@logger.add(Log4r::StdoutOutputter.new('console'))
-        if block_given?
-          log_file = yield
-          @@logger.add(Log4r::FileOutputter.new('fileOutputter', :filename => log_file, :trunc => false, :formatter => Log4r::PatternFormatter.new(:pattern => "[%l] %d :: %m"))) rescue nil
-          RestClient.log = log_file
-        end
-        @@host = opts[:host]
-      end
-      
-      def self.host
-        @@host
-      end
-      
-      def self.logger
-        @@logger
-      end
-
-      # KDR: returns the resource specified in hash form
-      def self.get(path, opts={}, force=false)
-        path, opts = check_config(path, opts)
-        @@rest_client ||= ::RestClient::Resource.new("http://#{@@host}")
-        format = Resourceful::Resource::Format.get(opts[:format])
-        request_summary = summary('get', path, format, opts[:params])
-        cache = Resourceful::Resource::Cache.new(@@host, 'get', path, format, opts[:params])
-
-        if force || (resp = cache.read).nil?
-          log "Resource call: #{request_summary}"
-          resp = cache.write(@@rest_client[rest_path(path, format, opts[:params])].get)
-        else
-          log "Resource call: [CACHE] #{request_summary}"
-        end
-        format.build(resp)
-      end
-
-      private
-
-      def self.summary(verb, path, format, params) # :nodoc:
-        "#{verb.upcase} #{@@rest_client.url}#{rest_path(path, format, params)}"
-      end
-      
-      def self.rest_path(path, format, params) # :nodoc:
-        "#{path}.#{format}#{params.to_http_query_str unless params.empty?}"
-      end
-
-      def self.check_config(path, opts)
-        raise Resourceful::Exceptions::ConfigurationError, "please configure a host for Resourceful resources" unless @@host
-        if path =~ /^(.+)\.(.+)$/
-          path = $1
-          opts[:format] ||= $2
-        end
-        opts[:format] ||= Resourceful::Resource::Json.to_s
-        opts[:params] ||= {}
-        [path, opts]
-      end
-      
-      def self.log(msg, level = :info) # :nodoc:
-        if(msg)
-          if @@logger && @@logger.respond_to?(level)
-            @@logger.send(level.to_s, msg) 
-          else
-            puts "** [#{level.to_s.upcase}]: #{msg}"
-          end
-        end
-      end 
-
-    end
-  end
-end