massive_record 0.1.0

data/lib/massive_record/orm/schema.rb

@@ -0,0 +1,4 @@
+require 'massive_record/orm/schema/column_families'
+require 'massive_record/orm/schema/column_family'
+require 'massive_record/orm/schema/fields'
+require 'massive_record/orm/schema/field'

data/lib/massive_record/orm/schema/column_families.rb

@@ -0,0 +1,48 @@
+require 'set'
+
+module MassiveRecord
+  module ORM
+    module Schema
+      class InvalidColumnFamily < ArgumentError; end
+
+      class ColumnFamilies < Set
+        def add(family)
+          family.column_families = self
+          raise InvalidColumnFamily.new(family.errors.full_messages.join(". ")) unless family.valid?
+          super
+        end
+        alias_method :<<, :add
+
+
+        def family_by_name(name)
+          detect { |family| family.name == name.to_s }
+        end
+
+        def family_by_name_or_new(name)
+          unless known_family = family_by_name(name)
+            known_family = ColumnFamily.new(:name => name)
+            add(known_family)
+          end
+          known_family
+        end
+
+
+        def to_hash
+          inject({}) do |hash, column_family|
+            hash.update(column_family.to_hash)
+            hash
+          end
+        end
+
+        def attribute_names
+          to_hash.keys
+        end
+
+
+        def attribute_name_taken?(name)
+          attribute_names.include? name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/schema/column_family.rb

@@ -0,0 +1,102 @@
+module MassiveRecord
+  module ORM
+    module Schema
+      class ColumnFamily
+        include ActiveModel::Validations
+
+        attr_accessor :column_families, :autoload_fields
+        attr_reader :name, :fields
+
+
+        validates_presence_of :name
+        validate do
+          errors.add(:column_families, :blank) if column_families.nil?
+          errors.add(:base, :invalid_fields) unless fields.all? { |field| field.valid? }
+        end
+
+
+        delegate :add, :add?, :<<, :to_hash, :attribute_names, :field_by_name, :to => :fields
+
+
+        def initialize(*args)
+          options = args.extract_options!
+          options.symbolize_keys!
+
+          @fields = Fields.new
+          @fields.contained_in = self
+
+          if options.has_key? :autoload
+            # TODO remove this for next version
+            ActiveSupport::Deprecation.warn("autoload is deprecated as an intitializer option. Please use autoload_fields instead!")
+            options[:autoload_fields] = options.delete :autoload
+          end
+
+          self.name = options[:name]
+          self.column_families = options[:column_families]
+          self.autoload_fields = options[:autoload_fields]
+        end
+
+        def ==(other)
+          other.instance_of?(self.class) && other.hash == hash
+        end
+        alias_method :eql?, :==
+
+        def hash
+          name.hash
+        end
+
+        def contained_in=(column_families)
+          self.column_families = column_families
+        end
+
+        def contained_in
+          column_families
+        end
+
+        def attribute_name_taken?(name, check_only_self = false)
+          name = name.to_s
+          check_only_self || contained_in.nil? ? fields.attribute_name_taken?(name, true) : contained_in.attribute_name_taken?(name)
+        end
+
+
+
+        def autoload_fields?
+          @autoload_fields == true
+        end
+
+        def autoload?
+          # TODO remove this method for next version
+          ActiveSupport::Deprecation.warn("ColumnFamily#autoload? is deprecated. Please use autoload_fields? instead")
+          autoload_fields?
+        end
+
+
+        private
+        
+        def name=(name)
+          @name = name.to_s
+        end
+        
+
+
+
+        # Internal DSL method
+        def field(*args)
+          self << Field.new_with_arguments_from_dsl(*args)
+        end
+
+
+        # Internal DSL method
+        def autoload_fields
+          @autoload_fields = true
+        end
+
+        def autoload
+          # TODO remove this method for next version
+          ActiveSupport::Deprecation.warn("ColumnFamily#autoload DSL call is deprecated. Please use autoload_fields instead")
+          autoload
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/schema/column_interface.rb

@@ -0,0 +1,91 @@
+require 'massive_record/orm/schema/common_interface'
+
+module MassiveRecord
+  module ORM
+    module Schema
+      module ColumnInterface
+        extend ActiveSupport::Concern
+
+        included do
+          include CommonInterface
+
+          class_attribute :fields, :instance_writer => false
+          self.fields = nil
+        end
+
+        module ClassMethods
+          #
+          # DSL method exposed into class. Makes it possible to do:
+          #
+          # class Person < MassiveRecord::ORM::Column
+          #  field :name
+          #  field :age, :integer, :default => 0
+          #  field :points, :integer, :column => :number_of_points
+          # end
+          #
+          #
+          def field(*args)
+            ensure_fields_exists
+            fields << Field.new_with_arguments_from_dsl(*args)
+          end
+
+          #
+          # If you need to add fields dynamically, use this method.
+          # It wraps functionality needed to keep the class in a consistent state.
+          # There is also an instance method defined which will inject default value
+          # to the object itself after defining the field.
+          #
+          def add_field(*args)
+            ensure_fields_exists
+
+            field = Field.new_with_arguments_from_dsl(*args)
+            fields << field
+
+            undefine_attribute_methods if respond_to? :undefine_attribute_methods
+
+            field
+          end
+
+
+
+
+          private
+          #
+          # Entrypoint for the CommonInterface
+          #
+          def schema_source
+            fields
+          end
+
+          def ensure_fields_exists
+            self.fields = Fields.new if fields.nil?
+          end
+        end
+
+        #
+        # Same as defined in class method, but also sets the default value
+        # in current object it was called from.
+        #
+        def add_field(*args)
+          new_field = self.class.add_field(*args)
+          method = "#{new_field.name}="
+          send(method, new_field.default) if respond_to? method
+        end
+        
+        #
+        # TODO : Need to be cleaned up after we implement the has_many method
+        #
+        def attributes_to_row_values_hash(only_attr_names = [])
+          values = Hash.new
+
+          attributes_schema.each do |attr_name, orm_field|
+            next unless only_attr_names.empty? || only_attr_names.include?(attr_name)
+            values[orm_field.column] = send(attr_name)
+          end
+
+          values
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/schema/common_interface.rb

@@ -0,0 +1,48 @@
+module MassiveRecord
+  module ORM
+    module Schema
+      #
+      # Common methods both shared with table interface and field interface.
+      # Methods are to be included as ClassMethods, and where they are to be
+      # included must provide a schema_source(). Currently it is expected to
+      # be a set of Schema::ColumnFamilies or a set of Schema::Fields, but
+      # I guess as long as it responds to to_hash and attribute_names you are fine.
+      #
+      module CommonInterface
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          #
+          # Returns a hash where attribute names are keys and it's field
+          # is the value.
+          #
+          def attributes_schema
+            schema_source.present? ? schema_source.to_hash : {}
+          end
+
+          #
+          # Returns an array of known attributes based on all fields found
+          # in schema source
+          #
+          def known_attribute_names
+            schema_source.present? ? schema_source.attribute_names : []
+          end
+
+
+          #
+          # Returns a hash with attribute name as keys, default values read from field as value.
+          #
+          def default_attributes_from_schema
+            Hash[attributes_schema.collect { |attribute_name, field| 
+              [attribute_name, field.default]
+            }]
+          end
+        end
+
+        def attributes_schema
+          self.class.attributes_schema
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/schema/field.rb

@@ -0,0 +1,128 @@
+module MassiveRecord
+  module ORM
+    module Schema
+      class Field
+        include ActiveModel::Validations
+
+        TYPES = [:string, :integer, :float, :boolean, :array, :hash, :date, :time]
+
+        attr_writer :default
+        attr_accessor :name, :column, :type, :fields
+
+
+        validates_presence_of :name
+        validates_inclusion_of :type, :in => TYPES
+        validate do
+          errors.add(:fields, :blank) if fields.nil?
+          errors.add(:name, :taken) if fields.try(:attribute_name_taken?, name)
+        end
+
+      
+        #
+        # Creates a new field based on arguments from DSL
+        # args: name, type, options
+        #
+        def self.new_with_arguments_from_dsl(*args)
+          field_options = args.extract_options!
+          field_options[:name] = args[0]
+          field_options[:type] = args[1]
+
+          new(field_options)
+        end
+
+
+
+        def initialize(*args)
+          options = args.extract_options!.to_options
+
+          self.fields = options[:fields]
+          self.name = options[:name]
+          self.column = options[:column]
+          self.type = options[:type] || :string
+          self.default = options[:default]
+        end
+
+
+        def ==(other)
+          other.instance_of?(self.class) && other.hash == hash
+        end
+        alias_method :eql?, :==
+
+        def hash
+          name.hash
+        end
+
+        def type=(type)
+          @type = type.to_sym
+        end
+
+
+        def column
+          @column || name
+        end
+
+        def default
+          @default.duplicable? ? @default.dup : @default
+        end
+
+        
+        def unique_name
+          raise "Can't generate a unique name as I don't have a column family!" if column_family.nil?
+          [column_family.name, column].join(":")
+        end
+
+        def column_family
+          fields.try :contained_in
+        end
+
+        def column=(column)
+          column = column.to_s unless column.nil?
+          @column = column
+        end
+
+
+
+
+        def decode(value)
+          return nil if value.nil?
+
+          if type == :boolean
+            return value if value === TrueClass || value === FalseClass
+          else
+            return value if value.class == type.to_s.classify.constantize
+          end
+          
+          case type
+          when :string
+            value
+          when :boolean
+            value.to_s.empty? ? nil : !value.to_s.match(/^(true|1)$/i).nil?
+          when :integer
+            value.to_s.empty? ? nil : value.to_i
+          when :float
+            value.to_s.empty? ? nil : value.to_f
+          when :date
+            # TODO : find a nicer way to do that
+            value.empty? || value.to_s == "0" ? nil : Date.parse(value)
+          when :time
+            value.empty? ? nil : Time.parse(value)
+          when :array
+            value
+          when :hash
+            value
+          else
+            value
+          end
+        end
+
+
+
+        private
+
+        def name=(name)
+          @name = name.to_s
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/schema/fields.rb

@@ -0,0 +1,37 @@
+module MassiveRecord
+  module ORM
+    module Schema
+      class InvalidField < ArgumentError; end
+
+      class Fields < Set
+        attr_accessor :contained_in
+
+        def add(field)
+          field.fields = self
+          raise InvalidField.new(field.errors.full_messages.join(". ")) unless field.valid?
+          super
+        end
+        alias_method :<<, :add
+
+        def field_by_name(name)
+          name = name.to_s
+          detect { |field| field.name == name }
+        end
+
+        def attribute_name_taken?(name, check_only_self = false)
+          name = name.to_s
+          check_only_self || contained_in.nil? ? attribute_names.include?(name) : contained_in.attribute_name_taken?(name) 
+        end
+
+
+        def to_hash
+          Hash[collect { |field| [field.name, field] }]
+        end
+
+        def attribute_names
+          to_hash.keys
+        end
+      end
+    end
+  end
+end