relax 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Tyler Hunt
+
+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

@@ -0,0 +1,4 @@
+Relax
+=====
+
+A simple library for creating REST consumers.

data/lib/relax/api.rb

@@ -0,0 +1,49 @@
+require 'openssl'
+require 'net/https'
+require 'uri'
+require 'date'
+require 'base64'
+require 'erb'
+
+module Relax
+  class API
+    attr_reader :endpoint
+
+    def initialize(endpoint)
+      @endpoint = URI::parse(endpoint)
+    end
+
+    private
+
+    def default_query
+      Query.new
+    end
+
+    def query(request)
+      Query.new(default_query.merge(request.to_query))
+    end
+
+    def call(request, response_class)
+      uri = @endpoint.clone
+      uri.query = query(request).to_s
+      response = request(uri)
+      puts "Response:\n#{response.body}\n\n" if $DEBUG
+      response_class.new(response.body)
+    end
+
+    def request(uri)
+      puts "Request:\n#{uri.to_s}\n\n" if $DEBUG
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if uri.scheme == 'https'
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      http.start do |http|
+        request = Net::HTTP::Get.new("#{uri.path}?#{uri.query}")
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/relax/query.rb

@@ -0,0 +1,39 @@
+require 'erb'
+require 'uri'
+
+require 'relax/symbolic_hash'
+
+module Relax
+  class Query < SymbolicHash
+    def to_s
+      keys.sort { |a, b| a.to_s <=> b.to_s }.collect do |key|
+        "#{key.to_s}=#{self.class.escape_value(fetch(key))}"
+      end.join('&')
+    end
+
+    class << self
+      def parse(uri)
+        query = uri.query.split('&').inject({}) do |query, parameter|
+          key, value = parameter.split('=')
+          query[key] = unescape_value(value)
+          query
+        end
+        self.new(query)
+      end
+
+      def escape_value(value)
+        ERB::Util.url_encode(value.to_s).gsub('%20', '+')
+      end
+
+      def unescape_value(value)
+        URI.unescape(value)
+      end
+    end
+
+    protected
+
+    def convert_value(value)
+      value.to_s
+    end
+  end
+end

data/lib/relax/request.rb

@@ -0,0 +1,49 @@
+require 'relax/query'
+
+module Relax
+  class Request
+    def initialize(options = {})
+      self.class.class_variables.each do |variable|
+        instance_variable_set(variable.slice(1..-1), self.class.send(:class_variable_get, variable))
+      end
+
+      options.each do |key, value|
+        instance_variable_set "@#{key}", value
+      end
+    end
+
+    def to_query
+      keys.inject(Query.new) do |parameters, key|
+        parameters[convert_key(key)] = send(key)
+        parameters
+      end
+    end
+
+    def to_s
+      keys.sort { |a, b| a.to_s <=> b.to_s }.collect do |key|
+        "#{key.to_s}=#{ERB::Util.url_encode(send('[]', key).to_s)}"
+      end.join('&')
+    end
+
+    class << self
+      def parameter(name, options = {})
+        attr_accessor name
+        class_variable_set("@@#{name}", options.delete(:value)) if options[:value]
+      end
+
+      def []=(key, value)
+        parameter(key, {:value => value})
+      end
+    end
+
+    protected
+
+    def keys
+      instance_variables.collect { |v| v.sub('@', '') }
+    end
+
+    def convert_key(key)
+      key
+    end
+  end
+end

data/lib/relax/response.rb

@@ -0,0 +1,110 @@
+require 'rubygems'
+require 'hpricot'
+
+require 'date'
+
+module Relax
+  class Response
+    attr_accessor :xml
+
+    def initialize(xml)
+      @xml = Hpricot.XML(xml.to_s)
+
+      if parameter = self.class.instance_variable_get('@parameters')
+        parameter.each do |parameter, options|
+          element = options[:element] ? options[:element] : parameter
+
+          if attribute = options[:attribute] and attribute == true
+            node = attribute(root, element)
+          elsif attribute
+            node = attribute(element(element), attribute)
+          elsif options[:collection]
+            node = elements(element)
+          else
+            node = element(element)
+          end
+
+          if options[:collection]
+            value = node.collect do |element|
+              options[:collection].new(element)
+            end
+          else
+            case options[:type]
+              when :float
+                value = float_value(node)
+
+              when :integer
+                value = integer_value(node)
+
+              when :text
+              else
+                value = text_value(node)
+            end
+          end
+
+          instance_variable_set("@#{parameter}", value)
+        end
+      end
+    end
+
+    def root
+      @xml.root
+    end
+
+    def is?(name)
+      root.name.gsub(/.*:(.*)/, '\1') == node_name(name)
+    end
+
+    def element(name)
+      root.at(root_path(name))
+    end
+
+    def attribute(element, name)
+      element[name]
+    end
+
+    def elements(name)
+      root.search(root_path(name))
+    end
+
+    def value(value)
+      value.is_a?(Hpricot::Elem) ? value.inner_text : value.to_s
+    end
+
+    def text_value(value)
+      value(value)
+    end
+
+    def integer_value(value)
+      value(value).to_i
+    end
+
+    def float_value(value)
+      value(value).to_f
+    end
+
+    def date_value(value)
+      Date.parse(value(value))
+    end
+
+    alias :has? :element
+
+    class << self
+      def parameter(name, options = {})
+        attr_accessor name
+        @parameters ||= {}
+        @parameters[name] = options
+      end
+    end
+
+    private
+
+    def node_name(name)
+      name.to_s.downcase
+    end
+
+    def root_path(name)
+      "/#{node_name(name)}"
+    end
+  end
+end

data/lib/relax/symbolic_hash.rb

@@ -0,0 +1,65 @@
+module Relax
+  class SymbolicHash < Hash
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def [](key)
+      super(convert_key(key))
+    end
+
+    def []=(key, value)
+      super(convert_key(key), convert_value(value))
+    end
+
+    def update(other_hash)
+      other_hash.each_pair { |key, value| store(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    def values_at(*indices)
+      indices.collect { |key| self[convert_key(key)] }
+    end
+
+    def dup
+      SymbolicHash.new(self)
+    end
+
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    protected
+
+    def convert_key(key)
+      !key.kind_of?(Symbol) ? key.to_sym : key
+    end
+
+    def convert_value(value)
+      value
+    end
+  end
+end

data/lib/relax.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'relax/api'
+require 'relax/symbolic_hash'
+require 'relax/query'
+require 'relax/request'
+require 'relax/response'

data/spec/query_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'relax/query'
+
+describe 'a query' do
+  before(:each) do
+    @uri = URI::parse('http://example.com/?action=search&query=keyword')
+    @query = Relax::Query.new
+  end
+
+  it 'should convert to a query string' do
+    @query[:action] = 'Search'
+    @query[:query] = 'strings'
+    @query.to_s.should == 'action=Search&query=strings'
+  end
+
+  it 'should convert its values to strings' do
+    date = Date.today
+    @query[:date] = date
+    @query.to_s.should == "date=#{date.to_s}"
+  end
+
+  it 'should escape its values using "+" instead of "%20"' do
+    Relax::Query.send(:escape_value, 'two words').should == 'two+words'
+  end
+
+  it 'should sort its parameters' do
+    @query[:charlie] = 3
+    @query[:alpha] = 1
+    @query[:bravo] = 2
+    @query.to_s.should == 'alpha=1&bravo=2&charlie=3'
+  end
+
+  it 'should encode its parameter values' do
+    @query[:spaces] = 'two words'
+    @query[:url] = 'http://example.com/'
+    @query.to_s.should == 'spaces=two+words&url=http%3A%2F%2Fexample.com%2F'
+  end
+
+  it 'should be able to parse query strings' do
+    parsed_query = Relax::Query.parse(@uri)
+    parsed_query[:action].should == 'search'
+    parsed_query[:query].should == 'keyword'
+  end
+end

data/spec/request_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'relax/request'
+
+class TestRequest < Relax::Request
+  parameter :action
+  parameter :token_id
+  parameter :user_id
+end
+
+class ChildRequest < TestRequest
+  parameter :child_id
+end
+
+describe 'an option initialized request', :shared => true do
+  it 'should have its values set by the options hash' do
+    request = TestRequest.new(:action => 'FetchAll', :token_id => 123)
+    request.action.should eql('FetchAll')
+    request.token_id.should eql(123)
+    request.user_id.should be_nil
+  end
+end
+
+describe 'a request that converts to a query', :shared => true do
+  before(:each) do
+    @query = TestRequest.new(:action => 'Search', :token_id => 123).to_query
+  end
+
+  it 'should include its parameters in the query' do
+    @query[:action].should eql('Search')
+    @query[:token_id].should eql('123')
+    @query[:user_id].should be_nil
+  end
+
+  it 'should only include parameters in the query if they are set' do
+    @query.key?(:action).should be_true
+    @query.key?(:token_id).should be_true
+    @query.key?(:user_id).should be_false
+  end
+end
+
+describe 'a normal request' do
+  it_should_behave_like 'a request that converts to a query'
+  it_should_behave_like 'an option initialized request'
+end
+
+describe 'a template request' do
+  it_should_behave_like 'a request that converts to a query'
+  it_should_behave_like 'an option initialized request'
+
+  before(:each) do
+    TestRequest[:api_key] = '123456'
+    TestRequest[:secret] = 'shhh!'
+  end
+
+  it 'should always have the template values in its query' do
+    request = TestRequest.new
+    request.api_key.should eql('123456')
+    request.secret.should eql('shhh!')
+  end
+
+  it 'should allow its template variables to be overridden' do
+    request = TestRequest.new(:secret => 'abracadabra')
+    request.api_key.should eql('123456')
+    request.secret.should eql('abracadabra')
+  end
+
+  it 'should pass its template on to its children' do
+    request = ChildRequest.new
+    request.api_key.should eql('123456')
+    request.secret.should eql('shhh!')
+  end
+
+  it 'should allow template parameters on its children that are additive' do
+    ChildRequest[:query] = '1a2b3c'
+    child = ChildRequest.new
+    child.api_key.should eql('123456')
+    child.secret.should eql('shhh!')
+    child.query.should eql('1a2b3c')
+
+    parent = TestRequest.new
+    parent.api_key.should eql('123456')
+    parent.secret.should eql('shhh!')
+    parent.respond_to?(:query).should be_false
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'relax/response'
+
+XML = <<EOF
+<?xml version="1.0"?>
+<RESTResponse>
+  <Tokens>
+    <TokenId>JPMQARDVJK</TokenId>
+    <Status>Active</Status>
+  </Tokens>
+  <Tokens>
+    <TokenId>RDVJKJPMQA</TokenId>
+    <Status>Inactive</Status>
+  </Tokens>
+  <Status>Success</Status>
+  <RequestId valid="true">44287</RequestId>
+</RESTResponse>
+EOF
+
+class TestResponse < Relax::Response
+  class Token < Relax::Response
+    parameter :token_id, :element => :tokenid
+    parameter :status
+  end
+
+  parameter :status
+  parameter :request_id, :element => :requestid, :type => :integer
+  parameter :valid_request, :element => :requestid, :attribute => :valid
+  parameter :tokens, :collection => Token
+end
+
+describe 'a response' do
+  before(:each) do
+    @response = Relax::Response.new(XML)
+  end
+
+  it 'should allow access to the root' do
+    root = @response.root
+    root.should be_an_instance_of(Hpricot::Elem)
+    root.name.should eql('restresponse')
+  end
+
+  it 'should be checkable by the name of its root' do
+    @response.is?(:RESTResponse).should be_true
+  end
+
+  it 'should allow access to an element by its name' do
+    @response.element(:RequestId).should be_an_instance_of(Hpricot::Elem)
+  end
+
+  it 'should allow access to an element\'s elements by its name' do
+    tokens = @response.elements(:Tokens)
+    tokens.should be_an_instance_of(Hpricot::Elements)
+    tokens.should_not be_empty
+  end
+
+  it 'should allow access to an element\'s value by its name' do
+    token = Relax::Response.new(@response.elements(:Tokens).first)
+    token.element(:TokenId).inner_text.should eql('JPMQARDVJK')
+    token.element(:Status).inner_text.should eql('Active')
+  end
+
+  it 'should have a means of checking for the existence of a node' do
+    @response.has?(:Status).should_not be_nil
+    @response.has?(:Errors).should be_nil
+  end
+
+  it 'should be able to define children of Request without modifying parent' do
+    Relax::Response.new(XML).respond_to?(:status).should be_false
+    TestResponse.new(XML).respond_to?(:status).should be_true
+  end
+
+  it 'should automatically pull parameters from the XML' do
+    response = TestResponse.new(XML)
+    response.status.should eql('Success')
+    response.request_id.should eql(44287)
+    response.valid_request.should eql('true')
+    response.tokens.length.should eql(2)
+    response.tokens.first.status.should eql('Active')
+  end
+end

data/spec/symbolic_hash_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'relax/symbolic_hash'
+
+describe 'a symbolic hash' do
+  before(:each) do
+    @url = 'http://example.com/'
+    @query = Relax::SymbolicHash.new
+  end
+
+  it 'should be accessible via string or symbol keys' do
+    @query[:amount] = 10
+    @query[:amount].should == 10
+    @query['amount'].should == 10
+  end
+
+  it 'should convert keys to symbols' do
+    @query['symbol'] = 'aleph'
+    @query[:symbol].should == 'aleph'
+  end
+
+  it 'should convert keys to symbols' do
+    @query['symbol'] = 'aleph'
+    @query[:symbol].should == 'aleph'
+  end
+
+  it 'should test for keys by symbol' do
+    @query[:symbol] = 'aleph'
+    @query.key?('symbol').should be_true
+  end
+
+  it 'should delete values with a symbolic key' do
+    @query[:symbol] = 'aleph'
+    @query.delete('symbol')
+    @query.key?(:symbol).should be_false
+  end
+
+  it 'should be mergeable' do
+    @query[:one] = 2
+    merged_query = @query.merge({ :one => 1, :two => 2 })
+    merged_query[:one].should == 1
+    merged_query[:two].should == 2
+  end
+
+  it 'should be able to duplicate itself' do
+    @query[:one] = 'uno'
+    @query[:two] = 'dos'
+    new_query = @query.dup
+    new_query[:one].should == 'uno'
+    new_query[:two].should == 'dos'
+
+    @query[:three] == 'tres'
+    new_query.key?(:three).should be_false
+  end
+
+  it 'should be able to get multiple values by symbol' do
+    @query[:one] = 1
+    @query[:two] = 2
+    @query.values_at(:one, :two).should == [1, 2]
+  end
+
+  it 'should be instantiable with a hash' do
+    query = Relax::SymbolicHash.new({ :one => 1, :two => 2 })
+    query[:one].should == 1
+    query[:two].should == 2
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: relax
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-09-24 00:00:00 -04:00
+summary: A simple library for creating REST consumers.
+require_paths: 
+- lib
+email: tyler@protoh.com
+homepage: http://protoh.com/
+rubyforge_project: 
+description: 
+autorequire: relax
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Tyler Hunt
+files: 
+- lib/relax.rb
+- lib/relax
+- lib/relax/response.rb
+- lib/relax/api.rb
+- lib/relax/request.rb
+- lib/relax/query.rb
+- lib/relax/symbolic_hash.rb
+- README
+- LICENSE
+test_files: 
+- spec/request_spec.rb
+- spec/symbolic_hash_spec.rb
+- spec/query_spec.rb
+- spec/response_spec.rb
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.5"
+    version: