josephholsten-rets4r 1.1.16 → 1.1.17

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

@@ -7,7 +7,8 @@ module RETS4R
     class CompactDataParser
       def parse_results(doc)
 
-        delimiter = doc.get_elements('/RETS/DELIMITER')[0].attributes['value'].to_i.chr
+        delimiter = doc.get_elements('/RETS/DELIMITER')[0] &&
+                    doc.get_elements('/RETS/DELIMITER')[0].attributes['value'].to_i.chr
         columns   = doc.get_elements('/RETS/COLUMNS')[0]
         rows      = doc.get_elements('/RETS/DATA')
 
@@ -16,7 +17,7 @@ module RETS4R
 
       def parse_data(column_element, row_elements, delimiter = "\t")
 
-        column_names = column_element.text.split(delimiter)
+        column_names = column_element.to_s.split(delimiter)
 
         result = []
 

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

@@ -2,15 +2,28 @@ require 'rubygems'
 require 'nokogiri'
 module RETS4R
   class Client
-    class CompactNokogiriParser < Nokogiri::XML::SAX::Document
-      def parse_results(io)
-        doc = CompactDocument.new
-        parser = Nokogiri::XML::SAX::Parser.new(doc)
-        parser.parse(io)
-        doc.results
+    class CompactNokogiriParser
+
+      def initialize(io)
+        @doc    = CompactDocument.new 
+        @parser = Nokogiri::XML::SAX::Parser.new(@doc)
+        @io     = io
+      end
+
+      def to_a
+        @parser.parse(@io) if @doc.results.empty?
+        @doc.results
       end
+
+      def each(&block)
+        @doc.proc = block.to_proc
+        @parser.parse(@io)
+        nil
+      end
+
       class CompactDocument < Nokogiri::XML::SAX::Document
         attr_reader :results
+        attr_writer :proc
         
         def initialize
           @results = []
@@ -35,10 +48,7 @@ module RETS4R
             @columns = @string.split(@delimiter)
           when 'DATA'
             @data_element = false
-            @results << @columns.zip(@string.split(@delimiter)).inject({}) do | h,(k,v) |
-              h[k] = v unless k.empty?
-              next h
-            end
+            handle_row
           end
         end
 
@@ -49,7 +59,23 @@ module RETS4R
             @string << string
           end
         end
+
+        private 
+        def handle_row
+          data = make_hash
+          if @proc
+            @proc.call(data)
+          else
+            @results << data
+          end
+        end
+        def make_hash
+          @columns.zip(@string.split(@delimiter)).inject({}) do | h,(k,v) |
+            h[k] = v unless k.empty?
+            next h
+          end
+        end
       end
     end
   end
-end
+end

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

@@ -61,10 +61,6 @@ module RETS4R
           raise RETSException, 'No transaction body was returned!'
         end
 
-        File.open('/tmp/meh', 'w') do |file|
-          file.write(xml)
-        end
-
         doc = REXML::Document.new(xml)
 
         root = doc.root
@@ -91,7 +87,7 @@ module RETS4R
 
       def get_parser_by_name(name)
         case name
-          when 'COMPACT'
+          when 'COMPACT', 'COMPACT-DECODED'
             type = RETS4R::Client::CompactDataParser
           else
             raise "Invalid format #{name}"

data/lib/rets4r/client/transaction.rb

@@ -23,6 +23,9 @@ module RETS4R
       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

@@ -1,12 +1,8 @@
 module RETS4R
   class Loader
-    def self.load(file)
-      parser = RETS4R::Client::CompactNokogiriParser.new
-      listings = parser.parse_results(file)
-
-      listings.each {|original|
-        yield original
-      }
+    def self.load(file, &block)
+      parser = RETS4R::Client::CompactNokogiriParser.new(file)
+      parser.each(&block)
     end
   end
-end
+end

data/test/compact_nokogiri_test.rb

@@ -6,14 +6,30 @@ require 'rets4r'
 class CompactNokogiriTest < Test::Unit::TestCase
   def test_should_do_stuff
     file = File.expand_path(File.join('test', 'data', '1.5', 'search_compact.xml'))
-    listings = RETS4R::Client::CompactNokogiriParser.new.parse_results(open(file))
+    listings = RETS4R::Client::CompactNokogiriParser.new(open(file)).to_a
     assert_equal({"Third"=>"Datum3", "Second"=>"Datum2", "First"=>"Datum1"}, listings[0])
     assert_equal({"Third"=>"Datum6", "Second"=>"Datum5", "First"=>"Datum4"}, listings[1])
   end
   def test_should_handle_big_data
     file = File.expand_path(File.join('test', 'data', '1.5', 'bad_compact.xml'))
-    listings = RETS4R::Client::CompactNokogiriParser.new.parse_results(open(file))
+    listings = RETS4R::Client::CompactNokogiriParser.new(open(file)).to_a
     assert_equal 1, listings.length
     assert_equal 79, listings.first.keys.length
   end
+  def test_each_should_yield_between_results
+    file = File.expand_path(
+      File.join('test', 'data', '1.5', 'search_compact_big.xml'))
+    stat = File::Stat.new(file)
+    unless stat.size > stat.blksize 
+      flunk "This test probably won't work on this machine. 
+        It needs a test input file larger than the native block size."
+    end
+    stream = open(file)
+    positions = []
+    listings = RETS4R::Client::CompactNokogiriParser.new(stream).each do |row|
+      positions << stream.pos
+    end
+    assert positions.first < positions.last, 
+      "data was yielded durring the reading of the stream"
+  end
 end

data/test/data/1.5/count_only_compact.xml

@@ -0,0 +1,3 @@
+<RETS ReplyCode="0" ReplyText="SUCCESS">
+<COUNT Records="1024"/>
+</RETS>

data/test/data/1.5/search_compact_big.xml

@@ -0,0 +1,136 @@
+<RETS ReplyCode="0" ReplyText="SUCCESS">
+<COUNT Records="4"/>
+<DELIMITER value="09" />
+<COLUMNS>	First	Second	Third	</COLUMNS>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum1	Datum2	Datum3</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<DATA>	Datum4	Datum5	Datum6</DATA>
+<MAXROWS/>
+</RETS>