relax 0.0.7 → 0.1.0

data/lib/relax/parsers/hpricot.rb

@@ -1,133 +0,0 @@
-require 'rubygems'
-require 'hpricot'
-
-module Relax
-  module Parsers
-    # Parses the server's raw response using the Hpricot library.
-    class Hpricot < Base
-      FACTORY_NAME = :hpricot
-
-      def initialize(raw, parent)
-        @xml = ::Hpricot.XML(raw)
-        super(raw, parent)
-      end
-
-      def parse!
-        if parameters
-          parameters.each do |parameter, options|
-            begin
-              element = options[:element] || parameter
-
-              node = case
-                when options[:attribute] && options[:attribute] == true
-                  attribute(root, element)
-                when options[:attribute]
-                  attribute(element(element), options[:attribute])
-                when options[:collection]
-                  elements(element)
-                else
-                  element(element)
-              end
-
-              if options[:collection]
-                value = node.collect do |element|
-                  options[:collection].new(element)
-                end
-              else
-                value = case type = options[:type]
-                  when Response
-                    type.new(node)
-                  when :date
-                    date_value(node)
-                  when :time
-                    time_value(node)
-                  when :float
-                    float_value(node)
-                  when :integer
-                    integer_value(node)
-                  when :text
-                  else
-                    text_value(node)
-                end
-              end
-
-              parent.instance_variable_set("@#{parameter}", value)
-            rescue ::Hpricot::Error
-              raise Relax::MissingParameter if options[:required]
-            end
-          end
-        end
-      end
-
-      # Returns the root of the XML document.
-      def root
-        @xml.root
-      end
-
-      # Checks the name of the root node.
-      def is?(name)
-        root.name.gsub(/.*:(.*)/, '\1') == node_name(name)
-      end
-
-      # Returns a set of elements matching name.
-      def elements(name)
-        root.search(root_path(name))
-      end
-
-      # Returns an element of the specified name.
-      def element(name)
-        root.at(root_path(name))
-      end
-      alias :has? :element
-
-      # Returns an attribute on an element.
-      def attribute(element, name)
-        element[name]
-      end
-
-      # Gets the value of an element or attribute.
-      def value(value)
-        value.is_a?(::Hpricot::Elem) ? value.inner_text : value.to_s
-      end
-
-      # Gets a text value.
-      def text_value(value)
-        value(value)
-      end
-
-      # Gets an integer value.
-      def integer_value(value)
-        value(value).to_i
-      end
-
-      # Gets a float value.
-      def float_value(value)
-        value(value).to_f
-      end
-
-      # Gets a date value.
-      def date_value(value)
-        Date.parse(value(value))
-      end
-
-      # Gets a time value.
-      def time_value(value)
-        Time.parse(value(value))
-      end
-
-      # Converts a name to a node name.
-      def node_name(name)
-        @parent.node_name(name)
-      end
-      private :node_name
-
-      # Gets the XPath expression representing the root node.
-      def root_path(name)
-        "/#{node_name(name)}"
-      end
-      private :root_path
-    end
-
-    Factory.register(Hpricot::FACTORY_NAME, Hpricot)
-  end
-end

data/lib/relax/parsers/rexml.rb

@@ -1,147 +0,0 @@
-require 'rubygems'
-require 'rexml/document'
-
-module Relax
-  module Parsers
-    # Parsers the server's response using the REXML library.
-    #
-    # Benefits:
-    #
-    # * XML Namespace support (parameter :foo, :namespace => 'bar')
-    #
-    # Drawbacks:
-    #
-    # * Case sensitive field names (<Status>..</> != parameter :status)
-    class REXML < Base
-      FACTORY_NAME = :rexml
-
-      def initialize(raw, parent)
-        @xml = ::REXML::Document.new(raw)
-        super(raw, parent)
-      end
-
-      def parse!
-        if parameters
-          parameters.each do |parameter, options|
-            begin
-              element = options[:element] || parameter
-              namespace = options[:namespace]
-
-              node = case
-                when options[:attribute] && options[:attribute] == true
-                  attribute(root, element, namespace)
-                when options[:attribute]
-                  attribute(element(element), options[:attribute], namespace)
-                when options[:collection]
-                  elements(element, namespace)
-                else
-                  element(element, namespace)
-              end
-
-              if options[:collection]
-                value = node.collect do |element|
-                  options[:collection].new(element.to_s)
-                end
-              else
-                value = case type = options[:type]
-                  when Response
-                    type.new(node)
-                  when :date
-                    date_value(node)
-                  when :time
-                    time_value(node)
-                  when :float
-                    float_value(node)
-                  when :integer
-                    integer_value(node)
-                  when :text
-                  else
-                    text_value(node)
-                end
-              end
-
-              parent.instance_variable_set("@#{parameter}", value)
-            rescue
-              raise(Relax::MissingParameter) if node.nil? && options[:required]
-            end
-          end
-        end
-      end
-
-      # Returns the root of the XML document.
-      def root
-        @xml.root
-      end
-
-      # Checks the name of the root node.
-      def is?(name, namespace=nil)
-        root.name == node_name(name, nil)
-      end
-
-      # Returns a set of elements matching name.
-      def elements(name, namespace=nil)
-        root.get_elements(node_path(name, namespace))
-      end
-
-      # Returns an element of the specified name.
-      def element(name, namespace=nil)
-        root.elements[node_path(name, namespace)]
-      end
-      alias :has? :element
-
-      # Returns an attribute on an element.
-      def attribute(element, name, namespace=nil)
-        element.attribute(name)
-      end
-
-      # Gets the value of an element or attribute.
-      def value(value)
-        value.is_a?(::REXML::Element) ? value.text : value.to_s
-      end
-
-      # Gets a text value.
-      def text_value(value)
-        value(value)
-      end
-
-      # Gets an integer value.
-      def integer_value(value)
-        value(value).to_i
-      end
-
-      # Gets a float value.
-      def float_value(value)
-        value(value).to_f
-      end
-
-      # Gets a date value.
-      def date_value(value)
-        Date.parse(value(value))
-      end
-
-      # Gets a time value.
-      def time_value(value)
-        Time.parse(value(value))
-      end
-
-      # Converts a name to a node name.
-      def node_name(name, namespace=nil)
-        @parent.node_name(name, namespace)
-      end
-      private :node_name
-
-      # Gets the XPath expression representing the root node.
-      def root_path(name)
-        "/#{node_name(name)}"
-      end
-      private :root_path
-
-      def node_path(name, namespace=nil)
-        "#{node_name(name, namespace)}"
-      end
-      private :node_path
-    end
-
-    Factory.register(REXML::FACTORY_NAME, REXML)
-  end
-end

data/lib/relax/parsers.rb

@@ -1,13 +0,0 @@
-require 'date'
-require 'time'
-
-require 'relax/parsers/factory'
-require 'relax/parsers/base'
-
-require 'relax/parsers/hpricot'
-require 'relax/parsers/rexml'
-
-module Relax
-  module Parsers
-  end
-end

data/lib/relax/query.rb

@@ -1,46 +0,0 @@
-require 'cgi'
-require 'uri'
-
-require 'relax/symbolic_hash'
-
-module Relax
-  # Query is used to represent the query portion of a URL. It's basically just
-  # a hash, where each key/value pair is a query parameter.
-  class Query < SymbolicHash
-    # Converts the Query to a query string for use in a URL.
-    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
-      # Parses a URL and returns a Query with its query portion.
-      def parse(uri)
-        query = uri.query.split('&').inject({}) do |query, parameter|
-          key, value = parameter.split('=', 2)
-          query[unescape_value(key)] = unescape_value(value)
-          query
-        end
-        self.new(query)
-      end
-
-      # Escapes a query parameter value.
-      def escape_value(value)
-        CGI.escape(value.to_s).gsub('%20', '+')
-      end
-
-      # Unescapes a query parameter value.
-      def unescape_value(value)
-        CGI.unescape(value)
-      end
-    end
-
-    protected
-
-    # Converts each value of the Query to a string as it's added.
-    def convert_value(value)
-      value.to_s
-    end
-  end
-end

data/lib/relax/request.rb

@@ -1,107 +0,0 @@
-require 'relax/query'
-
-module Relax
-  # Request is intended to be a parent class for requests passed to
-  # Service#call.
-  class Request
-    @parameters = {}
-
-    # New takes an optional hash of default parameter values. When passed,
-    # the values will be set on the request if the key exists as a valid
-    # parameter name.
-    def initialize(defaults={})
-      # initialize default parameter values
-      self.class.parameters.each do |parameter, options|
-        if defaults.has_key?(parameter)
-          value = defaults[parameter]
-        elsif options[:value]
-          value = options[:value]
-        end
-
-        instance_variable_set("@#{parameter}", value) if value
-      end
-    end
-
-    # Converts this request into a Query object.
-    def to_query
-      self.class.parameters.keys.inject(Query.new) do |query, key|
-        value = send(key)
-        options = self.class.parameters[key]
-
-        if value && !options[:type]
-          query[convert_key(key)] = value if value
-        elsif options[:type]
-          options[:type].parameters.each do |parameter, options|
-            query[convert_complex_key(key, parameter)] = value.send(parameter) if value
-          end
-        end
-
-        query
-      end
-    end
-
-    # Converts this request into a query string for use in a URL.
-    def to_s
-      to_query.to_s
-    end
-
-    # Checks the validity of the property values in this request.
-    def valid?
-      self.class.parameters.each do |key, options|
-        if options[:required]
-          value = send(key)
-          raise Relax::MissingParameter if value.nil?
-        end
-      end
-    end
-
-    # Converts a key when the Request is converted to a query. By default, no
-    # conversion actually takes place, but this method can be overridden by
-    # child classes to perform standard manipulations, such as replacing
-    # underscores.
-    def convert_key(key)
-      key
-    end
-    protected :convert_key
-
-    # Converts a complex key (i.e. a parameter with a custom type) when the
-    # Request is converted to a query. By default, this means the key name and
-    # the parameter name separated by two underscores. This method can be
-    # overridden by child classes.
-    def convert_complex_key(key, parameter)
-      "#{convert_key(key)}.#{convert_key(parameter)}"
-    end
-    protected :convert_complex_key
-
-    class << self
-      # Create the parameters hash for the subclass.
-      def inherited(subclass) #:nodoc:
-        subclass.instance_variable_set('@parameters', {})
-      end
-
-      # Specifies a parameter to create on the request class.
-      #
-      # Options:
-      # - <tt>:type</tt>: An optional custom data type for the parameter.
-      #   This must be a class that is a descendent of Request.
-      # - <tt>:value</tt>: The default value for this parameter.
-      def parameter(name, options = {})
-        attr_accessor name
-        options = @parameters[name].merge(options) if @parameters.has_key?(name)
-        @parameters[name] = options
-      end
-
-      # Adds a template value to a request class. Equivalent to creating a
-      # parameter with a default value.
-      def []=(key, value)
-        parameter(key, :value => value)
-      end
-
-      # Returns a hash of all of the parameters for this request, including
-      # those that are inherited.
-      def parameters #:nodoc:
-        (superclass.respond_to?(:parameters) ? superclass.parameters : {}).merge(@parameters)
-      end
-    end
-  end
-end

data/lib/relax/response.rb

@@ -1,82 +0,0 @@
-module Relax
-  # Response is intended to be a parent class for responses passed to
-  # Service#call.
-  #
-  # A response is in essence an object used to facilitate XML parsing. It
-  # stores an XML document, and provides access to it through methods like
-  # #element and #attribute.
-  class Response
-    attr_accessor :raw
-
-    # New takes in and parses the raw response.
-    #
-    # This will raise a MissingParameter error if a parameterd marked as
-    # required is not present in the parsed response.
-    def initialize(xml)
-      @raw = xml
-      @parser = Relax::Parsers::Factory.get(parser_name).new(xml.to_s, self)
-    end
-
-    def parser_name #:nodoc:
-      self.class.instance_variable_get('@parser') || :default
-    end
-
-    def node_name(name, namespace=nil) #:nodoc:
-      "#{namespace.to_s + ':' if namespace}#{name}"
-    end
-
-    def method_missing(method, *args) #:nodoc:
-      if @parser.respond_to?(method)
-        @parser.__send__(method, *args)
-      else
-        super
-      end
-    end
-
-    class << self
-      # When a Response is extended, the superclass's parameters are copied
-      # into the new class. This behavior has the following side-effect: if
-      # parameters are added to the superclass after it has been extended,
-      # those new paramters won't be passed on to its children. This shouldn't
-      # be a problem in most cases.
-      def inherited(subclass)
-        @parameters.each do |name, options|
-          subclass.parameter(name, options)
-        end if @parameters
-
-        subclass.parser(@parser) if @parser
-      end
-
-      # Specifes a parameter that will be automatically parsed when the
-      # Response is instantiated.
-      #
-      # Options:
-      # - <tt>:attribute</tt>: An attribute name to use, or <tt>true</tt> to
-      #   use the <tt>:element</tt> value as the attribute name on the root.
-      # - <tt>:collection</tt>: A class used to instantiate each item when
-      #   selecting a collection of elements.
-      # - <tt>:element</tt>: The XML element name.
-      # - <tt>:object</tt>: A class used to instantiate an element.
-      # - <tt>:type</tt>: The type of the parameter. Should be one of
-      #   <tt>:text</tt>, <tt>:integer</tt>, <tt>:float</tt>, or <tt>:date</tt>.
-      def parameter(name, options={})
-        attr_accessor name
-        @parameters ||= {}
-        @parameters[name] = options
-      end
-
-      # Specifies the parser to use when decoding the server response. If no
-      # parser is specified for the response, then the default parser will be
-      # used.
-      #
-      # See Relax::Parsers for a list of available parsers.
-      def parser(name)
-        @parser ||= name
-      end
-
-      def ===(response)
-        response.is_a?(Class) ? response.ancestors.include?(self) : super
-      end
-    end
-  end
-end

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?
-
-    def convert_key(key)
-      !key.kind_of?(Symbol) ? key.to_sym : key
-    end
-    protected :convert_key
-
-    def convert_value(value)
-      value
-    end
-    protected :convert_value
-  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,31 +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,36 +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