massive_record 0.2.1 → 0.2.2.rc1

data/lib/massive_record/orm/raw_data.rb

@@ -0,0 +1,47 @@
+module MassiveRecord
+  module ORM
+
+    #
+    # Class to hold one raw data, and some meta data for that value.
+    # As of writing this the meta data is when cell which the data
+    # originates from was last written to (created_at).
+    #
+    class RawData
+      attr_reader :value, :created_at
+
+
+      class << self
+        def new_with_data_from(object)
+          send("new_with_data_from_#{object.class.to_s.demodulize.underscore}", object)
+        end
+
+
+        private
+
+        def new_with_data_from_cell(cell)
+          new(value: cell.value, created_at: cell.created_at)
+        end
+      end
+
+
+
+      def initialize(attributes)
+        @value = attributes[:value]
+        @created_at = attributes[:created_at]
+      end
+
+      delegate :inspect, :to_s, :to => :value
+
+
+      def ==(other)
+        other.equal?(self) ||
+          other.instance_of?(self.class) && value == other.value && created_at == other.created_at
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [id, created_at].hash
+      end
+    end
+  end
+end

data/lib/massive_record/orm/relations.rb

@@ -1,6 +1,10 @@
 require 'massive_record/orm/relations/proxy'
+require 'massive_record/orm/relations/proxy_collection'
 require 'massive_record/orm/relations/proxy/references_one'
 require 'massive_record/orm/relations/proxy/references_one_polymorphic'
 require 'massive_record/orm/relations/proxy/references_many'
+require 'massive_record/orm/relations/proxy/embeds_many'
+require 'massive_record/orm/relations/proxy/embedded_in'
+require 'massive_record/orm/relations/proxy/embedded_in_polymorphic'
 require 'massive_record/orm/relations/metadata'
 require 'massive_record/orm/relations/interface'

data/lib/massive_record/orm/relations/interface.rb

@@ -92,6 +92,74 @@ module MassiveRecord
             create_references_many_accessors(metadata)
           end
 
+
+
+          #
+          # Used to defined a relationship to other models where the other models are embedded inside of owner record.
+          #
+          # class Person < MassiveRecord::ORM::Table
+          #   embeds_many :addresses
+          # end
+          #
+          #
+          # The embeds many association gets one column family per association. embeds_many :addresses
+          # will by default be stored in the addresses column family. You can however do this:
+          # embeds_many :addresses, :store_in => :base to manipulate the column family it is stored within.
+          #
+          # Embedded records gets a composite key consisting of base_class and the record's id. This is how
+          # it is possible to mix embedded collection in to one column family / existing family with "normal" attributes.
+          # Please mind however, doing such a mixing might get you into trouble if you have attribute names which looks
+          # like an embedded address key. Companybook wanted this option, as they said haveing multiple column family might
+          # slow down Hbase.
+          #
+          # Attributes will be serialized by the Base.coder, by default will be JSON, but it really can be anything.
+          # The way records are stored inside of a column family will be:
+          #
+          # | key           | attributes                                        |
+          # ---------------------------------------------------------------------
+          # | "address|id1" | { :street => "Askerveien", :number => "12", etc... }
+          #
+          #
+          #
+          # Options, all optional:
+          #
+          #   <tt>class_name</tt>::            Class name is calculated from name, but can be overridden here.
+          #   <tt>store_in</tt>::              Send in the column family to store foreign key in. If none given,
+          #
+          def embeds_many(name, *args)
+            metadata = set_up_relation('embeds_many', name, *args)
+            metadata.owner_class = self
+            add_column_family(metadata.store_in)
+            create_embeds_many_accessors(metadata)
+          end
+
+
+
+          #
+          # Embedded in is being used together with embeds_many on the other side
+          # of such a relation.
+          #
+          # class Address < MassiveRecord::ORM::Embedded
+          #   embedded_in :person
+          # end
+          #
+          # You can also pass in :polymorphic => true as an option. If you do so here is an example:
+          #
+          #   class Person < MassiveRecord::ORM::Table
+          #     embeds_many :addresses, :inverse_of => :addressable
+          #   end
+          #   
+          #   class Address < MassiveRecord::ORM::Embedded
+          #     embedded_in :addressable, :inverse_of => :addresses, :polymorphic => true
+          #   end
+          #
+          def embedded_in(name, *args)
+            metadata = set_up_relation('embedded_in', name, *args)
+            metadata.owner_class = self
+            create_embedded_in_accessors(metadata)
+          end
+
+
           private
 
           def set_up_relation(type, name, *args)
@@ -142,6 +210,29 @@ module MassiveRecord
               add_field_to_column_family(metadata.store_in, metadata.foreign_key, :type => :array, :allow_nil => false)
             end
           end
+
+
+          def create_embeds_many_accessors(metadata)
+            validates_associated metadata.name
+
+            redefine_method(metadata.name) do
+              relation_proxy(metadata.name)
+            end
+
+            redefine_method(metadata.name+'=') do |records|
+              relation_proxy(metadata.name).replace(records)
+            end
+          end
+
+          def create_embedded_in_accessors(metadata)
+            redefine_method(metadata.name) do
+              relation_proxy(metadata.name)
+            end
+
+            redefine_method(metadata.name+'=') do |record|
+              relation_proxy(metadata.name).replace(record)
+            end
+          end
         end
 
 
@@ -151,9 +242,52 @@ module MassiveRecord
           super
         end
 
+        def attributes=(attributes)
+          attributes_for_relations = {}
+
+          if relations && attributes.is_a?(Hash)
+            attributes.stringify_keys!
+            relation_names = relations.collect(&:name)
+
+            attributes.delete_if do |attr_name, value|
+              attributes_for_relations[attr_name] = value if relation_names.include? attr_name
+            end
+          end
+
+          super(attributes)
+          super(attributes_for_relations)
+        end
+
+
+        def relation_proxies
+          (relations || []).map { |metadata| relation_proxy(metadata.name) }
+        end
+
+        def relation_proxies_for_embedded
+          (relations || []).select(&:embedded?).map { |metadata| relation_proxy(metadata.name) }
+        end
+
 
         private
 
+        def create
+          embedded_relations = relation_proxies_for_embedded.select(&:changed?)
+          embedded_relations.each(&:parent_will_be_saved!)
+
+          super
+
+          embedded_relations.each(&:parent_has_been_saved!)
+        end
+
+        def update(attribute_names_to_update = attributes_with_embedded)
+          embedded_relations = relation_proxies_for_embedded.select(&:changed?)
+          embedded_relations.each(&:parent_will_be_saved!)
+
+          super
+
+          embedded_relations.each(&:parent_has_been_saved!)
+        end
+
         def relation_proxy(name)
           name = name.to_s
 

data/lib/massive_record/orm/relations/metadata.rb

@@ -3,14 +3,17 @@ require 'active_support/core_ext/array/extract_options'
 module MassiveRecord
   module ORM
     module Relations
+      # Raised when an invalid start option is given to a find_in_batches
+      class InvalidStartsWithOption < MassiveRecordError
+      end
 
       #
       # The master of metadata related to a relation. For instance;
       # references_one :employee, :foreign_key => "person_id", :class_name => "Person"
       #
       class Metadata
-        attr_writer :foreign_key, :store_in, :class_name, :name, :relation_type, :polymorphic
-        attr_accessor :find_with
+        attr_writer :foreign_key, :store_in, :class_name, :name, :relation_type, :polymorphic, :inverse_of
+        attr_accessor :find_with, :owner_class
         attr_reader :records_starts_from
         
         def initialize(name, options = {})
@@ -26,6 +29,7 @@ module MassiveRecord
           self.find_with = options[:find_with]
           self.records_starts_from = options[:records_starts_from] if options[:records_starts_from]
           self.polymorphic = options[:polymorphic]
+          self.inverse_of = options[:inverse_of]
         end
 
 
@@ -62,12 +66,17 @@ module MassiveRecord
           (@class_name || calculate_class_name).to_s
         end
 
+        def inverse_of
+          (@inverse_of || calculate_inverse_of).to_s
+        end
+
         def proxy_target_class
           class_name.constantize
         end
 
         def store_in
-          @store_in.to_s if @store_in
+          return @store_in.to_s if @store_in
+          @store_in = name if embedded?
         end
 
         def store_foreign_key_in
@@ -81,17 +90,24 @@ module MassiveRecord
         end
 
         def persisting_foreign_key?
-          !!store_in && !records_starts_from
+          !embedded? && !!store_in && !records_starts_from
         end
 
 
         def polymorphic
           !!@polymorphic
         end
+        alias polymorphic? polymorphic
 
-        def polymorphic?
-          polymorphic
+        def embedded
+          relation_type == "embeds_many"
         end
+        alias embedded? embedded
+
+        def embedded_in
+          relation_type == "embedded_in" || relation_type == "embedded_in_polymorphic"
+        end
+        alias embedded_in? embedded_in
 
 
         def new_relation_proxy(proxy_owner)
@@ -111,16 +127,37 @@ module MassiveRecord
 
 
         def represents_a_collection?
-          relation_type == 'references_many'
-        end
-
-        
+          %w(references_many embeds_many).include? relation_type
+        end
+
+        #
+        # Sets a method which we should ask for how to find where
+        # related records starts with. Method injects a find_with
+        # Proc which finds are made through.
+        #
+        # That proc takes different options as it sends on to the
+        # receiving finder method on target class. It also takes a
+        # block which is sent on to the finder method.
+        #
         def records_starts_from=(method)
           @records_starts_from = method
 
           if @records_starts_from
-            self.find_with = Proc.new do |proxy_owner, options = {}|
-              start = proxy_owner.send(records_starts_from) and proxy_target_class.all(options.merge({:start => start}))
+            self.find_with = Proc.new do |proxy_owner, options = {}, &block|
+              options = MassiveRecord::Adapters::Thrift::Table.warn_and_change_deprecated_finder_options(options)
+
+              finder_method = options.delete(:finder_method) || :all
+
+              if ids_starts_with = proxy_owner.send(records_starts_from)
+                if options[:starts_with]
+                  if options[:starts_with].starts_with?(ids_starts_with)
+                    ids_starts_with = options[:starts_with]
+                  else
+                    raise InvalidStartsWithOption.new("The starts with option: #{options[:starts_with]} must begin with: #{ids_starts_with}.")
+                  end
+                end
+                proxy_target_class.send(finder_method, options.merge({:starts_with => ids_starts_with}), &block)
+              end
             end
           else
             self.find_with = nil
@@ -135,6 +172,15 @@ module MassiveRecord
           name.to_s.classify
         end
 
+        def calculate_inverse_of
+          raise "Can't return inverse of without it being explicitly set or without an owner_class" unless owner_class
+          if represents_a_collection?
+            owner_class.to_s.demodulize.underscore.singularize
+          else
+            owner_class.to_s.demodulize.underscore.pluralize
+          end
+        end
+
         def calculate_foreign_key
           if represents_a_collection?
             name.downcase.singularize + "_ids"

data/lib/massive_record/orm/relations/proxy.rb

@@ -46,8 +46,8 @@ module MassiveRecord
         # Returns the proxy_target. Loads it, if it's not there.
         # Returns nil if for some reason proxy_target could not be found.
         #
-        def load_proxy_target
-          self.proxy_target = find_proxy_target_or_find_with_proc if find_proxy_target?
+        def load_proxy_target(options = {})
+          self.proxy_target = find_proxy_target_or_find_with_proc(options) if find_proxy_target?
           proxy_target
         rescue RecordNotFound
           reset
@@ -58,13 +58,13 @@ module MassiveRecord
           load_proxy_target
         end
 
-        def reset
+        def reset(force = true)
           @loaded = @proxy_target = nil
         end
 
         def replace(proxy_target)
           if proxy_target.nil?
-            reset 
+            reset(true)
           else
             raise_if_type_mismatch(proxy_target)
             self.proxy_target = proxy_target
@@ -88,9 +88,6 @@ module MassiveRecord
           @loaded = true
         end
 
-
-
-
         def respond_to?(*args)
           super || (load_proxy_target && proxy_target.respond_to?(*args))
         end
@@ -103,6 +100,14 @@ module MassiveRecord
         end
       
 
+        def blank?
+          load_proxy_target.blank?
+        end
+
+        def is_a?(type)
+          load_proxy_target.is_a?(type)
+        end
+
         # Strange.. Without Rails, to_param goes through method_missing,
         #           With Rails it seems like the proxy answered to to_param, which
         #           kinda was not what I wanted.
@@ -113,8 +118,8 @@ module MassiveRecord
 
         protected
 
-        def find_proxy_target_or_find_with_proc
-          find_with_proc? ? find_proxy_target_with_proc : find_proxy_target
+        def find_proxy_target_or_find_with_proc(options = {})
+          find_with_proc? ? find_proxy_target_with_proc(options) : find_proxy_target(options)
         end
 
         #
@@ -123,7 +128,7 @@ module MassiveRecord
         # data contains a find_with proc; in that case find_proxy_target_with_proc
         # is used instead
         #
-        def find_proxy_target
+        def find_proxy_target(options = {})
         end
         
         #
@@ -132,8 +137,8 @@ module MassiveRecord
         # references_many proxy ensures that the result of proc
         # is put inside of an array.
         #
-        def find_proxy_target_with_proc(options = {})
-          metadata.find_with.call(proxy_owner, options)
+        def find_proxy_target_with_proc(options = {}, &block)
+          metadata.find_with.call(proxy_owner, options, &block)
         end
 
         #

data/lib/massive_record/orm/relations/proxy/embedded_in.rb

@@ -0,0 +1,54 @@
+module MassiveRecord
+  module ORM
+    module Relations
+      class Proxy
+        class EmbeddedIn < Proxy
+
+          def replace(proxy_target, update_inverse_relation = true)
+            proxy_target_was = self.proxy_target
+
+            super(proxy_target).tap do |proxy_target_is|
+              if update_inverse_relation
+                if proxy_target_is.present?
+                  unless proxy_target_is.respond_to? metadata.inverse_of
+                    raise RelationMissing.new(
+                      <<-TXT
+                        Expected '#{metadata.proxy_target_class}' to have an embedded
+                        relation defined with name '#{metadata.inverse_of}'.
+                      TXT
+                    )
+                  end
+
+                  if proxy_target_was.nil?
+                    proxy_target_is.send(metadata.inverse_of).push proxy_owner
+                  elsif proxy_target_was != proxy_target_is
+                    proxy_target_was.send(metadata.inverse_of).delete(proxy_owner)
+                    proxy_target_was.save if proxy_target_was.persisted?
+                    proxy_target_is.send(metadata.inverse_of).push proxy_owner
+                  end
+                end
+              end
+            end
+          end
+
+          def reset(force = false)
+            # Does nothing.. if we are resetting this inside of an embedded setting
+            # we will lose the knowledge about parent.
+            super if force
+          end
+
+
+          private
+
+
+          # We can never load proxy target,
+          # it will always be set for us, as we live
+          # inside of our own target
+          def can_find_proxy_target?
+            false
+          end
+        end
+      end
+    end
+  end
+end