rets 0.9.0 → 0.10.0

data/lib/rets/metadata/rets_class.rb

@@ -1,36 +1,40 @@
 module Rets
   module Metadata
     class RetsClass
-      attr_accessor :tables
-      attr_accessor :name
-      attr_accessor :visible_name
-      attr_accessor :description
-      attr_accessor :resource
-
-      def initialize(rets_class_fragment, resource)
-        self.resource = resource
-        self.tables = []
-        self.name = rets_class_fragment["ClassName"]
-        self.visible_name = rets_class_fragment["VisibleName"]
-        self.description = rets_class_fragment["Description"]
-      end
+      attr_reader :name, :visible_name, :standard_name, :description, :tables
 
-      def self.find_table_container(metadata, resource, rets_class)
-        metadata[:table].detect { |t| t.resource == resource.id && t.class == rets_class.name }
-      end
+      def initialize(name, visible_name, standard_name, description, tables)
+        @name = name
+        @visible_name = visible_name
+        @description = description
+        @standard_name = standard_name
 
-      def self.build(rets_class_fragment, resource, metadata)
-        rets_class = new(rets_class_fragment, resource)
+        @tables = tables
+      end
 
-        table_container = find_table_container(metadata, resource, rets_class)
+      def self.find_table_container(metadata, resource_id, class_name)
+        metadata[:table].detect { |t| t.resource == resource_id && t.class == class_name }
+      end
 
+      def self.builds_tables(table_container, resource_id, lookup_types)
         if table_container
-          table_container.tables.each do |table_fragment|
-            rets_class.tables << TableFactory.build(table_fragment, resource)
+          table_container.tables.map do |table_fragment|
+            TableFactory.build(table_fragment, resource_id, lookup_types)
           end
+        else
+          []
         end
+      end
+
+      def self.build(rets_class_fragment, resource_id, lookup_types, metadata)
+        class_name = rets_class_fragment["ClassName"]
+        visible_name = rets_class_fragment["VisibleName"]
+        standard_name = rets_class_fragment["StandardName"]
+        description = rets_class_fragment["Description"]
 
-        rets_class
+        table_container = find_table_container(metadata, resource_id, class_name)
+        tables = builds_tables(table_container, resource_id, lookup_types)
+        new(class_name, visible_name, standard_name, description, tables)
       end
 
       # Print the tree to a file
@@ -46,7 +50,7 @@ module Rets
       end
 
       def find_table(name)
-        tables.detect { |value| value.name == name }
+        tables.detect { |value| value.name.downcase == name.downcase }
       end
     end
   end

data/lib/rets/metadata/rets_object.rb

@@ -0,0 +1,32 @@
+module Rets
+  module Metadata
+    class RetsObject
+      attr_reader :name, :mime_type, :description
+
+      def initialize(name, mime_type, description)
+        @name = name
+        @mime_type = mime_type
+        @description = description
+      end
+
+      def self.build(rets_object_fragment)
+        name = rets_object_fragment["VisibleName"]
+        mime_type = rets_object_fragment["MIMEType"]
+        description = rets_object_fragment["Description"]
+        new(name, mime_type, description)
+      end
+
+      def print_tree(out = $stdout)
+        out.puts "  Object: #{name}"
+        out.puts "    MimeType: #{mime_type}"
+        out.puts "    Description: #{description}"
+      end
+
+      def ==(other)
+        name == other.name &&
+          mime_type == other.mime_type &&
+          description == other.description
+      end
+    end
+  end
+end

data/lib/rets/metadata/table.rb

@@ -1,31 +1,14 @@
 module Rets
   module Metadata
-    class TableFactory
-      def self.build(table_fragment, resource)
-        enum?(table_fragment) ? LookupTable.new(table_fragment, resource) : Table.new(table_fragment, resource)
-      end
-
-      def self.enum?(table_fragment)
-        lookup_value   = table_fragment["LookupName"].strip
-        interpretation = table_fragment["Interpretation"].strip
-
-        interpretation =~ /Lookup/ && !lookup_value.empty?
-      end
-    end
-
     class Table
-      attr_accessor :type
-      attr_accessor :name
-      attr_accessor :long_name
-      attr_accessor :table_fragment
-      attr_accessor :resource
+      attr_reader :table_fragment, :resource_id, :name, :long_name
 
-      def initialize(table_fragment, resource)
-        self.table_fragment = table_fragment
-        self.resource = resource
-        self.type = table_fragment["DataType"]
-        self.name = table_fragment["SystemName"]
-        self.long_name = table_fragment["LongName"]
+      def initialize(table_fragment, resource_id)
+        @table_fragment = table_fragment
+        @resource_id = resource_id
+
+        @name = table_fragment["SystemName"]
+        @long_name = table_fragment["LongName"]
       end
 
       # Print the tree to a file
@@ -33,9 +16,9 @@ module Rets
       # [out] The file to print to.  Defaults to $stdout.
       def print_tree(out = $stdout)
         out.puts "    Table: #{name}"
-        out.puts "      Resource: #{resource.id}"
+        out.puts "      Resource: #{resource_id}"
         out.puts "      ShortName: #{ table_fragment["ShortName"] }"
-        out.puts "      LongName: #{ table_fragment["LongName"] }"
+        out.puts "      LongName: #{ long_name }"
         out.puts "      StandardName: #{ table_fragment["StandardName"] }"
         out.puts "      Units: #{ table_fragment["Units"] }"
         out.puts "      Searchable: #{ table_fragment["Searchable"] }"
@@ -46,80 +29,5 @@ module Rets
         value.to_s.strip
       end
     end
-
-    class LookupTable
-      attr_accessor :resource
-      attr_accessor :lookup_name
-      attr_accessor :name
-      attr_accessor :interpretation
-      attr_accessor :long_name
-      attr_accessor :table_fragment
-
-      def initialize(table_fragment, resource)
-        self.table_fragment = table_fragment
-        self.resource = resource
-        self.name = table_fragment["SystemName"]
-        self.interpretation = table_fragment["Interpretation"]
-        self.lookup_name = table_fragment["LookupName"]
-        self.long_name = table_fragment["LongName"]
-      end
-
-      def multi?
-        interpretation == "LookupMulti"
-      end
-
-      def lookup_types
-        resource.lookup_types[lookup_name]
-      end
-
-      # Print the tree to a file
-      #
-      # [out] The file to print to.  Defaults to $stdout.
-      def print_tree(out = $stdout)
-        out.puts "    LookupTable: #{name}"
-        out.puts "      Resource: #{resource.id}"
-        out.puts "      Required: #{table_fragment['Required']}"
-        out.puts "      Searchable: #{ table_fragment["Searchable"] }"
-        out.puts "      Units: #{ table_fragment["Units"] }"
-        out.puts "      ShortName: #{ table_fragment["ShortName"] }"
-        out.puts "      LongName: #{ table_fragment["LongName"] }"
-        out.puts "      StandardName: #{ table_fragment["StandardName"] }"
-        out.puts "      Types:"
-
-        lookup_types.each do |lookup_type|
-          lookup_type.print_tree(out)
-        end
-      end
-
-      def lookup_type(value)
-        lookup_types.detect {|lt| lt.value == value }
-      end
-
-      def resolve(value)
-        if value.empty?
-          return [] if multi?
-          return value.to_s.strip
-        end
-
-        values = multi? ? value.split(","): [value]
-
-        values = values.map do |v|
-
-          #Remove surrounding quotes
-          clean_value  = v.scan(/^["']?(.*?)["']?$/).join
-
-
-          lookup_type = lookup_type(clean_value)
-
-          resolved_value = lookup_type ? lookup_type.long_value : nil
-
-          warn("Discarding unmappable value of #{clean_value.inspect}") if resolved_value.nil? && $VERBOSE
-
-          resolved_value
-        end
-
-        multi? ? values.map {|v| v.to_s.strip } : values.first.to_s.strip
-      end
-    end
   end
 end

data/lib/rets/metadata/table_factory.rb

@@ -0,0 +1,19 @@
+module Rets
+  module Metadata
+    class TableFactory
+
+      def self.build(table_fragment, resource_id, lookup_types)
+        if table_fragment["LookupName"].empty?
+          Table.new(table_fragment, resource_id)
+        else
+          if table_fragment["Interpretation"] == "LookupMulti"
+            MultiLookupTable.build(table_fragment, resource_id, lookup_types)
+          else
+            LookupTable.build(table_fragment, resource_id, lookup_types)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rets/metadata/yaml_serializer.rb

@@ -0,0 +1,27 @@
+require 'yaml'
+
+module Rets
+  module Metadata
+
+    # Serialize/Deserialize metadata using Marshal.
+    class YamlSerializer
+
+      # Serialize to a file.  The library reserves the right to change
+      # the type or contents of o, so don't depend on it being
+      # anything in particular.
+      def save(file, o)
+        YAML.dump(o, file)
+      end
+
+      # Deserialize from a file.  If the metadata cannot be
+      # deserialized, return nil.
+      def load(file)
+        YAML.load(file)
+      rescue Psych::SyntaxError
+        nil
+      end
+
+    end
+    
+  end
+end

data/lib/rets/parser/compact.rb

@@ -1,26 +1,64 @@
+# coding: utf-8
+require 'cgi'
 module Rets
   module Parser
     class Compact
-      TAB = /\t/
+      DEFAULT_DELIMITER = "\t"
+
+      INCLUDE_NULL_FIELDS = -1
 
       InvalidDelimiter = Class.new(ArgumentError)
 
       def self.parse_document(xml)
-        doc = Nokogiri.parse(xml.to_s)
+        doc = SaxParser.new
+        parser = Nokogiri::XML::SAX::Parser.new(doc)
+        io = StringIO.new(xml.to_s)
+
+        parser.parse(io)
+        doc.results.map {|r| parse(doc.columns, r, doc.delimiter) }
+      end
 
-        delimiter = doc.at("//DELIMITER")
-        delimiter = delimiter ? Regexp.new(Regexp.escape(delimiter.attr(:value).to_i.chr)) : TAB
+      class SaxParser < Nokogiri::XML::SAX::Document
+        attr_reader :results, :columns, :delimiter
 
-        if delimiter == // || delimiter == /,/
-          raise InvalidDelimiter, "Empty or invalid delimiter found, unable to parse."
+        def initialize
+          @results = []
+          @columns = ''
+          @result_index = nil
+          @delimiter = nil
+          @columns_start = false
+          @data_start = false
+        end
+
+        def start_element name, attrs=[]
+          case name
+          when 'DELIMITER'
+            @delimiter = attrs.last.last.to_i.chr
+          when 'COLUMNS'
+            @columns_start = true
+          when 'DATA'
+            @result_index = @results.size
+          end
+        end
+
+        def end_element name
+          case name
+          when 'COLUMNS'
+            @columns_start = false
+          when 'DATA'
+            @result_index = nil
+          end
         end
 
-        column_node  = doc.at("//COLUMNS")
-        column_names = column_node.nil? ? [] : column_node.text.split(delimiter)
+        def characters string
+          if @columns_start
+            @columns << string
+          end
 
-        rows = doc.xpath("//DATA")
-        rows.map do |data|
-          self.parse_row(column_names, data.text, delimiter)
+          if @result_index
+            @results[@result_index] ||= ''
+            @results[@result_index] << string
+          end
         end
       end
 
@@ -29,10 +67,16 @@ module Rets
       # Delimiter must be a regexp because String#split behaves differently when
       # given a string pattern. (It removes leading spaces).
       #
-      def self.parse_row(column_names, data, delimiter = TAB)
-        raise ArgumentError, "Delimiter must be a regular expression" unless Regexp === delimiter
+      def self.parse(columns, data, delimiter = nil)
+        delimiter ||= DEFAULT_DELIMITER
+        delimiter = Regexp.new(Regexp.escape(delimiter))
+
+        if delimiter == // || delimiter == /,/
+          raise Rets::Parser::Compact::InvalidDelimiter, "Empty or invalid delimiter found, unable to parse."
+        end
 
-        data_values = data.split(delimiter).map { |x| CGI.unescapeHTML(x) }
+        column_names = columns.split(delimiter)
+        data_values = data.split(delimiter, INCLUDE_NULL_FIELDS).map { |x| CGI.unescapeHTML(x) }
 
         zipped_key_values = column_names.zip(data_values).map { |k, v| [k.freeze, v.to_s] }
 
@@ -43,10 +87,9 @@ module Rets
       def self.get_count(xml)
         doc = Nokogiri.parse(xml.to_s)
         if node = doc.at("//COUNT")
-          return node.attr('Records').to_i
-        elsif node = doc.at("//RETS-STATUS")
-          # Handle <RETS-STATUS ReplyCode="20201" ReplyText="No matching records were found" />
-          return 0 if node.attr('ReplyCode') == '20201'
+          node.attr('Records').to_i
+        else
+          0
         end
       end
 

data/lib/rets/parser/error_checker.rb

@@ -1,6 +1,8 @@
 module Rets
   module Parser
     class ErrorChecker
+      INVALID_REQUEST_ERROR_MAPPING = Hash[Rets.constants.map {|c| Rets.const_get(c) }.select { |klass| klass.is_a?(Class) && klass < Rets::InvalidRequest }.map {|klass| [klass.const_get('ERROR_CODE'), klass] }]
+
       def self.check(response)
         # some RETS servers returns HTTP code 412 when session cookie expired, yet the response body
         # passes XML check. We need to special case for this situation.
@@ -26,7 +28,12 @@ module Rets
               elsif reply_code == NoObjectFound::ERROR_CODE
                 raise NoObjectFound.new(reply_text)
               elsif reply_code.nonzero?
-                raise InvalidRequest.new(reply_code, reply_text)
+                error_class = INVALID_REQUEST_ERROR_MAPPING[reply_code]
+                if error_class
+                  raise error_class.new(reply_code, reply_text)
+                else
+                  raise InvalidRequest.new(reply_code, reply_text)
+                end
               else
                 return
               end

data/test/fixtures.rb

@@ -65,6 +65,16 @@ INVALID_DELIMETER = <<-XML
 </METADATA>
 XML
 
+CHANGED_DELIMITER = <<-XML
+<?xml version="1.0"?>
+<METADATA-RESOURCE Version="01.72.10306" Date="2011-03-15T19:51:22">
+  <DELIMITER value="45" />
+  <COLUMNS>A-B</COLUMNS>
+  <DATA>1-2</DATA>
+  <DATA>4-5</DATA>
+</METADATA>
+XML
+
 COMPACT = <<-XML
 <?xml version="1.0"?>
 <METADATA-RESOURCE Version="01.72.10306" Date="2011-03-15T19:51:22">
@@ -255,3 +265,51 @@ SAMPLE_COMPACT_WITH_SPECIAL_CHARS_2 = <<EOF
   <DATA>	text with &lt;tag&gt;		1999	00		</DATA>
 </RETS>
 EOF
+
+SAMPLE_PROPERTY_WITH_LOTS_OF_COLUMNS = <<EOF
+<RETS ReplyCode=\"0\" ReplyText=\"Operation Success.\">
+  <DELIMITER value=\"09\" />
+  <COLUMNS>\t#{800.times.map { |x| "K%03d" % x }.join("\t") }\t</COLUMNS>
+  <DATA>\t\t</DATA>
+</RETS>
+EOF
+
+EXAMPLE_METADATA_TREE = <<EOF
+Resource: Properties (Key Field: matrix_unique_key)
+  Class: T100
+    Visible Name: Prop
+    Description : some description
+    Table: L_1
+      Resource: Properties
+      ShortName: Sq
+      LongName: Square Footage
+      StandardName: Sqft
+      Units: Meters
+      Searchable: Y
+      Required: N
+    LookupTable: L_10
+      Resource: Properties
+      Required: N
+      Searchable: Y
+      Units: 
+      ShortName: HF
+      LongName: HOA Frequency
+      StandardName: HOA F
+      Types:
+        Quarterly -> Q
+        Annually -> A
+    MultiLookupTable: L_11
+      Resource: Properties
+      Required: N
+      Searchable: Y
+      Units: 
+      ShortName: HFs
+      LongName: HOA Frequencies
+      StandardName: HOA Fs
+      Types:
+        Quarterly -> Q
+        Annually -> A
+  Object: Photo
+    MimeType: photo/jpg
+    Description: photo description
+EOF