voorhees 0.2.0

data/lib/voorhees/exceptions.rb

@@ -0,0 +1,9 @@
+module Voorhees
+  class Error < ::StandardError; end
+  class ParameterMissingError < Error; end
+  class NotFoundError < Error; end
+  class TimeoutError < Error; end
+  class UnavailableError < Error; end
+  class ParseError < Error; end  
+  class NotResourceError < Error; end
+end

data/lib/voorhees/logging.rb

@@ -0,0 +1,5 @@
+module Voorhees
+  def self.debug(message)
+    Voorhees::Config[:logger].debug("VOORHEES: #{message}")
+  end
+end

data/lib/voorhees/request.rb

@@ -0,0 +1,146 @@
+require 'uri'
+require 'net/http'
+
+begin
+  require 'system_timer'
+  VoorheesTimer = SystemTimer
+rescue LoadError
+  require 'timeout'
+  VoorheesTimer = Timeout
+end
+
+module Voorhees 
+  
+  class Request
+    
+    attr_accessor :timeout,   :retries,     :path, 
+                  :required,  :defaults,    :parameters,
+                  :base_uri,  :http_method, :hierarchy
+    
+    def initialize(caller_class=nil)
+      @caller_class = caller_class
+    end
+    
+    def path=(uri)
+      @path = URI.parse(uri)
+    end
+    
+    def uri
+      u = path.relative? ? URI.parse("#{base_uri}#{path}") : path  
+      if query = query_string(u)
+        u.query = query
+      end
+      u
+    end    
+    
+    def base_uri
+      @base_uri || Voorhees::Config[:base_uri]
+    end
+    
+    def defaults
+      @defaults || Voorhees::Config[:defaults]
+    end
+    
+    def parameters
+      (defaults || {}).merge(@parameters || {})
+    end
+    
+    def timeout
+      @timeout  || Voorhees::Config[:timeout]
+    end
+    
+    def retries
+      @retries  || Voorhees::Config[:retries]      
+    end
+    
+    def http_method
+      @http_method  || Voorhees::Config[:http_method]      
+    end
+    
+    def perform
+      setup_request
+      build_response(perform_actual_request)
+    end
+        
+    private
+    
+      def setup_request
+        @http  = Net::HTTP.new(uri.host, uri.port)
+        @req   = http_method.new(uri.path)
+        
+        @req.form_data =  if Voorhees::Config[:post_json] 
+                            { Voorhees::Config[:post_json_parameter] => parameters.to_json }
+                          else
+                            parameters
+                          end
+        
+        @http.open_timeout = timeout
+        @http.read_timeout = timeout
+      end
+    
+      def perform_actual_request
+        retries_left = retries
+        
+        Voorhees.debug("Performing #{http_method} request for #{uri.to_s}")
+        
+        begin        
+          retries_left -= 1
+          
+          response = VoorheesTimer.timeout(timeout) do
+                       @http.start do |connection| 
+                         connection.request(@req) 
+                       end
+                     end
+          
+        rescue Timeout::Error
+          if retries_left >= 0
+            Voorhees.debug("Retrying due to Timeout::Error (#{uri.to_s})")            
+            retry
+          end
+          
+          Voorhees.debug("Request failed due to Timeout::Error (#{uri.to_s})")
+          raise Voorhees::TimeoutError.new
+          
+        rescue Errno::ECONNREFUSED
+          if retries_left >= 0          
+            Voorhees.debug("Retrying due to Errno::ECONNREFUSED (#{uri.to_s})")            
+            sleep(1) 
+            retry
+          end
+          
+          Voorhees.debug("Request failed due to Errno::ECONREFUSED (#{uri.to_s})")
+          raise Voorhees::UnavailableError.new
+          
+        end
+
+        if response.is_a?(Net::HTTPNotFound)
+          Voorhees.debug("Request failed due to Net::HTTPNotFound (#{uri.to_s})")           
+          raise Voorhees::NotFoundError.new
+        end
+        
+        response
+      end
+    
+      def query_string(uri)
+        return if post?
+        query_string_parts = []
+        query_string_parts << uri.query unless uri.query.blank?
+        query_string_parts += parameters.collect{|k,v| "#{k}=#{v}" } unless parameters.empty?
+        query_string_parts.size > 0 ? query_string_parts.join('&') : nil
+      end
+    
+      def build_response(response)
+        Voorhees::Config[:response_class].new(response.body, @caller_class, @hierarchy)
+      end
+    
+      def validate
+        raise Voorhees::ParameterMissingError if @required && !@required.all?{|x| @parameters.keys.include?(x) }
+      end
+    
+      def post?
+        http_method == Net::HTTP::Post
+      end
+    
+  end
+  
+end

data/lib/voorhees/resource.rb

@@ -0,0 +1,141 @@
+module Voorhees 
+  
+  module Resource
+    
+    def self.included(base)
+      base.extend ClassMethods    
+      base.send :include, InstanceMethods
+      
+      base.instance_eval do
+        attr_accessor :raw_json, :json_hierarchy
+        undef_method :id        
+      end
+    end    
+    
+    module ClassMethods
+      def new_from_json(json, hierarchy=nil)
+        obj = self.new
+        obj.raw_json       = json
+        obj.json_hierarchy = hierarchy
+        obj
+      end
+      
+      def json_service(name, request_options={})
+        klass = request_options.delete(:class) || self
+        (class << self; self; end).instance_eval do
+          define_method name do |*args|
+            params = args[0]
+            json_request(:class => klass) do |r|
+              r.parameters = params if params.is_a?(Hash)
+              request_options.each do |option, value|
+                r.send("#{option}=", value)
+              end
+            end
+          end
+        end
+      end
+      
+      def json_request(options={})
+        request = Voorhees::Request.new(options[:class] || self)
+        yield request
+        response = request.perform
+        
+        case options[:returning]
+        when :raw
+          response.body
+        when :json
+          response.json
+        when :response
+          response
+        else
+          response.to_objects
+        end
+      end
+    end
+    
+    module InstanceMethods
+      
+      def json_attributes
+        @json_attributes ||= @raw_json.keys.collect{|x| x.underscore.to_sym}
+      end
+      
+      def json_request(options={})
+        self.class.json_request(options) do |r|
+          yield r
+        end
+      end
+      
+      def method_missing(*args)
+        method_name = args[0]
+        if json_attributes.include?(method_name)
+          value = value_from_json(method_name)
+          build_methods(method_name, value)
+          value
+        elsif method_name.to_s =~ /(.+)=$/ && json_attributes.include?($1.to_sym)
+          build_methods($1, args[1])
+        else        
+          super
+        end
+      end
+      
+      private
+        
+        def value_from_json(method_name)
+          item = raw_json[method_name.to_s] || raw_json[method_name.to_s.camelize(:lower)]
+          
+          sub_hierarchy = nil
+          if json_hierarchy && hierarchy = json_hierarchy[method_name] 
+            if hierarchy.is_a?(Array)
+              klass         = hierarchy[0]
+              sub_hierarchy = hierarchy[1]
+            else
+              klass = hierarchy
+            end
+            
+            klass = Object.const_get(klass.to_s.pluralize.classify) if klass.is_a?(Symbol)
+          end
+          
+          if item.is_a?(Array)
+            build_collection_from_json(method_name, item, klass, sub_hierarchy)
+          else
+            build_item(item, klass, sub_hierarchy)
+          end
+        end
+        
+        def build_methods(name, value)
+          self.instance_variable_set("@#{name}".to_sym, value)
+          
+          instance_eval "          
+            def #{name}
+              @#{name} ||= value_from_json(:#{name})
+            end
+          
+            def #{name}=(val)
+              @#{name} = val
+            end
+          "
+        end
+        
+        def build_item(json, klass, hierarchy)
+          if klass
+            raise Voorhees::NotResourceError.new unless klass.respond_to?(:new_from_json)
+            klass.new_from_json(json, hierarchy)
+          else
+            json
+          end
+        end
+        
+        def build_collection_from_json(name, json, klass, hierarchy)
+          klass ||= Object.const_get(name.to_s.classify)
+          json.collect do |item|
+            klass.new_from_json(json, hierarchy)
+          end
+        rescue NameError
+          json
+        end
+      
+    end
+    
+  end
+  
+end

data/lib/voorhees/response.rb

@@ -0,0 +1,36 @@
+module Voorhees 
+  
+  class Response
+    
+    attr_reader :body, :klass
+    
+    def initialize(body, klass=nil, hierarchy=nil)
+      @body       = body
+      @hierarchy  = hierarchy
+      @klass      = klass      
+    end
+    
+    def json
+      @json ||= JSON.parse(@body)
+    rescue JSON::ParserError
+      Voorhees.debug("Parsing JSON failed.\nFirst 500 chars of body:\n#{response.body[0...500]}")
+      raise Voorhees::ParseError
+    end
+    
+    def to_objects
+      return unless @klass
+      
+      raise Voorhees::NotResourceError.new unless @klass.respond_to?(:new_from_json)
+      
+      if json.is_a?(Array)
+        json.collect do |item|
+          @klass.new_from_json(item, @hierarchy)
+        end
+      else
+        @klass.new_from_json(json, @hierarchy)
+      end
+    end
+    
+  end
+  
+end

data/spec/config_spec.rb

@@ -0,0 +1,144 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Voorhees::Config do
+
+  before :each do 
+    
+    Voorhees::Config.clear
+    Voorhees::Config.setup do |c|
+      c[:one] = 1
+      c[:two] = 2
+    end
+    
+  end
+
+  describe "logger" do
+    
+    before :each do 
+      Object.send(:remove_const, :RAILS_DEFAULT_LOGGER) if defined?(RAILS_DEFAULT_LOGGER)
+    end
+    
+    it "should default to RAILS_DEFAULT_LOGGER if defined" do
+      RAILS_DEFAULT_LOGGER = "something"
+      Voorhees::Config.reset
+      Voorhees::Config.logger.should == "something"
+    end
+    
+    it "should default to a Logger if RAILS_DEFAULT_LOGGER is not defined" do
+      Voorhees::Config.reset      
+      Voorhees::Config.logger.should be_a(Logger)
+    end
+    
+  end
+
+  describe "configuration" do
+    
+    it "should return the configuration hash" do
+      Voorhees::Config.configuration.should == {:one => 1, :two => 2}
+    end
+    
+  end
+  
+  describe "[]" do
+    
+    it "should return the config option matching the key" do
+      Voorhees::Config[:one].should == 1
+    end
+    
+    it "should return nil if the key doesn't exist" do
+      Voorhees::Config[:monkey].should be_nil
+    end
+    
+  end
+  
+  describe "[]=" do
+    
+    it "should set the config option for the key" do
+      lambda{
+        Voorhees::Config[:banana] = :yellow        
+      }.should change(Voorhees::Config, :banana).from(nil).to(:yellow)      
+    end
+    
+  end
+  
+  describe "delete" do
+    
+    it "should delete the config option for the key" do
+      lambda{
+        Voorhees::Config.delete(:one)
+      }.should change(Voorhees::Config, :one).from(1).to(nil)      
+    end
+    
+    it "should leave the config the same if the key doesn't exist" do
+      lambda{
+        Voorhees::Config.delete(:test)        
+      }.should_not change(Voorhees::Config, :configuration)
+    end
+    
+  end
+  
+  describe "fetch" do
+    
+    it "should return the config option matching the key if it exists" do
+      Voorhees::Config.fetch(:one, 100).should == 1
+    end
+    
+    it "should return the config default if the key doesn't exist" do
+      Voorhees::Config.fetch(:other, 100).should == 100      
+    end
+    
+  end
+  
+  describe "to_hash" do
+    
+    it "should return a hash of the configuration" do
+      Voorhees::Config.to_hash.should == {:one => 1, :two => 2}      
+    end
+    
+  end
+  
+  describe "setup" do
+    
+    it "should yield self" do
+      Voorhees::Config.setup do |c|
+        c.should == Voorhees::Config
+      end
+    end
+    
+    it "should let you set items on the configuration object as a hash" do
+      lambda{
+        Voorhees::Config.setup do |c|
+          c[:bananas] = 100
+        end
+      }.should change(Voorhees::Config, :bananas).from(nil).to(100)      
+    end
+    
+    it "should let you set items on the configuration object as a method" do
+      lambda{
+        Voorhees::Config.setup do |c|
+          c.monkeys = 100
+        end
+      }.should change(Voorhees::Config, :monkeys).from(nil).to(100)      
+    end    
+    
+  end
+  
+  describe "calling a missing method" do
+    
+    it "should retreive the config if the method matches a key" do
+      Voorhees::Config.one.should == 1
+    end
+    
+    it "should retreive nil if the method doesn't match a key" do
+      Voorhees::Config.moo.should be_nil
+    end
+    
+    it "should set the value of the config item matching the method name if it's an assignment" do
+      lambda{
+        Voorhees::Config.trees = 3
+      }.should change(Voorhees::Config, :trees).from(nil).to(3)            
+    end        
+    
+  end
+
+end