opium 1.1.8 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13bf8b7b6c86a85e42ef4efd054179cd07ec22d9
-  data.tar.gz: 328524b3e01c8ade53ffa6a2e8d7d306dc3b90f8
+  metadata.gz: 3bbf318b07ca2a59bb917e4495abda45117aa588
+  data.tar.gz: c85609101238b4c6142df1d421a90e33e9fbf38a
 SHA512:
-  metadata.gz: a950bcccc7f3d52d077f983701dc15c5e93136fe9682022f79a40953efb1f0f968ee827834983b1d6e75324c49d865e69bdbf8426e388a700da62301b9c2ac82
-  data.tar.gz: 10f6b86273cf753b873a667b31b3f30993682a177fb6ed121b0f1e8aa80156ac8dd07494db380099288c965c09c0ad8bd094806e7bab3bb8640c7489b3b14c45
+  metadata.gz: 661189662f2ac5cdeb1b0dcb87d32ca291bdb4e888a108e7669153758160ced3f4aa06e961e625544e87c4e7d66a514e588607f0338f81793ee7029ee5266093
+  data.tar.gz: 76ef297dfd71c71a063140c88f11b48bfb6326b6ca31d333155ac9d6cdbb0917c181d337a7e67adb2038af6261cf4387644ed98211208e932d2e25d9346a3b47

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.2.0
+### New Features
+- #33: Model associations.
+
 ## 1.1.8
 ### Resolved Issues
 - #41: Boolean and GeoPoint are now namespaced within Opium. The ModelGenerator also maps attribute types for these classes.

data/lib/opium/extensions/pointer.rb

@@ -2,6 +2,7 @@ module Opium
   class Pointer
     def initialize( attributes = {} )
       self.class_name = attributes[:class_name] || attributes[:model_name] || (attributes[:class] || attributes[:model]).model_name
+      self.class_name = self.class_name.name if self.class_name.respond_to?(:name)
       self.id = attributes[:id]
     end
     

data/lib/opium/model.rb

@@ -17,6 +17,7 @@ require 'opium/model/scopable'
 require 'opium/model/findable'
 require 'opium/model/inheritable'
 require 'opium/model/batchable'
+require 'opium/model/relatable'
 require 'opium/model/kaminari'
 
 module Opium
@@ -38,6 +39,7 @@ module Opium
       include Findable
       include Inheritable
       include Batchable
+      include Relatable
     end
     
     def initialize( attributes = {} )

data/lib/opium/model/attributable.rb

@@ -7,8 +7,12 @@ module Opium
         include ActiveModel::ForbiddenAttributesProtection
       end
       
+      def initialize( attributes = {} )
+        super( self.class.default_attributes( self ).merge attributes )
+      end
+      
       def attributes
-        @attributes ||= self.class.default_attributes
+        @attributes ||= {}.with_indifferent_access
       end
       
       def attributes=(values)
@@ -23,7 +27,7 @@ module Opium
       end
       
       def attributes_to_parse( options = {} )
-        options[:except] ||= self.class.fields.values.select {|f| f.readonly? }.map {|f| f.name} if options[:not_readonly]
+        options[:except] ||= self.class.fields.values.select {|f| f.readonly? || f.virtual? }.map {|f| f.name} if options[:not_readonly]
         Hash[*self.as_json( options ).flat_map {|k, v| [self.class.fields[k].name_to_parse, self.class.fields[k].type.to_parse(v)]}]
       end
       

data/lib/opium/model/batchable.rb

@@ -5,6 +5,89 @@ module Opium
   module Model
     module Batchable
       extend ActiveSupport::Concern
+      
+      require 'fiber'
+      
+      module ClassMethods
+        def batch( options = {} )
+          raise ArgumentError, 'no block given' unless block_given?
+          create_batch
+          fiber = Fiber.new { yield }
+          subfibers = []
+          subfibers << fiber.resume while fiber.alive?
+        ensure
+          delete_batch
+        end
+        
+        def batched?
+          batch_pool[Thread.current].present?
+        end
+        
+        def create_batch
+          batch = current_batch_job
+          if batch
+            batch.dive && batch
+          else
+            self.current_batch_job = Batch.new
+          end
+        end
+        
+        def delete_batch
+          batch = current_batch_job
+          fail 'No current batch job!' unless batch
+          if batch.depth == 0
+            self.current_batch_job = nil
+          else
+            batch.execute
+            batch
+          end
+        end
+        
+        def current_batch_job
+          batch_pool[Thread.current]
+        end
+        
+        def current_batch_job=( value )
+          batch_pool[Thread.current] = value
+        end
+        
+        def http_post( data, options = {} )
+          if batched?
+            current_batch_job.enqueue( method: :post, path: resource_name, body: data )
+            Fiber.yield
+          else
+            super
+          end
+        end
+        
+        def http_put( id, data, options = {} )
+          if batched?
+            current_batch_job.enqueue( method: :put, path: resource_name( id ), body: data )
+            Fiber.yield
+          else
+            super
+          end
+        end
+        
+        def http_delete( id, options = {} )
+          if batched?
+            current_batch_job.enqueue( method: :delete, path: resource_name( id ) )
+            Fiber.yield
+          else
+            super
+          end
+        end
+        
+        private
+        
+        def batch_pool
+          @batch_pool ||= {}
+        end
+        
+        def thread_local_id
+          @thread_local_id ||= :"#{ Module.nesting.first.name.parameterize('_') }_current_batch_job"
+        end
+      end
     end
   end
 end

data/lib/opium/model/batchable/batch.rb

@@ -29,8 +29,7 @@ module Opium
             ascend
           else
             batches = to_parse
-            fail 'no batches to process' if batches.empty?
-            batches.each {|batch| owner.http_post( batch ) }
+            batches.each {|batch| owner.http_post( batch ) } if batches.present?
           end
         end
         

data/lib/opium/model/connectable.rb

@@ -23,6 +23,7 @@ module Opium
           @@connection ||= Faraday.new( url: 'https://api.parse.com/1/' ) do |faraday|
             faraday.request :multipart
             faraday.request :url_encoded
+            faraday.request :json
             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
@@ -125,7 +126,6 @@ module Opium
         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
         

data/lib/opium/model/criteria.rb

@@ -23,7 +23,7 @@ module Opium
       end
       
       def chain
-        Marshal.load( Marshal.dump( self ) )
+        Marshal.load( Marshal.dump( self ) ).tap {|m| m.instance_variable_set( :@cache, nil )}
       end
       
       def constraints
@@ -81,9 +81,9 @@ module Opium
           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
+              instance = self.model.new( attributes )
+              @cache << instance if cached?
+              block.call instance
             end
           end
         end

data/lib/opium/model/field.rb

@@ -7,9 +7,11 @@ module Opium
       
       attr_reader :name, :type, :readonly, :as
       
-      def default
+      def default( context = nil )
         if @default.respond_to? :call
-          @default.call
+          params = []
+          params.push( context ) if @default.arity != 0
+          @default.call( *params )
         else
           @default
         end
@@ -19,6 +21,14 @@ module Opium
         self.readonly == true
       end
       
+      def relation?
+        self.type == Relation
+      end
+      
+      def virtual?
+        relation? || self.type == Reference
+      end
+      
       def name_to_parse
         @name_to_parse ||= (self.as || self.name).to_s.camelize(:lower)
       end

data/lib/opium/model/fieldable.rb

@@ -28,6 +28,10 @@ module Opium
               define_method("#{name}=") do |value|
                 converted = self.class.fields[name].type.to_ruby(value)
                 send( "#{name}_will_change!" ) unless self.attributes[name] == converted
+                if self.class.fields[name].relation?
+                  converted.owner ||= self 
+                  converted.metadata ||= self.class.relations[name]
+                end
                 self.attributes[name] = converted
               end
               send(:private, "#{name}=") if options[:readonly]
@@ -36,6 +40,12 @@ module Opium
           fields[name]
         end
         
+        def has_field?( field_name )
+          fields.key? field_name
+        end
+        
+        alias_method :field?, :has_field?
+        
         def fields
           @fields ||= ActiveSupport::HashWithIndifferentAccess.new
         end
@@ -48,8 +58,8 @@ module Opium
           @parse_canonical_field_names ||= ActiveSupport::HashWithIndifferentAccess.new
         end
         
-        def default_attributes
-          fields.transform_values {|field| field.type.to_ruby field.default}.with_indifferent_access
+        def default_attributes( context = nil )
+          fields.transform_values {|field| field.type.to_ruby field.default( context ) }.with_indifferent_access
         end
       end
     end

data/lib/opium/model/persistable.rb

@@ -107,7 +107,7 @@ module Opium
       end
       
       def pointer
-        @pointer ||= Pointer.new( model: self.class, id: id ) unless new_record?
+        @pointer ||= Pointer.new( model_name: model_name, id: id ) unless new_record?
       end
       
       def to_parse

data/lib/opium/model/reference.rb

@@ -0,0 +1,50 @@
+module Opium
+  module Model
+    class Reference < SimpleDelegator
+      class << self
+        def to_ruby( value )
+          case value
+          when Hash
+            new( value[:metadata] || value['metadata'], value[:context] || value['context'] )
+          when self
+            value
+          else
+            fail ArgumentError, "could not convert #{ value.inspect } into an Opium::Model::Reference"
+          end
+        end
+      end
+      
+      def initialize( metadata, context )
+        self.metadata = metadata
+        self.context = context
+        fail ArgumentError, 'did not receive a context object!' unless context
+        super( nil )
+      end
+      
+      attr_accessor :metadata, :context
+      
+      def __getobj__
+        @reference || __setobj__( lookup_reference )
+      end
+      
+      def __setobj__( obj )
+        @reference = obj
+      end
+      
+      def inspect
+        if @reference
+          @reference.inspect
+        else
+          "#<#{ self.class.name }<#{ self.metadata.target_class_name }>>"
+        end
+      end
+      
+      private
+      
+      def lookup_reference
+        return nil if context.new_record?
+        self.metadata.target_class_name.constantize.where( self.metadata.inverse_relation_name => self.context ).first
+      end
+    end
+  end
+end

data/lib/opium/model/relatable.rb

@@ -0,0 +1,64 @@
+require 'opium/model/relation'
+require 'opium/model/reference'
+require 'opium/model/relatable/metadata'
+
+module Opium
+  module Model
+    module Relatable
+      extend ActiveSupport::Concern
+      
+      included do
+        after_create :update_relations
+      end
+      
+      module ClassMethods
+        def relations
+          @relations ||= {}.with_indifferent_access
+        end
+        
+        def has_and_belongs_to_many( relation_name, options = {} )
+          create_relation_metadata_from( :has_and_belongs_to_many, relation_name, options )
+        end
+        
+        def has_many( relation_name, options = {} )
+          create_relation_metadata_from( :has_many, relation_name, options )
+          field relation_name, type: Relation, default: -> { relations[relation_name].target_class_name }
+        end
+        
+        def has_one( relation_name, options = {} )
+          create_relation_metadata_from( :has_one, relation_name, options )
+        end
+        
+        def belongs_to( relation_name, options = {} )
+          create_relation_metadata_from( :belongs_to, relation_name, options )
+          field relation_name, type: Reference, 
+            default: ->( model ) do
+              { metadata: relations[relation_name], context: model } 
+            end
+        end
+        
+        private
+                
+        def create_relation_metadata_from( relation_type, relation_name, options )
+          relations[relation_name] = Metadata.new( self, relation_type, relation_name, options )
+        end
+      end
+      
+      def save( options = {} )
+        super && relations.all? {|_, relation| relation.save}
+      end
+      
+      private
+      
+      def relations
+        attributes.select {|_, value| value.is_a? Relation}
+      end
+      
+      def update_relations
+        send(:relations).each do |_, value|
+          value.owner = self
+        end
+      end
+    end
+  end
+end

data/lib/opium/model/relatable/metadata.rb

@@ -0,0 +1,32 @@
+module Opium
+  module Model
+    module Relatable
+      class Metadata
+        attr_reader :relation_name, :inverse_relation_name, :target_class_name, :relation_type, :inverse_relation_type, :owning_class_name
+        
+        def initialize( klass, relation_type, relation_name, options = {} )
+          self.owning_class_name = klass.model_name
+          self.relation_type = relation_type
+          self.relation_name = relation_name
+          self.target_class_name = (options[:class_name] || relation_name).to_s.classify
+          self.inverse_relation_name = (options[:inverse_of] || determine_inverse_relation_name).to_s
+        end
+        
+        private
+        
+        attr_writer :relation_name, :inverse_relation_name, :target_class_name, :relation_type, :inverse_relation_type, :owning_class_name
+        
+        def determine_inverse_relation_name
+          method =
+            case relation_type
+            when :belongs_to
+              :plural
+            else
+              :singular
+            end
+          owning_class_name.send( method )
+        end
+      end
+    end
+  end
+end

data/lib/opium/model/relation.rb

@@ -0,0 +1,156 @@
+module Opium
+  module Model
+    class Relation < Criteria
+      include ActiveModel::Dirty
+      
+      class << self
+        def to_parse( object )
+          class_name =
+            case object
+            when Hash
+              fetch_hash_key_from( object, 'class_name' ) || fetch_hash_key_from( object, 'model_name' )
+            when String, Symbol
+              object
+            when is_descendant.curry[Opium::Model]
+              object.model_name
+            when self
+              object.class_name
+            else
+              fail ArgumentError, "could not convert #{ object.inspect } to a parse Relation hash"
+            end
+          fail ArgumentError, "could not determine class_name from #{ object.inspect }" unless class_name
+          { __type: 'Relation', className: class_name }.with_indifferent_access
+        end
+        
+        def to_ruby( object )
+          return if object.nil?
+          return object if object.is_a? self
+          class_name = 
+            case object
+            when Hash
+              fetch_hash_key_from( object, 'class_name' ) || fetch_hash_key_from( object, 'model_name' )
+            when String, Symbol
+              object
+            when is_descendant.curry[Opium::Model]
+              object.model_name
+            else
+              fail ArgumentError, "could not convert #{ object.inspect } to a Opium::Model::Relation"
+            end
+          new( class_name )
+        end
+        
+        private
+        
+        def is_descendant
+          @is_descendant ||= ->( expected_type, object ) { ( object.is_a?( Class ) ? object : object.class ) <= expected_type }
+        end
+        
+        def fetch_hash_key_from( hash, key )
+          snake_case_key = key.to_s.underscore
+          lower_camel_key = key.to_s.camelcase(:lower)
+          
+          hash[ snake_case_key ] || hash[ snake_case_key.to_sym ] || hash[ lower_camel_key ] || hash[ lower_camel_key.to_sym ]
+        end
+      end
+      
+      def initialize( model_name )
+        super
+        update_variable!( :cache, true )
+      end
+      
+      def to_parse
+        self.class.to_parse self
+      end
+      
+      def empty?
+        owner.nil? || owner.new_record? ? true : super
+      end
+      
+      attr_reader :owner, :metadata
+      
+      def owner=(value)
+        @owner = value
+        update_constraint!( :where, '$relatedTo' => { 'object' => value.to_parse } )
+      end
+      
+      def metadata=(value)
+        @metadata = value
+        update_constraint!( :where, '$relatedTo' => { 'key' => value.relation_name.to_s } )
+      end
+      
+      alias_method :class_name, :model_name
+      
+      #TODO: likely will need to reimplement .each
+      
+      def each(&block)
+        if !block_given?
+          to_enum(:each)
+        else
+          super() {|model| block.call( model ) unless __deletions__.include?( model ) }
+          (__additions__ - __deletions__).each(&block)
+        end
+      end
+      
+      def push( object )
+        __additions__.push( object )
+        self
+      end
+      
+      alias_method :<<, :push
+      
+      def delete( object )
+        __deletions__.push( object )
+        self
+      end
+      
+      def build( params = {} )
+        model.new( params || {} ).tap do |instance|
+          push instance
+        end
+      end
+      
+      alias_method :new, :build
+      
+      def save
+        self.reject {|model| model.persisted?}.each(&:save)
+        __apply_additions__
+        __apply_deletions__
+        true
+      end
+      
+      def parse_response
+        @parse_response ||= []
+      end
+      
+      private
+      
+      def __relation_deltas__
+        @__relation_deltas__ ||= {}
+      end
+      
+      def __additions__
+        __relation_deltas__[:additions] ||= []
+      end
+      
+      def __deletions__
+        __relation_deltas__[:deletions] ||= []
+      end
+      
+      def __apply_additions__
+        unless __additions__.empty?
+          parse_response << owner.class.http_put( owner.id, { metadata.relation_name => { __op: 'AddRelation', objects: __additions__.map(&:to_parse) } } )
+          @cache.concat( __additions__ )
+          __additions__.clear
+        end
+      end
+      
+      def __apply_deletions__
+        unless __deletions__.empty?
+          parse_response << owner.class.http_put( owner.id, { metadata.relation_name => { __op: 'RemoveRelation', objects: __deletions__.map(&:to_parse) } } )
+          @cache = @cache - __deletions__
+          __deletions__.clear
+        end
+      end
+    end
+  end
+end