curbala 0.0.1

data/CHANGELOG.rdoc

@@ -0,0 +1,4 @@
+0.0.1 2012-07-26
+
+* first whack
+

data/Gemfile

@@ -0,0 +1,53 @@
+# source 'https://rubygems.org'
+# 
+# gem 'rails', '3.2.3'
+# 
+# # Bundle edge Rails instead:
+# # gem 'rails', :git => 'git://github.com/rails/rails.git'
+# 
+# gem 'mysql'
+# 
+# gem 'json'
+# 
+# # Gems used only for assets and not required
+# # in production environments by default.
+# group :assets do
+#   gem 'sass-rails',   '~> 3.2.3'
+#   gem 'coffee-rails', '~> 3.2.1'
+# 
+#   # See https://github.com/sstephenson/execjs#readme for more supported runtimes
+#   # gem 'therubyracer', :platform => :ruby
+# 
+#   gem 'uglifier', '>= 1.0.3'
+# end
+# 
+# gem 'jquery-rails'
+# 
+# # To use ActiveModel has_secure_password
+# # gem 'bcrypt-ruby', '~> 3.0.0'
+# 
+# # To use Jbuilder templates for JSON
+# # gem 'jbuilder'
+# 
+# # Use unicorn as the app server
+# # gem 'unicorn'
+# 
+# # Deploy with Capistrano
+# # gem 'capistrano'
+# 
+# # To use debugger
+# # gem 'ruby-debug'
+# 
+# gem 'authlogic', '>= 3.1.0'
+
+source :rubygems
+
+# gem "sqlite3"
+# gem "activerecord", '~> 3.0.9', :require => "active_record"
+# gem "with_model", "~> 0.2.5"
+# gem "meta_where"
+
+gemspec
+
+gem 'rspec', "~> 2.10.0"
+gem 'curb', '~> 0.8.1'

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012 Frederick Fix
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,410 @@
+= Curbala
+
+Wiki[https://github.com/rickfix/curbala/wiki] | RDocs[http://rdoc.info/projects/rickfix/curbala] 
+
+Curbala is a curb[http://rubygems.org/gems/curb/] wrapper that acts as a client for externally-hosted services.
+
+In the system which Curbala was extracted from, the original curbala-esque implementation addressed some issues/requirements:
+
+1. environment specific configuration of base service URLs
+2. DRY'd references to base service URLs
+3. different http/https requirements in different environments
+4. a means to simulate service calls
+   + decoupled rails development from api development when interfaces were defined but service was not available yet or was broke.
+   + some of our services were not available in development mode
+   + did not want to hit external services in specs
+5. our internal services developers used curl to test their work.  wrapping curb provided good common ground.
+6. a log trail of each service call was desirable
+   + the application data which the action request was constructed.
+   + the url that was invoked
+   + the payload that was sent (post, put)
+   + the http status of the request.
+   + the raw and unpacked response
+   + our non-production systems where doing logging of each database read and write.
+     makes at least as much sense to log similar stuff for each service call.
+7. some service calls were inline in controllers and exhibited 'long line' and 'long arg list' code smells
+
+
+Curbala is implemented as a framework pattern which requires extending classes to implement two methods:
+1. action_url_segment()
+2. invoke_action()
+
+Extending classes can also implement/override base class implementations of the following methods:
+1. unpack_response() : perform xml/json/... response extraction/conversion
+2. success_message()
+3. fail_message()
+
+
+== Installation
+
+1. In <b>Rails 3</b>, add this to your Gemfile and run the +bundle+ command.
+
+  gem "curbala"
+  gem "curb" # currently tested against 0.8.1 : need to rectify when your app already uses curb...
+
+2. bundle exec gem install
+
+   should pull in curbala (and possibly curb)
+  
+== Getting Started
+
+Try using the curbala action generator in your app:
+
+This example sets uses the publicly accessible Acromine service as a rudimentary intro to curbala.
+The Acromine service is accessible at http://www.nactem.ac.uk/software/acromine/dictionary.py?sf=QUERY
+(where QUERY is the acronym to query on).
+
+Run the curbala action generator: it will ask you 4 questions:
+
+    $ rails g curbala:action
+
+    a
+    Enter path to directory where service/action should be installed [app/models] :  
+    What is the service name for the new action? cromine
+          create  config/acromine.yml
+          create  app/models/acromine/service.rb
+
+    What is the new action name? get
+          create  app/models/acromine/get.rb
+
+    Generate spec/models/acromine/get_spec.rb? [Yn] Y
+          create  spec/models/acromine/get_spec.rb
+            gsub  config/acromine.yml
+            gsub  config/acromine.yml
+            gsub  config/acromine.yml
+            gsub  app/models/acromine/service.rb
+            gsub  app/models/acromine/service.rb
+            gsub  app/models/acromine/service.rb
+            gsub  app/models/acromine/get.rb
+            gsub  app/models/acromine/get.rb
+            gsub  app/models/acromine/get.rb
+            gsub  spec/models/acromine/get_spec.rb
+            gsub  spec/models/acromine/get_spec.rb
+            gsub  spec/models/acromine/get_spec.rb
+
+  What just happened?
+
+  1. The generator asked :
+  
+  Enter path to directory where service/action should be installed [app/models] : 
+   
+  * default (taken in this example) is app/models
+  
+  + you could specify something like app/clients or lib or lib/services/clients, whatever directory adheres to your apps organizational sensibilities
+
+
+  2.1 The generator asked for the name of the service, and *acromine* was entered:
+  
+  What is the service name for the new action? acromine
+
+  
+  2.2 Two files were created:
+  
+  config/acromine.yml
+  
+  app/models/acromine/service.rb
+
+
+  3.1 The generator asked for the action name and *get* was entered:
+  
+  What is the new action name? get
+
+  3.2 The action class for get was created:
+  
+  app/models/acromine/get.rb
+
+
+  4.1 The generator asked if a spec should be generated and *Y* (to indicate yes) was entered:
+  
+  Generate spec/models/acromine/get_spec.rb? [Yn] Y
+
+  4.2 A spec was generated:
+  
+  spec/models/acromine/get_spec.rb
+
+  Hopefully your app is already using rspec.
+  
+  The generated spec is designed to help red/green your way toward gluing your config, service and action components together.
+
+
+Run specs and you should see something like:
+   
+   $ bundle exec rake spec
+   
+   Failures:
+
+   1) Acromine::Get invoke_action and http response code is 200 should indicate success
+      Failure/Error: @curbala_instance.url.should == @expected_url
+        expected: "http://base service url/service url segment/action url segment"
+             got: "http://base service url/service url segment/construct action segment of Acromine Get url in action_url_segment() method at /path to your/app/models/acromine/get.rb:9" (using ==)
+      # ./spec/models/acromine/get_spec.rb:66:in `verify_curbala_action'
+      # ./spec/models/acromine/get_spec.rb:49
+
+
+Notice the instructive portion of the 'got:' message:
+
+*construct action segment of Acromine Get url in action_url_segment() method at /path to your/app/models/acromine/get.rb:9*
+
+
+This is where you must decide how you want to slice up the service url among config, service and action.
+
+The acromine service url is http://www.nactem.ac.uk/software/acromine/dictionary.py?sf=QUERY
+
+There are a number of ways you can slice this one.
+1. config/acromine.yml:                                   http://www.nactem.ac.uk/software/acromine/
+   app/models/acromine/service.rb:service_url_segment() : "dictionary.py"
+   app/models/acromine/get.rb:action_url_segment() :      "?sf=#{@args_hash['sf']}"
+   
+2. config/acromine.yml:                                   http://www.nactem.ac.uk/software/acromine/dictionary.py?sf=
+   app/models/acromine/service.rb:service_url_segment() : ""
+   app/models/acromine/get.rb:action_url_segment() :      @args_hash['sf']
+
+3. config/acromine.yml:                                   http://www.nactem.ac.uk/
+   app/models/acromine/service.rb:service_url_segment() : "software/acromine/"
+   app/models/acromine/get.rb:action_url_segment() :      "dictionary.py?sf=#{@args_hash['sf']}"
+
+
+Option 1. most appealed to my aesthetic sense when I was playing with this example,
+so I edited the 3 files/methods as indicated.
+
+
+Rerun specs and should see something like:
+
+Failures:
+
+  1) Acromine::Get invoke_action and http response code is 200 should indicate success
+     Failure/Error: @curbala_instance.url.should == @expected_url
+       expected: "http://base service url/service url segment/action url segment"
+            got: "http://base service url/service url segment/?sf=" (using ==)
+     # ./spec/models/acromine/get_spec.rb:66:in `verify_curbala_action'
+     # ./spec/models/acromine/get_spec.rb:49
+
+
+The 'got:' value shows that the Acromine::Get.action_url_segment() seems to be doing its thing.
+
+Time to update expectations in the spec
+Insert the following two lines at spec/models/acromine/get_spec.rb:49
+
+    @args_hash['sf'] = 'HTTP'
+    @expected_url = "http://base service url/service url segment/?sf=HTTP"
+
+
+Rerun specs and should see something like:
+
+    Failures:
+
+      1) Acromine::Get invoke_action and http response code is 200 should indicate success
+         Failure/Error: @curbala_instance.message.should == @expected_message
+           expected: "Successful (200)"
+                got: "Service Not Available: undefined method `implement invoke_action() method in /path to your/app/models/acromine/get.rb:12' for #<Acromine::Get:0x10e5400b0>" (using ==)
+         # ./spec/models/acromine/get_spec.rb:69:in `verify_curbala_action'
+         # ./spec/models/acromine/get_spec.rb:51
+
+The 'got:' message is leading us to the next step to glue the Get action:
+'implement invoke_action() method in /path to your/app/models/acromine/get.rb:12'
+
+The invoke_action is where you tinker with, and invoke an http action (get/put/post/delete) on, the Curl::Easy (from the curb gem) instance in the @curl class variable.
+
+For the acromine example, we just have to invoke http_get,
+so change the guts of app/models/acromine/get.rb:invoke_action() to be:
+
+    def invoke_action
+      curl.http_get
+    end
+
+and adjust spec so that the http_get is expected by inserting the following prior at line 51:
+
+    @mocked_curl.should_receive(:http_get)
+    
+
+Rerun specs and they should pass.
+
+
+In a browser, hit the following url:
+http://www.nactem.ac.uk/software/acromine/dictionary.py?sf=HTTP
+
+
+The response is JSON.
+Curbala lets you massage/translate the raw string response however is appropriate
+to get it in a format that is palatable for invoking models, controllers and views
+by letting you override the Curbala::Action.unpack_response() base class implementation.
+Curbala provides two methods for helping unpack repsonses: hash_from_xml_response() and hash_from_json_response().
+
+
+Implement the following in app/models/acromine/get.rb:
+
+    def unpack_response
+      hash_from_json_response
+      @response = (@response[0]['lfs'] rescue 'no results') if @success == true
+    end
+    
+
+and adjust spec by inserting the following two lines at line spec/models/acromine/get_spec.rb:52
+
+    @mocked_response = '[{"sf": "HTTP", "lfs": [{"lf": "hypertext transfer protocol", "freq": 6, "since": 1995, "vars": [{"lf": "Hypertext Transfer Protocol", "freq": 3, "since": 1996}, {"lf": "hypertext transfer protocol", "freq": 3, "since": 1995}]}]}]'
+    @expected_response_data = [{"freq"=>6, "vars"=>[{"freq"=>3, "lf"=>"Hypertext Transfer Protocol", "since"=>1996}, {"freq"=>3, "lf"=>"hypertext transfer protocol", "since"=>1995}], "lf"=>"hypertext transfer protocol", "since"=>1995}]
+    
+    
+Rerun specs and they should pass.
+
+
+Oh goody, now we can try this in console (copy and paste the code snippet):
+
+    $ rails c
+    
+    >> def acro(acronym)
+         args = {'sf' => acronym}
+         get = Acromine::Service.invoke(:get, args)
+         get.success && get.response.kind_of?(Array) ? get.response.collect{|h| h['lf']} : []
+       end
+    => nil
+    >> # invoke the acromine service:
+    >? acro 'ABC'
+    
+    *** you should see something like:
+    => ["ATP-binding cassette", "avidin-biotin-peroxidase complex", "aneurysmal bone cyst", "abacavir", "advanced breast cancer", "antibody binding capacity", "Aberrant Behavior Checklist", "activity-based costing", "Activities-specific Balance Confidence", "argon beam coagulator", "aspiration biopsy cytology", "active breathing control", "activated B-cell-like", "absolute blast count", "adenoid basal carcinoma", "approximate Bayesian computation", "antibodies bound per cell", "alveolar bone crest", "accelerated blood clearance", "Alternative Birthing Center", "artificial beta cell", "American Biophysics Corporation", "adenine nucleotide binding cassette", "Movement Assessment Battery for Children", "Alcoholic Beverage Control", "The area between curves"]
+    
+    >> acro 'A'
+    => []
+    
+
+The acromine service is up and running and ready to be integrated into your models, controllers and views.
+
+
+
+== Final version of files for acromine example
+
+1. config/acromine.yml
+
+
+    url: http://www.nactem.ac.uk/software/acromine/
+
+    test:
+      simulate: true
+
+
+2. app/models/acromine/service.rb
+
+
+    class Acromine::Service < Curbala::Service
+
+      def self.service_url_segment(associated_model)
+        "dictionary.py"
+      end
+
+      def self.service_qualifier
+        'Acromine'
+      end
+
+      def self.config_file
+        'acromine.yml'
+      end
+
+    end
+
+
+3. app/models/acromine/get.rb
+
+
+    class Acromine::Get < Curbala::Action
+  
+      def action_url_segment
+        "?sf=#{@args_hash['sf']}"
+      end
+  
+      def invoke_action
+        curl.http_get
+      end
+  
+      def unpack_response
+        hash_from_json_response
+        @response = (@response[0]['lfs'] rescue 'no results') if @success == true
+      end
+
+    end
+
+
+4. spec/models/acromine/get_spec.rb
+
+    require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+    describe 'Acromine::Get' do
+      before(:each) do
+        @config = {'simulate' => true, 'url' => 'http://base service url/'}
+        (@logger = mock).should_receive(:debug).any_number_of_times
+      end
+  
+      it "should source action_url_segment, success_message and simulated response from Acromine::Get implementation when simulated" do
+        Curl::Easy.should_receive(:new).never # simulated : invoke_action() is not invoked.
+        @curbala_action_instance = Acromine::Get.new('service url segment/', @config, {}, @logger)
+        @curbala_action_instance.url.should == "http://base service url/service url segment/#{@curbala_action_instance.action_url_segment}"
+        @curbala_action_instance.success.should be_true
+        @curbala_action_instance.http_status.should == 200
+        @curbala_action_instance.message.should == "Successful (200)"
+        @curbala_action_instance.response.should == "simulated response"
+      end
+  
+      describe 'invoke_action' do
+        before(:each) do
+          @args_hash = {}
+          @config['simulate'] = false
+          @expected_url = "http://base service url/service url segment/dictionary.py?sf=HTTP"
+          @mocked_curl = mock # (:body_str => @mocked_response)
+        end
+    
+        describe "and http response code is 200" do
+      
+          it "should indicate success" do
+            @args_hash['sf'] = 'HTTP'
+            @mocked_response = '[{"sf": "HTTP", "lfs": [{"lf": "hypertext transfer protocol", "freq": 6, "since": 1995, "vars": [{"lf": "Hypertext Transfer Protocol", "freq": 3, "since": 1996}, {"lf": "hypertext transfer protocol", "freq": 3, "since": 1995}]}]}]'
+            @expected_response_data = [{"freq"=>6, "vars"=>[{"freq"=>3, "lf"=>"Hypertext Transfer Protocol", "since"=>1996}, {"freq"=>3, "lf"=>"hypertext transfer protocol", "since"=>1995}], "lf"=>"hypertext transfer protocol", "since"=>1995}]
+            @mocked_curl.should_receive(:http_get)
+            @expected_message = 'Successful (200)'
+            verify_curbala_action(Acromine::Get, 200, be_true)
+          end
+        end
+        
+        def verify_curbala_action(class_under_test, forced_http_status, be_expected_condition)
+          @mocked_curl.should_receive(:body_str).any_number_of_times.and_return(@mocked_response)
+          Curl::Easy.should_receive(:new).with(@expected_url).and_return(@mocked_curl)
+          @mocked_curl.should_receive(:timeout=).with(10)
+          @mocked_curl.should_receive(:response_code).any_number_of_times.and_return(forced_http_status)
+          @curbala_instance = class_under_test.new('service url segment/', @config, @args_hash, @logger)
+          @curbala_instance.url.should == @expected_url
+          @curbala_instance.message.should == @expected_message
+          @curbala_instance.success.should be_expected_condition
+          @curbala_instance.response.should == @expected_response_data
+          @curbala_instance.http_status.should == forced_http_status
+        end
+    
+      end
+  
+    end
+
+
+
+== Wiki Docs
+
+* {Home}[https://github.com/rickfix/curbala/wiki]
+
+
+== Project Status
+
+Active.
+
+Extracted from non-gem implementation of in-production {ProfitSteams}[http://profitstreams.com] system.
+
+
+== Questions or Problems?
+
+If you have any issues with Curbala which you cannot find the solution to in the documentation[https://github.com/rickfix/curbala/wiki],
+please add an {issue on GitHub}[https://github.com/rickfix/curbala/issues]
+or fork the project and send a pull request.
+
+If I have time, I'll try to help.
+
+
+== Thanks
+
+Thanks to Eric Rapp for permission to extract this gem
+and for giving me plenty of space and time to tinker and tune.

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc "Run RSpec"
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = false
+end
+
+desc "Run specs for all adapters"
+task :spec_all do
+  %w[active_record].each do |model_adapter|
+    puts "MODEL_ADAPTER = #{model_adapter}"
+    system "rake spec MODEL_ADAPTER=#{model_adapter}"
+  end
+end
+
+task :default => :spec

data/init.rb

@@ -0,0 +1 @@
+require 'curbala'

data/lib/curbala.rb

@@ -0,0 +1,2 @@
+require 'curbala/action'
+require 'curbala/service'

data/lib/curbala/action.rb

@@ -0,0 +1,123 @@
+require 'active_support/core_ext'
+# require 'rexml/document' # TODO : needed?
+
+module Curbala
+  class Action
+    attr_accessor :args_hash, :config, :curl, :exception, :http_status, :message, :payload, :raw_response_string, :response, :success, :url
+  
+    def initialize(service_url_segment, input_config, input_args_hash, logger, simulated_status=200, simulated_response="simulated response")
+      begin
+        
+        @payload, @args_hash, @config = '', input_args_hash, input_config
+        @url = "#{@config['url']}#{service_url_segment}#{action_url_segment}"
+        
+        @config['simulate'] == true ?
+          inject_status_and_response(simulated_status, simulated_response) :
+          invoke_curl_action
+        
+      rescue Exception => @exception
+
+        @success = false
+        @message = "Service Not Available: #{@exception.message}" # : BACKTRACE: #{@exception.backtrace[0..500]}"
+        logger.debug "Exception occurred: #{@exception.message}: BACKTRACE: #{@exception.backtrace}"
+        @raw_response_string ||= 'exception occurred in action processing'
+        @response ||= @raw_response_string
+        @http_status ||= -1
+
+      end
+      
+      self
+      
+    ensure
+      
+      logger.debug ''
+      logger.debug("#{self.class.name}: #{url}")
+      logger.debug("config:        #{config.inspect}")
+      logger.debug("args_hash:     #{args_hash.inspect}")
+      logger.debug("payload:       #{payload.inspect}") unless payload.nil? || payload.empty?
+      logger.debug("http status:   #{http_status},   success: #{success},   message: #{message}")
+      logger.debug("raw response string:")
+      logger.debug(raw_response_string.strip)
+      logger.debug("unpacked response:  #{response.class.name}")
+      logger.debug(response.inspect)
+      logger.debug ''
+      
+    end
+    
+    # any url utilities (for extending class implementations of action_url_segment()) ?
+    
+    # request utilities:
+    def xml_request
+      @curl.headers['Accept'] = 'application/xml'
+      @curl.headers['Content-Type'] = 'application/xml'
+    end
+
+    def xml_payload(xml)
+      xml_request
+      @payload = xml
+    end
+
+    def xml_payload_from_args_hash(root) # APIs have different formatting/hygiene needs...
+      xml_request
+      @payload = @args_hash.to_xml(:root => root, :indent => 0) # .gsub(/(>[ \t\r\n]+<\/)/,"><\/").gsub(/[ \t\r\n]+^/,'')
+    end
+    
+    # response utilities:
+    def hash_from_xml_response
+      @response = Hash.from_xml(@raw_response_string)
+      @response ||= {}
+    end
+
+    def hash_from_json_response
+      @response = (ActiveSupport::JSON.decode(@raw_response_string) rescue {})
+    end
+    
+    protected
+
+    def unpack_response
+      # convention is a plain string response
+      # usually it will be an XML or JSON response.
+      # extending classes can/should implement their own unpack_response method to deal with
+      # - unpacking response body xml/json usually to a hash or whatever is naturally consumable by invoker
+      #   (see hash_from_xml_response)
+      # - perform additional extraction/conversion,
+      # - trigger response-specific work, ...
+      @response = @raw_response_string
+    end
+  
+    private
+  
+    def success_message
+      "Successful (#{@http_status})"
+    end
+    
+    def fail_message
+      "Could not complete request : http response: #{@http_status}, response body : #{@raw_response_string[0..500]}"
+    end
+
+    def invoke_curl_action
+      @curl = Curl::Easy.new(url) 
+      curl.timeout = 10
+      invoke_action
+      @http_status = @curl.response_code
+      @raw_response_string = @curl.body_str
+      @raw_response_string ||= ''
+      determine_status
+      unpack_response
+    end
+
+    def inject_status_and_response(simulated_status, simulated_response)
+      @http_status = simulated_status
+      @raw_response_string = 'simulated'
+      determine_status
+      @response = simulated_response
+      @response ||= @raw_response_string
+    end
+        
+    def determine_status
+      # enhancement : allow specification/injection of (list of) successful http responses
+      @success = @http_status >= 200 && @http_status < 300
+      @message = success ? success_message : fail_message
+    end
+  end
+end

data/lib/curbala/service.rb

@@ -0,0 +1,33 @@
+module Curbala
+  class Service
+    
+    # enhancement : config specifies format of response, action base class supports xml and json config-based unpacking, keep unpack_response base class and extending class implementation
+    # enhancement : config to specify unpack method.  altho at service-level, may want flexibility for each action to do its own thing.  there's a reasonable strategy somewhere...
+    
+    def self.invoke(action_name, args_hash={}, associated_model=nil, logger=nil, simulated_status=200, inject_response=nil)
+      logger ||= self.find_or_create_logger(associated_model)
+      action = eval("#{service_qualifier}::#{action_name.to_s.camelize}.new(service_url_segment(associated_model), env_service_config, args_hash, logger, simulated_status, inject_response)")
+    end
+
+    private
+    
+    def self.env_service_config
+      config_path     = "#{Rails.root rescue '.'}/config/#{config_file}"
+      config_contents = File.open(config_path)
+      config_yml      = YAML.load(config_contents)
+      env             = (Rails.env rescue 'test')
+      env_yml         = config_yml[env]
+      env_yml       ||= {}
+      env_yml['simulate'] ||= false
+      env_yml['url']      ||= config_yml['url']
+      env_yml
+    end
+    
+    def self.find_or_create_logger(associated_model)
+      logger   = (associated_model.logger rescue nil)
+      logger ||= (Rails.logger rescue nil)
+      logger ||= Logger.new(STDOUT)
+    end
+    
+  end
+end

data/lib/generators/curbala/action/USAGE

@@ -0,0 +1,5 @@
+Description:
+  The curbala:action generator creates a new Curbala::Action class in app/models/curbala/services directory.
+  You can move this file anywhere you want as long as it is in the load path.
+  TODO : args or prompts?
+  

data/lib/generators/curbala/action/action_generator.rb

@@ -0,0 +1,47 @@
+module Curbala
+  module Generators
+    class ActionGenerator < Rails::Generators::Base
+      source_root File.expand_path('../template', __FILE__)
+
+      def generate_action
+        
+        puts ""
+        install_directory = ask("Enter path to directory where service/action should be installed [app/models] : ")
+        install_directory = 'app/models' if install_directory.blank?
+        
+        puts ""
+        service_name = ask("What is the service name for the new action?").downcase
+        generate_and_remember_file("config.yml", "config/#{service_name}.yml")
+        generate_and_remember_file("service.rb", "#{install_directory}/#{service_name}/service.rb")
+
+        puts ""
+        new_action_name = ask("What is the new action name?").downcase
+        generate_and_remember_file("action.rb", "#{install_directory}/#{service_name}/#{new_action_name}.rb")
+
+        puts ""
+        if ask("Generate spec/models/#{service_name}/#{new_action_name}_spec.rb? [Yn]") == "Y"
+          generate_and_remember_file("action_spec.rb", "spec/models/#{service_name}/#{new_action_name}_spec.rb")
+        end
+
+        @generated_files.each do |file_name|
+          gsub_file file_name, "SERVICE_NAME_DOWNCASE", service_name
+          gsub_file file_name, "SERVICE_CLASS_NAME", service_name.classify
+          gsub_file file_name, "ACTION_CLASS_NAME", new_action_name.classify
+        end
+        
+        # TODO : chmod's?
+        
+        puts ""
+        
+      end
+      
+      private
+      
+      def generate_and_remember_file(source, destination)
+        copy_file source, destination
+        @generated_files ||= []
+        @generated_files << destination
+      end
+    end
+  end
+end

data/lib/generators/curbala/action/template/action.rb

@@ -0,0 +1,62 @@
+class SERVICE_CLASS_NAME::ACTION_CLASS_NAME < Curbala::Action
+  
+  def action_url_segment
+    # if this is a GET index, GET new or POST create action, probably blank.
+    # for update, show, edit, delete, express id however service expects it (in URL or possibly in payload)
+    
+    # * data written/specified in this string must be appropriately url-encoded
+    
+    "construct action segment of SERVICE_CLASS_NAME ACTION_CLASS_NAME url in action_url_segment() method at #{__FILE__}:#{__LINE__}"
+  end
+  
+  def invoke_action
+    
+    # this is where arguments from @args_hash are transformed into url parameters or request payload.
+    # - see Curbala::Action.xml_payload_from_args_hash()
+    # the proper http method is invoked
+    
+    # can set action-specific curl options:
+    #   curl.timeout = 300
+    #   set_payload # see Curbala::Action.set_payload()
+    #   xml_request # see Curbala::Action.xml_request()
+    
+    # some examples:
+    #   curl.http_get
+    #   curl.http_post(Curl::PostField.content(:name, args_hash[:name]))
+    #   curl.http_put(Curl::PostField.content(:_arg, args_hash[:_arg]))
+    #   curl.http_delete
+
+    # APIs have different formatting/hygiene/unpacking needs...
+    # curbala is xml/json agnostic and does not induce any xml/json library bloat
+    # pull in whatever you need to correctly format your request data (REXML, Nokogiri, JSON) from args_hash data
+    # recommend an intermediate class for actions that are constructed and/or unpacked in a similar way
+
+    # some half-hearted support is provided.
+    # see xml_request(), xml_payload(xml) and xml_payload_from_args_hash(root) methods.
+    
+    send("implement invoke_action() method in #{__FILE__}:12")
+  end
+  
+  # methods you may choose to implement and override default/base-class implementations:
+  
+  # def unpack_response
+  #   # has a default implementation that just sets @response from @raw_response_string (no xml or json conversion)
+  #
+  #   # implementations of this method must transform @raw_response_string into @response
+  #   # your service responses will most likely be xml or json
+  #   # and need some unpacking into a hash for consumption by controllers, views and other models.
+  #
+  #   # @raw_response_string contains curl.body_str
+  #
+  #   # see hash_from_xml_response(),  hash_from_json_response() methods.
+  # end
+  
+  # def success_message
+  #   # has a default implementation : extending classes can override to suit app's needs
+  # end
+  
+  # def fail_message
+  #   # has a default implementation : extending classes can override to suit app's needs
+  # end
+  
+end

data/lib/generators/curbala/action/template/action_spec.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe 'SERVICE_CLASS_NAME::ACTION_CLASS_NAME' do
+  before(:each) do
+    @config = {'simulate' => true, 'url' => 'http://base service url/'}
+    (@logger = mock).should_receive(:debug).any_number_of_times
+  end
+  
+  it "should source action_url_segment, success_message and simulated response from SERVICE_CLASS_NAME::ACTION_CLASS_NAME implementation when simulated" do
+    Curl::Easy.should_receive(:new).never # simulated : invoke_action() is not invoked.
+    @curbala_action_instance = SERVICE_CLASS_NAME::ACTION_CLASS_NAME.new('service url segment/', @config, {}, @logger)
+    @curbala_action_instance.url.should == "http://base service url/service url segment/#{@curbala_action_instance.action_url_segment}"
+    @curbala_action_instance.success.should be_true
+    @curbala_action_instance.http_status.should == 200
+    @curbala_action_instance.message.should == "Successful (200)"
+    @curbala_action_instance.response.should == "simulated response"
+  end
+  
+  describe 'invoke_action' do
+    before(:each) do
+      @args_hash = {}
+      @config['simulate'] = false
+      @expected_url = "http://base service url/service url segment/action url segment"
+      @mocked_curl = mock # (:body_str => @mocked_response)
+    end
+    
+    describe "and http response code is 200" do
+      
+      it "should indicate success" do
+        # TODO1 : specify @args_hash data for test case
+        
+        # TODO2 : construct @mocked_response for test case
+        @mocked_response = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><your-response-root-node>mocked test case response</your-response-root-node>"
+        
+        # TODO3 : expectations for work performed in invoke_action()
+        
+        # TODO4 : expectations for work done in unpack_response
+        @expected_response_data = @mocked_response
+        
+        # Example:
+        # when invoke_action() is implemented as:
+        #   curl.http_put(Curl::PostField.content(:test_arg, args_hash['test_arg']).to_s)
+        # then do something like:
+        #   @args_hash['test_arg'] = 'test arg value'
+        #   Curl::PostField.should_receive(:content).with(:test_arg, 'test arg value').and_return("whatever post field content returns")
+        #   @mocked_curl.should_receive(:http_put).with("whatever post field content returns")
+        
+        @expected_message = 'Successful (200)'
+        verify_curbala_action(SERVICE_CLASS_NAME::ACTION_CLASS_NAME, 200, be_true)
+      end
+    end
+    
+    # TODO : specs for different HTTP stati
+    
+    # describe "when http response code is 501" do
+    # end
+    
+    def verify_curbala_action(class_under_test, forced_http_status, be_expected_condition)
+      @mocked_curl.should_receive(:body_str).any_number_of_times.and_return(@mocked_response)
+      Curl::Easy.should_receive(:new).with(@expected_url).and_return(@mocked_curl)
+      @mocked_curl.should_receive(:timeout=).with(10)
+      @mocked_curl.should_receive(:response_code).any_number_of_times.and_return(forced_http_status)
+  
+      @curbala_instance = class_under_test.new('service url segment/', @config, @args_hash, @logger)
+      
+      @curbala_instance.url.should == @expected_url
+      @curbala_instance.message.should == @expected_message
+      @curbala_instance.success.should be_expected_condition
+      @curbala_instance.response.should == @expected_response_data
+      @curbala_instance.http_status.should == forced_http_status
+    end
+    
+  end
+  
+end

data/lib/generators/curbala/action/template/config.yml

@@ -0,0 +1,26 @@
+# tips:
+# - can specify url at top level and override in environment-specific block as needed.
+# - be sure http or https is specified as needed for each unsimulated environment.
+# - block needed for each of your application's environments.
+# - do not recommend running test unsimulated : unit tests should be hitting external APIs.
+# - development makes no connectivity assumptions and, by default, runs simulated.
+#   set/manipulate action instance simulated_response implementations as needed.
+#   if service is available in development mode, set 'simulate' to false and specify url.
+#   - standard disclaimer about multiple developers testing concurrently in unsimulated mode : things could get weird...
+# - can specify additional parameters that an action instance can plug in via its invoke_action() implementation.
+#   handy for plugging in other environment-specific, or somehow appropriately specifiable, goo.
+
+# url: http://SERVICE_NAME_DOWNCASE base service url for all environments
+
+test:
+  simulate: true
+  url: http://test SERVICE_NAME_DOWNCASE base service url
+
+development:
+  simulate: true
+  url: http://development SERVICE_NAME_DOWNCASE base service url
+
+production:
+  simulate: false
+  url: http://TODO__SPECIFY_LEFT_JUSTIFIED_ENVIRONMENT_DEPENDENT_PORTION_OF_SERVICE_URL_IN___config__SERVICE_NAME_DOWNCASE.yml
+  

data/lib/generators/curbala/action/template/service.rb

@@ -0,0 +1,24 @@
+class SERVICE_CLASS_NAME::Service < Curbala::Service
+  
+  def self.service_url_segment(associated_model)
+    "/TODO__SPECIFY_ENVIRONMENT_INDEPENDENT_PORTION_OF_SERVICE_URL_IN___SERVICE_CLASS_NAME_Service__service_url_segment__method/"
+  end
+
+  def self.service_qualifier
+    'SERVICE_CLASS_NAME'
+  end
+  
+  def self.config_file # see self.env_service_config()
+    'SERVICE_NAME_DOWNCASE.yml'
+  end
+  
+  # def self.env_service_config
+  #   # a default YAML-based implementation is provided :
+  #   # YAML.load(File.open("#{Rails.root rescue '.'}/config/#{config_file}.yml"))
+  #
+  #   # if you prefer HAML/XML/... or don't need a config file,
+  #   # override implementation with logic that meets your needs
+  #   # and remove generated config/SERVICE_NAME_DOWNCASE.yml file.
+  # end
+  
+end

data/spec/curbala/action_spec.rb

@@ -0,0 +1,161 @@
+
+require 'spec_helper'
+
+describe 'Curbala::Action' do
+  before(:each) do
+    @args_hash = {:test_arg => 'test arg value'}
+    @expected_url = 'test base service url/' + 'service url segment/action url segment'
+    @expected_message = 'Successful (200)'
+  end
+
+  describe 'initialize' do    
+    describe 'and not simulated' do
+      before(:each) { @mocked_response_xml = "<?xml version='1.0' encoding='UTF-8'?><root>mocked response fields</root>" }
+      
+      it 'should use base implementation of unpack_response when extending class does not implement unpack_response' do
+        unsimulated_curbala_action(CurbalaActionTestClass, @mocked_response_xml)
+      end
+    
+      it 'should use implemented unpack_response method when extending class implements unpack_response' do
+        @expected_message = 'success message (overriden)'
+        unsimulated_curbala_action(CurbalaActionTestClassWithOverridenImplementations, {'root' => 'mocked response fields'})
+      end
+      
+      it 'should indicate failure and include exception message in action message when exception occurs' do
+        xmsg = 'message from exception'
+        Curl::Easy.should_receive(:new).with(@expected_url).and_raise(RuntimeError.new(xmsg))
+        @expected_message = "Service Not Available: #{xmsg}"
+        it_should_do_expected_curbala_action_stuff(CurbalaActionTestClass, config(false), -1, 'exception occurred in action processing', be_false)
+      end
+    end
+
+    [200, 299].each do |http_status|
+      it "should indicate success when http response code is #{http_status}" do
+        @expected_message = "Successful (#{http_status})"
+        it_should_simulate_curbala_call(CurbalaActionTestClass, config, http_status, {'root' => 'simulated response fields'})
+      end
+    end
+
+    [199, 300].each do |http_status|
+      it "should indicate failure when http response code is #{http_status}" do
+        @expected_message = "Could not complete request : http response: #{http_status}, response body : simulated"
+        it_should_simulate_curbala_call(CurbalaActionTestClass, config, http_status, {'root' => 'simulated failure response fields'}, be_false)
+      end
+    end
+
+    def it_should_simulate_curbala_call(class_under_test, config_hash, expected_response_code, expected_response_data, be_expected_condition = be_true)
+      Curl::Easy.should_receive(:new).never
+      Curl::PostField.should_receive(:content).never
+      Hash.should_receive(:from_xml).never
+      it_should_do_expected_curbala_action_stuff(class_under_test, config_hash, expected_response_code, expected_response_data, be_expected_condition)
+    end    
+  end
+
+  # describe 'url construction utilities' do
+  # end
+  
+  describe 'xml request utilities' do
+    before(:each) { unsimulated_curbala_action(CurbalaActionTestClass, "") }
+    
+    describe 'xml_request' do
+      it 'should set curl header Accept and Content-Type values to application/xml' do
+        @mocked_curl.headers['Accept'] = 'not application/xml'
+        @mocked_curl.headers['Content-Type'] = 'not application/xml'
+        @curbala_instance.xml_request
+        @mocked_curl.headers['Accept'].should == 'application/xml'
+        @mocked_curl.headers['Content-Type'].should == 'application/xml'
+      end
+    end
+
+    describe 'xml_payload(xml)' do
+      it 'should invoke xml_request and set payload from input payload' do
+        @curbala_instance.should_receive(:xml_request)
+        @curbala_instance.xml_payload('my xml payload')
+        @curbala_instance.payload.should == 'my xml payload'
+      end
+    end
+
+    describe 'xml_payload_from_args_hash(root)' do
+      it 'should invoke xml_request and set payload from input payload' do
+        @curbala_instance.should_receive(:xml_request)
+        @curbala_instance.xml_payload_from_args_hash('my xml root')
+        @curbala_instance.payload.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><my-xml-root><test-arg>test arg value</test-arg></my-xml-root>"
+      end
+    end
+  end
+
+  describe 'xml response utilities' do
+    before(:each) { unsimulated_curbala_action(CurbalaActionTestClass, "") }
+
+    describe 'hash_from_xml_response' do
+      it 'should set response to a hash representation of xml in raw_response_string' do
+        @curbala_instance.raw_response_string = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><response-root><response-object1><response-field1>test arg value</response-field1><response-field2>field2 value</response-field2></response-object1></response-root>"
+        @curbala_instance.hash_from_xml_response
+        @curbala_instance.response.should == { "response_root" => {"response_object1"=>{"response_field1"=>"test arg value", "response_field2"=>"field2 value"}} }
+      end
+    end
+
+    describe 'hash_from_json_response' do
+      it 'should set response to a hash representation of json in raw_response_string' do
+        @curbala_instance.raw_response_string = '[{"sf": "HTTP", "lfs": [{"lf": "hypertext transfer protocol", "freq": 6, "since": 1995, "vars": [{"lf": "Hypertext Transfer Protocol", "freq": 3, "since": 1996}, {"lf": "hypertext transfer protocol", "freq": 3, "since": 1995}]}]}]'
+        @curbala_instance.hash_from_json_response
+        @curbala_instance.response.should == [{"sf"=>"HTTP", "lfs"=>[{"freq"=>6, "vars"=>[{"freq"=>3, "lf"=>"Hypertext Transfer Protocol", "since"=>1996}, {"freq"=>3, "lf"=>"hypertext transfer protocol", "since"=>1995}], "lf"=>"hypertext transfer protocol", "since"=>1995}]}]
+      end
+    end
+  end
+  
+  def unsimulated_curbala_action(test_class, expected_response)
+    @mocked_curl = mock(:body_str => @mocked_response_xml)
+    Curl::Easy.should_receive(:new).with(@expected_url).and_return(@mocked_curl)
+    @mocked_curl.should_receive(:timeout=).with(10)
+    Curl::PostField.should_receive(:content).with(:test_arg, 'test arg value').and_return('whatever post field content returns')
+    @mocked_curl.should_receive(:http_put).with('whatever post field content returns')
+    @mocked_curl.should_receive(:response_code).any_number_of_times.and_return(200)
+
+    it_should_do_expected_curbala_action_stuff test_class, config(false), 200, expected_response
+
+    headers = {}
+    @mocked_curl.should_receive(:headers).any_number_of_times.and_return(headers)
+    @curbala_instance.xml_payload_from_args_hash 'a root node'
+    @curbala_instance.payload.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><a-root-node><test-arg>test arg value</test-arg></a-root-node>"
+    headers.should == {"Content-Type"=>"application/xml", "Accept"=>"application/xml"}
+  end
+
+  def it_should_do_expected_curbala_action_stuff(class_under_test, config_hash, expected_response_code, expected_response_data, be_expected_condition = be_true)
+    curbala_action(class_under_test, config_hash, expected_response_code, expected_response_data)
+    @curbala_instance.url.should == @expected_url
+    @curbala_instance.message.should == @expected_message
+    @curbala_instance.success.should be_expected_condition
+    @curbala_instance.response.should == expected_response_data
+    @curbala_instance.http_status.should == expected_response_code
+  end
+
+  def curbala_action(class_under_test, config_hash, expected_response_code, expected_response_data)
+    (logger = mock).should_receive(:debug).any_number_of_times # TODO : tighten this up?
+    @curbala_instance = class_under_test.new('service url segment/', config_hash, @args_hash, logger, expected_response_code, expected_response_data)
+  end
+    
+  def config(simulate = true)
+    {'simulate' => simulate, 'url' => 'test base service url/'}
+  end
+  
+end
+
+class CurbalaActionTestClass < Curbala::Action
+  def action_url_segment;     "action url segment";                                                     end
+  def invoke_action;    curl.http_put(Curl::PostField.content(:test_arg, args_hash[:test_arg]));  end
+end
+
+class CurbalaActionTestClassWithOverridenImplementations < CurbalaActionTestClass
+  def unpack_response
+    hash_from_xml_response
+  end
+
+  def success_message
+    "success message (overriden)"
+  end
+
+  def fail_message
+    "fail message (overriden)"
+  end
+end

data/spec/curbala/service_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe 'Curbala::Service' do
+  describe 'invoke and no/nil logger input' do
+    before(:each) { @mocked_config = { 'test' => {'simulate' => true, 'url' => 'service url segment'} } }
+    
+    it 'should use associated model logger to invoke new on proper Curbala::Action class with expected arguments, and return the action instance when no logger input and associated model has a logger' do
+      @mocked_model = mock(:logger => 'model logger')
+      verify_invoked_with 'model logger'
+    end
+    
+    describe 'and associated model does not have a logger' do
+      before(:each) { @mocked_model = mock(:logger => nil) }
+    
+      it 'should use Rails logger when in a Rails environment' do
+        unless defined?(Rails) # is this beggin for trouble?
+          class Rails; end
+        end
+        Rails.should_receive(:logger).and_return('rails logger')
+        verify_invoked_with 'rails logger'
+      end
+      
+      it 'should create a new Logger to STDOUT when not in a Rails environment' do
+        verify_invoked_with_new_logger
+      end
+    end
+    
+    describe 'and config file has url specified at top-level' do
+      before(:each) { @mocked_config = {'url' => 'top level config service url segment'} }
+      
+      it 'should use top-level url and not simulate when config file does not have a block for Rails.env (test)' do
+        @expected_config = {'simulate' => false, 'url' => 'top level config service url segment'}
+        verify_invoked_with_new_logger
+      end
+      
+      it 'should use environment-specific url when specified in environment block of config file' do
+        @mocked_config['test'] = {'simulate' => true, 'url' => 'service url segment'}
+        verify_invoked_with_new_logger
+      end
+    end
+    
+    def verify_invoked_with_new_logger
+      Logger.should_receive(:new).with(STDOUT).and_return('new logger')
+      verify_invoked_with 'new logger'
+    end
+    
+    def verify_invoked_with(logger)
+      @expected_config ||= @mocked_config['test']
+      File.should_receive(:open).with("./config/test curbala config file.yml").and_return('mocked open file') # TODO : Rails.root + 
+      YAML.should_receive(:load).with('mocked open file').and_return(@mocked_config)
+      TestCurbalaActionClass::SomeAction.should_receive(:new).with('test_curbala_service_url_segment', @expected_config, 'args_hash', logger, 200, nil).and_return('test service response')
+      TestCurbala::Service.invoke(:some_action, 'args_hash', @mocked_model).should == 'test service response'
+    end
+  end
+end
+
+module TestCurbalaActionClass
+  class SomeAction < Curbala::Action
+  end
+end
+
+module TestCurbala
+  class Service < Curbala::Service
+    def self.service_url_segment(business)
+      "test_curbala_service_url_segment"
+    end
+
+    def self.service_qualifier
+      'TestCurbalaActionClass'
+    end
+    
+    def self.config_file
+      'test curbala config file.yml'
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'curb'
+require 'curbala'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: curbala
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Frederick Fix
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: curb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+description: Does you application invoke services that have different URLs in different
+  Rails environments?  Would you like to log the application input to each service
+  call, have fine grain control over API-specific data encoding and decoding, and
+  log responses for each service call?  Are some of your service calls exhibiting
+  a 'long line' code odor?  Do your API developers test their calls using curl commands?  This
+  little ditty remedied these symptoms in our system and, most imporantly, expedited
+  our rails app development and troubleshooting with internal and external API teams.
+email: rickfix80004@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/curbala/action.rb
+- lib/curbala/service.rb
+- lib/curbala.rb
+- lib/generators/curbala/action/action_generator.rb
+- lib/generators/curbala/action/template/action.rb
+- lib/generators/curbala/action/template/action_spec.rb
+- lib/generators/curbala/action/template/config.yml
+- lib/generators/curbala/action/template/service.rb
+- lib/generators/curbala/action/USAGE
+- spec/curbala/action_spec.rb
+- spec/curbala/service_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- CHANGELOG.rdoc
+- Gemfile
+- LICENSE
+- Rakefile
+- README.rdoc
+- init.rb
+homepage: http://github.com/rickfix/curbala
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.4
+requirements: []
+rubyforge_project: curbala
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Curb client wrapper which encourages DRY implementations of, and provides
+  logging for, external REST/API/Service calls.
+test_files: []