jschairb-rets4r 1.1.18

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

@@ -0,0 +1,31 @@
+module RETS4R
+  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

data/lib/rets4r/listing_mapper.rb

@@ -0,0 +1,17 @@
+module RETS4R
+  class ListingMapper
+    def initialize(params = {})
+      @select = params[:select] || ListingService.connection[:select]
+    end
+    def select
+      @select
+    end
+    def map(original)
+      listing = {}
+      @select.each_pair {|rets_key, record_key|
+        listing[record_key] = original[rets_key]
+      }
+      listing
+    end
+  end
+end

data/lib/rets4r/listing_service.rb

@@ -0,0 +1,35 @@
+require 'rets4r/core_ext/class/attribute_accessors'
+require 'rets4r/core_ext/hash/keys'
+require 'rets4r/core_ext/hash/slice'
+
+module RETS4R
+  class ListingService
+    # RECORD_COUNT_ONLY=Librets::SearchRequest::RECORD_COUNT_ONLY
+    RECORD_COUNT_ONLY='fixme'
+    # Contains the listing service configurations - typically stored in
+    # config/listing_service.yml - as a Hash.
+    cattr_accessor :configurations, :instance_writer => false
+    cattr_accessor :env, :instance_writer => false
+
+    class << self
+
+      # Connection configuration for the specified environment, or the current
+      # environment if none is given.
+      def connection(spec = nil)
+        case spec
+          when nil
+            connection(RETS4R::ListingService.env)
+          when Symbol, String
+            if configuration = configurations[spec.to_s]
+              configuration.symbolize_keys
+            else
+              raise ArgumentError, "#{spec} listing service is not configured"
+            end
+          else
+            raise ArgumentError, "#{spec} listing service is not configured"
+        end
+      end
+
+    end # class << self
+  end
+end

data/lib/rets4r/loader.rb

@@ -0,0 +1,8 @@
+module RETS4R
+  class Loader
+    def self.load(io, &block)
+      parser = RETS4R::Client::CompactNokogiriParser.new(io)
+      parser.each(&block)
+    end
+  end
+end

data/lib/tasks/annotations.rake

@@ -0,0 +1,121 @@
+# Implements the logic behind the rake tasks for annotations like
+#
+#   rake notes
+#   rake notes:optimize
+#
+# and friends. See <tt>rake -T notes</tt> and <tt>railties/lib/tasks/annotations.rake</tt>.
+#
+# Annotation objects are triplets <tt>:line</tt>, <tt>:tag</tt>, <tt>:text</tt> that
+# represent the line where the annotation lives, its tag, and its text. Note
+# the filename is not stored.
+#
+# Annotations are looked for in comments and modulus whitespace they have to
+# start with the tag optionally followed by a colon. Everything up to the end
+# of the line (or closing ERb comment tag) is considered to be their text.
+class SourceAnnotationExtractor
+  class Annotation < Struct.new(:line, :tag, :text)
+
+    # Returns a representation of the annotation that looks like this:
+    #
+    #   [126] [TODO] This algorithm is simple and clearly correct, make it faster.
+    #
+    # If +options+ has a flag <tt>:tag</tt> the tag is shown as in the example above.
+    # Otherwise the string contains just line and text.
+    def to_s(options={})
+      s = "[%3d] " % line
+      s << "[#{tag}] " if options[:tag]
+      s << text
+    end
+  end
+
+  # Prints all annotations with tag +tag+ under the root directories +app+, +lib+,
+  # and +test+ (recursively). Only filenames with extension +.builder+, +.rb+,
+  # +.rxml+, +.rjs+, +.rhtml+, or +.erb+ are taken into account. The +options+
+  # hash is passed to each annotation's +to_s+.
+  #
+  # This class method is the single entry point for the rake tasks.
+  def self.enumerate(tag, options={})
+    extractor = new(tag)
+    extractor.display(extractor.find, options)
+  end
+
+  attr_reader :tag
+
+  def initialize(tag)
+    @tag = tag
+  end
+
+  # Returns a hash that maps filenames under +dirs+ (recursively) to arrays
+  # with their annotations. Only files with annotations are included, and only
+  # those with extension +.builder+, +.rb+, +.rxml+, +.rjs+, +.rhtml+, and +.erb+
+  # are taken into account.
+  def find(dirs=%w(app lib test))
+    dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
+  end
+
+  # Returns a hash that maps filenames under +dir+ (recursively) to arrays
+  # with their annotations. Only files with annotations are included, and only
+  # those with extension +.builder+, +.rb+, +.rxml+, +.rjs+, +.rhtml+, and +.erb+
+  # are taken into account.
+  def find_in(dir)
+    results = {}
+
+    Dir.glob("#{dir}/*") do |item|
+      next if File.basename(item)[0] == ?.
+
+      if File.directory?(item)
+        results.update(find_in(item))
+      elsif item =~ /\.(builder|(r(?:b|xml|js)))$/
+        results.update(extract_annotations_from(item, /#\s*(#{tag}):?\s*(.*)$/))
+      elsif item =~ /\.(rhtml|erb)$/
+        results.update(extract_annotations_from(item, /<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/))
+      end
+    end
+
+    results
+  end
+
+  # If +file+ is the filename of a file that contains annotations this method returns
+  # a hash with a single entry that maps +file+ to an array of its annotations.
+  # Otherwise it returns an empty hash.
+  def extract_annotations_from(file, pattern)
+    lineno = 0
+    result = File.readlines(file).inject([]) do |list, line|
+      lineno += 1
+      next list unless line =~ pattern
+      list << Annotation.new(lineno, $1, $2)
+    end
+    result.empty? ? {} : { file => result }
+  end
+
+  # Prints the mapping from filenames to annotations in +results+ ordered by filename.
+  # The +options+ hash is passed to each annotation's +to_s+.
+  def display(results, options={})
+    results.keys.sort.each do |file|
+      puts "#{file}:"
+      results[file].each do |note|
+        puts "  * #{note.to_s(options)}"
+      end
+      puts
+    end
+  end
+end
+
+desc "Enumerate all annotations"
+task :notes do
+  SourceAnnotationExtractor.enumerate "OPTIMIZE|FIXME|TODO", :tag => true
+end
+
+namespace :notes do
+  ["OPTIMIZE", "FIXME", "TODO"].each do |annotation|
+    desc "Enumerate all #{annotation} annotations"
+    task annotation.downcase.intern do
+      SourceAnnotationExtractor.enumerate annotation
+    end
+  end
+
+  desc "Enumerate a custom annotation, specify with ANNOTATION=WTFHAX"
+  task :custom do
+    SourceAnnotationExtractor.enumerate ENV['ANNOTATION']
+  end
+end