simplyrets 0.1 → 1.0.0

data/#example.rb#

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-
-%w(rubygems simplyrets).each {|lib| require lib}
-%w(rubygems simplyrets).each {|models| require models}
-
-require "simplyrets"
-require "properties_api"
-require "listing"
-
-p "SimplyRETS Ruby SDK"
-
-SimplyRets.configure do |config|
-  config.username = 'simplyrets'
-  config.password = 'simplyrets'
-end
-
-# Properties
-listings = Properties_api.properties({:minbeds => 2,:brokers => [ "COLD09" ]})
-listings.each do |l|
-  p l.property['bedrooms']
-  p l.office['brokerid']
-end
-
-
-# Single Properties
-# Single Listing
-p = Properties_api.property(47638976)
-Agentlist 47638976
-p "#{p.geo['lat']}, #{p.geo['lng']}"

data/lib/monkey.rb

@@ -1,90 +0,0 @@
-# module SimplyRets
-  class Object
-
-    unless Object.method_defined? :blank?
-      def blank?
-        respond_to?(:empty?) ? empty? : !self
-      end
-    end
-
-    unless Object.method_defined? :present?
-      def present?
-        !blank?
-      end
-    end
-
-  end
-
-  class String
-
-    unless String.method_defined? :underscore
-      def underscore
-        self.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
-      end
-    end
-
-    unless String.method_defined? :camelize
-      def camelize(first_letter_in_uppercase = true)
-        if first_letter_in_uppercase != :lower
-          self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-        else
-          self.to_s[0].chr.downcase + camelize(self)[1..-1]
-        end
-      end
-    end
-
-  end
-
-  class Hash
-
-    unless Hash.method_defined? :stringify_keys
-      def stringify_keys
-        inject({}) do |options, (key, value)|
-          options[key.to_s] = value
-          options
-        end
-      end
-    end
-
-    unless Hash.method_defined? :stringify_keys!
-      def stringify_keys!
-        self.replace(self.stringify_keys)
-      end
-    end
-
-    unless Hash.method_defined? :symbolize_keys
-      def symbolize_keys
-        inject({}) do |options, (key, value)|
-          options[(key.to_sym rescue key) || key] = value
-          options
-        end
-      end
-    end
-
-    unless Hash.method_defined? :symbolize_keys!
-      def symbolize_keys!
-        self.replace(self.symbolize_keys)
-      end
-    end
-
-    unless Hash.method_defined? :symbolize_and_underscore_keys
-      def symbolize_and_underscore_keys
-        inject({}) do |options, (key, value)|
-          options[(key.to_s.underscore.to_sym rescue key) || key] = value
-          options
-        end
-      end
-    end
-
-    unless Hash.method_defined? :symbolize_and_underscore_keys!
-      def symbolize_and_underscore_keys!
-        self.replace(self.symbolize_and_underscore_keys)
-      end
-    end
-
-  end
-# end

data/lib/properties_api.rb

@@ -1,75 +0,0 @@
-require "uri"
-
-class Properties_api
-  basePath = "https://api.simplyrets.com"
-
-  def self.escapeString(string)
-    URI.encode(string.to_s)
-  end
-
-  def self.properties (opts={})
-    query_param_keys = [:brokers,:features,:amenities,:agent,:maxarea,
-                        :minarea,:minprice,:minbaths,:maxbeds,:minbeds,
-                        :neighborhoods,:points,:counties,:status,:type,:q]
-
-    # set default values and merge with input
-    options = {
-      :brokers => nil ,
-      :features => nil ,
-      :amenities => nil ,
-      :agent => nil ,
-      :maxarea => nil ,
-      :minarea => nil ,
-      :minprice => nil ,
-      :minbaths => nil ,
-      :maxbeds => nil ,
-      :minbeds => nil ,
-      :neighborhoods => nil ,
-      :points => nil ,
-      :counties => nil ,
-      :status => nil ,
-      :type => nil ,
-      :q => nil }.merge(opts)
-
-    #resource path
-    path = "/properties".sub('{format}','json')
-
-    # pull querystring keys from options
-    queryopts = options.select do |key,value|
-      query_param_keys.include? key
-    end
-
-    headers = nil
-    post_body = nil
-    response = SimplyRets::Request.new(:GET, path,{:params=>queryopts, :headers=>headers, :body=>post_body }).make.body
-    response.map {|response|Listing.new(response)}
-
-  end
-
-  def self.property (mls_id=nil,opts={})
-     query_param_keys = []
-
-     # verify existence of params
-     raise "mls_id is required" if mls_id.nil?
-
-     # set default values and merge with input
-     options = {
-       :mls_id => nil
-     }.merge(opts)
-
-     #resource path
-     path = "/properties/{mlsId}".sub('{format}','json').sub('{' + 'mlsId' + '}', escapeString(mls_id))
-
-     # pull querystring keys from options
-     queryopts = options.select do |key,value|
-       query_param_keys.include? key
-     end
-
-     headers = nil
-     post_body = nil
-     response = SimplyRets::Request.new(:GET, path, {:params=>queryopts,:headers=>headers, :body=>post_body }).make.body
-     Listing.new(response)
-
-  end
-
-end

data/lib/simplyrets.rb~

@@ -1,85 +0,0 @@
-
-require 'monkey'
-require 'simplyrets/configuration'
-require 'simplyrets/request'
-require 'simplyrets/response'
-require 'simplyrets/version'
-require 'logger'
-
-module SimplyRets
-
-  class << self
-    attr_accessor :logger
-
-    # A SimplyRets configuration object. Must act like a hash and return sensible
-    # values for all SimplyRets configuration options. See SimplyRets::Configuration.
-    attr_accessor :configuration
-
-    attr_accessor :resources
-
-    # Call this method to modify defaults in your initializers.
-    #
-    # @example
-    #   SimplyRets.configure do |config|
-    #     config.api_key = '1234567890abcdef'     # required
-    #     config.username = 'wordlover'           # optional, but needed for user-related functions
-    #     config.password = 'i<3words'            # optional, but needed for user-related functions
-    #     config.format = 'json'                  # optional, defaults to 'json'
-    #   end
-    #
-    def configure
-      self.configuration ||= Configuration.new
-      yield(configuration) if block_given?
-
-      # Configure logger.  Default to use Rails
-      self.logger ||= configuration.logger || (defined?(Rails) ? Rails.logger : Logger.new(STDOUT))
-
-      # remove :// from scheme
-      configuration.scheme.sub!(/:\/\//, '')
-
-      # remove http(s):// and anything after a slash
-      configuration.host.sub!(/https?:\/\//, '')
-      configuration.host = configuration.host.split('/').first
-
-      # Add leading and trailing slashes to base_path
-      configuration.base_path = "/#{configuration.base_path}".gsub(/\/+/, '/')
-      configuration.base_path = "" if configuration.base_path == "/"
-    end
-
-    def authenticated?
-      SimplyRets.configuration.auth_token.present?
-    end
-
-    def de_authenticate
-      SimplyRets.configuration.auth_token = nil
-    end
-
-    def authenticate
-      return if SimplyRets.authenticated?
-
-      if SimplyRets.configuration.username.blank? || SimplyRets.configuration.password.blank?
-        raise ClientError, "Username and password are required to authenticate."
-      end
-
-      request = SimplyRets::Request.new(
-        :get,
-        "account/authenticate/{username}",
-        :params => {
-          :username => SimplyRets.configuration.username,
-          :password => SimplyRets.configuration.password
-        }
-      )
-
-      response_body = request.response.body
-      SimplyRets.configuration.auth_token = response_body['token']
-    end
-
-  end
-
-end
-
-class ServerError < StandardError
-end
-
-class ClientError < StandardError
-end

data/lib/simplyrets/configuration.rb

@@ -1,25 +0,0 @@
-module SimplyRets
-
-  class Configuration
-    require 'simplyrets/version'
-
-    attr_accessor :format, :api_key, :username, :password,
-                  :auth_token, :scheme, :host, :base_path,
-                  :user_agent, :logger, :inject_format,
-                  :force_ending_format, :camelize_params
-
-    # Defaults go in here..
-    def initialize
-      @format = 'json'
-      @scheme = 'https'
-      @host = 'api.simplyrets.com'
-      @base_path = '/'
-      @user_agent = "ruby-#{SimplyRets::VERSION}"
-      @inject_format = false
-      @force_ending_format = false
-      @camelize_params = true
-    end
-
-  end
-
-end

data/lib/simplyrets/request.rb

@@ -1,205 +0,0 @@
-module SimplyRets
-
-  class Request
-    require 'uri'
-    require 'addressable/uri'
-    require 'typhoeus'
-    require 'base64'
-    require "simplyrets/version"
-
-    attr_accessor :host, :path, :format, :params, :body, :http_method, :headers
-
-
-    # All requests must have an HTTP method and a path
-    # Optionals parameters are :params, :headers, :body, :format, :host
-    #
-    def initialize(http_method, path, attributes={})
-      attributes[:format] ||= SimplyRets.configuration.format
-      attributes[:params] ||= {}
-
-      # Set default headers
-      default_headers = {
-        'Content-Type' => "application/#{attributes[:format].downcase}",
-        :api_key => SimplyRets.configuration.api_key
-      }
-
-      # api_key from headers hash trumps the default, even if its value is blank
-      if attributes[:headers].present? && attributes[:headers].has_key?(:api_key)
-        default_headers.delete(:api_key)
-      end
-
-      # api_key from params hash trumps all others (headers and default_headers)
-      if attributes[:params].present? && attributes[:params].has_key?(:api_key)
-        default_headers.delete(:api_key)
-        attributes[:headers].delete(:api_key) if attributes[:headers].present?
-      end
-
-      # Merge argument headers into defaults
-      attributes[:headers] = default_headers.merge(attributes[:headers] || {})
-
-      # Stick in the auth header
-      auth = SimplyRets.configuration.username + ":" + SimplyRets.configuration.password
-      attributes[:headers].merge!({"Authorization" =>
-          ("Basic " + Base64.encode64(auth))})
-
-      self.http_method = http_method.to_sym
-      self.path = path
-      attributes.each do |name, value|
-        send("#{name.to_s.underscore.to_sym}=", value)
-      end
-    end
-
-    # Construct a base URL
-    #
-    def url(options = {})
-      u = Addressable::URI.new(
-        :scheme => SimplyRets.configuration.scheme,
-        :host => SimplyRets.configuration.host,
-        :path => self.interpreted_path,
-        :query => self.query_string.sub(/\?/, '')
-      ).to_s
-
-      # Drop trailing question mark, if present
-      u.sub! /\?$/, ''
-
-      u
-    end
-
-    # Iterate over the params hash, injecting any path values into the path string
-    #
-    # NOTE: This is currently not supported in the SimplyRETS API. Content
-    # formatting is handled via the accept header.
-    #
-    # e.g. /properties.{format}/{word}/entries => /word.json/cat/entries
-    def interpreted_path
-      p = self.path.dup
-
-      # Fill in the path params
-      self.params.each_pair do |key, value|
-        p = p.gsub("{#{key}}", value.to_s)
-      end
-
-      # Stick a .{format} placeholder into the path if there isn't
-      # one already or an actual format like json or xml
-      # e.g. /properties/mlsId => /properties.{format}/mlsId
-      if SimplyRets.configuration.inject_format
-        unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
-          p = p.sub(/^(\/?\w+)/, "\\1.#{format}")
-        end
-      end
-
-      # Stick a .{format} placeholder on the end of the path if there
-      # isn't one already or an actual format like json or xml
-      #
-      # NOTE: This is currently not supported in the SimplyRETS
-      # API. Content formatting is handled via the accept header.
-      #
-      # e.g. /properties/blah => /properties/blah.{format}
-      if SimplyRets.configuration.force_ending_format
-        unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
-          p = "#{p}.#{format}"
-        end
-      end
-
-      p = p.sub("{format}", self.format.to_s)
-
-      URI.encode [SimplyRets.configuration.base_path, p].join("/").gsub(/\/+/, '/')
-    end
-
-    # Massage the request body into a state of readiness If body is a
-    # hash, camelize all keys then convert to a json string
-    def body=(value)
-      if value.is_a?(Hash)
-        value = value.inject({}) do |memo, (k,v)|
-          memo[k.to_s.camelize(:lower).to_sym] = v
-          memo
-        end
-      end
-      @body = value
-    end
-
-    # If body is an object, JSONify it before making the actual request.
-    #
-    def outgoing_body
-      body.is_a?(String) ? body : body.to_json
-    end
-
-    # Construct a query string from the query-string-type params
-    def query_string
-
-      # Iterate over all params,
-      # .. removing the ones that are part of the path itself.
-      # .. stringifying values so Addressable doesn't blow up.
-      query_values = {}
-      self.params.each_pair do |key, value|
-        next if self.path.include? "{#{key}}"               # skip path params
-        next if value.blank? && value.class != FalseClass   # skip empties
-        if SimplyRets.configuration.camelize_params
-          # api_key is not a camelCased param
-          #
-          # NOTE: api_key param is not currently used by SimplyRETS API
-          key = key.to_s.camelize(:lower).to_sym unless key.to_sym == :api_key
-        end
-        query_values[key] = value
-      end
-
-      # We don't want to end up with '?' as our query string
-      # if there aren't really any params
-      return "" if query_values.blank?
-
-      # Addressable requires query_values to be set after initialization..
-      qs = Addressable::URI.new
-      qs.query_values = query_values
-      qs.to_s
-    end
-
-    def make
-      logger = Logger.new STDOUT
-      logger.debug self.url
-      response = case self.http_method.to_sym
-      when :get,:GET
-        Typhoeus::Request.get(
-          self.url,
-          :headers => self.headers.stringify_keys,
-        )
-
-      when :post,:POST
-        Typhoeus::Request.post(
-          self.url,
-          :body => self.outgoing_body,
-          :headers => self.headers.stringify_keys,
-        )
-
-      when :put,:PUT
-        Typhoeus::Request.put(
-          self.url,
-          :body => self.outgoing_body,
-          :headers => self.headers.stringify_keys,
-        )
-
-      when :delete,:DELETE
-        Typhoeus::Request.delete(
-          self.url,
-          :body => self.outgoing_body,
-          :headers => self.headers.stringify_keys,
-        )
-      end
-      Response.new(response)
-    end
-
-    def response
-      self.make
-    end
-
-    def response_code_pretty
-      return unless @response.present?
-      @response.code.to_s
-    end
-
-    def response_headers_pretty
-      return unless @response.present?
-      @response.headers.gsub(/\n/, '<br/>') # <- This is for Typhoeus
-    end
-
-  end
-end