opium 1.0.0.beta

data/lib/opium/model/callbacks.rb

@@ -0,0 +1,38 @@
+module Opium
+  module Model
+    module Callbacks
+      extend ActiveSupport::Concern
+      
+      CALLBACKS = %w[before after around].map {|event| %w[save create update destroy].map {|action| :"#{event}_#{action}"}}.flatten +
+        %w[initialize find touch].map {|action| :"after_#{action}"} +
+        %w[before after].map {|event| :"#{event}_validation"}
+      
+      included do
+        extend ActiveModel::Callbacks
+        include ActiveModel::Validations::Callbacks
+        
+        define_model_callbacks :initialize, :find, :touch, only: :after
+        define_model_callbacks :save, :create, :update, :destroy
+        
+        wrap_callbacks_around :save, :destroy, :touch, :find
+        wrap_callbacks_around :initialize, :create, :update, private: true
+      end
+      
+      module ClassMethods
+        def wrap_callbacks_around( *methods )
+          options = methods.last.is_a?(::Hash) ? methods.pop : {}
+          methods.each do |method|
+            class_eval do
+              define_method method do |*args|
+                run_callbacks( method ) do
+                  super( *args )
+                end
+              end
+              send( :private, method ) if options[:private]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opium/model/connectable.rb

@@ -0,0 +1,155 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module Opium
+  module Model
+    module Connectable
+      extend ActiveSupport::Concern
+      
+      included do
+      end
+      
+      class ParseError < StandardError
+        def initialize( code, error )
+          super( error )
+          @code = code
+        end
+        
+        attr_reader :code
+      end
+      
+      module ClassMethods
+        def connection
+          @@connection ||= Faraday.new( url: 'https://api.parse.com/1/' ) do |faraday|
+            faraday.request :multipart
+            faraday.request :url_encoded
+            faraday.response :logger if Opium.config.log_network_responses
+            faraday.response :json, content_type: /\bjson$/
+            faraday.headers[:x_parse_application_id] = Opium.config.app_id
+            faraday.adapter Faraday.default_adapter
+          end
+        end
+        
+        def reset_connection!
+          @@connection = nil
+        end
+        
+        def object_prefix
+          @object_prefix ||= 'classes'
+        end
+        
+        # Parse doesn't route User objects through /classes/, instead treating them as a top-level class.
+        def no_object_prefix!
+          @object_prefix = ''
+        end
+        
+        def as_resource( name, &block )
+          fail ArgumentError, 'no block given' unless block_given?
+          @masked_resource_name = name.to_s.freeze
+          block.call
+        ensure
+          @masked_resource_name = nil
+        end
+        
+        def resource_name( resource_id = nil )
+          return @masked_resource_name if @masked_resource_name
+          @resource_name ||= Pathname.new( object_prefix ).join( map_name_to_resource( model_name ) )
+          ( resource_id ? @resource_name.join( resource_id ) : @resource_name ).to_s
+        end
+        
+        def http_get( options = {} )
+          http( :get, options ) do |request|
+            options.fetch(:query, {}).each do |key, value|
+              request.params[key] = key.to_s == 'where' ? value.to_json : value
+            end
+          end
+        end
+        
+        def http_post( data, options = {} )
+          http( :post, deeply_merge( options, content_type_json ), &infuse_request_with( data ) )
+        end
+        
+        def http_put( id, data, options = {} )
+          http( :put, deeply_merge( options, content_type_json, id: id ), &infuse_request_with( data ) )          
+        end
+        
+        def http_delete( id, options = {} )
+          http( :delete, deeply_merge( options, id: id ) )
+        end
+        
+        def requires_heightened_privileges!
+          @requires_heightened_privileges = true
+        end
+        
+        def requires_heightened_privileges?
+          !@requires_heightened_privileges.nil?
+        end
+        
+        private
+                
+        def http( method, options, &block )
+          check_for_error( options ) do
+            if options[:sent_headers]
+              applier = apply_headers_to_request( method, options, &block )
+              request = connection.build_request( method )
+              applier.call( request )
+              request.headers
+            else
+              connection.send( method, resource_name( options[:id] ), &apply_headers_to_request( method, options, &block ) )
+            end
+          end
+        end
+        
+        def deeply_merge( *args )
+          args.reduce {|a, e| a.deep_merge e }
+        end
+        
+        def content_type_json
+          @content_type_json ||= { headers: { content_type: 'application/json' } }
+        end
+        
+        def map_name_to_resource( model_name )
+          name = model_name.name.demodulize
+          @object_prefix.empty? ? name.tableize : name
+        end
+        
+        def infuse_request_with( data )
+          lambda do |request|
+            request.body = data
+            request.body = request.body.to_json unless request.body.is_a?(String)
+          end
+        end
+        
+        def apply_headers_to_request( method, options, &further_operations )
+          lambda do |request|
+            request.headers.update options[:headers] if options[:headers]
+
+            added_master_key = 
+              unless request.headers[:x_parse_session_token]
+                if method != :get && requires_heightened_privileges? && Opium.config.master_key
+                  request.headers[:x_parse_master_key] = Opium.config.master_key
+                end
+              end
+            
+            request.headers[:x_parse_rest_api_key] = Opium.config.api_key unless added_master_key
+            
+            further_operations.call( request ) if block_given?
+          end
+        end
+        
+        def check_for_error( options = {}, &block )
+          fail ArgumentError, 'no block given' unless block_given?
+          result = yield
+          if options[:raw_response] || options[:sent_headers]
+            result
+          else
+            result = result.body
+            result = result.is_a?(Hash) ? result.with_indifferent_access : {}
+            fail ParseError.new( result[:code], result[:error] ) if result[:code] && result[:error]
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opium/model/criteria.rb

@@ -0,0 +1,123 @@
+module Opium
+  module Model
+    class Criteria
+      include Opium::Model::Queryable::ClassMethods
+      include Enumerable
+      
+      class_attribute :models
+      self.models = {}.with_indifferent_access
+      
+      def initialize( model_name )
+        @model_name = model_name.respond_to?(:name) ? model_name.name : model_name
+        constraints[:count] = 1
+      end
+      
+      attr_reader :model_name
+      
+      def model
+        models[model_name] ||= model_name.constantize
+      end
+      
+      def chain
+        Marshal.load( Marshal.dump( self ) )
+      end
+      
+      def constraints
+        @constraints ||= {}.with_indifferent_access
+      end
+      
+      def update_constraint( constraint, value )
+        chain.tap {|c| c.update_constraint!( constraint, value )}
+      end
+      
+      def update_constraint!( constraint, value )
+        update_hash_value :constraints, constraint, value
+      end
+      
+      def constraints?
+        !constraints.except(:count).empty?
+      end
+      
+      def variables
+        @variables ||= {}.with_indifferent_access
+      end
+      
+      def update_variable( variable, value )
+        chain.tap {|c| c.update_variable!( variable, value )}
+      end
+      
+      def update_variable!( variable, value )
+        update_hash_value :variables, variable, value
+      end
+      
+      def variables?
+        !variables.empty?
+      end
+      
+      def empty?
+        count == 0
+      end
+      
+      def criteria
+        self
+      end
+      
+      def ==( other )
+        other.is_a?( self.class ) && self.model_name == other.model_name && self.constraints == other.constraints && self.variables == other.variables
+      end
+      
+      def each(&block)
+        if !block_given?
+          to_enum(:each)
+        elsif cached? && @cache
+          @cache.each(&block)
+        else
+          response = self.model.http_get( query: self.constraints )
+          @cache = []
+          if response && response['results']
+            variables[:total_count] = response['count']
+            response['results'].each do |attributes|
+              model = self.model.new( attributes )
+              @cache << model if cached?
+              block.call model
+            end
+          end
+        end
+      end
+            
+      def inspect
+        inspected_constraints = constraints.map {|k, v| [k, v.inspect].join(': ')}.join(', ')
+        inspected_constraints.prepend ' ' if inspected_constraints.size > 0
+        "#<#{ self.class.name }<#{ model_name }>#{ inspected_constraints }>"
+      end
+      
+      def to_parse
+        {}.with_indifferent_access.tap do |result|
+          result[:query] = { where: constraints[:where], className: model_name } if constraints[:where]
+          result[:key] = constraints[:keys] if constraints[:keys]
+        end
+      end
+      
+      def uncache
+        super.tap do |criteria|
+          criteria.instance_variable_set(:@cache, nil)
+        end
+      end
+      
+      def total_count
+        count && variables[:total_count]
+      end
+      
+      private
+      
+      def update_hash_value( hash_name, key, value )
+        hash = self.send( hash_name )
+        if hash[key].nil? || !value.is_a?(Hash)
+          hash[key] = value
+        elsif hash[key].is_a?(Hash) || value.is_a?(Hash)
+          hash[key].deep_merge!( value )
+        end
+      end
+    end
+  end
+end

data/lib/opium/model/dirty.rb

@@ -0,0 +1,35 @@
+module Opium
+  module Model
+    module Dirty
+      extend ActiveSupport::Concern
+      
+      included do
+        include ActiveModel::Dirty
+      end
+      
+      def initialize( attributes = {} )
+        super( attributes ).tap { self.send :clear_changes_information }
+      end
+      
+      def save( options = {} )
+        super( options ).tap { self.send :changes_applied }
+      end
+      
+      private
+      
+      unless defined?(clear_changes_information)
+        def clear_changes_information
+          @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
+          @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+        end
+      end
+      
+      unless defined?(changes_applied)
+        def changes_applied
+          @previously_changed = changes
+          @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+        end        
+      end
+    end
+  end
+end

data/lib/opium/model/field.rb

@@ -0,0 +1,31 @@
+module Opium
+  module Model
+    class Field
+      def initialize(name, type, default, readonly, as)
+        self.name, self.type, self.default, self.readonly, self.as = name, type, default, readonly, as
+      end
+      
+      attr_reader :name, :type, :readonly, :as
+      
+      def default
+        if @default.respond_to? :call
+          @default.call
+        else
+          @default
+        end
+      end
+      
+      def readonly?
+        self.readonly == true
+      end
+      
+      def name_to_parse
+        @name_to_parse ||= (self.as || self.name).to_s.camelize(:lower)
+      end
+      
+      private
+      
+      attr_writer :name, :type, :default, :readonly, :as
+    end
+  end
+end

data/lib/opium/model/fieldable.rb

@@ -0,0 +1,57 @@
+require 'opium/model/field'
+
+module Opium
+  module Model
+    module Fieldable
+      extend ActiveSupport::Concern
+      
+      included do
+        field :id, type: String, readonly: true, as: :object_id
+        field :created_at, type: DateTime, readonly: true
+        field :updated_at, type: DateTime, readonly: true
+      end
+      
+      module ClassMethods
+        def field( name, options = {} )
+          name = name.to_sym
+          fields[name] = Field.new( name, options[:type] || Object, options[:default], options[:readonly] || false, options[:as] )
+          ruby_canonical_field_names[name] = ruby_canonical_field_names[fields[name].name_to_parse] = name.to_s
+          parse_canonical_field_names[name] = parse_canonical_field_names[fields[name].name_to_parse] = fields[name].name_to_parse.to_s
+          class_eval do
+            define_attribute_methods [name]
+            define_method(name) do
+              self.attributes[name]
+            end
+          end
+          unless self.respond_to? "#{name}="
+            class_eval do
+              define_method("#{name}=") do |value|
+                converted = self.class.fields[name].type.to_ruby(value)
+                send( "#{name}_will_change!" ) unless self.attributes[name] == converted
+                self.attributes[name] = converted
+              end
+              send(:private, "#{name}=") if options[:readonly]
+            end
+          end
+          fields[name]
+        end
+        
+        def fields
+          @fields ||= ActiveSupport::HashWithIndifferentAccess.new
+        end
+        
+        def ruby_canonical_field_names
+          @ruby_canonical_field_names ||= ActiveSupport::HashWithIndifferentAccess.new
+        end
+        
+        def parse_canonical_field_names
+          @parse_canonical_field_names ||= ActiveSupport::HashWithIndifferentAccess.new
+        end
+        
+        def default_attributes
+          ActiveSupport::HashWithIndifferentAccess[ *fields.map {|key, field| [key, field.default]}.flatten ]
+        end
+      end
+    end
+  end
+end

data/lib/opium/model/findable.rb

@@ -0,0 +1,20 @@
+module Opium
+  module Model
+    module Findable
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+        def find( id )
+          new self.http_get( id: id )
+        end
+        
+        delegate \
+          :first,
+          :each,
+          :each_with_index,
+          :map,
+          to: :criteria
+      end
+    end
+  end
+end

data/lib/opium/model/kaminari/queryable.rb

@@ -0,0 +1,46 @@
+if defined?( Kaminari )
+  module Opium
+    module Model
+      module Kaminari
+        module Queryable
+          extend ActiveSupport::Concern
+          
+          included do
+            include ::Kaminari::PageScopeMethods
+            
+            alias_method :offset, :skip
+            
+            delegate :max_per_page, :default_per_page, :max_pages, to: :model_class
+            
+            define_method ::Kaminari.config.page_method_name do |num|
+              cache.limit( limit_value ).offset( limit_value * ((num = num.to_i - 1) < 0 ? 0 : num) )
+            end
+            
+            define_method :per do |num|
+              super( num ).cache
+            end
+          end
+          
+          def limit_value
+            criteria.constraints.fetch(:limit, default_per_page)
+          end
+          
+          def offset_value
+            criteria.constraints.fetch(:skip, 0)
+          end
+          
+          def model_class
+            criteria.model
+          end
+          
+          def entry_name
+            model_class.model_name.human.downcase
+          end
+        end
+      end
+      
+      Opium::Model::Queryable::ClassMethods.send :include, Kaminari::Queryable
+      Opium::Model::Criteria.send :include, Kaminari::Queryable
+    end
+  end
+end

data/lib/opium/model/kaminari/scopable.rb

@@ -0,0 +1,15 @@
+module Opium
+  module Model
+    module Kaminari
+      module Scopable
+        extend ActiveSupport::Concern
+        
+        included do
+          include ::Kaminari::ConfigurationMethods
+        end
+      end
+    end
+    
+    Opium::Model::Scopable.send :include, Kaminari::Scopable
+  end
+end

data/lib/opium/model/kaminari.rb

@@ -0,0 +1,4 @@
+if defined?( Kaminari )
+  require 'opium/model/kaminari/queryable'
+  require 'opium/model/kaminari/scopable'
+end

data/lib/opium/model/persistable.rb

@@ -0,0 +1,153 @@
+module Opium
+  module Model
+    module Persistable
+      extend ActiveSupport::Concern
+      
+      included do
+      end
+      
+      class InvalidError < StandardError
+      end
+      
+      module ClassMethods
+        def create( attributes = {} )
+          new( attributes ).tap {|model| model.save}
+        end
+        
+        def create!( attributes = {} )
+          new( attributes ).tap {|model| model.save!}
+        end
+        
+        def destroy_all( query = nil )
+          
+        end
+        
+        def delete_all( query = nil )
+          
+        end
+        
+        def added_headers
+          @added_headers ||= {}.with_indifferent_access
+        end
+        
+        def add_header_to( methods, header, value, options = {} )
+          Array( methods ).each do |method|
+            added_headers[method] = { header: header, value: value, options: options }
+            
+            added_headers[method][:options][:only] = Array( options[:only] )
+            added_headers[method][:options][:except] = Array( options[:except] )
+          end
+          nil
+        end
+        
+        def get_header_for( method, context, owner = nil )
+          return {} unless added_headers[method]
+          
+          eval_only = !added_headers[method][:options][:only].empty?
+          eval_except = !added_headers[method][:options][:except].empty?
+          
+          within_only = added_headers[method][:options][:only].include?( context )
+          within_except = added_headers[method][:options][:except].include?( context )
+          
+          value = added_headers[method][:value]
+          value = value.call( owner ) if owner && value.respond_to?( :call )
+          
+          if value && ( ( !eval_only && !eval_except ) || ( eval_only && within_only ) || ( eval_except && !within_except ) )
+            { headers: { added_headers[method][:header] => value } } 
+          else
+            {}
+          end
+        end
+      end
+      
+      def save( options = {} )
+        create_or_update( options )
+      rescue => e
+        errors.add( :base, e.to_s )
+        false
+      end
+      
+      def save!
+        create_or_update( validates: true ) || raise( InvalidError, 'failed to save, as model is invalid' )
+      end
+      
+      def update_attributes( attributes = {} )
+        self.attributes = attributes
+        save
+      end
+      
+      def update_attributes!( attributes = {} )
+        self.attributes = attributes
+        save!
+      end
+      
+      def touch
+        save( validates: false )
+      end
+      
+      def delete( options = {} )
+        self.tap do
+          attributes_or_headers( :delete, :delete, options ) do |headers|
+            self.class.http_delete id, headers unless new_record?
+          end
+          self.freeze
+        end
+      end
+      alias_method :destroy, :delete
+      
+      def new_record?
+        self.id.nil?
+      end
+      
+      def persisted?
+        !new_record? && !self.changed?
+      end
+      
+      def pointer
+        @pointer ||= Pointer.new( model: self.class, id: id ) unless new_record?
+      end
+      
+      def to_parse
+        pointer.to_parse
+      end
+            
+      private
+      
+      def create_or_update( options )
+        if options[:validates] == false || valid?
+          if new_record?
+            create( options )
+          else
+            update( options )
+          end
+        end.present?
+      end
+      
+      def create( options = {} )
+        self.attributes = attributes_or_headers( :post, :create, options ) do |headers|
+          self.class.http_post self.attributes_to_parse( except: [:id, :created_at, :updated_at] ), headers
+        end
+      end
+      
+      def update( options = {} )
+        self.attributes = attributes_or_headers( :put, :update, options ) do |headers|
+          self.class.http_put id, self.attributes_to_parse( only: changes.keys ), headers
+        end
+      end
+      
+      def sent_headers
+        @_sent_headers || {}
+      end
+      
+      def attributes_or_headers( method, action, options, &block )
+        result = block.call( options.deep_merge self.class.get_header_for( method, action, self ) )
+        if options[:sent_headers]
+          @_sent_headers = result
+          {}
+        else
+          result
+        end 
+      end
+    end
+  end
+end