massive_record 0.1.0

data/lib/massive_record/orm/attribute_methods/dirty.rb

@@ -0,0 +1,80 @@
+module MassiveRecord
+  module ORM
+    module AttributeMethods
+      module Dirty
+        extend ActiveSupport::Concern
+        include ActiveModel::Dirty
+
+
+        def save(*)
+          if status = super
+            changes_before_save = changes
+            clear_dirty_states!
+            @previously_changed = changes_before_save
+          end
+          status
+        end
+
+        def save!(*)
+          super.tap do
+            changes_before_save = changes
+            clear_dirty_states!
+            @previously_changed = changes_before_save
+          end
+        end
+
+        def reload(*)
+          super.tap do
+            clear_dirty_states!
+          end
+        end
+
+        def write_attribute(attr_name, value)
+          attr_name = attr_name.to_s
+
+          if will_change_attribute?(attr_name, value)
+            if will_change_back_to_original_value?(attr_name, value)
+              changed_attributes.delete(attr_name)
+            else
+              super(attr_name, original_attribute_value(attr_name))
+              send("#{attr_name}_will_change!")
+            end
+          end
+
+          super
+        end
+
+
+        private
+
+        def update(*)
+          changes.empty? ? true : super(changes.keys)
+        end
+
+        def original_attribute_value(attr_name)
+          @original_attribute_values ||= {}
+
+          unless @original_attribute_values.has_key? attr_name
+            @original_attribute_values[attr_name] = send(attr_name)
+          end
+
+          @original_attribute_values[attr_name]
+        end
+
+        def will_change_attribute?(attr_name, value)
+          read_attribute(attr_name) != value
+        end
+
+        def will_change_back_to_original_value?(attr_name, value)
+          original_attribute_value(attr_name) == value
+        end
+
+        def clear_dirty_states!
+          changed_attributes.clear
+          @original_attribute_values.clear if @original_attribute_values
+          @previously_changed.clear if @previously_changed
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/attribute_methods/read.rb

@@ -0,0 +1,23 @@
+module MassiveRecord
+  module ORM
+    module AttributeMethods
+      module Read
+        extend ActiveSupport::Concern
+
+        included do
+          attribute_method_suffix ""
+        end
+        
+        def read_attribute(attr_name)
+          attributes_schema[attr_name].nil? ? @attributes[attr_name.to_s] : attributes_schema[attr_name].decode(@attributes[attr_name.to_s])
+        end
+
+        private
+
+        def attribute(attr_name)
+          read_attribute(attr_name)
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/attribute_methods/write.rb

@@ -0,0 +1,24 @@
+module MassiveRecord
+  module ORM
+    module AttributeMethods
+      module Write
+        extend ActiveSupport::Concern
+
+        included do
+          attribute_method_suffix "="
+        end
+        
+
+        def write_attribute(attr_name, value)
+          @attributes[attr_name.to_s] = value
+        end
+
+        private
+
+        def attribute=(attr_name, value)
+          write_attribute(attr_name, value)
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/base.rb

@@ -0,0 +1,176 @@
+require 'active_model'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/class/subclasses'
+require 'active_support/core_ext/module'
+require 'active_support/core_ext/string'
+require 'active_support/memoizable'
+
+require 'massive_record/orm/schema'
+require 'massive_record/orm/errors'
+require 'massive_record/orm/config'
+require 'massive_record/orm/finders'
+require 'massive_record/orm/attribute_methods'
+require 'massive_record/orm/attribute_methods/write'
+require 'massive_record/orm/attribute_methods/read'
+require 'massive_record/orm/attribute_methods/dirty'
+require 'massive_record/orm/validations'
+require 'massive_record/orm/callbacks'
+require 'massive_record/orm/persistence'
+
+module MassiveRecord
+  module ORM
+    class Base
+      include ActiveModel::Conversion
+      
+      # Add a prefix or a suffix to the table name
+      # example:
+      #
+      #   MassiveRecord::ORM::Base.table_name_prefix = "_production"
+      class_attribute :table_name_overriden, :instance_writer => false
+      self.table_name_overriden = nil
+
+      class_attribute :table_name_prefix, :instance_writer => false
+      self.table_name_prefix = ""
+      
+      class_attribute :table_name_suffix, :instance_writer => false
+      self.table_name_suffix = ""
+     
+      class << self
+        def table_name
+          @table_name ||= table_name_prefix + (table_name_overriden.blank? ? self.to_s.demodulize.underscore.pluralize : table_name_overriden) + table_name_suffix
+        end
+
+        def table_name=(name)
+          self.table_name_overriden = name
+        end
+        alias :set_table_name :table_name=
+
+        def reset_table_name_configuration!
+          @table_name = self.table_name_overriden = nil
+          self.table_name_prefix = self.table_name_suffix = ""
+        end
+      end
+
+      #
+      # Initialize a new object. Send in attributes which
+      # we'll dynamically set up read- and write methods for
+      # and assign to instance variables. How read- and write 
+      # methods are defined might change over time when the DSL
+      # for describing column families and fields are in place
+      #
+      def initialize(attributes = {})
+        self.attributes_raw = attributes_from_field_definition.merge(attributes)
+        self.attributes = attributes
+        @new_record = true
+        @destroyed = false
+
+        _run_initialize_callbacks
+      end
+
+      # Initialize an empty model object from +coder+.  +coder+ must contain
+      # the attributes necessary for initializing an empty model object.  For
+      # example:
+      #
+      # This should be used after finding a record from the database, as it will
+      # trust the coder's attributes and not load it with default values.
+      #
+      #   class Person < MassiveRecord::ORM::Table
+      #   end
+      #
+      #   person = Person.allocate
+      #   person.init_with('attributes' => { 'name' => 'Alice' })
+      #   person.name # => 'Alice'
+      def init_with(coder)
+        @new_record = false
+        @destroyed = false
+
+        self.attributes_raw = coder['attributes']
+
+        _run_find_callbacks
+        _run_initialize_callbacks
+      end
+
+
+      def ==(other)
+        other.equal?(self) || other.instance_of?(self.class) && id == other.id
+      end
+      alias_method :eql?, :==
+
+
+      def freeze
+        @attributes.freeze
+      end
+
+      def frozen?
+        @attributes.frozen?
+      end
+
+
+
+      def inspect
+        attributes_as_string = self.class.known_attribute_names.collect do |attr_name|
+          "#{attr_name}: #{attribute_for_inspect(attr_name)}"
+        end.join(', ')
+
+        "#<#{self.class} id: #{id.inspect}, #{attributes_as_string}>"
+      end
+
+
+      def attribute_for_inspect(attr_name)
+        value = read_attribute(attr_name)
+
+        if value.is_a?(String) && value.length > 50
+          "#{value[0..50]}...".inspect
+        elsif value.is_a?(Date) || value.is_a?(Time)
+          %("#{value.to_s}")
+        else
+          value.inspect
+        end
+      end
+
+      def id
+        if read_attribute(:id).blank? && respond_to?(:default_id, true)
+          @attributes["id"] = default_id
+        end
+
+        read_attribute(:id)
+      end
+
+
+
+
+
+      private
+
+      def next_id
+        IdFactory.next_for(self.class).to_s
+      end
+    end
+
+
+    Base.class_eval do
+      include Config
+      include Persistence
+      include Finders
+      include ActiveModel::Translation
+      include AttributeMethods
+      include AttributeMethods::Write, AttributeMethods::Read
+      include AttributeMethods::Dirty
+      include Validations
+      include Callbacks
+
+
+      alias [] read_attribute
+      alias []= write_attribute
+    end
+  end
+end
+
+
+
+
+
+require 'massive_record/orm/table'
+require 'massive_record/orm/column'
+require 'massive_record/orm/id_factory'

data/lib/massive_record/orm/callbacks.rb

@@ -0,0 +1,52 @@
+module MassiveRecord
+  module ORM
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      CALLBACKS = [
+        :after_initialize, :after_find, :after_touch, 
+        :before_validation, :after_validation,
+        :before_save, :around_save, :after_save,
+        :before_create, :around_create, :after_create,
+        :before_update, :around_update, :after_update,
+        :before_destroy, :around_destroy, :after_destroy
+      ]
+
+      included do
+        extend ActiveModel::Callbacks
+        include ActiveModel::Validations::Callbacks
+
+        define_model_callbacks :initialize, :find, :touch, :only => :after
+        define_model_callbacks :save, :create, :update, :destroy
+      end
+
+
+
+      def destroy
+        _run_destroy_callbacks { super }
+      end
+
+      def touch(*)
+        _run_touch_callbacks { super }
+      end
+
+
+
+
+      private
+
+
+      def create_or_update
+        _run_save_callbacks { super }
+      end
+
+      def create
+        _run_create_callbacks { super }
+      end 
+
+      def update
+        _run_update_callbacks { super }
+      end
+    end
+  end
+end

data/lib/massive_record/orm/column.rb

@@ -0,0 +1,18 @@
+require 'massive_record/orm/schema/column_interface'
+
+module MassiveRecord
+  module ORM
+    class Column < Base
+      include Schema::ColumnInterface
+
+      # TODO  Column does not support these kind of methods
+      class << self
+        undef_method :first, :last, :all, :exists?, :destroy_all
+      end
+
+      undef_method :create, :reload, :save, :save!, :update_attribute, :update_attributes,
+        :update_attributes!, :touch, :destroy, :increment!, :atomic_increment!,
+        :decrement!, :delete
+    end
+  end
+end

data/lib/massive_record/orm/config.rb

@@ -0,0 +1,47 @@
+module MassiveRecord
+  module ORM
+    module Config
+      extend ActiveSupport::Concern 
+
+      included do
+        cattr_accessor :connection_configuration, :instance_writer => false
+        @@connection_configuration = {}
+      end
+
+      module ClassMethods
+        extend ActiveSupport::Memoizable
+        @@connection = nil
+
+        def connection
+          if @@connection.blank?
+            @@connection = if !connection_configuration.empty?
+                            MassiveRecord::Wrapper::Connection.new(connection_configuration)
+                          elsif defined? Rails
+                            MassiveRecord::Wrapper::Base.connection
+                          else
+                            raise ConnectionConfigurationMissing
+                          end
+
+            @@connection.open
+          end
+          @@connection
+        end
+
+        def reset_connection!
+          @@connection = nil
+        end
+
+
+        def table
+          MassiveRecord::Wrapper::Table.new(connection, table_name)
+        end
+        memoize :table
+
+
+        def table_exists?
+          connection.tables.include?(table_name)
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/errors.rb

@@ -0,0 +1,47 @@
+module MassiveRecord
+  module ORM
+
+    # Generic error / exception class
+    class MassiveRecordError < StandardError
+    end
+
+
+    # Railsed by save! and create! if the record passes
+    # validation, but for some reason was not saved.
+    class RecordNotSaved < MassiveRecordError
+    end
+    
+    # Raised if a conncetion was being accessed, but no
+    # configuration was set to tell us how to connect.
+    class ConnectionConfigurationMissing < MassiveRecordError
+    end
+
+    # Raised on find(id) when id does not exist.
+    class RecordNotFound < MassiveRecordError
+    end
+
+    # Raised if an attribute is unkown
+    class UnkownAttributeError < MassiveRecordError
+    end
+
+    # Raised if id is missing when you try a save
+    # TODO  It might be that we some time later will offer a kind of
+    #       auto increment key functionality, and then this should only
+    #       be raised if that is disabled.
+    class IdMissing < MassiveRecordError
+    end
+
+    class ColumnFamiliesMissingError < MassiveRecordError
+      attr_reader :missing_column_families
+      def initialize(missing_column_families)
+        @missing_column_families = missing_column_families
+        super("hbase are missing some column families: #{@missing_column_families.join(' ')}. Please migrate the database.")
+      end
+    end
+
+    # Raised when trying to manipulate non-numeric fields by operations
+    # requiring a number to work on.
+    class NotNumericalFieldError < MassiveRecordError
+    end
+  end
+end