massive_record 0.1.1 → 0.2.0.beta

data/lib/massive_record/orm/coders/json.rb

@@ -0,0 +1,17 @@
+require 'active_support/json'
+
+module MassiveRecord
+  module ORM
+    module Coders
+      class JSON
+        def dump(object)
+          ActiveSupport::JSON.encode(object)
+        end
+
+        def load(json)
+          ActiveSupport::JSON.decode(json)
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/coders/yaml.rb

@@ -0,0 +1,15 @@
+module MassiveRecord
+  module ORM
+    module Coders
+      class YAML
+        def dump(object)
+          ::YAML.dump(object)
+        end
+
+        def load(yaml)
+          ::YAML.load(yaml)
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/coders.rb

@@ -0,0 +1,3 @@
+require 'massive_record/orm/coders/json'
+require 'massive_record/orm/coders/yaml'
+require 'massive_record/orm/coders/chained'

data/lib/massive_record/orm/errors.rb

@@ -33,9 +33,9 @@ module MassiveRecord
 
     class ColumnFamiliesMissingError < MassiveRecordError
       attr_reader :missing_column_families
-      def initialize(missing_column_families)
+      def initialize(klass, missing_column_families)
         @missing_column_families = missing_column_families
-        super("hbase are missing some column families: #{@missing_column_families.join(' ')}. Please migrate the database.")
+        super("hbase are missing some column families for class '#{klass.to_s}', table '#{klass.table_name}': #{@missing_column_families.join(' ')}. Please migrate the database.")
       end
     end
 
@@ -52,5 +52,18 @@ module MassiveRecord
     # Raised if you try to save a record which is read only
     class ReadOnlyRecord < MassiveRecordError
     end
+
+
+    # Raised when a relation s already defined
+    class RelationAlreadyDefined < MassiveRecordError
+    end
+
+    # Raised if proxy_target in a relation proxy does not match what the proxy expects
+    class RelationTypeMismatch < MassiveRecordError
+    end
+
+    # Raised when an attribute is decoded from the database, but the type returned does not match what is expected
+    class SerializationTypeMismatch < MassiveRecordError
+    end
   end
 end

data/lib/massive_record/orm/finders/scope.rb

@@ -0,0 +1,166 @@
+module MassiveRecord
+  module ORM
+    module Finders
+
+      #
+      # A finder scope's jobs is to contain and build up
+      # limitations and meta data of a DB query about to being
+      # executed, allowing us to call for instance
+      #
+      # User.select(:info).limit(5) or
+      # User.select(:info).find(a_user_id)
+      #
+      # Each call adds restrictions or info about the query about
+      # to be executed, and the proxy will act as an Enumerable object
+      # when asking for multiple values
+      #
+      class Scope
+        MULTI_VALUE_METHODS = %w(select)
+        SINGLE_VALUE_METHODS = %w(limit)
+        
+        attr_accessor *MULTI_VALUE_METHODS.collect { |m| m + "_values" }
+        attr_accessor *SINGLE_VALUE_METHODS.collect { |m| m + "_value" }
+        attr_accessor :loaded, :klass
+        alias :loaded? :loaded
+
+
+        delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to => :to_a
+        
+
+        def initialize(klass, options = {})
+          @klass = klass
+          @extra_finder_options = {}
+
+          reset
+          reset_single_values_options
+          reset_multi_values_options
+
+          apply_finder_options(options[:find_options]) if options.has_key? :find_options
+        end
+        
+        
+        def reset
+          @loaded = false
+        end
+
+
+
+        #
+        # Multi value options
+        #
+
+        def select(*select)
+          self.select_values |= select.flatten.compact.collect(&:to_s)
+          self
+        end
+
+
+        #
+        # Single value options
+        #
+
+        def limit(limit)
+          self.limit_value = limit
+          self
+        end
+
+
+
+
+
+        def ==(other)
+          case other
+          when Scope
+            object_id == other.object_id
+          when Array
+            to_a == other
+          else
+            raise "Don't know how to compare #{self.class} with #{other.class}"
+          end
+        end
+
+
+
+        def find(*args)
+          options = args.extract_options!.to_options
+          apply_finder_options(options)
+          args << options.merge(find_options)
+
+          klass.do_find(*args)
+        end
+
+        def all(options = {})
+          apply_finder_options(options)
+          to_a
+        end
+
+        def first(options = {})
+          apply_finder_options(options)
+          limit(1).to_a.first
+        end
+
+        def last(*args)
+          raise "Sorry, not implemented!"
+        end
+
+
+
+        def to_a
+          return @records if loaded?
+          @records = load_records
+          @records = [@records] unless @records.is_a? Array
+          @records
+        end
+
+
+
+
+        private
+
+
+        def load_records
+          @records = klass.do_find(:all, find_options)
+          @loaded = true
+          @records
+        end
+
+        def find_options
+          options = {}
+
+          SINGLE_VALUE_METHODS.each do |m|
+            value = send("#{m}_value") and options[m.to_sym] = value
+          end
+
+          MULTI_VALUE_METHODS.each do |m|
+            values = send("#{m}_values") and values.any? and options[m.to_sym] = values
+          end
+
+          options.merge(@extra_finder_options)
+        end
+
+
+
+        def apply_finder_options(options)
+          options.each do |scope_method, arguments|
+            if respond_to? scope_method
+              send(scope_method, arguments)
+            else
+              @extra_finder_options[scope_method] = arguments              
+            end
+          end
+        end
+
+
+
+
+        def reset_single_values_options
+          SINGLE_VALUE_METHODS.each { |m| instance_variable_set("@#{m}_value", nil) } 
+        end
+
+        def reset_multi_values_options
+          MULTI_VALUE_METHODS.each { |m| instance_variable_set("@#{m}_values", []) } 
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/finders.rb

@@ -3,23 +3,30 @@ module MassiveRecord
     module Finders
       extend ActiveSupport::Concern
 
+      included do
+        class << self
+          delegate :find, :first, :last, :all, :select, :limit, :to => :finder_scope
+        end
+
+        class_attribute :default_scoping, :instance_writer => false
+      end
+
       module ClassMethods
-        #
-        # Interface for retrieving objects based on key.
-        # Has some convenience behaviour like find :first, :last, :all.
-        #
-        def find(*args)
+        def do_find(*args) # :nodoc:
           options = args.extract_options!.to_options
           raise ArgumentError.new("At least one argument required!") if args.empty?
           raise RecordNotFound.new("Can't find a #{model_name.human} without an ID.") if args.first.nil?
           raise ArgumentError.new("Sorry, conditions are not supported!") if options.has_key? :conditions
+
+          skip_expected_result_check = options.delete(:skip_expected_result_check)
+
           args << options
 
           type = args.shift if args.first.is_a? Symbol
           find_many = type == :all
           expected_result_size = nil
 
-          return (find_many ? [] : nil) unless table.exists?
+          return (find_many ? [] : raise(RecordNotFound.new("Could not find #{model_name} with id=#{args.first}"))) unless table.exists?
           
           result_from_table = if type
                                 table.send(type, *args) # first() / all()
@@ -43,7 +50,7 @@ module MassiveRecord
           # we have no expectations on the returned rows' ids)
           unless type || result_from_table.blank?
             if find_many
-              result_from_table.select! { |result| what_to_find.include? result.id }
+              result_from_table.select! { |result| what_to_find.include? result.try(:id) }
             else 
               if result_from_table.id != what_to_find
                 result_from_table = nil
@@ -53,7 +60,7 @@ module MassiveRecord
 
           raise RecordNotFound.new("Could not find #{model_name} with id=#{what_to_find}") if result_from_table.blank? && type.nil?
           
-          if find_many && expected_result_size && expected_result_size != result_from_table.length
+          if find_many && !skip_expected_result_check && expected_result_size && expected_result_size != result_from_table.length
             raise RecordNotFound.new("Expected to find #{expected_result_size} records, but found only #{result_from_table.length}")
           end
           
@@ -64,19 +71,9 @@ module MassiveRecord
           find_many ? records : records.first
         end
 
-        def first(*args)
-          find(:first, *args)
-        end
-
-        def last(*args)
-          raise "Sorry, not implemented!"
-        end
-
-        def all(*args)
-          find(:all, *args)
-        end
-        
         def find_in_batches(*args)
+          return unless table.exists?
+
           table.find_in_batches(*args) do |rows|
             records = rows.collect do |row|
               instantiate(transpose_hbase_columns_to_record_attributes(row))
@@ -99,6 +96,26 @@ module MassiveRecord
         end
 
 
+        def finder_scope
+          default_scoping || unscoped
+        end
+
+        def default_scope(scope)
+          self.default_scoping =  case scope
+                                    when Scope, nil
+                                      scope
+                                    when Hash
+                                      Scope.new(self, :find_options => scope)
+                                    else
+                                      raise "Don't know how to set scope with #{scope.class}."
+                                    end
+        end
+
+        def unscoped
+          Scope.new(self)
+        end
+
+
         private
 
         def transpose_hbase_columns_to_record_attributes(row)
@@ -109,15 +126,19 @@ module MassiveRecord
           # Parse the schema to populate the instance attributes
           attributes_schema.each do |key, field|
             cell = row.columns[field.unique_name]
-            attributes[field.name] = cell.nil? ? nil : cell.deserialize_value
+            attributes[field.name] = cell.nil? ? nil : field.decode(cell.value)
           end
           attributes
         end
 
         def instantiate(record)
-          allocate.tap do |model|
-            model.init_with('attributes' => record)
-          end
+          model = if klass = record[inheritance_attribute] and klass.present?
+                    klass.constantize.allocate
+                  else
+                    allocate
+                  end
+
+          model.init_with('attributes' => record)
         end
       end
     end

data/lib/massive_record/orm/persistence.rb

@@ -30,7 +30,7 @@ module MassiveRecord
 
 
       def reload
-        self.attributes_raw = self.class.find(id).attributes
+        self.attributes_raw = self.class.find(id).attributes if persisted?
         self
       end
       
@@ -64,7 +64,7 @@ module MassiveRecord
       end
 
       def destroy
-        @destroyed = row_for_record.destroy and freeze
+        @destroyed = (persisted? ? row_for_record.destroy : true) and freeze
       end
       alias_method :delete, :destroy
 
@@ -155,7 +155,7 @@ module MassiveRecord
           self.class.table.save
         end
 
-        raise ColumnFamiliesMissingError.new(calculate_missing_family_names) if !calculate_missing_family_names.empty?
+        raise ColumnFamiliesMissingError.new(self.class, calculate_missing_family_names) if !calculate_missing_family_names.empty?
       end
       
       #
@@ -190,7 +190,7 @@ module MassiveRecord
 
         attributes_schema.each do |attr_name, orm_field|
           next unless only_attr_names.empty? || only_attr_names.include?(attr_name)
-          values[orm_field.column_family.name][orm_field.column] = send(attr_name)
+          values[orm_field.column_family.name][orm_field.column] = orm_field.encode(send(attr_name))
         end
 
         values

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

@@ -0,0 +1,170 @@
+module MassiveRecord
+  module ORM
+    module Relations
+      module Interface
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :relations, :instance_writer => false
+          self.relations = nil
+        end
+
+
+        module ClassMethods
+          #
+          # Used to define a references one relation. Example of usage:
+          # 
+          # class Person < MassiveRecord::ORM::Table
+          #   column_family :info do
+          #     field :name
+          #   end
+          #   
+          #   references_one :boss, :class_name => "Person", :store_in => :info
+          # end
+          #
+          # First argument is the name of the relation. class_name and foreign key is calculated from it, if none given.
+          #
+          #
+          # Options, all optional:
+          #
+          #   <tt>class_name</tt>::   Class name is calculated from name, but can be overridden here.
+          #   <tt>polymorphic</tt>::  Set it to true for make the association polymorphic. Will use foreign_key,
+          #                           remove the "_id" (if it's there) and add _type for it's reading/writing of type.
+          #   <tt>foreign_key</tt>::  Foreign key is calculated from name suffixed by _id as default.
+          #   <tt>store_in</tt>::     Send in the column family to store foreign key in. If none given,
+          #                           you should define the foreign key method in class if it can be
+          #                           calculated from another attributes in your class.
+          #   <tt>find_with</tt>::    Assign it to a Proc and we will call it with the proxy_owner if you need complete
+          #                           control over how you retrieve your record.
+          #                           As a default TargetClass.find(foreign_key_method) is used.
+          #
+          def references_one(name, *args)
+            metadata = set_up_relation('references_one', name, *args)
+
+            create_references_one_accessors(metadata)
+            create_references_one_polymorphic_accessors(metadata) if metadata.polymorphic?
+          end
+
+
+          #
+          # Used to define a reference many relation. Example of usage:
+          # 
+          # class Person < MassiveRecord::ORM::Table
+          #   column_family :info do
+          #     field :name
+          #   end
+          #   
+          #   references_many :cars, :store_in => :info
+          # end
+          #
+          # First argument is the name of the relation. class_name and attribute for foreign keys are calculated from it,
+          # if noen given. In the example above Person records will have attribute cars_ids which will be
+          # an array populated with foreign keys.
+          #
+          #
+          # Options, all optional:
+          #
+          #   <tt>class_name</tt>::            Class name is calculated from name, but can be overridden here.
+          #   <tt>foreign_key</tt>::           Foreign key is calculated from name suffixed by _ids as default.
+          #   <tt>store_in</tt>::              Send in the column family to store foreign key in. If none given,
+          #                                    you should define the foreign key method in class if it can be
+          #                                    calculated from another attributes in your class.
+          #   <tt>records_starts_from</tt>::   A method name which returns an ID to start from when fetching rows in
+          #                                    Person's table. This is useful if you for instance has a person with id 1
+          #                                    and in your table for cars have cars id like "<person_id>-<incremental number>"
+          #                                    or something. Then you can say references_many :cars, :starts_with => :id.
+          #   <tt>find_with</tt>::             Assign it to a Proc and we will call it with the proxy_owner if you need complete
+          #                                    control over how you retrieve your record.
+          #                                    As a default TargetClass.find(foreign_keys_method) is used.
+          #
+          #
+          # Example usage:
+          #
+          # person = Person.first
+          # person.cars               # loads and returns all cars.
+          # person.cars.first         # Returns first car, either by loading just one object, or return first object in loaded proxy.
+          # person.cars.find("an_id") # Tries to load car with id 1 if that id is among person's cars. Either by a query and look among loaded records
+          # person.cars.limit(3)      # Returns the 3 first cars, either by slice the loaded array of cars, or do a limited DB query.
+          #
+          #
+          def references_many(name, *args)
+            metadata = set_up_relation('references_many', name, *args)
+            create_references_many_accessors(metadata)
+          end
+
+          private
+
+          def set_up_relation(type, name, *args)
+            ensure_relations_exists
+
+            Metadata.new(name, *args).tap do |metadata|
+              metadata.relation_type = type
+              raise RelationAlreadyDefined unless self.relations.add?(metadata)
+            end
+          end
+
+          def ensure_relations_exists
+            self.relations = Set.new if relations.nil?
+          end
+
+
+          def create_references_one_accessors(metadata)
+            redefine_method(metadata.name) do
+              proxy = relation_proxy(metadata.name)
+              proxy.load_proxy_target ? proxy : nil
+            end
+
+            redefine_method(metadata.name+'=') do |record|
+              relation_proxy(metadata.name).replace(record)
+            end
+
+            if metadata.persisting_foreign_key?
+              add_field_to_column_family(metadata.store_in, metadata.foreign_key)
+            end
+          end
+
+          def create_references_one_polymorphic_accessors(metadata)
+            if metadata.persisting_foreign_key?
+              add_field_to_column_family(metadata.store_in, metadata.polymorphic_type_column)
+            end
+          end
+
+          def create_references_many_accessors(metadata)
+            redefine_method(metadata.name) do
+              relation_proxy(metadata.name)
+            end
+
+            if metadata.persisting_foreign_key?
+              add_field_to_column_family(metadata.store_in, metadata.foreign_key, :type => :array, :default => [])
+            end
+          end
+        end
+
+
+
+        private
+
+        def relation_proxy(name)
+          name = name.to_s
+
+          unless proxy = relation_proxy_get(name)
+            if metadata = relations.find { |meta| meta.name == name }
+              proxy = metadata.new_relation_proxy(self)
+              relation_proxy_set(name, proxy)
+            end
+          end
+
+          proxy
+        end
+
+        def relation_proxy_get(name)
+          @relation_proxy_cache[name.to_s]
+        end
+
+        def relation_proxy_set(name, proxy)
+          @relation_proxy_cache[name.to_s] = proxy
+        end
+      end
+    end
+  end
+end