rets4r 0.8.5 → 1.1.18

data/lib/rets4r/client/parsers/response_parser.rb

@@ -0,0 +1,100 @@
+require 'rets4r/client/transaction'
+require 'rets4r/client/parsers/compact'
+require 'rexml/document'
+
+module RETS4R
+  class Client
+    class ResponseParser
+      def parse_key_value(xml)
+        parse_common(xml) do |doc|
+          parsed = nil
+          first_child = doc.get_elements('/RETS/RETS-RESPONSE')[0] ? doc.get_elements('/RETS/RETS-RESPONSE')[0] : doc.get_elements('/RETS')[0]
+          unless first_child.nil?
+            parsed = {}
+            first_child.text.each do |line|
+              (key, value) = line.strip.split('=')
+              key.strip! if key
+              value.strip! if value
+              parsed[key] = value
+            end
+          else
+            raise 'Response was not a proper RETS XML doc!'
+          end
+
+          if parsed.nil?
+            raise "Response was not valid key/value format"
+          else
+            parsed
+          end
+        end
+      end
+
+      def parse_results(xml, format)
+        parse_common(xml) do |doc|
+          parser = get_parser_by_name(format)
+          parser.parse_results(doc)
+        end
+      end
+
+      def parse_count(xml)
+        parse_common(xml) do |doc|
+          doc.get_elements('/RETS/COUNT')[0].attributes['Records']
+        end
+      end
+
+      def parse_metadata(xml, format)
+        parse_common(xml) do |doc|
+          return REXML::Document.new(xml)
+        end
+      end
+
+      def parse_object_response(xml)
+        parse_common(xml) do |doc|
+          # XXX
+        end
+      end
+
+      private
+
+      def parse_common(xml, &block)
+        if xml == ''
+          raise RETSException, 'No transaction body was returned!'
+        end
+
+        doc = REXML::Document.new(xml)
+
+        root = doc.root
+        if root.nil? || root.name != 'RETS'
+          raise "Response had invalid root node. Document was: #{doc.inspect}"
+        end
+
+        transaction = Transaction.new
+        transaction.reply_code = root.attributes['ReplyCode']
+        transaction.reply_text = root.attributes['ReplyText']
+        transaction.maxrows    = (doc.get_elements('/RETS/MAXROWS').length > 0)
+
+
+        # XXX: If it turns out we need to parse the response of errors, then this will
+        # need to change.
+        if transaction.reply_code.to_i > 0 && transaction.reply_code.to_i != 20201
+          exception_type = Client::EXCEPTION_TYPES[transaction.reply_code.to_i] || RETSTransactionException
+          raise exception_type, "#{transaction.reply_code} - #{transaction.reply_text}"
+        end
+
+        transaction.response = yield doc
+        return transaction
+      end
+
+      def get_parser_by_name(name)
+        case name
+          when 'COMPACT', 'COMPACT-DECODED'
+            type = RETS4R::Client::CompactDataParser
+          else
+            raise "Invalid format #{name}"
+        end
+        type.new
+      end
+    end
+  end
+end
+

data/lib/rets4r/client/requester.rb

@@ -0,0 +1,143 @@
+require 'rets4r'
+require 'rets4r/client/exceptions'
+
+module RETS4R
+  class Client
+    class Requester
+      DEFAULT_USER_AGENT      = "rets4r/#{::RETS4R::VERSION}"
+      DEFAULT_RETS_VERSION    = '1.7'
+
+      attr_accessor :logger, :headers, :pre_request_block, :nc, :username, :password, :method
+      def initialize
+        @nc = 0
+        @headers = {
+          'User-Agent'   => DEFAULT_USER_AGENT,
+          'Accept'       => '*/*',
+          'RETS-Version' => "RETS/#{DEFAULT_RETS_VERSION}",
+        }
+        @pre_request_block = nil
+      end
+
+      def user_agent
+        @headers['User-Agent']
+      end
+
+      def user_agent=(name)
+        set_header('User-Agent', name)
+      end
+
+      def rets_version=(version)
+        if (SUPPORTED_RETS_VERSIONS.include? version)
+          set_header('RETS-Version', "RETS/#{version}")
+        else
+          raise Unsupported.new("The client does not support RETS version '#{version}'.")
+        end
+      end
+
+      def rets_version
+        (@headers['RETS-Version'] || "").gsub("RETS/", "")
+      end
+
+      def set_header(name, value)
+        if value.nil? then
+          @headers.delete(name)
+        else
+          @headers[name] = value
+        end
+
+        logger.debug("Set header '#{name}' to '#{value}'") if logger
+      end
+
+      def user_agent
+        @headers['User-Agent']
+      end
+
+      # Given a hash, it returns a URL encoded query string.
+      def create_query_string(hash)
+        parts = hash.map {|key,value| "#{CGI.escape(key)}=#{CGI.escape(value)}" unless key.nil? || value.nil?}
+        return parts.join('&')
+      end
+      # This is the primary transaction method, which the other public methods make use of.
+      # Given a url for the transaction (endpoint) it makes a request to the RETS server.
+      #
+      #--
+      # This needs to be better documented, but for now please see the public transaction methods
+      # for how to make use of this method.
+      #++
+      def request(url, data = {}, header = {}, method = @method, retry_auth = DEFAULT_RETRY)
+        response = ''
+
+        http = Net::HTTP.new(url.host, url.port)
+        http.read_timeout = 600
+
+        if logger && logger.debug?
+          http.set_debug_output HTTPDebugLogger.new(logger)
+        end
+
+        http.start do |http|
+          begin
+            uri = url.path
+
+            if ! data.empty? && method == METHOD_GET
+              uri += "?#{create_query_string(data)}"
+            end
+
+            headers = @headers
+            headers.merge(header) unless header.empty?
+
+            @pre_request_block.call(self, http, headers) if @pre_request_block
+
+            logger.debug(headers.inspect) if logger
+
+            post_data = data.map {|k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&') if method == METHOD_POST
+            response  = method == METHOD_POST ? http.post(uri, post_data, headers) :
+                                                http.get(uri, headers)
+
+
+            if response.code == '401'
+              # Authentication is required
+              raise AuthRequired
+            elsif response.code.to_i >= 300
+              # We have a non-successful response that we cannot handle
+              raise HTTPError.new(response)
+            else
+              cookies = []
+              if set_cookies = response.get_fields('set-cookie') then
+                set_cookies.each do |cookie|
+                  cookies << cookie.split(";").first
+                end
+              end
+              set_header('Cookie', cookies.join("; ")) unless cookies.empty?
+              # totally wrong. session id is only ever under the Cookie header
+              #set_header('RETS-Session-ID', response['RETS-Session-ID']) if response['RETS-Session-ID'] 
+              set_header('RETS-Session-ID',nil)
+            end
+          rescue AuthRequired
+            @nc += 1
+
+            if retry_auth > 0
+              retry_auth -= 1
+                        auth = Auth.authenticate(response,
+                                                                           @username,
+                                                                           @password,
+                                                                           url.path,
+                                                                           method,
+                                                                           @headers['RETS-Request-ID'],
+                                                                           @headers['User-Agent'],
+                                                                           @nc)
+              set_header('Authorization', auth)
+              retry
+            else
+              raise LoginError.new(response.message)
+            end
+          end
+
+          logger.debug(response.body) if logger
+        end
+
+        return response
+      end
+
+    end
+  end
+end

data/lib/rets4r/client/transaction.rb

@@ -1,34 +1,31 @@
 module RETS4R
-	class Client
-		class Transaction
-			attr_accessor :reply_code, :reply_text, :response, :metadata, :header, :data, :maxrows, 
-				:count, :delimiter, :secondary_response
-			
-			def initialize
-				self.maxrows = false
-				self.header = []
-				self.data = []
-				self.delimiter = ?\t
-			end
-			
-			def success?
-				return true if self.reply_code == '0'
-				return false
-			end
-			
-			def has_data?
-				return true if self.data.length > 0
-				return false
-			end
-			
-			def maxrows?
-				return true if self.maxrows
-				return false
-			end
-			
-			def ascii_delimiter
-				self.delimiter.chr
-			end
-		end
-	end
-end
+  class Client
+    class Transaction
+      attr_accessor :reply_code, :reply_text, :response, :metadata,
+        :header, :maxrows, :delimiter, :secondary_response
+
+      def initialize
+        self.maxrows = false
+        self.header = []
+        self.delimiter = ?\t
+      end
+
+      def success?
+        return true if self.reply_code == '0'
+        return false
+      end
+
+      def maxrows?
+        return true if self.maxrows
+        return false
+      end
+
+      def ascii_delimiter
+        self.delimiter.chr
+      end
+
+      # For compatibility with the original library.
+      alias :data :response
+    end
+  end
+end

data/lib/rets4r/core_ext/array/extract_options.rb

@@ -0,0 +1,15 @@
+# from ActiveSupport
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end

data/lib/rets4r/core_ext/class/attribute_accessors.rb

@@ -0,0 +1,58 @@
+require 'rets4r/core_ext/array/extract_options'
+# from ActiveSupport
+
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+#
+#  class Person
+#    cattr_accessor :hair_colors
+#  end
+#
+#  Person.hair_colors = [:brown, :black, :blonde, :red]
+class Class
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}  # unless defined? @@hair_colors
+          @@#{sym} = nil          #   @@hair_colors = nil
+        end                       # end
+                                  #
+        def self.#{sym}           # def self.hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+                                  #
+        def #{sym}                # def hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.extract_options!
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}                       # unless defined? @@hair_colors
+          @@#{sym} = nil                               #   @@hair_colors = nil
+        end                                            # end
+                                                       #
+        def self.#{sym}=(obj)                          # def self.hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
+      EOS
+      self.send("#{sym}=", yield) if block_given?
+    end
+  end
+
+  def cattr_accessor(*syms, &blk)
+    cattr_reader(*syms)
+    cattr_writer(*syms, &blk)
+  end
+end

data/lib/rets4r/core_ext/hash/keys.rb

@@ -0,0 +1,46 @@
+# from ActiveSupport
+class Hash
+  # Return a new hash with all keys converted to strings.
+  def stringify_keys
+    dup.stringify_keys!
+  end
+
+  # Destructively convert all keys to strings.
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+.
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+
+  alias_method :to_options,  :symbolize_keys
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+  # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+  # as keys, this will fail.
+  #
+  # ==== Examples
+  #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    unknown_keys = keys - [valid_keys].flatten
+    raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+  end
+end

data/lib/rets4r/core_ext/hash/slice.rb

@@ -0,0 +1,39 @@
+# from ActiveSupport
+class Hash
+  # Slice a hash to include only the given keys. This is useful for
+  # limiting an options hash to valid keys before passing to a method:
+  #
+  #   def search(criteria = {})
+  #     assert_valid_keys(:mass, :velocity, :time)
+  #   end
+  #
+  #   search(options.slice(:mass, :velocity, :time))
+  #
+  # If you have an array of keys you want to limit to, you should splat them:
+  #
+  #   valid_keys = [:mass, :velocity, :time]
+  #   search(options.slice(*valid_keys))
+  def slice(*keys)
+    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+    hash = self.class.new
+    keys.each { |k| hash[k] = self[k] if has_key?(k) }
+    hash
+  end
+
+  # Replaces the hash with only the given keys.
+  # Returns a hash contained the removed key/value pairs
+  #   {:a => 1, :b => 2, :c => 3, :d => 4}.slice!(:a, :b) # => {:c => 3, :d =>4}
+  def slice!(*keys)
+    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    replace(hash)
+    omit
+  end
+
+  def extract!(*keys)
+    result = {}
+    keys.each {|key| result[key] = delete(key) }
+    result
+  end
+end