opium 1.0.0.beta

data/lib/opium/model/queryable.rb

@@ -0,0 +1,150 @@
+module Opium
+  module Model
+    module Queryable
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+        delegate :count, :total_count, to: :criteria
+        
+        def all( constraints )
+          imbued_where( arrayize( constraints ), '$all' )
+        end
+        
+        alias_method :all_in, :all
+        
+        def between( constraints )
+          start = constraints.map {|key, range| [key, range.begin]}
+          inclusive = constraints.reject {|_, range| range.exclude_end?}.map {|key, range| [key, range.end]}
+          exclusive = constraints.select {|_, range| range.exclude_end?}.map {|key, range| [key, range.end]}
+          gte( start ).lte( inclusive ).lt( exclusive )
+        end
+        
+        def exists( constraints )
+          imbued_where( constraints.map {|key, value| [key, value.to_bool] }, '$exists' )
+        end
+        
+        def gt( constraints )
+          imbued_where( constraints, '$gt' )
+        end
+        
+        def gte( constraints )
+          imbued_where( constraints, '$gte' )
+        end
+        
+        def lt( constraints )
+          imbued_where( constraints, '$lt' )
+        end
+        
+        def lte( constraints )
+          imbued_where( constraints, '$lte' )
+        end
+        
+        def in( constraints )
+          imbued_where( arrayize( constraints ), '$in' )
+        end
+        
+        alias_method :any_in, :in
+        
+        def nin( constraints )
+          imbued_where( arrayize( constraints ), '$nin' )
+        end
+        
+        def ne( constraints )
+          imbued_where( constraints, '$ne' )
+        end
+        
+        def or( *subqueries )
+          where( '$or' => subqueries )
+        end
+        
+        def select( constraints )
+          imbued_where( constraints, '$select' )
+        end
+        
+        def dont_select( constraints )
+          imbued_where( constraints, '$dontSelect' )
+        end
+        
+        def keys( *field_names )
+          validate_fields_exist( field_names )
+          criteria.update_constraint( :keys, field_names.map(&method(:translate_name)).join(',') )
+        end
+        
+        # Should be noted that pluck is an immediate query execution, so doesn't play well with further chainable criteria        
+        def pluck( field_name )
+
+        end
+        
+        def order( options )
+          validate_fields_exist( options )
+          previous = criteria.constraints[:order]
+          ordering = (
+            [previous].compact + options.map {|key, value| (['-', 'desc', '-1'].include?( value.to_s ) ? '-' : '' ) + translate_name( key.to_s ) }
+            ).join(',')
+          criteria.update_constraint( :order, ordering )
+        end
+        
+        def limit( value )
+          criteria.update_constraint( :limit, value )
+        end
+        
+        def skip( value )
+          criteria.update_constraint( :skip, value )
+        end
+        
+        def where( constraints )
+          validate_fields_exist( constraints )
+          criteria.update_constraint( :where, translate_to_parse( constraints ) )
+        end
+        
+        alias_method :and, :where
+        
+        def cache
+          criteria.update_variable( :cache, true )
+        end
+        
+        def uncache
+          criteria.update_variable( :cache, false )
+        end
+        
+        def cached?
+          criteria.variables[:cache]
+        end
+        
+        private
+        
+        def model
+          self
+        end
+        
+        def validate_fields_exist( field_names )
+          field_names = field_names.keys if field_names.respond_to? :keys
+          unless field_names.all? {|field_name| model.fields.key?( field_name ) || field_name =~ /^\$/ }
+            not_fields = field_names.reject {|field_name| model.fields.key? field_name }
+            raise ArgumentError, "#{not_fields.join(', ')} #{not_fields.length > 1 ? 'are not fields' : 'is not a field'} on this model"
+          end
+        end
+        
+        def translate_name( field_name )
+          field_name =~ /^\$/ ? field_name : model.parse_canonical_field_names[ field_name ]
+        end
+        
+        def translate_to_parse( constraints )
+          Hash[ *constraints.flat_map {|key, value| [translate_name( key ), value.to_parse]} ]
+        end
+        
+        def arrayize( constraints )
+          constraints.map {|key, value| [key, value.to_a]}
+        end
+        
+        def imbued_where( constraints, operator )
+          where( imbue_field_constraints_with_operator( constraints, operator ) )
+        end
+        
+        def imbue_field_constraints_with_operator( constraints, operator )
+          Hash[ *constraints.flat_map {|key, value| [key, { operator => value }]} ]
+        end
+      end
+    end
+  end
+end

data/lib/opium/model/scopable.rb

@@ -0,0 +1,58 @@
+module Opium
+  module Model
+    module Scopable
+      extend ActiveSupport::Concern
+      
+      included do
+      end
+      
+      module ClassMethods
+        def criteria
+          @_unscoped ? blank_criteria : default_scope
+        end
+        
+        def scope( scope_name, criteria = nil, &block )
+          class_eval do
+            method_body = if block_given? || criteria.is_a?(Proc)
+              block || criteria
+            elsif criteria.nil?
+              raise ArgumentError, "Criteria cannot be nil if no block is provided."
+            else
+              -> { criteria }
+            end
+            define_singleton_method( scope_name, method_body )
+          end
+        end
+        
+        def default_scope( criteria = nil, &block )
+          @default_scope = block || criteria if block_given? || criteria
+          s = @default_scope || blank_criteria
+          s.is_a?( Proc ) ? unscoped { s.call } : s
+        end
+        
+        def scoped
+          
+        end
+        
+        def unscoped
+          if block_given?
+            @_unscoped = true
+            yield
+          else
+            blank_criteria
+          end
+        ensure
+          @_unscoped = false
+        end
+        
+        def blank_criteria
+          Criteria.new( self.model_name )
+        end
+        
+        def with_scope( criteria )
+          
+        end
+      end
+    end
+  end
+end

data/lib/opium/model/serialization.rb

@@ -0,0 +1,13 @@
+module Opium
+  module Model
+    module Serialization
+      extend ActiveSupport::Concern
+      
+      include ActiveModel::Serializers::JSON
+      
+      included do
+        self.include_root_in_json = false
+      end
+    end
+  end
+end

data/lib/opium/model.rb

@@ -0,0 +1,47 @@
+require 'active_support/concern'
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/inflector'
+require 'opium/model/connectable'
+require 'opium/model/persistable'
+require 'opium/model/callbacks'
+require 'opium/model/serialization'
+require 'opium/model/dirty'
+require 'opium/model/fieldable'
+require 'opium/model/attributable'
+require 'opium/model/queryable'
+require 'opium/model/criteria'
+require 'opium/model/scopable'
+require 'opium/model/findable'
+require 'opium/model/kaminari'
+
+module Opium
+  module Model
+    extend ActiveSupport::Concern
+        
+    include ActiveModel::Model
+    
+    included do
+      include Connectable
+      include Persistable
+      include Dirty
+      include Fieldable
+      include Serialization
+      include Attributable
+      include Queryable
+      include Callbacks
+      include Scopable
+      include Findable
+    end
+    
+    def initialize( attributes = {} )
+      self.attributes = attributes
+    end
+        
+    def inspect
+      inspected_fields = self.attributes.map {|k, v| [k, v.inspect].join(': ')}.join(', ')
+      "#<#{self.class.model_name} #{inspected_fields}>"
+    end
+  end
+end

data/lib/opium/railtie.rb

@@ -0,0 +1,14 @@
+module Opium
+  class Railtie < Rails::Railtie
+    config.app_generators.orm :opium, migration: false
+    
+    config.opium = ::Opium.config
+    
+    initializer 'opium.load-config' do
+      config_file = Rails.root.join( 'config', 'opium.yml' )
+      if config_file.file?
+        ::Opium.load!( config_file )
+      end
+    end
+  end
+end

data/lib/opium/user.rb

@@ -0,0 +1,44 @@
+module Opium
+  class User
+    include Opium::Model
+    
+    field :username, type: String
+    field :password, type: String
+    field :email, type: String
+    field :email_verified, type: Boolean
+    field :session_token, type: String, readonly: true
+    
+    no_object_prefix!
+    requires_heightened_privileges!
+    add_header_to [:put, :delete], :x_parse_session_token, :session_token.to_proc
+    
+    class << self
+      # Note that this will eat any ParseErrors which get raised, and not perform any logging.
+      def authenticate( username, password )
+        authenticate!( username, password )
+      rescue Opium::Model::Connectable::ParseError => e
+        nil
+      end
+    
+      def authenticate!( username, password )
+        new( as_resource('login') { http_get query: { username: username, password: password } } )
+      end
+      
+      def find_by_session_token( token )
+        new( http_get id: 'me', headers: { x_parse_session_token: token } )
+      end
+    end
+    
+    def reset_password
+      reset_password!
+    rescue => e
+      self.errors.add( :email, e.to_s )
+      false
+    end
+    
+    def reset_password!
+      fail KeyError, 'an email address is required to reset password' unless email
+      self.class.as_resource('requestPasswordReset') { self.class.http_post data: email }.empty?
+    end
+  end
+end

data/lib/opium/version.rb

@@ -0,0 +1,3 @@
+module Opium
+  VERSION = "1.0.0.beta"
+end

data/lib/opium.rb

@@ -0,0 +1,9 @@
+require "rubygems"
+require "active_model"
+require "active_support"
+require "opium/version"
+require "opium/config"
+require "opium/extensions"
+require "opium/model"
+require "opium/user"
+require "opium/railtie" if defined?( Rails )

data/opium.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'opium/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "opium"
+  spec.version       = Opium::VERSION
+  spec.authors       = ["Joshua Bowers"]
+  spec.email         = ["joshua.bowers+code@gmail.com"]
+  spec.summary       = %q{An Object Parse.com Mapping technology for defining models.}
+  spec.description   = %q{Provides an intuitive, Mongoid-inspired mapping layer between your application's object space and Parse.'}
+  spec.homepage      = "https://github.com/joshuabowers/opium"
+  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_development_dependency "rspec"
+  spec.add_development_dependency "rspec-nc"
+  spec.add_development_dependency "rspec-its"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-remote"
+  spec.add_development_dependency "pry-nav"
+  spec.add_development_dependency "coveralls"
+  
+  spec.add_development_dependency "rails"
+  spec.add_development_dependency "kaminari"
+  
+  spec.add_dependency "activemodel", "~> 4.0"
+  spec.add_dependency "faraday", "~> 0.9"
+  spec.add_dependency "faraday_middleware", "~> 0.9"
+end

data/spec/opium/config/opium.yml

@@ -0,0 +1,5 @@
+test:
+  app_id: abcd1234
+  api_key: efgh5678
+  master_key: 9012ijkl
+  log_network_responses: true

data/spec/opium/config_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Opium do
+  it { should respond_to(:configure, :config) }
+  it { should respond_to(:load!).with(2).arguments }
+  it { should respond_to(:reset) }
+  
+  describe ':configure' do
+    it do
+      expect {|b| Opium.configure(&b) }.to yield_with_args
+    end
+  end
+  
+  describe ':config' do
+    subject { Opium.config }
+    
+    it { should_not be_nil }
+    it { should be_an( Opium::Config ) }
+  end
+  
+  describe ':reset' do
+    it 'should put all changed settings back to their defaults' do
+      expect { described_class.config.log_network_responses = true }.to change( described_class.config, :log_network_responses ).from( false ).to( true )
+      described_class.reset
+      described_class.config.log_network_responses.should == false
+    end
+  end
+  
+  describe ':load!' do
+    let(:file) { File.join( File.dirname( __FILE__ ), 'config', 'opium.yml' ) }
+  
+    before do
+      described_class.load!( file, :test )
+    end
+    
+    after do
+      described_class.reset
+    end
+  
+    it { subject.config.app_id.should == 'abcd1234' }
+    it { subject.config.api_key.should == 'efgh5678' }
+    it { subject.config.master_key.should == '9012ijkl' }
+    it { subject.config.log_network_responses.should == true }
+  end
+    
+  describe Opium::Config do
+    it { should respond_to( :app_id, :api_key, :master_key, :log_network_responses ) }
+    
+    describe 'defaults' do
+      its(:app_id) { should == 'PARSE_APP_ID' }
+      its(:api_key) { should == 'PARSE_API_KEY' }
+      its(:master_key) { should == 'PARSE_MASTER_KEY' }
+      its(:log_network_responses) { should == false }
+    end
+  end
+end

data/spec/opium/extensions/array_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Array do
+  subject { Array }
+  
+  describe 'instance' do
+    describe ':to_parse' do
+      subject { [GeoPoint.new( latitude: 33.33, longitude: -117.117 )] }
+      
+      it 'should call :to_parse on each element' do
+        subject.to_parse.tap do |result|
+          result.should =~ [ { '__type' => 'GeoPoint', 'latitude' => 33.33, 'longitude' => -117.117 } ]
+        end
+      end
+    end
+    
+    describe ':to_geo_point' do
+      describe 'with two values' do
+        subject { [33.33, -117.117] }
+      
+        it { subject.to_geo_point.should be_a_kind_of(GeoPoint) }
+        it 'should have the expected latitude and longitude' do
+          subject.to_geo_point.latitude.should == 33.33
+          subject.to_geo_point.longitude.should == -117.117
+        end
+      end
+      
+      describe 'with more or fewer than two values' do
+        it { expect { [33.33].to_geo_point }.to raise_exception }
+        it { expect { [33.33, -117.117, :deadbeef].to_geo_point }.to raise_exception }
+      end
+    end
+  end
+end

data/spec/opium/extensions/boolean_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Boolean do
+  subject { Boolean }
+  it { should respond_to(:to_ruby).with(1).argument }
+  it { should respond_to(:to_parse).with(1).argument }
+  
+  it ":to_ruby(object) should convert object to a boolean" do
+    ["true", "false", true, false, 1.0, 1, 0.0, 0].each do |value|
+      subject.to_ruby(value).should be_a_kind_of(Boolean)
+      subject.to_ruby(value).should == value.to_bool
+    end
+  end
+  
+  it ":to_parse(object) should convert object to a boolean" do
+    ["true", "false", true, false, 1.0, 1, 0.0, 0].each do |value|
+      subject.to_parse(value).should be_a_kind_of(Boolean)
+      subject.to_parse(value).should == value.to_bool
+    end
+  end
+  
+  describe "instance" do
+    subject { Class.new { include Boolean }.new }
+    it { should respond_to(:to_ruby, :to_parse).with(0).arguments }
+    its(:to_ruby) { should == subject }
+    its(:to_parse) { should == subject }
+  end
+end

data/spec/opium/extensions/date_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Date do
+  subject { Date }
+  it { should respond_to(:to_parse, :to_ruby).with(1).argument }
+  
+  describe ":to_ruby" do
+    describe "with a Hash containing '__type: Date'" do
+      let(:object) { { '__type' => 'Date', 'iso' => Date.today.iso8601 } }
+      it { subject.to_ruby(object).should be_a_kind_of( Date ) }
+    end
+  
+    describe "with a Hash without a '__type' key" do
+      let(:object) { { 'iso' => Date.today.iso8601 } }
+      it { expect { subject.to_ruby(object) }.to raise_exception }
+    end
+  
+    describe "with an object which responds to :to_date" do
+      let(:objects) { [ Date.today.iso8601, DateTime.now, Time.now, Date.today ] }
+      it do
+        objects.each do |object|
+          subject.to_ruby(object).should be_a_kind_of( Date )
+        end
+      end
+    end
+  end
+  
+  describe ":to_parse(object)" do
+    let(:objects) { [ Date.today.iso8601, DateTime.now, Time.now, Date.today ] }
+    it "should ensure that the object is a datetime" do
+      objects.each do |object|
+        object.should_receive :to_date
+        subject.to_parse(object)
+      end
+    end
+    
+    it "should make a parse object hash" do
+      objects.each do |object|
+        result = subject.to_parse(object)
+        result.should be_a_kind_of(Hash)
+        result.keys.should == ['__type', 'iso']
+        result['__type'].should == 'Date'
+      end
+    end
+  end
+  
+  describe "instance" do
+    subject { Date.today }
+    let(:result) { subject.to_parse }
+    it { result.should be_a_kind_of(Hash) }
+    it { result.keys.should == ['__type', 'iso'] }
+    it { result['__type'].should == 'Date' }
+    it { result['iso'].should == subject.iso8601 }
+  end
+end

data/spec/opium/extensions/date_time_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe DateTime do
+  subject { DateTime }
+  it { should respond_to(:to_parse, :to_ruby).with(1).argument }
+  
+  describe ":to_ruby" do
+    describe "with a Hash containing '__type: DateTime'" do
+      let(:object) { { '__type' => 'Date', 'iso' => DateTime.now.iso8601 } }
+      it { subject.to_ruby(object).should be_a_kind_of( DateTime ) }
+    end
+  
+    describe "with a Hash without a '__type' key" do
+      let(:object) { { 'iso' => DateTime.now.iso8601 } }
+      it { expect { subject.to_ruby(object) }.to raise_exception }
+    end
+  
+    describe "with an object which responds to :to_datetime" do
+      let(:objects) { [ DateTime.now.iso8601, DateTime.now, Time.now, Date.today ] }
+      it do
+        objects.each do |object|
+          subject.to_ruby(object).should be_a_kind_of( DateTime )
+        end
+      end
+    end
+  end
+  
+  describe ":to_parse(object)" do
+    let(:objects) { [ DateTime.now.iso8601, DateTime.now, Time.now, Date.today ] }
+    it "should ensure that the object is a datetime" do
+      objects.each do |object|
+        object.should_receive :to_datetime
+        subject.to_parse(object)
+      end
+    end
+    
+    it "should make a parse object hash" do
+      objects.each do |object|
+        result = subject.to_parse(object)
+        result.should be_a_kind_of(Hash)
+        result.keys.should == ['__type', 'iso']
+        result['__type'].should == 'Date'
+      end
+    end
+  end
+  
+  describe "instance" do
+    subject { DateTime.now }
+    let(:result) { subject.to_parse }
+    it { result.should be_a_kind_of(Hash) }
+    it { result.keys.should == ['__type', 'iso'] }
+    it { result['__type'].should == 'Date' }
+    it { result['iso'].should == subject.iso8601 }
+  end
+end

data/spec/opium/extensions/float_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe ::Float do
+  subject { Float }
+  it { should respond_to(:to_ruby).with(1).argument }
+  it { should respond_to(:to_parse).with(1).argument }
+  
+  it ":to_ruby(object) should convert object to a float" do
+    {nil => nil, :foo => :foo.to_s.to_f}.each do |value, expected|
+      subject.to_ruby(value).should be_a_kind_of(expected.class)
+      subject.to_ruby(value).should == expected
+    end
+    ["foo", 42.0, 42, Time.now].each do |value|
+      subject.to_ruby(value).should be_a_kind_of(Float)
+      subject.to_ruby(value).should == value.to_f
+    end
+  end
+  
+  it ":to_parse(object) should convert object to a float" do
+    {nil => nil, :foo => :foo.to_s.to_f}.each do |value, expected|
+      subject.to_parse(value).should be_a_kind_of(expected.class)
+      subject.to_parse(value).should == expected
+    end
+    ["foo", 42.0, 42, Time.now].each do |value|
+      subject.to_parse(value).should be_a_kind_of(Float)
+      subject.to_parse(value).should == value.to_f
+    end    
+  end
+  
+  describe "instance" do
+    subject { 42.0 }
+    it { should respond_to(:to_ruby, :to_parse, :to_bool).with(0).arguments }
+    its(:to_ruby) { should == subject }
+    its(:to_parse) { should == subject }
+    
+    it "should convert 1.0 and 0.0 to true and false, all others raise" do
+      1.0.to_bool.should == true
+      0.0.to_bool.should == false
+      expect { subject.to_bool }.to raise_exception
+    end
+  end
+end