orthrus 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.8.7@orthrus

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in orthrus.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,57 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.co.jp>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING.txt file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them,
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.markdown

@@ -0,0 +1,81 @@
+# Orthrus
+
+http://github.com/xijo/orthrus
+
+In Greek mythology, Orthrus (Greek: Όρθρος) was a two-headed dog and son of Typhoeus.
+He was charged with guarding Geryon's herd of red cattle in Erytheia.
+
+## Typhoeus
+
+Thanks to the guys who are developing Typhoeus (http://github.com/dbalatero/typhoeus)
+
+Orthrus is a small extension inspired by the original remote method API from Paul Dix
+which is deprecated in the current Typhoeus release.
+
+It can be used to encapsulate remote method calls in a clean way and provide an
+easy interface to work with.
+
+## Installation
+
+    gem install orthrus
+
+## Usage
+
+*Simple: OpenLibrary Example*
+
+    require 'rubygems'
+    require 'typhoeus'
+    require 'orthrus'
+
+    class OpenLibrary
+      include Orthrus
+      remote_defaults :base_uri => "http://openlibrary.org/api"
+
+      define_remote_method :book, :path => '/books'
+    end
+
+    book = OpenLibrary.book(:params => {:bibkeys => "ISBN:0451526538", :format => "json"})
+    puts book.inspect # Typhoeus::Response
+
+*Advanced: Twitter Example with JSON handling and path interpolation*
+
+    require 'rubygems'
+    require 'typhoeus'
+    require 'orthrus'
+    require 'json'
+
+    class Twitter
+      include Orthrus
+      remote_defaults :on_success => lambda { |response| JSON.parse(response.body) },
+                      :on_failure => lambda { |response| puts "error code: #{response.code}"; {} },
+                      :base_uri   => "http://api.twitter.com"
+
+      define_remote_method :search, :path   => "/:version/search.json"
+      define_remote_method :trends, :path   => "/:version/trends/:time_frame.json"
+      define_remote_method :tweet,  :path   => "/:version/statuses/update.json",
+                                    :method => :post
+    end
+
+    # Get all tweets mentioning pluto
+    tweets = Twitter.search(:version => 1, :params => {:q => "pluto"})
+
+    # Get all current trends
+    trends = Twitter.trends(:version => 1, :time_frame => :current)
+
+    # Submit a tweet. Authentication skipped in example.
+    Twitter.tweet(:version => 1, :params => {:status => "I #love #planets! :)"})
+
+## TODO
+
+ - no cache handling yet.
+ - make requests hydra-compatible
+ - set default parameters
+
+## Author
+
+Johannes Opper <xijo@gmx.de>
+
+## License
+
+Published under the Ruby License. For detailed information see
+http://www.ruby-lang.org/en/LICENSE.txt and http://www.ruby-lang.org/en/COPYING.txt

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/orthrus.rb

@@ -0,0 +1,51 @@
+require 'orthrus/remote_method'
+
+module Orthrus
+  # Include Orthrus functionality in the given class
+  # @param base class to include
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    # Define default settings for the remote connection.
+    # @attribute remote_defaults
+    # @param [Hash] options to be set as default
+    # @return [Hash] the current remote default settings
+    def remote_defaults(options)
+      @remote_defaults ||= {}
+      @remote_defaults.merge!(options) if options
+      @remote_defaults
+    end
+
+    # If we get subclassed, make sure that child inherits the remote defaults
+    # of the parent class.
+    def inherited(child)
+      child.__send__(:remote_defaults, @remote_defaults)
+    end
+
+    # Declare a remote method and create a class method as wrapper
+    # @param [Symbol] name of the remote method
+    # @param [Hash] options for the remote method
+    def define_remote_method(name, options = {})
+      remote_options = (@remote_defaults || {}).merge(options)
+      @remote_methods ||= {}
+      @remote_methods[name] = RemoteMethod.new(remote_options)
+
+      class_eval <<-SRC
+        def self.#{name.to_s}(args = {})
+          call_remote_method(:#{name.to_s}, args)
+        end
+      SRC
+    end
+
+    # Find the specified remote method and pass the arguments
+    # @param [Symbol] method_name to identify the remote method
+    # @param [Hash] args to pass through
+    def call_remote_method(method_name, args)
+      remote_method = @remote_methods[method_name]
+      remote_method.run(args)
+    end
+  end
+end

data/lib/orthrus/remote_method.rb

@@ -0,0 +1,58 @@
+module Orthrus
+  class RemoteMethod
+    attr_accessor :options, :base_uri, :path, :on_success, :on_failure
+
+    # Extract request options to class variables. All other options
+    # will be passed through to Typhoeus.
+    # @param [Hash] options for the request
+    def initialize(options = {})
+      options[:method] ||= :get
+      @options     = options
+      @base_uri    = options.delete(:base_uri)
+      @path        = options.delete(:path)
+      @on_success  = options[:on_success] || lambda { |response| response }
+      @on_failure  = options[:on_failure] || lambda { |response| response }
+    end
+
+    # Perform the request, handle response and return the result
+    # @param [Hash] args for interpolation and request options
+    # @return [Response, Object] the Typhoeus::Response or the result of the on_complete block
+    def run(args = {})
+      url     = base_uri + interpolated_path(args)
+      request = Typhoeus::Request.new(url, @options.merge(args))
+      handle_response(request)
+      Typhoeus::Hydra.hydra.queue request
+      Typhoeus::Hydra.hydra.run
+      request.handled_response
+    end
+
+    # Interpolate parts of the path marked through color
+    # @param [Hash] args to perform interpolation
+    # @return [String] the interpolated path
+    # @example Interpolate a path
+    #   path = "/planet/:identifier"
+    #   interpolated_path({:identifier => "mars"}) #=> "/planet/mars"
+    def interpolated_path(args = {})
+      interpolated_path = @path
+      args.each do |key, value|
+        if interpolated_path.include?(":#{key}")
+          interpolated_path.sub!(":#{key}", value.to_s)
+          args.delete(key)
+        end
+      end
+      interpolated_path
+    end
+
+    # Call success and failure handler on request complete
+    # @param [Typhoeus::Request] request that needs success or failure handling
+    def handle_response(request)
+      request.on_complete do |response|
+        if response.success?
+          @on_success.call(response)
+        else
+          @on_failure.call(response)
+        end
+      end
+    end
+  end
+end

data/lib/orthrus/version.rb

@@ -0,0 +1,3 @@
+module Orthrus
+  VERSION = "0.0.1"
+end

data/orthrus.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "orthrus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "orthrus"
+  s.version     = Orthrus::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Johannes Opper"]
+  s.email       = ["xijo@gmx.de"]
+  s.homepage    = "http://github.com/xijo/orthrus"
+  s.summary     = %q{Remote method handling for Typhoeus}
+  s.description = %q{Orthrus extends Typhoeus with remote method handling, since it is deprecated in Typhoeus itself.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency 'typhoeus', '~> 0.2'
+
+  s.add_development_dependency 'test-unit', '~> 2.3'
+  s.add_development_dependency 'json', '~> 1.5'
+end

data/test/test_define_remote_method.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class TestDefineRemoteMethod < Test::Unit::TestCase
+  class A
+    include Orthrus
+    define_remote_method :method_on_a,
+                         :path => 'entities',
+                         :base_uri => "http://fancydomain.com"
+  end
+
+  class B
+    include Orthrus
+    remote_defaults :base_uri => "http://superfancy.com"
+    define_remote_method :method_on_b, :path => "entities/index"
+  end
+
+  def test_define_remote_method_without_defaults
+    assert A.respond_to? :method_on_a
+  end
+
+  def test_define_remote_method_with_remote_defaults
+    assert B.respond_to? :method_on_b
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+require 'rubygems'
+require 'typhoeus'
+require 'orthrus'
+require 'json'
+
+class Test::Unit::TestCase
+end

data/test/test_remote_defaults.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class TestRemoteDefaults < Test::Unit::TestCase
+  class A
+    include Orthrus
+    remote_defaults :headers => { :authentication => "Basic someting" },
+                    :base_uri => "http://fancydomain.com"
+  end
+
+  class B < A
+    remote_defaults :base_uri => "http://superfancy.com"
+  end
+
+  def test_setting_remote_defaults
+    assert_not_nil defaults = A.instance_variable_get(:@remote_defaults)
+    assert_equal "http://fancydomain.com", defaults[:base_uri]
+    assert_equal "Basic someting", defaults[:headers][:authentication]
+  end
+
+  def test_overwritting_remote_defaults_in_subclass
+    assert_not_nil defaults = B.instance_variable_get(:@remote_defaults)
+    assert_equal "http://superfancy.com", defaults[:base_uri]
+    assert_equal "Basic someting", defaults[:headers][:authentication]
+  end
+
+end

data/test/test_remote_method.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+class TestDefineRemoteMethod < Test::Unit::TestCase
+  def setup
+    hydra           = Typhoeus::Hydra.hydra
+    @index_response = Typhoeus::Response.new(:code => 200, :body => '{ "planets" : ["mars", "earth", "venus"] }', :time => 0.3)
+    @show_response  = Typhoeus::Response.new(:code => 200, :body => '{ "mars" : { "density" : "3.9335 g/cm3" , "temperature" : "210K" } }', :time => 0.3)
+    @error_response = Typhoeus::Response.new(:code => 404, :body => '{ "eris" : "is no planet but a TNO" }', :time => 0.3)
+    @put_response   = Typhoeus::Response.new(:code => 403, :body => 'Creating planets is not your business!', :time => 0.3)
+    hydra.stub(:get, "http://astronomical.joe/planets").and_return(@index_response)
+    hydra.stub(:get, "http://astronomical.joe/planets/mars").and_return(@show_response)
+    hydra.stub(:get, "http://astronomical.joe/planets/eris").and_return(@error_response)
+    hydra.stub(:put, "http://astronomical.joe/planets").and_return(@put_response)
+  end
+
+  def test_path_interpolation
+    remote_method = Orthrus::RemoteMethod.new :path => "/some/:id/with/:child"
+    args = { :id => 4, :child => 2, :another => 3 }
+    interpolated  = remote_method.interpolated_path(args)
+    assert_equal "/some/4/with/2", interpolated
+    assert_equal({ :another => 3 }, args)
+  end
+
+  def test_simple_remote_method_get
+    remote_method = Orthrus::RemoteMethod.new(
+      :base_uri => "http://astronomical.joe",
+      :path     => "/planets",
+      :method   => :get
+    )
+    assert_equal @index_response.body, remote_method.run.body
+  end
+
+  def test_simple_remote_method_with_get_as_default
+    remote_method = Orthrus::RemoteMethod.new(
+      :base_uri => "http://astronomical.joe",
+      :path     => "/planets"
+    )
+    assert_equal @index_response.body, remote_method.run.body
+  end
+
+  def test_remote_method_with_interpolation
+    remote_method = Orthrus::RemoteMethod.new(
+      :base_uri => "http://astronomical.joe",
+      :path     => "/planets/:identifier",
+      :method   => :get
+    )
+    assert_equal @show_response.body, remote_method.run(:identifier => :mars).body
+  end
+
+  def test_remote_method_with_success_handler
+    remote_method = Orthrus::RemoteMethod.new(
+      :base_uri => "http://astronomical.joe",
+      :path     => "/planets/:identifier",
+      :on_success => lambda { |response| JSON.parse(response.body) },
+      :method   => :get
+    )
+    response = remote_method.run(:identifier => :mars)
+    assert_equal '3.9335 g/cm3', response['mars']['density']
+    assert_equal '210K', response['mars']['temperature']
+  end
+
+  def test_remote_method_with_failure_handler
+    remote_method = Orthrus::RemoteMethod.new(
+      :base_uri   => "http://astronomical.joe",
+      :path       => "/planets/:identifier",
+      :on_failure => lambda { |response| JSON.parse(response.body) },
+      :method     => :get
+    )
+    response = remote_method.run(:identifier => :eris)
+    assert_equal "is no planet but a TNO", response['eris']
+  end
+
+  def test_remote_method_put
+    remote_method = Orthrus::RemoteMethod.new(
+      :base_uri   => "http://astronomical.joe",
+      :path       => "/planets",
+      :method     => :put
+    )
+    response = remote_method.run(:body => '{ :planet => :naboo }')
+    assert_equal "Creating planets is not your business!", response.body
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification 
+name: orthrus
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Johannes Opper
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-16 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: typhoeus
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 2
+        version: "0.2"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        version: "2.3"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 5
+        version: "1.5"
+  type: :development
+  version_requirements: *id003
+description: Orthrus extends Typhoeus with remote method handling, since it is deprecated in Typhoeus itself.
+email: 
+- xijo@gmx.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/orthrus.rb
+- lib/orthrus/remote_method.rb
+- lib/orthrus/version.rb
+- orthrus.gemspec
+- test/test_define_remote_method.rb
+- test/test_helper.rb
+- test/test_remote_defaults.rb
+- test/test_remote_method.rb
+has_rdoc: true
+homepage: http://github.com/xijo/orthrus
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Remote method handling for Typhoeus
+test_files: 
+- test/test_define_remote_method.rb
+- test/test_helper.rb
+- test/test_remote_defaults.rb
+- test/test_remote_method.rb