tylerhunt-relax 0.0.5 → 0.1.1

data/lib/relax/symbolic_hash.rb

@@ -1,79 +0,0 @@
-module Relax
-  # SymbolicHash provides an extension of Hash, but one that only supports keys
-  # that are symbols. This has been done in an effort to prevent the case where
-  # both a string key and a symbol key are set on the same hash, and espcially
-  # for dealing with this particular case when convert the hash to a string.
-  #
-  # === Example
-  #
-  #   hash = Relax::SymbolicHash.new
-  #   hash[:one] = 1
-  #   hash['one'] = 2
-  #   puts hash[:one] # => 2
-  #
-  # === Credits
-  #
-  # Some of the inspiration (and code) for this class comes from the
-  # HashWithIndifferentAccess that ships with Rails.
-  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 :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 :include? :key?
-    alias :has_key? :key?
-    alias :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/spec/parsers/factory_spec.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-require 'relax'
-require 'relax/parsers/factory'
-
-class TestParser ; end
-
-describe 'a parser factory' do
-  
-  before(:each) do
-    @factory = Relax::Parsers::Factory
-    Relax::Parsers::Factory.register(:test, TestParser)
-  end
-  
-  it 'should raise UnrecognizedParser for un-registered names' do
-    lambda {
-      @factory.get(:bad_name)
-    }.should raise_error(Relax::UnrecognizedParser)
-  end
-  
-  it 'should return a registered parser class' do
-    @factory.get(:test).should ==TestParser
-  end
-  
-  it 'should register the first registered parser as the default' do
-    @factory.get(:default).should ==Relax::Parsers::Hpricot
-  end
-  
-end

data/spec/parsers/hpricot_spec.rb

@@ -1,35 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../parser_helper'
-
-
-class HpricotTestResponse < Relax::Response
-  class Token < Relax::Response
-    parser :hpricot
-    parameter :token_id, :element => :tokenid
-    parameter :status
-  end
-
-  class Error < Relax::Response
-    parser :hpricot
-    parameter :code, :type => :integer
-    parameter :message
-  end
-  
-  parser :hpricot
-  parameter :status, :required => true
-  parameter :request_id, :element => :requestid, :type => :integer
-  parameter :valid_request, :element => :requestid, :attribute => :valid
-  parameter :tokens, :collection => Token
-  parameter :error, :type => Error
-end
-
-
-describe 'an Hpricot parser' do
-  
-  before(:each) do
-    @response = HpricotTestResponse.new(XML)
-  end
-  
-  it_should_behave_like 'a successfully parsed response'
-  
-end

data/spec/parsers/rexml_spec.rb

@@ -1,40 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../parser_helper'
-
-
-class RexmlTestResponse < Relax::Response
-  class Token < Relax::Response
-    parser :rexml
-    parameter :token_id,  :element => 'TokenId'
-    parameter :status,    :element => 'Status'
-  end
-  
-  class Error < Relax::Response
-    parser :rexml
-    parameter :code,      :element => 'Code',         :type => :integer
-    parameter :message,   :element => 'Message'
-  end
-  
-  parser :rexml
-  parameter :status,        :element => 'Status',     :required => true
-  parameter :request_id,    :element => 'RequestId',  :type => :integer
-  parameter :valid_request, :element => 'RequestId',  :attribute => :valid
-  parameter :namespace,     :element => 'Namespace',  :namespace => 'ns1'
-  parameter :tokens,        :element => 'Tokens',     :collection => Token
-  parameter :error,         :element => 'Error',      :type => Error
-end
-
-
-describe 'a REXML parser' do
-  
-  before(:each) do
-    @response = RexmlTestResponse.new(XML)
-  end
-  
-  it_should_behave_like 'a successfully parsed response'
-  
-  it 'should parse namespaced parameters' do
-    @response.namespace.should eql('Passed')
-  end
-  
-end

data/spec/query_spec.rb

@@ -1,60 +0,0 @@
-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 eql('action=Search&query=strings')
-  end
-
-  it 'should convert its values to strings' do
-    date = Date.today
-    @query[:date] = date
-    @query.to_s.should eql("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 eql('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 eql('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 eql('search')
-    parsed_query[:query].should eql('keyword')
-  end
-  
-  it 'should parse key value pairs into only two parts' do
-    parsed_query = Relax::Query.parse(URI.parse("http://example.com/?action=test=&foo=bar"))
-    parsed_query[:action].should eql('test=')
-  end
-  
-  it 'should unescape query string key-value pair keys' do
-    parsed_query = Relax::Query.parse(URI.parse("http://example.com/?action%20helper=test"))
-    parsed_query[:"action helper"].should eql('test')
-  end
-  
-  it 'should unescape query string key-value pair values' do
-    parsed_query = Relax::Query.parse(URI.parse("http://example.com/?action=test%20action"))
-    parsed_query[:action].should eql('test action')
-  end
-end

data/spec/request_spec.rb

@@ -1,108 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-require 'relax/request'
-
-class Amount < Relax::Request
-  parameter :amount
-  parameter :currency
-end
-
-class TestRequest < Relax::Request
-  parameter :action
-  parameter :token_id
-  parameter :user_id
-  parameter :amount, :type => Amount
-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
-    @query[:amount].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
-    @query.key?(:amount).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
-    # this syntax may need to go away unless we can find a way to make it work 
-    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
-
-describe 'a request with a custom type' do
-  before(:each) do
-    request = TestRequest.new(:action => 'Pay', :token_id => 123)
-    request.amount = Amount.new(:amount => 3.50, :currency => 'USD')
-    @query = request.to_query
-  end
-
-  it 'should add the type parameters to the query' do
-    @query.key?(:"amount.amount").should be_true
-    @query.key?(:"amount.currency").should be_true
-  end
-end

data/spec/response_spec.rb

@@ -1,98 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-
-class BaseResponse < Relax::Response
-  parameter :status, :required => true
-  parameter :request_id, :element => :requestid, :type => :integer
-end
-
-class TestResponse < BaseResponse
-  class Token < Relax::Response
-    parameter :token_id, :element => :tokenid
-    parameter :status
-  end
-
-  class Error < Relax::Response
-    parser :hpricot
-    parameter :code, :type => :integer
-    parameter :message
-  end
-
-  parameter :valid_request, :element => :requestid, :attribute => :valid
-  parameter :tokens, :collection => Token
-  parameter :error, :type => Error
-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 Response 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.valid_request.should eql('true')
-    response.tokens.length.should eql(2)
-    response.tokens.first.status.should eql('Active')
-    response.error.code.should eql(1)
-    response.error.message.should eql('Failed')
-  end
-
-  it "should automatically pull its parent's parameters from the XML" do
-    response = TestResponse.new(XML)
-    response.status.should eql('Success')
-    response.request_id.should eql(44287)
-  end
-
-  it 'should be relationally equivalent to its children' do
-    (Relax::Response === TestResponse).should be_true
-  end
-
-  it 'should raise MissingParameter if required parameters are missing' do
-    proc { TestResponse.new('') }.should raise_error(Relax::MissingParameter)
-  end
-  
-  it 'should use the default parser when undefined' do
-    TestResponse::Token.new('').parser_name.should ==:default
-  end
-  
-  it 'should use the defined parser when given' do
-    TestResponse::Error.new('').parser_name.should ==:hpricot
-  end
-end