tylerhunt-relax 0.0.5 → 0.1.1

data/lib/relax/parsers/hpricot.rb

@@ -1,145 +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
-
-              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 type = options[:type]
-                  when Response
-                    value = type.new(node)
-
-                  when :date
-                    value = date_value(node)
-
-                  when :time
-                    value = time_value(node)
-
-                  when :float
-                    value = float_value(node)
-
-                  when :integer
-                    value = integer_value(node)
-
-                  when :text
-                  else
-                    value = 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
-      
-      
-      private
-      
-      
-      # Converts a name to a node name.
-      def node_name(name)
-        name.to_s
-      end
-
-      # Gets the XPath expression representing the root node.
-      def root_path(name)
-        "/#{node_name(name)}"
-      end
-      
-    end
-    
-    Factory.register(Hpricot::FACTORY_NAME, Hpricot)
-    
-  end
-end

data/lib/relax/parsers/rexml.rb

@@ -1,158 +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]
-            
-              if attribute = options[:attribute] and attribute == true
-                node = attribute(root, element, namespace)
-              elsif attribute
-                node = attribute(element(element), attribute, namespace)
-              elsif options[:collection]
-                node = elements(element, namespace)
-              else
-                node = element(element, namespace)
-              end
-              
-              if options[:collection]
-                value = node.collect do |element|
-                  options[:collection].new(element.deep_clone)
-                end
-              else
-                case type = options[:type]
-                  when Response
-                    value = type.new(node)
-            
-                  when :date
-                    value = date_value(node)
-            
-                  when :time
-                    value = time_value(node)
-            
-                  when :float
-                    value = float_value(node)
-            
-                  when :integer
-                    value = integer_value(node)
-            
-                  when :text
-                  else
-                    value = 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
-      
-      
-      private
-      
-      
-      # Converts a name to a node name.
-      def node_name(name, namespace = nil)
-        "#{namespace.to_s + ':' if namespace}#{name}"
-      end
-
-      # Gets the XPath expression representing the root node.
-      def root_path(name)
-        "/#{node_name(name)}"
-      end
-      
-      def node_path(name, namespace = nil)
-        "#{node_name(name, namespace)}"
-      end
-      
-    end
-    
-    Factory.register(REXML::FACTORY_NAME, REXML)
-    
-  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,95 +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
-
-    # 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,78 +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
-      self.class.instance_variable_get('@parser') || :default
-    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