sean-rets 0.6.0

data/lib/rets/locking_http_client.rb

@@ -0,0 +1,34 @@
+module Rets
+  class LockingHttpClient
+    def initialize(http_client, locker, lock_name, options={})
+      @http_client = http_client
+      @locker = locker
+      @lock_name = lock_name
+      @options = options
+    end
+
+    def http_get(url, params=nil, extra_headers={})
+      lock_around do
+        @http_client.http_get(url, params, extra_headers)
+      end
+    end
+
+    def http_post(url, params, extra_headers = {})
+      lock_around do
+        @http_client.http_post(url, params, extra_headers)
+      end
+    end
+
+    def save_cookie_store(force=nil)
+      @http_client.save_cookie_store(force)
+    end
+
+    def lock_around(&block)
+      result = nil
+      @locker.lock(@lock_name, @options) do
+        result = block.call
+      end
+      result
+    end
+  end
+end

data/lib/rets/measuring_http_client.rb

@@ -0,0 +1,27 @@
+module Rets
+  class MeasuringHttpClient
+    def initialize(http_client, stats, prefix)
+      @http_client = http_client
+      @stats = stats
+      @prefix = prefix
+    end
+
+    def http_get(url, params=nil, extra_headers={})
+      @stats.count("#{@prefix}.http_get_rate")
+      @stats.time("#{@prefix}.http_get") do
+        @http_client.http_get(url, params, extra_headers)
+      end
+    end
+
+    def http_post(url, params, extra_headers = {})
+      @stats.count("#{@prefix}.http_post_rate")
+      @stats.time("#{@prefix}.http_post") do
+        @http_client.http_post(url, params, extra_headers)
+      end
+    end
+
+    def save_cookie_store(force=nil)
+      @http_client.save_cookie_store(force)
+    end
+  end
+end

data/lib/rets/metadata.rb

@@ -0,0 +1,6 @@
+require 'rets/metadata/containers'
+require 'rets/metadata/lookup_type'
+require 'rets/metadata/resource'
+require 'rets/metadata/rets_class'
+require 'rets/metadata/root'
+require 'rets/metadata/table'

data/lib/rets/metadata/containers.rb

@@ -0,0 +1,84 @@
+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
+              instance_variable_get("@#{field}") ||
+                instance_variable_set("@#{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
+
+      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/lookup_type.rb

@@ -0,0 +1,17 @@
+module Rets
+  module Metadata
+    class LookupType
+      attr_accessor :long_value, :short_value, :value
+
+      def initialize(lookup_type_fragment)
+        self.value       = lookup_type_fragment["Value"]
+        self.short_value = lookup_type_fragment["ShortValue"]
+        self.long_value  = lookup_type_fragment["LongValue"]
+      end
+
+      def print_tree
+        puts "        #{long_value} -> #{value}"
+      end
+    end
+  end
+end

data/lib/rets/metadata/resource.rb

@@ -0,0 +1,84 @@
+module Rets
+  module Metadata
+    class Resource
+      class MissingRetsClass < RuntimeError; end
+      attr_accessor :rets_classes
+      attr_accessor :lookup_types
+      attr_accessor :key_field
+
+      attr_accessor :id
+
+      def initialize(resource)
+        self.rets_classes = []
+        self.lookup_types = {}
+
+        self.id = resource["ResourceID"]
+        self.key_field = resource["KeyField"]
+      end
+
+      def self.find_lookup_containers(metadata, resource)
+        metadata[:lookup].select { |lc| lc.resource == resource.id }
+      end
+
+      def self.find_lookup_type_containers(metadata, resource, lookup_name)
+        metadata[:lookup_type].select { |ltc| ltc.resource == resource.id && ltc.lookup == lookup_name }
+      end
+
+      def self.find_rets_classes(metadata, resource)
+        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.build_lookup_tree(resource, metadata)
+        lookup_types = Hash.new {|h, k| h[k] = Array.new }
+
+        find_lookup_containers(metadata, resource).each do |lookup_container|
+          lookup_container.lookups.each do |lookup_fragment|
+            lookup_name = lookup_fragment["LookupName"]
+
+            find_lookup_type_containers(metadata, resource, 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, metadata)
+        find_rets_classes(metadata, resource).map do |rets_class_fragment|
+          RetsClass.build(rets_class_fragment, resource, metadata)
+        end
+      end
+
+      def self.build(resource_fragment, metadata, logger)
+        resource = new(resource_fragment)
+
+        resource.lookup_types = build_lookup_tree(resource, metadata)
+        resource.rets_classes = build_classes(resource, metadata)
+        resource
+      rescue MissingRetsClass => e
+        logger.warn(e.message)
+        nil
+      end
+
+      def print_tree
+        puts "Resource: #{id} (Key Field: #{key_field})"
+
+        rets_classes.each(&:print_tree)
+      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,48 @@
+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
+
+      def self.find_table_container(metadata, resource, rets_class)
+        metadata[:table].detect { |t| t.resource == resource.id && t.class == rets_class.name }
+      end
+
+      def self.build(rets_class_fragment, resource, metadata)
+        rets_class = new(rets_class_fragment, resource)
+
+        table_container = find_table_container(metadata, resource, rets_class)
+
+        if table_container
+          table_container.tables.each do |table_fragment|
+            rets_class.tables << TableFactory.build(table_fragment, resource)
+          end
+        end
+
+        rets_class
+      end
+
+      def print_tree
+        puts "  Class: #{name}"
+        puts "    Visible Name: #{visible_name}"
+        puts "    Description : #{description}"
+        tables.each(&:print_tree)
+      end
+
+      def find_table(name)
+        tables.detect { |value| value.name == name }
+      end
+    end
+  end
+end

data/lib/rets/metadata/root.rb

@@ -0,0 +1,152 @@
+module Rets
+  module Metadata
+    METADATA_TYPES = %w(SYSTEM RESOURCE CLASS TABLE LOOKUP LOOKUP_TYPE OBJECT)
+
+    # It's useful when dealing with the Rets standard to represent their
+    # relatively flat namespace of interweived components as a Tree. With
+    # a collection of resources at the top, and their various, classes,
+    # tables, lookups, and lookup types underneath.
+    #
+    # It looks something like ...
+    #
+    #    Resource
+    #     |
+    #    Class
+    #     |
+    #     `-- Table
+    #     |
+    #     `-- Lookups
+    #           |
+    #           `-- LookupType
+    #
+    # For our purposes it was helpful to denormalize some of the more deeply
+    # nested branches. In particular by relating Lookups to LookupTypes, and
+    # Tables to lookups with can simplify this diagram.
+    #
+    #
+    #    Resource
+    #     |
+    #    Class
+    #     |
+    #     `-- Table
+    #          |
+    #          `-- Lookups
+    #
+    # By associating Tables and lookups when we parse this structure. It allows
+    # us to seemlessly map Lookup values to their Long or Short value forms.
+    class Root
+      # Metadata_types is the low level parsed representation of the raw xml
+      # sources. Just one level up, they contain Containers, consisting of
+      # SystemContainers or RowContainers
+      attr_writer :metadata_types
+
+      # the tree is the high level represenation of the metadata heiarchy
+      # it begins with root. Stored as a list of Metadata::Resources
+      attr_writer :tree
+
+      # Sources are the raw xml documents fetched for each metadata type
+      # they are stored as a hash with the type names as their keys
+      # and the raw xml as the values
+      attr_reader :sources
+
+      # Metadata can be unmarshalled from cache. @logger is not set during that process, constructor is not called.
+      # Client code must set it after unmarshalling.
+      attr_reader :logger
+
+      # fetcher is a proc that inverts control to the client to retrieve metadata
+      # types
+      def initialize(logger, sources)
+        @logger = logger
+        @tree = nil
+        @metadata_types = nil # TODO think up a better name ... containers?
+        @sources = sources
+      end
+
+      def marshal_dump
+        sources
+      end
+
+      def version
+        metadata_types[:system].first.version
+      end
+
+      def date
+        metadata_types[:system].first.date
+      end
+
+      # Wether there exists a more up to date version of the metadata to fetch
+      # is dependant on either a timestamp indicating when the most recent
+      # version was published, or a version number. These values may or may
+      # not exist on any given rets server.
+      def current?(current_timestamp, current_version)
+        if !current_version.to_s.empty? && !version.to_s.empty?
+          current_version == version
+        else
+          current_timestamp ? current_timestamp == date : true
+        end
+      end
+
+      def build_tree
+        tree = Hash.new { |h, k| h.key?(k.downcase) ? h[k.downcase] : nil }
+
+        resource_containers = metadata_types[:resource]
+
+        resource_containers.each do |resource_container|
+          resource_container.rows.each do |resource_fragment|
+            resource = Resource.build(resource_fragment, metadata_types, @logger)
+            #some mlses list resource types without an associated data, throw those away
+            tree[resource.id.downcase] = resource if resource
+          end
+        end
+
+        tree
+      end
+
+      def tree
+        @tree ||= build_tree
+      end
+
+      def print_tree
+        tree.each do |name, value|
+          value.print_tree
+        end
+      end
+
+      def metadata_types
+        return @metadata_types if @metadata_types
+
+        h = {}
+
+        sources.each do |name, source|
+          h[name.downcase.to_sym] = build_containers(Nokogiri.parse(source))
+        end
+
+        @metadata_types = h
+      end
+
+      # Returns an array of container classes that represents
+      # the metadata stored in the document provided.
+      def build_containers(doc)
+        # find all tags that match /RETS/METADATA-*
+        fragments = doc.xpath("/RETS/*[starts-with(name(), 'METADATA-')]")
+
+        fragments.map { |fragment| build_container(fragment) }
+      end
+
+      def build_container(fragment)
+        tag  = fragment.name             # METADATA-RESOURCE
+        type = tag.sub(/^METADATA-/, "") # RESOURCE
+
+        class_name = type.capitalize.gsub(/_(\w)/) { $1.upcase }
+        container_name = "#{class_name}Container"
+
+        if ::RUBY_VERSION < '1.9'
+          container_class = Containers.const_defined?(container_name) ? Containers.const_get(container_name) : Containers::Container
+        else
+          container_class = Containers.const_defined?(container_name, true) ? Containers.const_get(container_name, true) : Containers::Container
+        end
+        container_class.new(fragment)
+      end
+    end
+  end
+end