rets-hack 0.11

data/lib/rets/metadata/containers.rb

@@ -0,0 +1,89 @@
+module Rets
+  module Metadata
+    #########################
+    # Basic representation of the underlying metadata. This models
+    # the structure of RETS metadata closely. The OO-representation
+    # uses this structure for its construction. External usage of
+    # this API should be discouraged in favor of the richer OO
+    # representation.
+    #
+    module Containers
+      class Container
+        attr_accessor :fragment
+
+        def self.uses(*fields)
+          fields.each do |field|
+            define_method(field) do
+              fields_hash[field] || fields_hash[field] = extract(fragment, field.to_s.capitalize)
+            end
+          end
+        end
+
+        uses :date, :version
+
+        def initialize(fragment)
+          self.fragment = fragment
+        end
+
+        def extract(fragment, attr)
+          fragment.attr(attr)
+        end
+
+        private
+
+        def fields_hash
+          @fields ||= {}
+        end
+
+      end
+
+      class RowContainer < Container
+
+        attr_accessor :rows
+
+        def initialize(doc)
+          super
+          self.rows = Parser::Compact.parse_document(doc)
+        end
+
+      end
+
+      class ResourceContainer < RowContainer
+        alias resources rows
+      end
+
+      class ClassContainer < RowContainer
+        uses :resource
+
+        alias classes rows
+      end
+
+      class TableContainer < RowContainer
+        uses :resource, :class
+
+        alias tables rows
+      end
+
+      class LookupContainer < RowContainer
+        uses :resource
+
+        alias lookups rows
+      end
+
+      class LookupTypeContainer < RowContainer
+        uses :resource, :lookup
+
+        alias lookup_types rows
+      end
+
+      class ObjectContainer < RowContainer
+        uses :resource
+
+        alias objects rows
+      end
+
+      class SystemContainer < Container
+      end
+    end
+  end
+end

data/lib/rets/metadata/file_cache.rb

@@ -0,0 +1,29 @@
+module Rets
+  module Metadata
+
+    # This metadata cache persists the metadata to a file.
+    class FileCache
+
+      def initialize(path)
+        @path = path
+      end
+
+      # Save the metadata.  Should yield an IO-like object to a block;
+      # that block will serialize the metadata to that object.
+      def save(&block)
+        File.open(@path, "wb", &block)
+      end
+
+      # Load the metadata.  Should yield an IO-like object to a block;
+      # that block will deserialize the metadata from that object and
+      # return the metadata.  Returns the metadata, or nil if it could
+      # not be loaded.
+      def load(&block)
+        File.open(@path, "rb", &block)
+      rescue IOError, SystemCallError
+        nil
+      end
+    end
+    
+  end
+end

data/lib/rets/metadata/json_serializer.rb

@@ -0,0 +1,27 @@
+require 'json'
+
+module Rets
+  module Metadata
+
+    # Serialize/Deserialize metadata using JSON.
+    class JsonSerializer
+
+      # 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)
+        file.write o.to_json
+      end
+
+      # Deserialize from a file.  If the metadata cannot be
+      # deserialized, return nil.
+      def load(file)
+        JSON.load(file)
+      rescue JSON::ParserError
+        nil
+      end
+
+    end
+    
+  end
+end

data/lib/rets/metadata/lookup_table.rb

@@ -0,0 +1,65 @@
+module Rets
+  module Metadata
+    class LookupTable
+      attr_reader :resource_id, :lookup_types, :table_fragment, :name, :long_name
+
+      def initialize(resource_id, lookup_types, table_fragment)
+        @resource_id = resource_id
+        @lookup_types = lookup_types
+
+        @table_fragment = table_fragment
+        @name = table_fragment["SystemName"]
+        @long_name = table_fragment["LongName"]
+      end
+
+      def self.build(table_fragment, resource_id, lookup_types)
+        lookup_name = table_fragment["LookupName"]
+        lookup_types = lookup_types[lookup_name]
+        new(resource_id, lookup_types, table_fragment)
+      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: #{ long_name }"
+        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 value.to_s.strip
+        end
+
+        #Remove surrounding quotes
+        clean_value  = value.scan(/^["']?(.*?)["']?$/).join
+
+
+        lookup_type = lookup_type(clean_value)
+
+        resolved_value = lookup_type ? lookup_type.long_value : nil
+
+        if resolved_value.nil? && $VERBOSE
+          warn("Discarding unmappable value of #{clean_value.inspect}")
+        end
+
+        resolved_value.to_s.strip
+      end
+    end
+  end
+end

data/lib/rets/metadata/lookup_type.rb

@@ -0,0 +1,19 @@
+module Rets
+  module Metadata
+    class LookupType
+      attr_reader :long_value, :value
+
+      def initialize(lookup_type_fragment)
+        @value       = lookup_type_fragment["Value"].strip
+        @long_value  = lookup_type_fragment["LongValue"].strip
+      end
+
+      # Print the tree to a file
+      #
+      # [out] The file to print to.  Defaults to $stdout.
+      def print_tree(out = $stdout)
+        out.puts "        #{long_value} -> #{value}"
+      end
+    end
+  end
+end

data/lib/rets/metadata/marshal_serializer.rb

@@ -0,0 +1,27 @@
+require 'json'
+
+module Rets
+  module Metadata
+
+    # Serialize/Deserialize metadata using Marshal.
+    class MarshalSerializer
+
+      # 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)
+        Marshal.dump(o, file)
+      end
+
+      # Deserialize from a file.  If the metadata cannot be
+      # deserialized, return nil.
+      def load(file)
+        Marshal.load(file)
+      rescue TypeError
+        nil
+      end
+      
+    end
+    
+  end
+end

data/lib/rets/metadata/multi_lookup_table.rb

@@ -0,0 +1,70 @@
+module Rets
+  module Metadata
+    class MultiLookupTable
+      attr_reader :resource_id, :lookup_types, :table_fragment, :name, :long_name
+
+      def initialize(resource_id, lookup_types, table_fragment)
+        @resource_id = resource_id
+        @lookup_types = lookup_types
+
+        @table_fragment = table_fragment
+        @name = table_fragment["SystemName"]
+        @long_name = table_fragment["LongName"]
+      end
+
+      def self.build(table_fragment, resource_id, lookup_types)
+        lookup_name = table_fragment["LookupName"]
+        lookup_types = lookup_types[lookup_name]
+        new(resource_id, lookup_types, table_fragment)
+      end
+
+      # Print the tree to a file
+      #
+      # [out] The file to print to.  Defaults to $stdout.
+      def print_tree(out = $stdout)
+        out.puts "### MultiLookupTable: #{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: #{ long_name }"
+        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 []
+        end
+
+        values = value.split(",")
+
+        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
+
+          if resolved_value.nil? && $VERBOSE
+            warn("Discarding unmappable value of #{clean_value.inspect}")
+          end
+
+          resolved_value.to_s.strip
+        end
+      end
+    end
+  end
+end

data/lib/rets/metadata/null_cache.rb

@@ -0,0 +1,24 @@
+module Rets
+  module Metadata
+
+    # This type of metadata cache, which is the default, neither saves
+    # nor restores.
+    class NullCache
+
+      # Save the metadata.  Should yield an IO-like object to a block;
+      # that block will serialize the metadata to that object.
+      def save(&_block)
+      end
+
+      # Load the metadata.  Should yield an IO-like object to a block;
+      # that block will deserialize the metadata from that object and
+      # return the metadata.  Returns the metadata, or nil if it could
+      # not be loaded.
+      def load(&_block)
+        nil
+      end
+      
+    end
+    
+  end
+end

data/lib/rets/metadata/resource.rb

@@ -0,0 +1,103 @@
+module Rets
+  module Metadata
+    class Resource
+      class MissingRetsClass < RuntimeError; end
+      attr_reader :id, :key_field, :rets_classes, :rets_objects
+
+      def initialize(id, key_field, rets_classes, rets_objects)
+        @id = id
+        @key_field = key_field
+        @rets_classes = rets_classes
+        @rets_objects = rets_objects
+      end
+
+      def self.find_lookup_containers(metadata, resource_id)
+        metadata[:lookup].select { |lc| lc.resource == resource_id }
+      end
+
+      def self.find_lookup_type_containers(metadata, resource_id, lookup_name)
+        metadata[:lookup_type].select { |ltc| ltc.resource == resource_id && ltc.lookup == lookup_name }
+      end
+
+      def self.find_rets_classes(metadata, resource_id)
+        class_container = metadata[:class].detect { |c| c.resource == resource_id }
+        if class_container.nil?
+          raise MissingRetsClass.new("No Metadata classes for #{resource_id}")
+        else
+          class_container.classes
+        end
+      end
+
+      def self.find_rets_objects(metadata, resource_id)
+        objects = metadata[:object]
+        if objects
+          objects.select { |object| object.resource == resource_id }.map(&:objects).flatten
+        else
+          []
+        end
+      end
+
+      def self.build_lookup_tree(resource_id, metadata)
+        lookup_types = Hash.new {|h, k| h[k] = Array.new }
+
+        find_lookup_containers(metadata, resource_id).each do |lookup_container|
+          lookup_container.lookups.each do |lookup_fragment|
+            lookup_name = lookup_fragment["LookupName"]
+
+            find_lookup_type_containers(metadata, resource_id, lookup_name).each do |lookup_type_container|
+              lookup_type_container.lookup_types.each do |lookup_type_fragment|
+                lookup_types[lookup_name] << LookupType.new(lookup_type_fragment)
+              end
+            end
+          end
+        end
+
+        lookup_types
+      end
+
+      def self.build_classes(resource_id, lookup_types, metadata)
+        find_rets_classes(metadata, resource_id).map do |rets_class_fragment|
+          RetsClass.build(rets_class_fragment, resource_id, lookup_types, metadata)
+        end
+      end
+
+      def self.build_objects(resource_id, metadata)
+        find_rets_objects(metadata, resource_id).map do |rets_object_fragment|
+          RetsObject.build(rets_object_fragment)
+        end
+      end
+
+      def self.build(resource_fragment, metadata, logger)
+        resource_id = resource_fragment["ResourceID"]
+        key_field = resource_fragment["KeyField"]
+
+        lookup_types = build_lookup_tree(resource_id, metadata)
+        rets_classes = build_classes(resource_id, lookup_types, metadata)
+        rets_objects = build_objects(resource_id, metadata)
+
+        new(resource_id, key_field, rets_classes, rets_objects)
+      rescue MissingRetsClass => e
+        logger.warn(e.message)
+        nil
+      end
+
+      # Print the tree to a file
+      #
+      # [out] The file to print to.  Defaults to $stdout.
+      def print_tree(out = $stdout)
+        out.puts "# Resource: #{id} (Key Field: #{key_field})"
+        rets_classes.each do |rets_class|
+          rets_class.print_tree(out)
+        end
+        rets_objects.each do |rets_object|
+          rets_object.print_tree(out)
+        end
+      end
+
+      def find_rets_class(rets_class_name)
+        rets_classes.detect {|rc| rc.name == rets_class_name }
+      end
+    end
+  end
+end
+

data/lib/rets/metadata/rets_class.rb

@@ -0,0 +1,57 @@
+module Rets
+  module Metadata
+    class RetsClass
+      attr_reader :name, :visible_name, :standard_name, :description, :tables
+
+      def initialize(name, visible_name, standard_name, description, tables)
+        @name = name
+        @visible_name = visible_name
+        @description = description
+        @standard_name = standard_name
+
+        @tables = tables
+      end
+
+      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.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"]
+
+        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
+      #
+      # [out] The file to print to.  Defaults to $stdout.
+      def print_tree(out = $stdout)
+        out.puts "## Class: #{name}"
+        out.puts "    Visible Name: #{visible_name}"
+        out.puts "    Description : #{description}"
+        tables.each do |table|
+          table.print_tree(out)
+        end
+      end
+
+      def find_table(name)
+        tables.detect { |value| value.name.downcase == name.downcase }
+      end
+    end
+  end
+end

data/lib/rets/metadata/rets_object.rb

@@ -0,0 +1,41 @@
+module Rets
+  module Metadata
+    class RetsObject
+      attr_reader :name, :mime_type, :description, :type
+
+      def initialize(type, name, mime_type, description)
+        @name = name
+        @mime_type = mime_type
+        @description = description
+        @type = type
+      end
+
+      def self.build(rets_object_fragment)
+        rets_object_fragment = downcase_hash_keys(rets_object_fragment)
+        name = rets_object_fragment["visiblename"]
+        mime_type = rets_object_fragment["mimetype"]
+        description = rets_object_fragment["description"]
+        type = rets_object_fragment['objecttype']
+        new(type, name, mime_type, description)
+      end
+
+      def print_tree(out = $stdout)
+        out.puts "  Object: #{type}"
+        out.puts "    Visible Name: #{name}"
+        out.puts "    Mime Type: #{mime_type}"
+        out.puts "    Description: #{description}"
+      end
+
+      def ==(other)
+        name == other.name &&
+          mime_type == other.mime_type &&
+          description == other.description
+      end
+
+      private
+      def self.downcase_hash_keys(hash)
+        Hash[hash.map { |k, v| [k.downcase, v] }]
+      end
+    end
+  end
+end