ninja-model 0.4.2 → 0.5.1

data/lib/ninja_model/associations/association_proxy.rb

@@ -2,7 +2,125 @@ require 'active_record/associations/association_proxy'
 
 module NinjaModel
   module Associations
-    class AssociationProxy < ActiveRecord::Associations::AssociationProxy
+    class AssociationProxy
+      alias_method :proxy_respond_to?, :respond_to?
+      alias_method :proxy_extend, :extend
+      delegate :to_param, :to => :proxy_target
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to_missing|proxy_/ }
+
+      def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+        @updated = false
+        Array.wrap(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
+        reset
+      end
+
+      def proxy_owner
+        @owner
+      end
+
+      def proxy_reflection
+        @reflection
+      end
+
+      def proxy_target
+        @target
+      end
+
+      def respond_to?(*args)
+        proxy_respond_to?(*args) || (load_target && @target.respond_to?(*args))
+      end
+
+      def ===(other)
+        load_target
+        other === @target
+      end
+
+      def reload
+        reset
+        load_target
+        self unless @target.nil?
+      end
+
+      def reset
+        @loaded = false
+        @target = nil
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def loaded
+        @loaded = true
+      end
+
+      def target
+        @target
+      end
+
+      def target=(target)
+        @target = target
+        loaded
+      end
+
+      def inspect
+        load_target
+        @target.inspect
+      end
+
+      def send(method, *args)
+        if proxy_respond_to?(method)
+          super
+        else
+          load_target
+          @target.send(method, *args)
+        end
+      end
+
+      protected
+
+      def dependent?
+        @reflection.options[:dependent]
+      end
+
+      def with_scope(*args, &block)
+        @reflection.klass.send :with_scope, *args, &block
+      end
+
+      private
+
+      def method_missing(method, *args)
+        if load_target
+          unless @target.respond_to?(method)
+            message = "undefined method '#{method.to_s}' for \"#{@target}\":#{@target.class.to_s}"
+            raise NoMethodError, message
+          end
+
+          if block_given?
+            @target.send(method, *args) { |*block_args| yield(*block_args) }
+          else
+            @target.send(method, *args)
+          end
+        end
+      end
+
+      def load_target
+        return nil unless defined?(@loaded)
+
+        if !loaded? and (@owner.persisted? || foreign_key_present)
+          @target = find_target
+        end
+
+        @loaded = true
+        @target
+      rescue NinjaModel::RecordNotFound
+        reset
+      end
+
+      def foreign_key_present
+        false
+      end
     end
   end
 end

data/lib/ninja_model/associations/belongs_to_association.rb

@@ -20,7 +20,11 @@ module NinjaModel
       private
 
       def find_target
-        @reflection.klass.scoped.where(@reflection.association_foreign_key => @owner.send(@reflection.primary_key_name)).first
+        if @reflection.options[:primary_key]
+          @reflection.klass.scoped.where( @reflection.options[:primary_key] => @owner.send(@reflection.primary_key_name)).first
+        else
+          @reflection.klass.scoped.where( :id => @owner.send(@reflection.primary_key_name)).first
+        end
       end
 
       def record_id(record)

data/lib/ninja_model/attribute.rb

@@ -0,0 +1,130 @@
+require 'active_support/core_ext/date_time/conversions'
+
+module NinjaModel
+  class UnsupportedType < NinjaModelError; end
+  class InvalidConversion < NinjaModelError; end
+
+  class Attribute
+    attr_reader :name, :type, :default
+
+    VALID_TYPES = [:string, :integer, :float, :date, :datetime, :boolean]
+
+    def initialize(name, type, options = {})
+      @name, @type = name.to_s, type
+      @default = options[:default]
+      raise UnsupportedType.new("Invalid type: #{@type}") unless VALID_TYPES.include?(@type)
+    end
+
+    def number?
+      [:integer, :float].include?(@type)
+    end
+
+    #
+    # Most of the following code was taken from ActiveRecord.  Credit to the
+    # Rails team is due.
+    #
+
+    def convert(value)
+      case type
+      when :string    then self.class.convert_to_string(value)
+      when :integer   then value.to_i rescue value ? 1 : 0
+      when :float     then value.to_f rescue value ? 1.0 : 0.0
+      when :date      then self.class.string_to_date(value)
+      when :datetime  then self.class.string_to_time(value)
+      when :boolean   then self.class.value_to_boolean(value)
+      end
+    end
+
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
+    FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
+
+    module Format
+      ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
+      ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+    end
+
+    class << self
+
+      def convert_to_string(value)
+        case value
+        when String, NilClass
+          value
+        when Fixnum, Float, Date, DateTime, TrueClass, FalseClass
+          value.to_s
+        else
+          raise InvalidConversion.new("Unable to convert #{value.inspect} to string")
+        end
+      end
+
+      def string_to_date(string)
+        return string unless string.is_a?(String)
+        return nil if string.empty?
+
+        fast_string_to_date(string) || fallback_string_to_date(string)
+      end
+
+      def string_to_time(string)
+        return string unless string.is_a?(String)
+        return nil if string.empty?
+
+        fast_string_to_time(string) || fallback_string_to_time(string)
+      end
+
+      # convert something to a boolean
+      def value_to_boolean(value)
+        if value.is_a?(String) && value.blank?
+          nil
+        else
+          TRUE_VALUES.include?(value)
+        end
+      end
+
+      protected
+
+      # '0.123456' -> 123456
+      # '1.123456' -> 123456
+      def microseconds(time)
+        ((time[:sec_fraction].to_f % 1) * 1_000_000).to_i
+      end
+
+      def new_date(year, mon, mday)
+        if year && year != 0
+          Date.new(year, mon, mday) rescue nil
+        end
+      end
+
+      def new_time(year, mon, mday, hour, min, sec, microsec)
+        # Treat 0000-00-00 00:00:00 as nil.
+        return nil if year.nil? || year == 0
+
+        DateTime.new(year, mon, mday, hour, min, sec, microsec) rescue nil
+      end
+
+      def fast_string_to_date(string)
+        if string =~ Format::ISO_DATE
+          new_date $1.to_i, $2.to_i, $3.to_i
+        end
+      end
+
+      # Doesn't handle time zones.
+      def fast_string_to_time(string)
+        if string =~ Format::ISO_DATETIME
+          microsec = ($7.to_f * 1_000_000).to_i
+          res = new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+          res
+        end
+      end
+
+      def fallback_string_to_date(string)
+        new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+      end
+
+      def fallback_string_to_time(string)
+        time_hash = Date._parse(string)
+        time_hash[:sec_fraction] = microseconds(time_hash)
+
+        new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+      end
+    end
+  end
+end

data/lib/ninja_model/{attributes.rb → attribute_methods.rb}

@@ -1,48 +1,23 @@
-require 'active_support'
-require 'active_model/attribute_methods'
-
 module NinjaModel
-  class Attribute
-    attr_reader :name, :type, :default, :primary_key
-    alias :primary_key? :primary_key
-    alias :primary :primary_key
-
-    def initialize(name, type, default, owner_class, options)
-      @name, @type, @default = name.to_s, type, default
-      @owner_class = owner_class
-      @options = options
-      @primary_key = options.key?(:primary_key) && options[:primary_key]
-    end
-
-    def define_methods!
-      @owner_class.define_attribute_methods(true)
-      @owner_class.primary_key = name.to_sym if @primary_key
-    end
+  class Base
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Dirty
 
-    def convert(value)
-      case type
-      when :string    then value
-      when :text      then value
-      when :integer   then value.to_i rescue value ? 1 : 0
-      when :float     then value.to_f
-      when :date      then ActiveRecord::ConnectionAdapters::Column.string_to_date(value)
-      else value
-      end
-    end
-  end
+    class_inheritable_accessor :model_attributes
+    self.model_attributes = []
+    attribute_method_suffix('', '=', '_before_type_cast')
 
-  module Attributes
-    extend ActiveSupport::Concern
-    include ActiveModel::AttributeMethods
+    class << self
 
-    module ClassMethods
       def attribute(name, data_type, *args)
         name = name.to_s
         opts = args.extract_options!
+        primary = opts.delete(:primary_key)
+        self.primary_key = name if primary.eql?(true)
         default = args.first unless args.blank?
-        new_attr = Attribute.new(name, data_type, default, self, opts)
+        new_attr = Attribute.new(name, data_type, opts)
         self.model_attributes << new_attr
-        new_attr.define_methods!
+        define_attribute_methods(true)
       end
 
       def define_attribute_methods(force = false)
@@ -67,12 +42,9 @@ module NinjaModel
 
       alias :column_names :attribute_names
     end
+  end
 
-    included do
-      class_inheritable_accessor :model_attributes
-      self.model_attributes = []
-      attribute_method_suffix('', '=')
-    end
+  module AttributeMethods
 
     def attributes_from_model_attributes
       self.class.model_attributes.inject({}) do |result, attr|
@@ -128,7 +100,14 @@ module NinjaModel
     end
 
     def attribute=(name, value)
-      write_attribute(name, value)
+      unless read_attribute(name).eql?(value)
+        attribute_will_change!(name)
+        write_attribute(name, value)
+      end
+    end
+
+    def attribute_before_type_cast(name)
+      @attributes[name]
     end
   end
 end

data/lib/ninja_model/base.rb

@@ -1,17 +1,34 @@
+require 'ninja_model/attribute_methods'
+require 'ninja_model/associations'
+require 'ninja_model/adapters'
+require 'ninja_model/callbacks'
+require 'ninja_model/identity'
+require 'ninja_model/persistence'
+require 'ninja_model/predicate'
+require 'ninja_model/reflection'
+require 'ninja_model/relation'
+require 'ninja_model/validation'
+require 'ninja_model/attribute'
+require 'active_record/named_scope'
+require 'active_record/aggregations'
+
 module NinjaModel
   class Base
-    include Attributes
-    include Callbacks
+    include AttributeMethods
     include Identity
     include Persistence
-    include Scoping
     include Validation
     include Adapters
     include Associations
     include Reflection
-    include ActiveRecord::Aggregations
     extend ActiveModel::Translation
     extend ActiveModel::Naming
+    include ActiveModel::Observing
+    include ActiveModel::Dirty
+    include ActiveRecord::Aggregations
+    include ActiveRecord::NamedScope
+
+    define_model_callbacks :initialize, :find, :touch, :only => :after
 
     class_inheritable_accessor :default_scoping, :instance_writer => false
     self.default_scoping = []
@@ -21,20 +38,6 @@ module NinjaModel
       delegate :find, :first, :last, :all, :exists?, :to => :scoped
       delegate :where, :order, :limit, :to => :scoped
 
-      def configuration_path
-        @config_path ||= File.join(Rails.root, "config/ninja_model.yml")
-      end
-
-      def configuration_path=(new_path)
-        @config_path = new_path
-      end
-
-      def configuration
-        require 'erb'
-        require 'yaml'
-        @configuration ||= YAML::load(ERB.new(IO.read(configuration_path)).result).with_indifferent_access
-      end
-
       def relation
         @relation ||= Relation.new(self)
       end
@@ -98,9 +101,9 @@ module NinjaModel
       @attributes = record.stringify_keys
       @readonly = @destroyed = false
       @persisted = true
+      _run_find_callbacks
+      _run_initialize_callbacks
       self
     end
   end
 end
-
-require 'ninja_model/core_ext/symbol'

data/lib/ninja_model/callbacks.rb

@@ -1,14 +1,5 @@
-require 'active_support'
-require 'active_model/callbacks'
-
 module NinjaModel
-  module Callbacks
-    extend ActiveSupport::Concern
-
-    included do
-      extend ActiveModel::Callbacks
-      define_model_callbacks :initialize, :find, :touch, :only => :after
-      define_model_callbacks :save, :create, :update, :destroy, :validation
-    end
+  class Base
+    extend ActiveModel::Callbacks
   end
 end