remote_api 0.1.0

data/Manifest.txt

@@ -0,0 +1,20 @@
+History.txt
+Manifest.txt
+README.txt
+
+Rakefile
+setup.rb
+
+lib/dsl_accessor.rb
+lib/remote_api.rb
+
+lib/remote_api/base.rb
+lib/remote_api/xml.rb
+lib/remote_api/xml_response.rb
+
+lib/remote_api/version.rb
+
+test/test_helper.rb
+test/base_test.rb
+test/xml_test.rb
+test/xml_response_test.rb

data/README.txt

@@ -0,0 +1,3 @@
+README for remote_api
+=====================
+

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'remote_api', 'version')
+
+AUTHOR = "Alex Wayne"
+EMAIL = "rubyonrails@beautifulpixel.com"
+DESCRIPTION = "Provides a basic framework for easily creating classes that access remote APIs."
+GEM_NAME = "remote_api"                                 # what ppl will type to install your gem
+RUBYFORGE_PROJECT = "remote-api"                        # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+RELEASE_TYPES = %w( gem )                               # can use: gem, tar, zip
+
+
+NAME = "remote_api"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (RemoteAPI::VERSION::STRING + (REV ? ".#{REV}" : ""))
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "remote_api documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/*_test.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  #p.changes        - A description of the release's latest changes.
+  p.extra_deps = %w( activesupport )
+  #p.spec_extras    - A hash of extra values to set in the gemspec.
+end

data/lib/dsl_accessor.rb

@@ -0,0 +1,50 @@
+class Class
+  def dsl_accessor(name, options = {})
+    raise TypeError, "DSL Error: options should be a hash. but got `#{options.class}'" unless options.is_a?(Hash)
+    writer = options[:writer] || options[:setter]
+    writer =
+      case writer
+      when NilClass then Proc.new{|value| value}
+      when Symbol   then Proc.new{|value| __send__(writer, value)}
+      when Proc     then writer
+      else raise TypeError, "DSL Error: writer should be a symbol or proc. but got `#{options[:writer].class}'"
+      end
+    write_inheritable_attribute(:"#{name}_writer", writer)
+
+    default =
+      case options[:default]
+      when NilClass then nil
+      when []       then Proc.new{[]}
+      when {}       then Proc.new{{}}
+      when Symbol   then Proc.new{__send__(options[:default])}
+      when Proc     then options[:default]
+      else Proc.new{options[:default]}
+      end
+    write_inheritable_attribute(:"#{name}_default", default)
+
+    self.class.class_eval do
+      define_method("#{name}=") do |value|
+        writer = read_inheritable_attribute(:"#{name}_writer")
+        value  = writer.call(value) if writer
+        write_inheritable_attribute(:"#{name}", value)
+      end
+
+      define_method(name) do |*values|
+        if values.empty?
+          # getter method
+          key = :"#{name}"
+          if !inheritable_attributes.has_key?(key)
+            default = read_inheritable_attribute(:"#{name}_default")
+            value   = default ? default.call(self) : nil
+            __send__("#{name}=", value)
+          end
+          read_inheritable_attribute(key)
+        else
+          # setter method
+          __send__("#{name}=", *values)
+        end
+      end
+    end
+  end
+end
+

data/lib/remote_api/base.rb

@@ -0,0 +1,120 @@
+class RemoteAPI
+  class ResponseFailure < RuntimeError; end
+  
+  dsl_accessor :debug
+  dsl_accessor :url
+  dsl_accessor :content_type
+  
+  class ResponseFailure < RuntimeError; end
+  
+  # Eeverything happens on instantiation.  Pass in a hash, and each key in the hash will 
+  # become an instance variable for use in the rest of the instance methods.
+  # 
+  # Then we send the request, assert that is the response is successful, and process the 
+  # response.
+  def initialize(params = {})
+    params.each do |k, v|
+      instance_variable_set "@#{k}", v
+    end
+    
+    send_request
+    assert_success
+    process
+  end
+  
+  private
+    
+    # Send the request to the UPS servers
+    def send_request(request_body = nil)
+      request_body ||= request
+      debug_request(request_body)
+      
+      # Setup HTTP objects
+      url               = URI.parse(server_url)
+      http              = Net::HTTP.new(url.host, url.port)
+      
+      if url.is_a?(URI::HTTPS)
+	      http.verify_mode  = OpenSSL::SSL::VERIFY_NONE
+	      http.use_ssl      = true
+      end
+      
+      # Setup request options
+      options = {}
+      options['ContentType'] = self.class.content_type if self.class.content_type
+      
+      # Send Request
+      response = http.post(url.path, request_body, options)      
+      debug_response(response.body, url)
+      
+      # Convert response to proper format
+      @response = prepare_response(response)
+      
+      # Code hook to raise execption if error conditions are met
+      assert_success
+    end
+    
+    def assert_success
+      true
+    end
+    
+    def process(*args)
+      raise 'You must define a "process" method!  This should should parse the @response and' + 
+            'extract relevant data.'
+    end
+    
+    def request(*args)
+      raise 'You must define a "request" method!  This should create the body of your API request'
+    end
+    
+    def prepare_response(response)
+      response.body
+    end
+    
+    def server_url
+      url = self.class.url
+      
+      case url.class.to_s
+      when 'String'
+        url
+      when 'Hash'
+        url.symbolize_keys[ENV['RAILS_ENV'].to_sym]
+      when 'Proc'
+        url.call
+      else
+        raise "url attribute must be a String, Proc or Hash.  Got #{url.class}"
+      end
+    end
+    
+    def format_response(response)
+      response
+    end
+    
+    def debug_request(request_body)
+      return unless self.class.debug
+      puts <<DEBUG
+
+-----------
+- REQUEST -
+-----------
+
+#{request_body}
+DEBUG
+    end
+    
+    def debug_response(response, url)
+      return unless self.class.debug
+      
+      parsed_response = format_response(response)
+      
+      puts <<DEBUG
+
+------------"
+- RESPONSE -"
+------------"
+--- From: #{url}" 
+
+#{parsed_response}
+
+DEBUG
+    end
+end

data/lib/remote_api/version.rb

@@ -0,0 +1,9 @@
+class RemoteAPI #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/remote_api/xml.rb

@@ -0,0 +1,19 @@
+class RemoteAPI
+  class XML < RemoteAPI
+    
+    include REXML
+    
+    content_type 'application/xml'
+    
+    private
+      
+      def prepare_response(response)
+        Response.new(response.body)
+      end
+      
+      def format_response(response)
+        Response.new(response).to_formatted_s
+      end
+      
+  end
+end

data/lib/remote_api/xml_response.rb

@@ -0,0 +1,34 @@
+class RemoteAPI
+  class XML
+    class Response
+  
+      def initialize(data)
+        @data = REXML::Document.new(data.to_s).root
+      end
+  
+      # equivalent to:
+      #   xml.elements[xpath].text
+      def [](xpath)
+        if element = @data.elements[xpath]
+          element.text
+        else
+          nil
+        end
+      end
+  
+      # equivalent to:
+      #   xml.each_element(xpath) { |node| ... }
+      def each(xpath)
+        raise ArgumentError, 'You must supply a block to the "each" method' unless block_given?
+        @data.each_element(xpath) do |node|
+          yield self.class.new(node)
+        end
+      end
+      
+      def to_formatted_s
+        output = ''
+        @data.write(output, 0)
+      end
+    end # Response
+  end # XML
+end # RemoteAPI

data/lib/remote_api.rb

@@ -0,0 +1,13 @@
+require 'net/https'
+require 'rexml/document'
+require 'uri'
+
+require 'active_support'
+
+# Why isn't this a gem?
+require File.join(File.dirname(__FILE__), 'dsl_accessor')
+
+# remote_api files
+require 'remote_api/base'
+require 'remote_api/xml'
+require 'remote_api/xml_response'