ruby-rets 2.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b4fb43a879323ee4c589b274cb52c7f3f6d10b2
+  data.tar.gz: 8bdf9ae5be3b1da6aac9a203c29f63ddec811993
+SHA512:
+  metadata.gz: dc338096a89979e92136e00b857e7f9ec12597bff78c16d4e424d87230fffdc34fe6f7a9037dc31b0dd3a3fb563cc131bec596c4a2006addd4cc631cca988f9a
+  data.tar.gz: 74c09c0271b537c61e2c629215fe37c189ce3db9300a2d55174c3747fc1e4551439fd2cca5d11218e6eb9c78fc8144c5a75a53bf4b3adec78fe25640bb266c0e

data/CHANGELOG.md

@@ -0,0 +1,94 @@
+# Overview
+
+## 2.0.7
+
+Confirmed to work with Ruby 2.0.0-p0
+
+### Fixes
+  * `RETS-Version` is no longer set to `RETS/1.7` unless an error `20037` is returned and no other one is specified
+  * `RETS-Version` can be set based on a HTTP 200 response for systems which only pass it after authentication (Innovia)
+
+## 2.0.6
+
+### Features
+  * System name added to `rets_data[:system_id]` when pulling metadata out
+  * `client.request_size` and `client.request_hash` can be used when streaming is disabled in `client.search`
+  * Added `client.request_time` which gives the time taken in seconds for a `client.search` or `client.get_object` to run
+
+### Fixes
+  * Fixed an authentication issue when using Retsiq where it would return 20041 in place of HTTP 401
+  * Fixed errors when streaming with an unknown Content-Length and chunked encoding
+  * Fixed a block being required when making a `client.search` call with `:count_mode => :only`
+  * Fixed character encoding that was causing issues on some RETS servers (Paul Trippett)
+  * Fixed an exception when Rapattoni RETS servers returned a "RETS-STATUS" XML tag on a multipart `client.get_object` call
+  * Fixed a `RETS::APIError` code 0 error under some RETS systems when making a call to `client.get_object` with `:location`
+
+## 2.0.5
+
+### Features
+  * Make `client.rets_data` available immediately when calling `client.search` rather than having to wait until it finishes (Paul Trippett)
+  * `:rets_version` can be passed to `client.login` without the User-Agent fields being set, for RETS servers that require the version to be passed initially
+
+### Fixes
+  * Default to HTTP Digest authentication when Digest and Basic are provided (Paul Trippett)
+  * Fixed authentication header parser if a server returns Basic/Digest and the Digest data goes stale (Paul Trippett)
+  * Fixed query strings from the initial login request not being saved when discovery service URLs (Paul Trippett)
+
+## 2.0.4
+
+### Features
+  * Added support for RETS servers that use digest authentication without the quality of protection flag (MRIS)
+  * Added SSL support (Paul Trippett)
+
+### Fixes
+  * Fixed metadata parsing breaking if a field wasn't filled out (Paul Trippett)
+  * Fixed multipart parsing for `client.get_object` if a part is blank
+
+## 2.0.3
+
+### Fixes
+  * Fixed a stack overflow due to how Interealty handles User-Agent authentication errors
+
+## 2.0.2
+
+### Features
+  * Dropped support for TimeoutSeconds, instead if an HTTP 401 is received after a successful request then a reauthentication is forced. Provides better compatibility with how some RETS implementations handle sessions
+
+### Fixes
+  * Client methods no longer return the HTTP request
+  * Requests will correctly be called after a HTTP digest becomes stale
+
+## 2.0.1
+
+### API Changes
+  * `client.login` will now raise `ResponseError` errors if the RETS tag cannot be found in the response
+  * `client.login` added the ability to pass `:rets_version` to force the RETS Version used in HTTP requests. Provides a small speedup as it can skip one HTTP request depending on the RETS implementation
+  * `client.get_object` can return both Content-Description or Description rather than just Description. Also will return Preferred
+
+### Features
+  * Added support for TimeoutSeconds, after the timeout passes the gem seamlessly reauthenticates
+  * Improved the edge case handling for authentication requests to greatly increase compatability with logging into any RETS based system
+
+### Fixes
+  * Object multipart parsing no longer fails if the boundary is wrapped in quotes
+  * Response parsing won't fail if the RETS server uses odd casing for the "ReplyText" and "ReplyCode" args in RETS
+
+## 2.0.0
+
+### API Changes
+  * `client.logout` will now raise `CapabilityNotFound` errors if it's unsupported
+  * `client.get_object` now requires a block which is yielded to rather than returning an array of the content
+  * `client.get_object` headers are now returned in lowercase form ("content-id" not "Content-ID" and so on)
+  * `RETS::Client.login` now uses `:useragent => {:name => "Foo", :password => "Bar"}` to pass User Agent data
+  * `RETS::Client.login` no longer implies the User-Agent username or password by the primary username and password
+
+### Features
+  * Added support for Count, Offset, Select and RestrictedIndicators in `client.search`
+  * Added support for Location in `client.get_object`
+  * RETS reply code, text and other data such as count or delimiter can be gotten through `client.rets_data` after the call is finished
+
+### Fixes
+  * Redid how authentication is handled, no longer implies HTTP Basic auth when using RETS-UA-Authorization
+  * RETS-Version is now used for RETS-UA-Authorization when available with "RETS/1.7" as a fallback
+  * Exceptions are now raised consistently and have been simplifed to `APIError`, `HTTPError`, `Unauthorized` and `CapabilityNotFound`
+  * `HTTPError` and `APIError` now include the reply text and code in `reply_code` and `reply_text`

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Placester, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+Overview
+===
+Simplifies the process of pulling data from RETS servers without having to worry about various authentication setups, should support all 1.x implementations. Parsing uses SAX to stream data as it comes rather than having to pull the entire document down and parse it all at once as some servers can return quite a lot of data.
+
+Compability
+-
+Tested against Ruby 1.8.7, 1.9.2, 2.0.0, RBX and JRuby, build history is available [here](http://travis-ci.org/Placester/ruby-rets).
+
+<img src="https://secure.travis-ci.org/Placester/ruby-rets.png?branch=master&.png"/>
+
+Documentation
+-
+See http://rubydoc.info/github/Placester/ruby-rets/master/frames for full documentation.
+
+Examples
+-
+
+    client = RETS::Client.login(:url => "http://foobar.com/rets/Login", :username => "foo", :password => "bar")
+    client.search(:search_type => :Property, :class => :RES, :query => "(ListPrice=50000-)") do |data|
+      # RETS data in key/value format, as COMPACT-DECODED
+    end
+
+    client.get_object(:resource => :Property, :type => :Photo, :location => false, :id => "1:0:*") do |headers, content|
+      puts "Object-ID #{headers"object-id"]}, Content-ID #{headers["content-id"]}, Description #{["description"]}"
+      puts "Data"
+      puts content
+    end
+
+VCR / WebMock
+-
+Due to the streaming parser, the search features won't work with a library like VCR or Ephemeral Response. For WebMock, you can use the below patch to enable support for saving the HTTP requests to speed up your own tests.
+
+    module Net
+        module WebMockHTTPResponse
+            def self.extended(response)
+                response.instance_variable_set(:@socket, StringIO.new(response.body))
+            end
+        end
+    end
+
+License
+-
+Licensed under MIT

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler"
+Bundler.setup
+
+require "rake"
+require "rspec"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new("spec") do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :spec

data/lib/rets/base/core.rb

@@ -0,0 +1,290 @@
+# For more information on what the possible values of fields that are passed to the RETS server can be, see {http://www.rets.org/documentation}.
+module RETS
+  module Base
+    class Core
+      GET_OBJECT_DATA = ["object-id", "description", "content-id", "content-description", "location", "content-type", "preferred"]
+
+      # Can be called after any {RETS::Base::Core} call that hits the RETS Server.
+      # @return [String] How big the request was
+      attr_reader :request_size
+
+      # Can be called after any {RETS::Base::Core} call that hits the RETS Server.
+      # @return [String] SHA1 hash of the request
+      attr_reader :request_hash
+
+      # Can be called after any {#get_object} or {#search} call that hits the RETS Server.
+      # @return [Float] How long the request took
+      attr_reader :request_time
+
+      # Can be called after any {RETS::Base::Core} call that hits the RETS Server.
+      # @return [Hash]
+      #   Gives access to the miscellaneous RETS data, such as reply text, code, delimiter, count and so on depending on the API call made.
+      #   * *text* (String) - Reply text from the server
+      #   * *code* (String) - Reply code from the server
+      attr_reader :rets_data
+
+      def initialize(http, urls)
+        @http = http
+        @urls = urls
+      end
+
+      ##
+      # Attempts to logout of the RETS server.
+      #
+      # @raise [RETS::CapabilityNotFound]
+      # @raise [RETS::APIError]
+      # @raise [RETS::HTTPError]
+      def logout
+        unless @urls[:logout]
+          raise RETS::CapabilityNotFound.new("No Logout capability found for given user.")
+        end
+
+        @http.request(:url => @urls[:logout])
+
+        nil
+      end
+
+      ##
+      # Whether the RETS server has the requested capability.
+      #
+      # @param [Symbol] type Lowercase of the capability, "getmetadata", "getobject" and so on
+      # @return [Boolean]
+      def has_capability?(type)
+        @urls.has_key?(type)
+      end
+
+      ##
+      # Requests metadata from the RETS server.
+      #
+      # @param [Hash] args
+      # @option args [String] :type Metadata to request, the same value if you were manually making the request, "METADATA-SYSTEM", "METADATA-CLASS" and so on
+      # @option args [String] :id Filter the data returned by ID, "*" would return all available data
+      # @option args [Integer, Optional] :read_timeout How many seconds to wait before giving up
+      #
+      # @yield For every group of metadata downloaded
+      # @yieldparam [String] :type Type of data that was parsed with "METADATA-" stripped out, for "METADATA-SYSTEM" this will be "SYSTEM"
+      # @yieldparam [Hash] :attrs Attributes of the data, generally *Version*, *Date* and *Resource* but can vary depending on what metadata you requested
+      # @yieldparam [Array] :metadata Array of hashes with metadata info
+      #
+      # @raise [RETS::CapabilityNotFound]
+      # @raise [RETS::APIError]
+      # @raise [RETS::HTTPError]
+      # @see #rets_data
+      # @see #request_size
+      # @see #request_hash
+      def get_metadata(args, &block)
+        raise ArgumentError, "No block passed" unless block_given?
+
+        unless @urls[:getmetadata]
+          raise RETS::CapabilityNotFound.new("No GetMetadata capability found for given user.")
+        end
+
+        @request_size, @request_hash, @request_time, @rets_data = nil, nil, nil, nil
+        @http.request(:url => @urls[:getmetadata], :read_timeout => args[:read_timeout], :params => {:Format => :COMPACT, :Type => args[:type], :ID => args[:id]}) do |response|
+          stream = RETS::StreamHTTP.new(response)
+          sax = RETS::Base::SAXMetadata.new(block)
+
+          Nokogiri::XML::SAX::Parser.new(sax).parse_io(stream)
+
+          @request_size, @request_hash = stream.size, stream.hash
+          @rets_data = sax.rets_data
+        end
+
+        nil
+      end
+
+      ##
+      # Requests an object from the RETS server.
+      #
+      # @param [Hash] args
+      # @option args [String] :resource Resource to load, typically *Property*
+      # @option args [String] :type Type of object you want, usually *Photo*
+      # @option args [String] :id What objects to return
+      # @option args [Array, Optional] :accept Array of MIME types to accept, by default this is *image/png*, *image/gif* and *image/jpeg*
+      # @option args [Boolean, Optional] :location Return the location of the object rather than the contents of it
+      # @option args [Integer, Optional] :read_timeout How many seconds to wait before timing out
+      #
+      # @yield For every object downloaded
+      # @yieldparam [Hash] :headers Object headers
+      #     * *object-id* (String) - Objects ID
+      #     * *content-id* (String) - Content ID
+      #     * *content-type* (String) - MIME type of the content
+      #     * *description* (String, Optional) - A description of the object
+      #     * *location* (String, Optional) - Where the file is located, only returned is *location* is true
+      # @yieldparam [String, Optional] :content Content for the object, not called when *location* is set
+      #
+      # @raise [RETS::CapabilityNotFound]
+      # @raise [RETS::APIError]
+      # @raise [RETS::HTTPError]
+      # @see #rets_data
+      # @see #request_size
+      # @see #request_hash
+      def get_object(args, &block)
+        raise ArgumentError, "No block passed" unless block_given?
+
+        unless @urls[:getobject]
+          raise RETS::CapabilityNotFound.new("No GetObject capability found for given user.")
+        end
+
+        req = {:url => @urls[:getobject], :read_timeout => args[:read_timeout], :headers => {}}
+        req[:params] = {:Resource => args[:resource], :Type => args[:type], :Location => (args[:location] ? 1 : 0), :ID => args[:id]}
+        if args[:accept].is_a?(Array)
+          req[:headers]["Accept"] = args[:accept].join(",")
+        else
+          req[:headers]["Accept"] = "image/png,image/gif,image/jpeg"
+        end
+
+        # Will get swapped to a streaming call rather than a download-and-parse later, easy to do as it's called with a block now
+        start = Time.now.utc.to_f
+
+        @request_size, @request_hash, @request_time, @rets_data = nil, nil, nil, nil
+        @http.request(req) do |response|
+          body = response.read_body
+
+          @request_time = Time.now.utc.to_f - start
+          @request_size, @request_hash = body.length, Digest::SHA1.hexdigest(body)
+
+          # Make sure we aren't erroring
+          if body =~ /(<RETS (.+)\>)/
+            # RETSIQ (and probably others) return a <RETS> tag on a location request without any error inside
+            # since parsing errors out of full image data calls is a tricky pain. We're going to keep the
+            # loose error checking, but will confirm that it has an actual error code
+            code, text = @http.get_rets_response(Nokogiri::XML($1).xpath("//RETS").first)
+            unless code == "0"
+              @rets_data = {:code => code, :text => text}
+
+              if code == "20403"
+                return
+              else
+                raise RETS::APIError.new("#{code}: #{text}", code, text)
+              end
+            end
+          end
+
+          # Using a wildcard somewhere
+          if response.content_type == "multipart/parallel"
+            boundary = response.type_params["boundary"]
+            boundary.gsub!(/^"|"$/, "")
+
+            parts = body.split("--#{boundary}\r\n")
+            parts.last.gsub!("\r\n--#{boundary}--", "")
+            parts.each do |part|
+              part.strip!
+              next if part == ""
+
+              headers, content = part.split("\r\n\r\n", 2)
+
+              parsed_headers = {}
+              headers.split("\r\n").each do |line|
+                name, value = line.split(":", 2)
+                next unless value and value != ""
+
+                parsed_headers[name.downcase] = value.strip
+              end
+
+              # Check off the first children because some Rap Rets seems to use RETS-Status
+              # and it will include it with an object while returning actual data.
+              # It only does this for multipart requests, single image pulls will use <RETS> like it should.
+              if parsed_headers["content-type"] == "text/xml"
+                code, text = @http.get_rets_response(Nokogiri::XML(content).children.first)
+                next if code == "20403"
+              end
+
+              if block.arity == 1
+                yield parsed_headers
+              else
+                yield parsed_headers, content
+              end
+
+            end
+
+          # Either text (error) or an image of some sorts, which is irrelevant for this
+          else
+            headers = {}
+            GET_OBJECT_DATA.each do |field|
+              next unless response.header[field] and response.header[field] != ""
+              headers[field] = response.header[field].strip
+            end
+
+            if block.arity == 1
+              yield headers
+            else
+              yield headers, body
+            end
+          end
+        end
+
+        nil
+      end
+
+      ##
+      # Searches the RETS server for data.
+      #
+      # @param [Hash] args
+      # @option args [String] :search_type What to search on, typically *Property*, *Office* or *Agent*
+      # @option args [String] :class What class of data to return, varies between RETS implementations and can be anything from *1* to *ResidentialProperty*
+      # @option args [String] :query How to filter data, should be unescaped as CGI::escape will be called on the string
+      # @option args [Symbol, Optional] :count_mode Either *:only* to return just the total records found or *:both* to get count and records returned
+      # @option args [Integer, Optional] :limit Limit total records returned
+      # @option args [Integer, Optional] :offset Offset to start returning records from
+      # @option args [Array, Optional] :select Restrict the fields the RETS server returns
+      # @option args [Boolean, Optional] :standard_names Whether to use standard names for all fields
+      # @option args [String, Optional] :restricted String to show in place of a field value for any restricted fields the user cannot see
+      # @option args [Integer, Optional] :read_timeout How long to wait for data from the socket before giving up
+      # @option args [Boolean, Optional] :disable_stream Disables the streaming setup for data and instead loads it all and then parses
+      #
+      # @yield Called for every <DATA></DATA> group from the RETS server
+      # @yieldparam [Hash] :data One record of data from the RETS server
+      #
+      # @raise [RETS::CapabilityNotFound]
+      # @raise [RETS::APIError]
+      # @raise [RETS::HTTPError]
+      # @see #rets_data
+      # @see #request_size
+      # @see #request_hash
+      def search(args, &block)
+        if !block_given? and args[:count_mode] != :only
+          raise ArgumentError, "No block found"
+        end
+
+        unless @urls[:search]
+          raise RETS::CapabilityNotFound.new("Cannot find URL for Search call")
+        end
+
+        req = {:url => @urls[:search], :read_timeout => args[:read_timeout]}
+        req[:params] = {:Format => "COMPACT-DECODED", :SearchType => args[:search_type], :QueryType => "DMQL2", :Query => args[:query], :Class => args[:class], :Limit => args[:limit], :Offset => args[:offset], :RestrictedIndicator => args[:restricted]}
+        req[:params][:Select] = args[:select].join(",") if args[:select].is_a?(Array)
+        req[:params][:StandardNames] = 1 if args[:standard_names]
+
+        if args[:count_mode] == :only
+          req[:params][:Count] = 2
+        elsif args[:count_mode] == :both
+          req[:params][:Count] = 1
+        end
+
+        @request_size, @request_hash, @request_time, @rets_data = nil, nil, nil, {}
+
+        start = Time.now.utc.to_f
+        @http.request(req) do |response|
+          if args[:disable_stream]
+            stream = StringIO.new(response.body)
+            @request_time = Time.now.utc.to_f - start
+          else
+            stream = RETS::StreamHTTP.new(response)
+          end
+
+          sax = RETS::Base::SAXSearch.new(@rets_data, block)
+          Nokogiri::XML::SAX::Parser.new(sax).parse_io(stream)
+
+          if args[:disable_stream]
+            @request_size, @request_hash = response.body.length, Digest::SHA1.hexdigest(response.body)
+          else
+            @request_size, @request_hash = stream.size, stream.hash
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/rets/base/sax_metadata.rb

@@ -0,0 +1,63 @@
+# SAX parser for the GetMetadata call.
+class RETS::Base::SAXMetadata < Nokogiri::XML::SAX::Document
+  attr_accessor :rets_data
+
+  def initialize(block)
+    @rets_data = {:delimiter => "\t"}
+    @block = block
+    @parent = {}
+  end
+
+  def start_element(tag, attrs)
+    @current_tag = nil
+
+    # Figure out if the request is a success
+    if tag == "RETS"
+      @rets_data[:code], @rets_data[:text] = attrs.first.last, attrs.last.last
+      if @rets_data[:code] != "0" and @rets_data[:code] != "20201"
+        raise RETS::APIError.new("#{@rets_data[:code]}: #{@rets_data[:text]}", @rets_data[:code], @rets_data[:text])
+      end
+
+    elsif tag == "SYSTEM"
+      @rets_data[:system_id] = attrs.first.last
+
+    # Parsing data
+    elsif tag == "COLUMNS" or tag == "DATA"
+      @buffer = ""
+      @current_tag = tag
+
+    # Start of the parent we're working with
+    elsif tag =~ /^METADATA-(.+)/
+      @parent[:tag] = tag
+      @parent[:name] = $1
+      @parent[:data] = []
+      @parent[:attrs] = {}
+      attrs.each {|attr| @parent[:attrs][attr[0]] = attr[1] }
+    end
+  end
+
+  def characters(string)
+    @buffer << string if @current_tag
+  end
+
+  def end_element(tag)
+    return unless @current_tag
+
+    if @current_tag == "COLUMNS"
+      @columns = @buffer.split(@rets_data[:delimiter])
+    elsif tag == "DATA"
+      data = {}
+
+      list = @buffer.split(@rets_data[:delimiter])
+      list.each_index do |index|
+        next if @columns[index].nil? or @columns[index] == ""
+        data[@columns[index]] = list[index]
+      end
+
+      @parent[:data].push(data)
+    elsif tag == @parent[:tag]
+      @block.call(@parent[:name], @parent[:attrs], @parent[:data])
+      @parent[:tag] = nil
+    end
+  end
+end

data/lib/rets/base/sax_search.rb

@@ -0,0 +1,58 @@
+# SAX parser for the Search API call.
+class RETS::Base::SAXSearch < Nokogiri::XML::SAX::Document
+  attr_reader :rets_data
+
+  def initialize(rets_data, block)
+    @block = block
+    @rets_data = rets_data
+  end
+
+  def start_element(tag, attrs)
+    @current_tag = nil
+
+    # Figure out if the request is a success
+    if tag == "RETS"
+      @rets_data[:code], @rets_data[:text] = attrs.first.last, attrs.last.last
+      if @rets_data[:code] != "0" and @rets_data[:code] != "20201"
+        raise RETS::APIError.new("#{@rets_data[:code]}: #{@rets_data[:text]}", @rets_data[:code], @rets_data[:text])
+      end
+
+    # Determine the separator for data
+    elsif tag == "DELIMITER"
+      @rets_data[:delimiter] = attrs.first.last.to_i.chr
+
+    # Total records returned
+    elsif tag == "COUNT"
+      @rets_data[:count] = attrs.first.last.to_i
+
+    # Parsing data
+    elsif tag == "COLUMNS" or tag == "DATA"
+      @buffer = ""
+      @current_tag = tag
+    end
+  end
+
+  def characters(string)
+    @buffer << string if @current_tag
+  end
+
+  def end_element(tag)
+    return unless @current_tag
+
+    if @current_tag == "COLUMNS"
+      @columns = @buffer.split(@rets_data[:delimiter])
+
+    # Finalize data and send it off
+    elsif tag == "DATA"
+      data = {}
+
+      list = @buffer.split(@rets_data[:delimiter])
+      list.each_index do |index|
+        next if @columns[index].nil? or @columns[index] == ""
+        data[@columns[index]] = list[index]
+      end
+
+      @block.call(data)
+    end
+  end
+end

data/lib/rets/client.rb

@@ -0,0 +1,70 @@
+require "nokogiri"
+
+module RETS
+  class Client
+    URL_KEYS = {:getobject => true, :login => true, :logout => true, :search => true, :getmetadata => true}
+
+    ##
+    # Attempts to login to a RETS server.
+    # @param [Hash] args
+    # @option args [String] :url Login URL for the RETS server
+    # @option args [String] :username Username to authenticate with
+    # @option args [String] :password Password to authenticate with
+    # @option args [Symbol, Optional] :auth_mode When set to *:basic* will automatically use HTTP Basic authentication, skips a discovery request when initially connecting
+    # @option args [Hash, Optional] :useragent Only necessary for User Agent authentication
+    #   * :name [String, Optional] - Name to set the User-Agent to
+    #   * :password [String, Optional] - Password to use for RETS-UA-Authorization
+    # @option args [String, Optional] :rets_version Forces RETS-UA-Authorization on the first request if this and useragent name/password are set. Can be auto detected, but usually lets you bypass 1 - 2 additional authentication requests initially.
+    # @option args [Hash, Optional] :http Additional configuration for the HTTP requests
+    #   * :verify_mode [Integer, Optional] How to verify the SSL certificate when connecting through HTTPS, either OpenSSL::SSL::VERIFY_PEER or OpenSSL::SSL::VERIFY_NONE, defaults to OpenSSL::SSL::VERIFY_NONE
+    #   * :ca_file [String, Optional] Path to the CA certification file in PEM format
+    #   * :ca_path [String, Optional] Path to the directory containing CA certifications in PEM format
+    #
+    # @raise [ArgumentError]
+    # @raise [RETS::APIError]
+    # @raise [RETS::HTTPError]
+    # @raise [RETS::Unauthorized]
+    # @raise [RETS::ResponseError]
+    #
+    # @return [RETS::Base::Core]
+    def self.login(args)
+      raise ArgumentError, "No URL passed" unless args[:url]
+
+      urls = {:login => URI.parse(args[:url])}
+      raise ArgumentError, "Invalid URL passed" unless urls[:login].is_a?(URI::HTTP)
+
+      base_url = urls[:login].to_s
+      base_url.gsub!(urls[:login].path, "") if urls[:login].path
+
+      http = RETS::HTTP.new(args)
+      http.request(:url => urls[:login], :check_response => true) do |response|
+        rets_attr = Nokogiri::XML(response.body).xpath("//RETS")
+        if rets_attr.empty?
+          raise RETS::ResponseError, "Does not seem to be a RETS server."
+        end
+
+        rets_attr.first.content.split("\n").each do |row|
+          key, value = row.split("=", 2)
+          next unless key and value
+
+          key, value = key.downcase.strip.to_sym, value.strip
+
+          if URL_KEYS[key]
+            # In case it's a relative path and doesn't include the domain
+            if value =~ /(http|www)/
+              urls[key] = URI.parse(value)
+            else
+              key_url = URI.parse(urls[:login].to_s)
+              key_url.path = value
+              urls[key] = key_url
+            end
+          end
+        end
+      end
+
+      http.login_uri = urls[:login]
+
+      RETS::Base::Core.new(http, urls)
+    end
+  end
+end

data/lib/rets/exceptions.rb

@@ -0,0 +1,37 @@
+module RETS
+  ##
+  # Generic module that provides access to the code and text separately of the exception
+  module ReplyErrors
+    attr_reader :reply_text, :reply_code
+
+    def initialize(msg, reply_code=nil, reply_text=nil)
+      super(msg)
+      @reply_code, @reply_text = reply_code, reply_text
+    end
+  end
+
+  ##
+  # RETS server replied to a request with an error of some sort.
+  class APIError < StandardError
+    include ReplyErrors
+  end
+
+  ##
+  # Server responded with bad data.
+  class ResponseError < StandardError
+  end
+
+  ##
+  # HTTP errors related to a request.
+  class HTTPError < StandardError
+    include ReplyErrors
+  end
+
+  ##
+  # Cannot login
+  class Unauthorized < RuntimeError; end
+
+  ##
+  # Account does not have access to the requested API.
+  class CapabilityNotFound < RuntimeError; end
+end

data/lib/rets/http.rb

@@ -0,0 +1,329 @@
+require "net/https"
+require "digest"
+
+module RETS
+  class HTTP
+    attr_accessor :login_uri
+
+    ##
+    # Creates a new HTTP instance which will automatically handle authenting to the RETS server.
+    def initialize(args)
+      @headers = {"User-Agent" => "Ruby RETS/v#{RETS::VERSION}"}
+      @request_count = 0
+      @config = {:http => {}}.merge(args)
+      @rets_data, @cookie_list = {}, {}
+
+      if @config[:useragent] and @config[:useragent][:name]
+        @headers["User-Agent"] = @config[:useragent][:name]
+      end
+
+      if @config[:rets_version]
+        @rets_data[:version] = @config[:rets_version]
+        self.setup_ua_authorization(:version => @config[:rets_version])
+      end
+
+      if @config[:auth_mode] == :basic
+        @auth_mode = @config.delete(:auth_mode)
+      end
+    end
+
+    def url_encode(str)
+      encoded_string = ""
+      str.each_char do |char|
+        case char
+        when "+"
+          encoded_string << "%2b"
+        when "="
+          encoded_string << "%3d"
+        when "?"
+          encoded_string << "%3f"
+        when "&"
+          encoded_string << "%26"
+        when "%"
+          encoded_string << "%25"
+        when ","
+          encoded_string << "%2C"
+        else
+          encoded_string << char
+        end
+      end
+      encoded_string
+    end
+
+    def get_digest(header)
+      return unless header
+
+      header.each do |text|
+        mode, text = text.split(" ", 2)
+        return text if mode == "Digest"
+      end
+
+      nil
+    end
+
+    ##
+    # Creates and manages the HTTP digest auth
+    # if the WWW-Authorization header is passed, then it will overwrite what it knows about the auth data.
+    def save_digest(header)
+      @request_count = 0
+
+      @digest = {}
+      header.split(",").each do |line|
+        k, v = line.strip.split("=", 2)
+        @digest[k] = (k != "algorithm" and k != "stale") && v[1..-2] || v
+      end
+
+      @digest_type = @digest["qop"] ? @digest["qop"].split(",") : []
+    end
+
+    ##
+    # Creates a HTTP digest header.
+    def create_digest(method, request_uri)
+      # http://en.wikipedia.org/wiki/Digest_access_authentication
+      first = Digest::MD5.hexdigest("#{@config[:username]}:#{@digest["realm"]}:#{@config[:password]}")
+      second = Digest::MD5.hexdigest("#{method}:#{request_uri}")
+
+      # Using the "newer" authentication QOP
+      if @digest_type.include?("auth")
+        cnonce = Digest::MD5.hexdigest("#{@headers["User-Agent"]}:#{@config[:password]}:#{@request_count}:#{@digest["nonce"]}")
+        hash = Digest::MD5.hexdigest("#{first}:#{@digest["nonce"]}:#{"%08X" % @request_count}:#{cnonce}:#{@digest["qop"]}:#{second}")
+      # Nothing specified, so default to the old one
+      elsif @digest_type.empty?
+        hash = Digest::MD5.hexdigest("#{first}:#{@digest["nonce"]}:#{second}")
+      else
+        raise RETS::HTTPError, "Cannot determine auth type for server (#{@digest_type.join(",")})"
+      end
+
+      http_digest = "Digest username=\"#{@config[:username]}\", "
+      http_digest << "realm=\"#{@digest["realm"]}\", "
+      http_digest << "nonce=\"#{@digest["nonce"]}\", "
+      http_digest << "uri=\"#{request_uri}\", "
+      http_digest << "algorithm=MD5, " unless @digest_type.empty?
+      http_digest << "response=\"#{hash}\", "
+      http_digest << "opaque=\"#{@digest["opaque"]}\""
+
+      unless @digest_type.empty?
+        http_digest << ", "
+        http_digest << "qop=\"#{@digest["qop"]}\", "
+        http_digest << "nc=#{"%08X" % @request_count}, "
+        http_digest << "cnonce=\"#{cnonce}\""
+      end
+
+      http_digest
+    end
+
+    ##
+    # Creates a HTTP basic header.
+    def create_basic
+       "Basic " << ["#{@config[:username]}:#{@config[:password]}"].pack("m").delete("\r\n")
+    end
+
+    ##
+    # Finds the ReplyText and ReplyCode attributes in the response
+    #
+    # @param [Nokogiri::XML::NodeSet] rets <RETS> attributes found
+    #
+    # @return [String] RETS ReplyCode
+    # @return [String] RETS ReplyText
+    def get_rets_response(rets)
+      code, text = nil, nil
+      rets.attributes.each do |attr|
+        key = attr.first.downcase
+        if key == "replycode"
+          code = attr.last.value
+        elsif key == "replytext"
+          text = attr.last.value
+        end
+      end
+
+      return code, text
+    end
+
+    ##
+    # Handles managing the relevant RETS-UA-Authorization headers
+    #
+    # @param [Hash] args
+    # @option args [String] :version RETS Version
+    # @option args [String, Optional] :session_id RETS Session ID
+    def setup_ua_authorization(args)
+      # Most RETS implementations don't care about RETS-Version for RETS-UA-Authorization, they don't require RETS-Version in general.
+      # Rapattoni require RETS-Version even without RETS-UA-Authorization, so will try and set the header when possible from the HTTP request rather than implying it.
+      # Interealty requires RETS-Version for RETS-UA-Authorization, so will fake it when we get an 20037 error
+      @headers["RETS-Version"] = args[:version] if args[:version]
+
+      if @headers["RETS-Version"] and @config[:useragent] and @config[:useragent][:password]
+        login = Digest::MD5.hexdigest("#{@config[:useragent][:name]}:#{@config[:useragent][:password]}")
+        @headers.merge!("RETS-UA-Authorization" => "Digest #{Digest::MD5.hexdigest("#{login}::#{args[:session_id]}:#{@headers["RETS-Version"]}")}")
+      end
+    end
+
+    ##
+    # Sends a request to the RETS server.
+    #
+    # @param [Hash] args
+    # @option args [URI] :url URI to request data from
+    # @option args [Hash, Optional] :params Query string to include with the request
+    # @option args [Integer, Optional] :read_timeout How long to wait for the socket to return data before timing out
+    #
+    # @raise [RETS::APIError]
+    # @raise [RETS::HTTPError]
+    # @raise [RETS::Unauthorized]
+    def request(args, &block)
+      if args[:params]
+        url_terminator = (args[:url].request_uri.include?("?")) ? "&" : "?"
+        request_uri = "#{args[:url].request_uri}#{url_terminator}"
+        args[:params].each do |k, v|
+          request_uri << "#{k}=#{url_encode(v.to_s)}&" if v
+        end
+      else
+        request_uri = args[:url].request_uri
+      end
+
+      headers = args[:headers]
+
+      # Digest will change every time due to how its setup
+      @request_count += 1
+      if @auth_mode == :digest
+        if headers
+          headers["Authorization"] = create_digest("GET", request_uri)
+        else
+          headers = {"Authorization" => create_digest("GET", request_uri)}
+        end
+      end
+
+      headers = headers ? @headers.merge(headers) : @headers
+
+      http = ::Net::HTTP.new(args[:url].host, args[:url].port)
+      http.read_timeout = args[:read_timeout] if args[:read_timeout]
+      http.set_debug_output(@config[:debug_output]) if @config[:debug_output]
+
+      if args[:url].scheme == "https"
+        http.use_ssl = true
+        http.verify_mode = @config[:http][:verify_mode] || OpenSSL::SSL::VERIFY_NONE
+        http.ca_file = @config[:http][:ca_file] if @config[:http][:ca_file]
+        http.ca_path = @config[:http][:ca_path] if @config[:http][:ca_path]
+      end
+
+      http.start do
+        http.request_get(request_uri, headers) do |response|
+          # Pass along the cookies
+          # Some servers will continually call Set-Cookie with the same value for every single request
+          # to avoid authentication problems from cookies being stomped over (which is sad, nobody likes having their cookies crushed).
+          # We keep a hash of every cookie set and only update it if something changed
+          if response.header["set-cookie"]
+            cookies_changed = nil
+
+            response.header.get_fields("set-cookie").each do |cookie|
+              key, value = cookie.split(";").first.split("=")
+              key.strip!
+              value.strip!
+
+              # If it's a RETS-Session-ID, it needs to be shoved into the RETS-UA-Authorization field
+              # Save the RETS-Session-ID so it can be used with RETS-UA-Authorization
+              if key.downcase == "rets-session-id"
+                @rets_data[:session_id] = value
+                self.setup_ua_authorization(@rets_data) if @rets_data[:version]
+              end
+
+              cookies_changed = true if @cookie_list[key] != value
+              @cookie_list[key] = value
+            end
+
+            if cookies_changed
+              @headers.merge!("Cookie" => @cookie_list.map {|k, v| "#{k}=#{v}"}.join("; "))
+            end
+          end
+
+          # Rather than returning HTTP 401 when User-Agent authentication is needed, Retsiq returns HTTP 200
+          # with RETS error 20037. If we get a 20037, will let it pass through and handle it as if it was a HTTP 401.
+          # Retsiq apparently returns a 20041 now instead of a 20037 for the same use case.
+          # StratusRETS returns 20052 for an expired season
+          rets_code = nil
+          if response.code != "401" and ( response.code != "200" or args[:check_response] )
+            if response.body =~ /<RETS/i
+              rets_code, text = self.get_rets_response(Nokogiri::XML(response.body).xpath("//RETS").first)
+              unless rets_code == "20037" or rets_code == "20041" or rets_code == "20052" or rets_code == "0"
+                raise RETS::APIError.new("#{rets_code}: #{text}", rets_code, text)
+              end
+
+            elsif !args[:check_response]
+              raise RETS::HTTPError.new("#{response.code}: #{response.message}", response.code, response.message)
+            end
+          end
+
+          # Strictly speaking, we do not need to set a RETS-Version in most cases, if RETS-UA-Authorization is not used
+          # It makes more sense to be safe and set it. Innovia at least does not set this until authentication is successful
+          # which is why this check is also here for HTTP 200s and not just 401s
+          if response.code == "200" and !@rets_data[:version] and response.header["rets-version"] != ""
+            @rets_data[:version] = response.header["rets-version"]
+          end
+
+          # Digest can become stale requiring us to reload data
+          if @auth_mode == :digest and response.header["www-authenticate"] =~ /stale=true/i
+            save_digest(get_digest(response.header.get_fields("www-authenticate")))
+
+            args[:block] ||= block
+            return self.request(args)
+
+          elsif response.code == "401" or rets_code == "20037" or rets_code == "20041" or rets_code == "20052"
+            raise RETS::Unauthorized, "Cannot login, check credentials" if ( @auth_mode and @retried_request ) or ( @retried_request and rets_code == "20037" )
+            @retried_request = true
+
+            # We already have an auth mode, and the request wasn't retried.
+            # Meaning we know that we had a successful authentication but something happened so we should relogin.
+            if @auth_mode
+              @headers.delete("Cookie")
+              @cookie_list = {}
+
+              self.request(:url => login_uri)
+              return self.request(args.merge(:block => block))
+            end
+
+            # Find a valid way of authenticating to the server as some will support multiple methods
+            if response.header.get_fields("www-authenticate") and !response.header.get_fields("www-authenticate").empty?
+              digest = get_digest(response.header.get_fields("www-authenticate"))
+              if digest
+                save_digest(digest)
+                @auth_mode = :digest
+              else
+                @headers.merge!("Authorization" => create_basic)
+                @auth_mode = :basic
+              end
+
+              unless @auth_mode
+                raise RETS::HTTPError.new("Cannot authenticate, no known mode found", response.code)
+              end
+            end
+
+            # Check if we need to deal with User-Agent authorization
+            if response.header["rets-version"] and response.header["rets-version"] != ""
+              @rets_data[:version] = response.header["rets-version"]
+
+            # If we get a 20037 error, it could be due to not having a RETS-Version set
+            # Under Innovia, passing RETS/1.7 will cause some errors
+            # because they don't pass the RETS-Version header until a successful login which is a HTTP 200
+            # They also don't use RETS-UA-Authorization, and it's better to not imply the RETS-Version header
+            # unless necessary, so will only do it for 20037 errors now.
+            elsif !@rets_data[:version] and rets_code == "20037"
+              @rets_data[:version] = "RETS/1.7"
+            end
+
+            self.setup_ua_authorization(@rets_data)
+
+            args[:block] ||= block
+            return self.request(args)
+
+          # We just tried to auth and don't have access to the original block in yieldable form
+          elsif args[:block]
+            @retried_request = nil
+            args.delete(:block).call(response)
+
+          elsif block_given?
+            @retried_request = nil
+            yield response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rets/stream_http.rb

@@ -0,0 +1,159 @@
+# This is a slightly crazy hack, but it's saner if we can just use Net::HTTP and then fallback on the StreamHTTP class when we need to do stream parsing.
+# If we were to do it ourselves with Sockets, it would be a bigger pain to manage that, and we would have to do roughly the same setup as below anyway.
+# Essentially, for the hack of using instance_variable_get/instance_variable_set, we get a simple stream parser, without having to write our own HTTP class.
+module RETS
+  class StreamHTTP
+    ENCODABLE = RUBY_VERSION >= "1.9.0"
+
+    ##
+    # Initializes a new HTTP stream which can be passed to Nokogiri for SAX parsing.
+    # @param [Net::HTTPResponse] response
+    #   Unused HTTP response, no calls to any of the read_body or other methods can have been called.
+    def initialize(response)
+      @response = response
+      @left_to_read = @response.content_length
+      @content_length = @response.content_length
+      @chunked = @response.chunked?
+      @socket = @response.instance_variable_get(:@socket)
+
+      @digest = Digest::SHA1.new
+      @total_size = 0
+
+      if @response.header.key?("content-type") and @response["content-type"] =~ /.*charset=(.*)/i
+        @encoding = $1.to_s.upcase
+      end
+    end
+
+    ##
+    # The total size read from the stream, can be called either while reading or at the end.
+    def size
+      @total_size
+    end
+
+    ##
+    # SHA1 hash of the data read from the stream
+    def hash
+      @digest.hexdigest
+    end
+
+    ##
+    # Detected encoding
+    def encoding
+      @encoding
+    end
+
+    ##
+    # Read
+    #
+    # @param [Integer] read_len
+    #   How many bytes to read from the HTTP stream
+    def read(read_len)
+      # If we closed the connection, return nil without calling anything again to avoid EOF
+      # or other errors
+      return nil if @closed
+
+      if @left_to_read
+        # We hit the end of what we need to read, if this is a chunked request, then we need to check for the next chunk
+        if @left_to_read <= read_len
+          data = @socket.read(@left_to_read)
+          @total_size += @left_to_read
+          @left_to_read = nil
+          @read_clfr = true
+        # Reading from known buffer still
+        else
+          @left_to_read -= read_len
+          @total_size += read_len
+          data = @socket.read(read_len)
+        end
+
+      elsif @chunked
+        # We finished reading the chunks, read the last 2 to get \r\n out of the way, and then find the next chunk
+        if @read_clfr
+          @read_clfr = nil
+          @socket.read(2)
+        end
+
+        data, chunk_read = "", 0
+        while true
+          # Read first line to get the chunk length
+          line = @socket.readline
+
+          len = line.slice(/[0-9a-fA-F]+/) or raise Net::HTTPBadResponse.new("wrong chunk size line: #{line}")
+          len = len.hex
+
+          # Nothing left, read off the final \r\n
+          if len == 0
+            @socket.read(2)
+            @socket.close
+            @response.instance_variable_set(:@read, true)
+
+            @closed = true
+            break
+          end
+
+          # Reading this chunk will set us over the buffer amount
+          # Read what we can of it (if anything), and send back what we have and queue a read for the rest
+          if ( chunk_read + len ) > read_len
+            can_read = len - ( ( chunk_read + len ) - read_len )
+
+            @left_to_read = len - can_read
+            @total_size += can_read
+
+            data << @socket.read(can_read) if can_read > 0
+            break
+          # We can just return the chunk as-is
+          else
+            @total_size += len
+            chunk_read += len
+
+            data << @socket.read(len)
+            @socket.read(2)
+          end
+        end
+
+      # If we don't have a content length, then we need to keep reading until we run out of data
+      elsif !@content_length
+        data = @socket.readline
+
+        @total_size += data.length if data
+      end
+
+      # We've finished reading, set this so Net::HTTP doesn't try and read it again
+      if !data or data == ""
+        @response.instance_variable_set(:@read, true)
+
+        nil
+      else
+        if data.length >= @total_size and !@chunked
+          @response.instance_variable_set(:@read, true)
+        end
+
+        if ENCODABLE and @encoding
+          data = data.force_encoding(@encoding) if @encoding
+          data = data.encode("UTF-8")
+        end
+
+        @digest.update(data)
+        data
+      end
+
+    # Mark as read finished, return the last bits of data (if any)
+    rescue EOFError
+      @response.instance_variable_set(:@read, true)
+      @socket.close
+      @closed = true
+
+      if data and data != ""
+        @digest.update(data)
+        data
+      else
+        nil
+      end
+    end
+
+    ##
+    # Does nothing, only used because Nokogiri requires it in a SAX parser.
+    def close
+    end
+  end
+end

data/lib/rets/version.rb

@@ -0,0 +1,3 @@
+module RETS
+  VERSION = "2.0.8"
+end

data/lib/ruby-rets.rb

@@ -0,0 +1,9 @@
+path = File.expand_path("../rets", __FILE__)
+require "#{path}/version"
+require "#{path}/exceptions"
+require "#{path}/client"
+require "#{path}/http"
+require "#{path}/stream_http"
+require "#{path}/base/core"
+require "#{path}/base/sax_search"
+require "#{path}/base/sax_metadata"

data/ruby-rets.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rets/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby-rets"
+  spec.version       = RETS::VERSION
+  spec.authors       = ["Placester"]
+  spec.email         = ["sean@seancoleman.net"]
+  spec.summary       = %q{Mirror of the github ruby-rets gem}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency 'nokogiri', '>= 1.5.0'
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: ruby-rets
+version: !ruby/object:Gem::Version
+  version: 2.0.8
+platform: ruby
+authors:
+- Placester
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+description: 
+email:
+- sean@seancoleman.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/rets/base/core.rb
+- lib/rets/base/sax_metadata.rb
+- lib/rets/base/sax_search.rb
+- lib/rets/client.rb
+- lib/rets/exceptions.rb
+- lib/rets/http.rb
+- lib/rets/stream_http.rb
+- lib/rets/version.rb
+- lib/ruby-rets.rb
+- ruby-rets.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Mirror of the github ruby-rets gem
+test_files: []