mls 0.14.0 → 1.0.0

data/lib/mls/attributes/fixnum.rb

@@ -1,16 +0,0 @@
-class MLS::Attribute::Fixnum < ::MLS::Attribute
-	
-	def load(value) # from_json
-		if value.nil?
-			nil
-		elsif value.is_a?(::Fixnum)
-			value
-		else
-			value.to_i
-		end
-		
-	end
-	
-	alias :dump :load #only for primatives
-	
-end

data/lib/mls/attributes/hash.rb

@@ -1,15 +0,0 @@
-class MLS::Attribute::Hash < MLS::Attribute
-  
-  def load(value) # from_json
-    if value.is_a?(Hash)
-      value.with_indifferent_access
-    else
-      value
-    end
-  end
-
-  def dump(value)
-    value
-  end
-
-end

data/lib/mls/attributes/string.rb

@@ -1,15 +0,0 @@
-class MLS::Attribute::String < MLS::Attribute
-	
-	def load(value) # from_json
-		if value.nil?
-			nil
-		elsif value.is_a?(::String)
-			value
-		else
-			value.to_s
-		end
-	end
-	
-	alias :dump :load #only for primatives
-	
-end

data/lib/mls/errors.rb

@@ -1,29 +0,0 @@
-class MLS::Exception < Exception
-end
-
-class MLS::Exception::UnexpectedResponse < MLS::Exception
-end
-
-class MLS::Exception::BadRequest < MLS::Exception
-end
-
-class MLS::Exception::Unauthorized < MLS::Exception
-end
-
-class MLS::Exception::NotFound < MLS::Exception
-end
-
-class MLS::Exception::Gone < MLS::Exception
-end
-
-class MLS::Exception::MovedPermanently < MLS::Exception
-end
-
-class MLS::Exception::ApiVersionUnsupported < MLS::Exception
-end
-
-class MLS::Exception::RecordInvalid < MLS::Exception
-end
-
-class MLS::Exception::ServiceUnavailable < MLS::Exception
-end

data/lib/mls/factories/account.rb

@@ -1,34 +0,0 @@
-FactoryGirl.define do
-  factory :account, :class => MLS::Account do
-    name { Faker::Name.name }
-    email { Faker::Internet.email }
-    password { 'test' }
-    password_confirmation 'test'
-  end
-  
-  factory :agent, :class => MLS::Account do
-    phone                   { Faker::PhoneNumber.phone_number }
-    company                 { Faker::Company.name }
-    license                 '12123123123'
-    name                    { Faker::Name.name }
-    email                   { Faker::Internet.email }
-    password                'test'
-    password_confirmation   'test'
-    type                    'Agent'
-  end
-
-  factory :admin, :class => MLS::Account do
-    name { Faker::Name.name }
-    email { Faker::Internet.email }
-    type {'Admin'}
-    password { 'admin_test' }
-    password_confirmation 'admin_test'
-  end
-  
-  factory :ghost_account, :class => MLS::Account do
-    name                    { Faker::Name.name }
-    email                   { Faker::Internet.email }
-    password_required       { false } 
-  end
-
-end

data/lib/mls/factories/address.rb

@@ -1,16 +0,0 @@
-FactoryGirl.define do
-  factory :address, :class => MLS::Address do
-    street_number { Kernel.rand(1000).to_s }
-    street        { Faker::Address.street_name }
-    neighborhood  { Faker::Name.name }
-    city          { Faker::Address.city }
-    county        { |p| p.city }
-    state         { Faker::Address.state_abbr }
-    country       'US'
-    postal_code   { Faker::Address.zip_code }
-    formatted_address { |p| "#{p.street_number} #{p.street}, #{p.city}, #{p.state}, #{p.postal_code}" }
-    latitude      { Kernel.rand((-90.0)..(90.0)) }
-    longitude     { Kernel.rand((-180.0)..(180.0)) }
-  end
-end
-

data/lib/mls/factories/listing.rb

@@ -1,29 +0,0 @@
-FactoryGirl.define do
-  factory :listing, :class => MLS::Listing do
-    before(:create) { |l|
-      MLS_GEM_CACHE['auth_cookie'] = MLS.auth_cookie
-      MLS.auth_cookie = l.account.auth_cookie
-    }
-    after(:create) { |l|
-      MLS.auth_cookie = MLS_GEM_CACHE['auth_cookie']
-    }
-
-    association :account
-    association :address, :strategy => :build
-
-    agents  { [FactoryGirl.attributes_for(:agent)] }
-
-    use 'Office'
-    size { Kernel.rand(3000..900000) }
-    maximum_contiguous_size { Kernel.rand(3000..900000) }
-    minimum_divisible_size { Kernel.rand(3000..900000) }
-    type 'lease'
-    #lease_terms { ::MLS::Listing::LEASE_TERMS.sample }
-    space_type 'unit'
-    rate { rand(15..300) }
-    available_on { Time.now + (20 + rand(0..360).to_i).days }
-    sublease_expiration { |l| l.sublease? ? (l.available_on + (30 + Kernel.rand(10..360)).days) : nil }
-    name { |l| l.type == 'coworking_space' ? Faker::Name.name : nil }
-  end
-end
-

data/lib/mls/factories_helper.rb

@@ -1,7 +0,0 @@
-require 'factory_girl'
-
-factories_dir = File.join(File.dirname(__FILE__), 'factories')
-FactoryGirl.definition_file_paths = [factories_dir]
-FactoryGirl.find_definitions
-
-MLS_GEM_CACHE={}

data/lib/mls/model.rb

@@ -1,125 +0,0 @@
-module MLS::Model
-
-  def self.extended(model) #:nodoc:
-    model.instance_variable_set(:@attributes, {})
-    model.instance_variable_set(:@associations, {})
-  end
-
-  # Creates an object and saves it to the MLS. The resulting object is returned
-  # whether or no the object was saved successfully to the MLS or not.
-  #
-  # ==== Examples
-  #  #!ruby
-  #  # Create a single new object
-  #  User.create(:first_name => 'Jamie')
-  #  
-  #  # Create a single object and pass it into a block to set other attributes.
-  #  User.create(:first_name => 'Jamie') do |u|
-  #    u.is_admin = false
-  #  end
-  def create(attributes={}, &block) # TODO: testme
-    model = self.new(attributes)
-    yield(model) if block_given?
-    model.save
-    model
-  end
-
-  # Attributes ===================================================================================================
-
-  def attribute(name, type, options = {})
-    klass = MLS::Attribute.determine_class(type)
-    raise NotImplementedError, "#{type} is not supported" unless klass
-
-    attribute = klass.new(name, options)
-    @attributes[attribute.name] = attribute
-    @attributes_excluded_from_comparison = []
-
-    create_reader_for(attribute)
-    create_writer_for(attribute)
-  end
-
-  def exclude_from_comparison(*attributes)
-    @attributes_excluded_from_comparison |= attributes
-  end
-
-  def attributes_excluded_from_comparison
-    @attributes_excluded_from_comparison
-  end
-
-  def attributes
-    @attributes
-  end
-
-  def attribute_module
-    @attribute_module ||= begin
-      mod = Module.new
-      class_eval do
-        include mod
-      end
-      mod
-    end
-  end
-
-  def create_reader_for(attribute)
-    reader_name             = attribute.name.to_s
-    boolean_reader_name     = "#{reader_name}?"
-    reader_visibility       = attribute.reader_visibility
-    instance_variable_name  = attribute.instance_variable_name
-
-    attribute_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-      #{reader_visibility}
-      def #{reader_name}
-        return #{instance_variable_name} if defined?(#{instance_variable_name})
-        attribute = attributes[:#{reader_name}]
-        #{instance_variable_name} = attribute ? attribute.default : nil
-      end
-    RUBY
-
-    if attribute.kind_of?(MLS::Attribute::Boolean)
-      attribute_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-        #{reader_visibility}
-        def #{boolean_reader_name}
-          #{reader_name}
-        end
-      RUBY
-    end
-  end
-
-  def create_writer_for(attribute)
-    name                    = attribute.name
-    writer_name             = "#{name}="
-    writer_visibility       = attribute.writer_visibility
-    instance_variable_name  = attribute.instance_variable_name
-
-    attribute_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-      #{writer_visibility}
-      def #{writer_name}(value)
-        attribute = self.class.attributes[:#{name}]
-        #{instance_variable_name} = attribute.load(value)
-      end
-    RUBY
-  end
-
-  #== for rails form stuff
-  def model_name
-    self
-  end
-  
-  def param_key
-    root_element.to_s
-  end
-  
-  # used for parser
-  def root_element_string
-    ActiveSupport::Inflector.demodulize(self).underscore
-  end
-
-  def root_element
-    @root_element ||= root_element_string.to_sym
-  end
-  
-  def collection_root_element
-    @collection_root_element ||= root_element_string.pluralize.to_sym
-  end
-  
-end

data/lib/mls/models/account.rb

@@ -1,174 +0,0 @@
-class MLS::Account < MLS::Resource
-
-  attribute :id,                      Fixnum,  :serialize => :if_present
-  attribute :type,                    String,  :default => 'Account'
-  attribute :name,                    String,  :serialize => :if_present
-  attribute :title,                   String,  :serialize => :if_present
-  attribute :email,                   String,  :serialize => :if_present
-  attribute :password,                String,  :serialize => :if_present
-  attribute :password_confirmation,   String,  :serialize => :if_present
-  attribute :perishable_token,        String,  :serialize => false
-  attribute :perishable_token_set_at, String,  :serialize => false
-  attribute :ghost,                   Boolean, :serialize => false, :default => false
-
-  attribute :phone,                   String,  :serialize => :if_present
-  attribute :company,                 String,  :serialize => :if_present
-  attribute :license,                 String,  :serialize => :if_present
-  attribute :linkedin,                String,  :serialize => :if_present
-  attribute :twitter,                 String,  :serialize => :if_present
-  attribute :facebook,                String,  :serialize => :if_present
-  attribute :web,                     String,  :serialize => :if_present
-  attribute :direct_phone,            String,  :serialize => :if_present
-  attribute :direct_email,            String,  :serialize => :if_present
-
-  attribute :city,                    String,  :serialize => :if_present
-  attribute :state,                   String,  :serialize => :if_present
-  attribute :country,                 String,  :serialize => :if_present
-
-  attribute :created_at,              DateTime,  :serialize => :false
-  attribute :updated_at,              DateTime,  :serialize => :false
-
-  attribute :email_token,             String,  :serialize => false
-  attribute :start_hours_of_operation, Fixnum,  :serialize => :if_present
-  attribute :end_hours_of_operation,   Fixnum,  :serialize => :if_present
-  attribute :days_of_operation,        String,  :serialize => :if_present
-  attribute :timezone,                 String,  :serialize => :if_present
-  attribute :lead_status,              String,  :serialize => :if_present
-  attribute :buyer_id,                 Fixnum,  :serialize => :if_present
-
-  exclude_from_comparison :password, :password_confirmation
-
-  attr_accessor :password_required, :brokerage
-
-  attr_writer :favorites
-
-  def update
-    raise "cannot update account without id" unless id
-    MLS.put("/accounts/#{id}", { :account => to_hash}, 400) do |response, code|
-      MLS::Account::Parser.update(self, response.body)
-      code == 200
-    end
-  end
-
-  # Save the Account to the MLS. @errors will be set on the account if there
-  # are any errors. @persisted will also be set to +true+ if the Account was
-  # succesfully created
-  def create
-    MLS.post('/accounts', {:account => to_hash}, 400) do |response, code|
-      raise MLS::Exception::UnexpectedResponse if ![201, 400].include?(code)
-      MLS::Account::Parser.update(self, response.body)
-      @persisted = true
-      code == 201
-    end
-  end
-
-  def display_name
-    name || email
-  end
-
-  def agent?
-    type == 'Agent'
-  end
-
-  def favorites
-    return @favorites if @favorites
-    response = MLS.get('/account/favorites')
-    @favorites = MLS::Listing::Parser.parse_collection(response.body, {:collection_root_element => :favorites})
-  end
-
-  def agent_profile
-    @agent_profile ||= MLS.agent_profile id
-  end
-
-  def favorited?(listing)
-    favorites.include?(listing)
-  end
-
-  def favorite(listing) # TODO: test me, i don't work on failures
-    params_hash = {:id => listing.is_a?(MLS::Listing) ? listing.id : listing }
-    MLS.post('/account/favorites', params_hash) do |response, code|
-      @favorites = nil
-      true
-    end
-  end
-
-  def unfavorite(listing_id) # TODO: test me, i don't work on failures
-    listing_id = listing_id.is_a?(MLS::Listing) ? listing_id.id : listing_id
-    MLS.delete("/account/favorites/#{listing_id}") do |response, code|
-      @favorites = nil
-      true
-    end
-  end
-
-  def to_hash
-    hash = super
-    hash[:password_required] = password_required unless password_required.nil?
-    hash
-  end
-
-  class << self
-
-    def current
-      response = MLS.get('/account')
-      MLS::Account::Parser.parse(response.body)
-    end
-
-    # Authenticate and Account via <tt>email</tt> and <tt>password</tt>. Returns
-    # the <tt>Account</tt> object if successfully authenticated. Returns <tt>nil</tt>
-    # if the account could not be found, password was incorrect, or the account
-    # was revoked
-    #
-    # ==== Examples
-    #  #!ruby
-    #  Account.authenticate(:email => 'jon@does.net', :password => 'opensesame') # => #<Account>
-    #
-    #  Account.authenticate('jon@does.net', 'opensesame') # => #<Account>
-    #
-    #  Account.authenticate('jon@does.net', 'wrong') # => nil
-    def authenticate(attrs_or_email, password=nil)
-      email = attrs_or_email.is_a?(Hash) ? attrs_or_email[:email] : attrs_or_email
-      password = attrs_or_email.is_a?(Hash) ? attrs_or_email[:password] : password
-      response = MLS.post('/login', {:email => email, :password => password})
-      account = MLS::Account::Parser.parse(response.body)
-      account
-    rescue MLS::Exception::Unauthorized => response
-      nil
-    end
-
-    # URL is currently required to not have any query params in it
-    def reset_password!(email, url)
-      MLS.post('/account/password', {:email => email, :url => url}, 400, 404) do |response, code|
-        code == 204
-      end
-    end
-
-    def update_password!(token, password, password_confirmation)
-      MLS.put('/account/password', {:token => token, :password => password, :password_confirmation => password_confirmation}, 400) do |response, code|
-        MLS::Account::Parser.parse(response.body)
-      end
-    end
-
-    def find(id, includes=[])
-      response = MLS.get("/accounts/#{id}", :include =>  includes)
-      MLS::Account::Parser.parse(response.body)
-    end
-
-    def where(terms)
-      response = MLS.get('/accounts', :where => terms)
-      MLS::Account::Parser.parse_collection(response.body)
-    end
-
-  end
-
-end
-
-class MLS::Account::Parser < MLS::Parser
-
-  def favorites=(favorites)
-    @object.favorites = favorites.map {|a| MLS::Listing::Parser.build(a) }
-  end
-
-  def brokerage=(brokerage)
-    @object.brokerage = MLS::Brokerage::Parser.build(brokerage)
-  end
-end