rets 0.9.0 → 0.10.0

data/lib/rets/http_client.rb

@@ -1,3 +1,6 @@
+require 'http-cookie'
+require 'httpclient'
+
 module Rets
   class HttpClient
     attr_reader :http, :options, :logger, :login_url
@@ -10,6 +13,45 @@ module Rets
       @options.fetch(:ca_certs, []).each {|c| @http.ssl_config.add_trust_ca(c) }
     end
 
+    def self.from_options(options, logger)
+      if options[:http_proxy]
+        http = HTTPClient.new(options.fetch(:http_proxy))
+
+        if options[:proxy_username]
+          http.set_proxy_auth(options.fetch(:proxy_username), options.fetch(:proxy_password))
+        end
+      else
+        http = HTTPClient.new
+      end
+
+      if options[:receive_timeout]
+        http.receive_timeout = options[:receive_timeout]
+      end
+
+      if options[:cookie_store]
+        ensure_cookie_store_exists! options[:cookie_store]
+        http.set_cookie_store(options[:cookie_store])
+      end
+
+      http_client = new(http, options, logger, options[:login_url])
+
+      if options[:http_timing_stats_collector]
+        http_client = Rets::MeasuringHttpClient.new(http_client, options.fetch(:http_timing_stats_collector), options.fetch(:http_timing_stats_prefix))
+      end
+
+      if options[:lock_around_http_requests]
+        http_client = Rets::LockingHttpClient.new(http_client, options.fetch(:locker), options.fetch(:lock_name), options.fetch(:lock_options))
+      end
+
+      http_client
+    end
+
+    def self.ensure_cookie_store_exists!(cookie_store)
+      unless File.exist? cookie_store
+        FileUtils.touch(cookie_store)
+      end
+    end
+
     def http_get(url, params=nil, extra_headers={})
       http.set_auth(url, options[:username], options[:password])
       headers = extra_headers.merge(rets_extra_headers)

data/lib/rets/metadata.rb

@@ -1,6 +1,18 @@
+require 'rets/metadata/caching'
+require 'rets/metadata/null_cache'
+require 'rets/metadata/file_cache'
+require 'rets/metadata/json_serializer'
+require 'rets/metadata/yaml_serializer'
+require 'rets/metadata/marshal_serializer'
+
 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/resource'
+require 'rets/metadata/lookup_type'
+require 'rets/metadata/table_factory'
 require 'rets/metadata/table'
+require 'rets/metadata/lookup_table'
+require 'rets/metadata/multi_lookup_table'
+require 'rets/metadata/rets_class'
+require 'rets/metadata/rets_object'

data/lib/rets/metadata/caching.rb

@@ -0,0 +1,59 @@
+module Rets
+  module Metadata
+
+    # Metadata caching.
+    # @api internal
+    class Caching
+
+      # Given the options passed to Client#initialize, make an
+      # instance.  Options:
+      #
+      # * :metadata_cache - Persistence mechanism.  Defaults to
+      #   NullCache.
+      #
+      # * "metadata_serializer - Serialization mechanism.  Defaults to
+      #   MarshalSerializer.
+      def self.make(options)
+        cache = options.fetch(:metadata_cache) { Metadata::NullCache.new }
+        serializer = options.fetch(:metadata_serializer) do
+          Metadata::MarshalSerializer.new
+        end
+        new(cache, serializer)
+      end
+
+      attr_reader :cache
+      attr_reader :serializer
+
+      # The cache is responsible for reading and writing the
+      # serialized metadata.  The cache should quack like a
+      # Rets::Metadata::FileCache.
+      #
+      # The serializer is responsible for serializing/deserializing
+      # the metadata.  The serializer should quack like a
+      # Rets::Metadata::MarshalSerializer.
+      def initialize(cache, serializer)
+        @cache = cache
+        @serializer = serializer
+      end
+
+      # Load metadata.  Returns a Metadata::Root if successful, or nil
+      # if it could be loaded for any reason.
+      def load(logger)
+        sources = @cache.load do |file|
+          @serializer.load(file)
+        end
+        return nil unless sources.is_a?(Hash)
+        Metadata::Root.new(logger, sources)
+      end
+
+      # Save metadata.
+      def save(metadata)
+        @cache.save do |file|
+          @serializer.save(file, metadata.sources)
+        end
+      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

@@ -1,12 +1,11 @@
 module Rets
   module Metadata
     class LookupType
-      attr_accessor :long_value, :short_value, :value
+      attr_reader :long_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"]
+        @value       = lookup_type_fragment["Value"]
+        @long_value  = lookup_type_fragment["LongValue"]
       end
 
       # Print the tree to a file

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

@@ -2,46 +2,44 @@ module Rets
   module Metadata
     class Resource
       class MissingRetsClass < RuntimeError; end
-      attr_accessor :rets_classes
-      attr_accessor :lookup_types
-      attr_accessor :key_field
+      attr_reader :id, :key_field, :rets_classes, :rets_objects
 
-      attr_accessor :id
-
-      def initialize(resource)
-        self.rets_classes = []
-        self.lookup_types = {}
-
-        self.id = resource["ResourceID"]
-        self.key_field = resource["KeyField"]
+      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)
-        metadata[:lookup].select { |lc| lc.resource == resource.id }
+      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, lookup_name)
-        metadata[:lookup_type].select { |ltc| ltc.resource == resource.id && ltc.lookup == lookup_name }
+      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)
-        class_container = metadata[:class].detect { |c| c.resource == resource.id }
+      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}")
+          raise MissingRetsClass.new("No Metadata classes for #{resource_id}")
         else
           class_container.classes
         end
       end
 
-      def self.build_lookup_tree(resource, metadata)
+      def self.find_rets_objects(metadata, resource_id)
+        metadata[:object].select { |object| object.resource == resource_id }.map(&:objects).flatten
+      end
+
+      def self.build_lookup_tree(resource_id, metadata)
         lookup_types = Hash.new {|h, k| h[k] = Array.new }
 
-        find_lookup_containers(metadata, resource).each do |lookup_container|
+        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, lookup_name).each do |lookup_type_container|
-
+            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
@@ -52,18 +50,27 @@ module Rets
         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)
+      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 = new(resource_fragment)
+        resource_id = resource_fragment["ResourceID"]
+        key_field = resource_fragment["KeyField"]
 
-        resource.lookup_types = build_lookup_tree(resource, metadata)
-        resource.rets_classes = build_classes(resource, metadata)
-        resource
+        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
@@ -77,6 +84,9 @@ module Rets
         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)