ninja-model 0.4.2

data/lib/ninja_model/associations/ninja_model_proxy.rb

@@ -0,0 +1,46 @@
+module NinjaModel
+  module Associations
+    class NinjaModelProxy
+      attr_reader :proxy_klass
+      def initialize(active_record)
+        @klass = active_record
+        @klass.class_eval do
+          def ninja_proxy
+            @ninja_proxy ||= begin
+              self.class.ninja_proxy.instance(self)
+            end
+            @ninja_proxy.attributes = self.attributes.delete_if { |k,v| k.eql?('id') }
+            @ninja_proxy
+          end
+        end
+
+        @proxy_klass = active_record.parent.const_set("#{@klass.model_name}Proxy", Class.new(NinjaModel::Base))
+
+        @klass.columns_hash.each_pair do |k,v|
+          @proxy_klass.send :attribute, k, v.type, v.default, @proxy_klass
+        end
+      end
+
+      def instance(obj)
+        proxy = @proxy_klass.new
+        proxy.send :instantiate, {'attributes' => obj.attributes}
+        proxy
+      end
+
+      def handle_association(macro, association_id, options)
+        unless macro.eql?(:belongs_to)
+          options = {:foreign_key => derive_foreign_key}.merge(options)
+        end
+
+        @proxy = nil
+        @proxy_klass.send macro, association_id, options
+      end
+
+      private
+
+      def derive_foreign_key
+        "#{@klass.name.underscore}_id".to_sym
+      end
+    end
+  end
+end

data/lib/ninja_model/associations.rb

@@ -0,0 +1,198 @@
+require 'active_support/concern'
+require 'ninja_model/associations/active_record_proxy'
+require 'ninja_model/associations/ninja_model_proxy'
+
+module ActiveRecord
+  module Associations
+    module ClassMethods
+      alias :has_one_without_ninja_model :has_one
+      def has_one(association_id, options = {})
+        if ninja_model?(:has_one, options[:class_name] || association_id)
+          ninja_proxy.handle_association(:has_one, association_id, options)
+        else
+          has_one_without_ninja_model(association_id, options)
+        end
+      end
+
+      def ninja_proxy
+        read_inheritable_attribute(:ninja_proxy) || write_inheritable_attribute(:ninja_proxy, NinjaModel::Associations::NinjaModelProxy.new(self))
+      end
+
+      private
+
+      def ninja_model?(macro, association)
+        klass = association.to_s.camelize
+        klass = klass.singularize unless [:has_one, :belongs_to].include?(macro)
+        klass = klass.constantize
+        klass.ancestors.include?(NinjaModel::Base)
+      end
+    end
+
+    def method_missing(method, *args)
+      begin
+        super
+      rescue NoMethodError => ex
+        if self.class.read_inheritable_attribute(:ninja_proxy) && ninja_proxy.respond_to?(method)
+          ninja_proxy.send(method, *args)
+        else
+          raise ex
+        end
+      end
+    end
+  end
+
+  module Reflection
+    module ClassMethods
+      alias :reflect_on_association_without_ninja_model :reflect_on_association
+      def reflect_on_association(association)
+        if read_inheritable_attribute(:ninja_proxy) && ninja_proxy.proxy_klass.reflections.include?(association)
+          ninja_proxy.proxy_klass.reflect_on_association(association)
+        else
+          reflect_on_association_without_ninja_model(association)
+        end
+      end
+    end
+  end
+end
+
+module NinjaModel
+  module Associations
+    extend ActiveSupport::Concern
+
+    autoload :AssociationProxy, 'ninja_model/associations/association_proxy'
+    autoload :HasOneAssociation, 'ninja_model/associations/has_one_association'
+    autoload :HasManyAssociation, 'ninja_model/associations/has_many_association'
+    autoload :BelongsToAssociation, 'ninja_model/associations/belongs_to_association'
+
+
+    module ClassMethods
+      def has_one(association_id, options = {})
+        if ninja_model?(:has_one, options[:class_name] || association_id)
+          reflection = create_has_one_reflection(association_id, options)
+          association_accessor_methods(reflection, HasOneAssociation)
+          #association_constructor_method(:build, reflection, HasOneAssociation)
+          #association_constructor_method(:create, reflection, HasOneAssociation)
+          #configure_dependency_for_has_one(reflection)
+        else
+          #puts "Setting up has_one proxy for #{association_id}"
+          proxy.handle_association(:has_one, association_id, options)
+        end
+      end
+
+      def belongs_to(association_id, options = {})
+        if ninja_model?(:belongs_to, options[:class_name] || association_id)
+          reflection = create_belongs_to_reflection(association_id, options)
+          association_accessor_methods(reflection, BelongsToAssociation)
+          #association_constructor_method(:build, reflection, BelongsToAssociation)
+          #association_constructor_method(:create, reflection, BelongsToAssociation)
+        else
+          proxy.handle_association(:belongs_to, association_id, options)
+        end
+      end
+
+      def has_many(association_id, options = {})
+        if ninja_model?(:has_many, association_id)
+          reflection = create_has_many_reflection(association_id, options)
+          collection_accessor_methods(reflection, HasManyAssociation)
+          #collection_accessor_methods(reflection, HasManyAssociation)
+        else
+          proxy.handle_association(:has_many, association_id, options)
+        end
+      end
+
+      def proxy
+        read_inheritable_attribute(:proxy) || write_inheritable_attribute(:proxy, ActiveRecordProxy.new(self))
+      end
+
+      private
+
+      def create_has_one_reflection(association, options = {})
+        create_reflection(:has_one, association, options, self)
+      end
+
+      def create_has_many_reflection(association, options = {})
+        create_reflection(:has_many, association, options, self)
+        #options[:extend] = create_extension_modules(association, extension
+      end
+
+      def create_belongs_to_reflection(association, options = {})
+        create_reflection(:belongs_to, association, options, self)
+      end
+
+      def association_accessor_methods(reflection, association_proxy_class)
+        redefine_method(reflection.name) do |*params|
+          association = association_instance_get(reflection.name)
+
+          if association.nil?
+            association = association_proxy_class.new(self, reflection)
+            retval = association.reload
+            if retval.nil? and association_proxy_class == BelongsToAssociation
+              association_instance_set(reflection.name, nil)
+              return nil
+            end
+            association_instance_set(reflection.name, association)
+          end
+          association.target.nil? ? nil : association
+        end
+
+        redefine_method("loaded_#{reflection.name}?") do
+          association = association_instance_get(reflection.name)
+          association && association.loaded?
+        end
+
+        redefine_method("#{reflection.name}=") do |new_value|
+          association = association_instance_get(reflection.name)
+          if association.nil? || association.target != new_value
+            association = association_proxy_class.new(self, reflection)
+          end
+
+          association.replace(new_value)
+          association_instance_set(reflection.name, new_value.nil? ? nil : association)
+        end
+
+        redefine_method("set_#{reflection.name}_target") do |target|
+          return if target.nil? and association_proxy_class == BelongsToAssociation
+          association = association_proxy_class.new(self, reflection)
+          association.target = target
+          association_instance_set(reflection.name, association)
+        end
+      end
+
+      def collection_accessor_methods(reflection, association_proxy_class)
+        collection_reader_method(reflection, association_proxy_class)
+      end
+
+      def collection_reader_method(reflection, association_proxy_class)
+        redefine_method(reflection.name) do |*params|
+          association = association_instance_get(reflection.name)
+
+          if association.nil?
+            association = association_proxy_class.new(self, reflection)
+          end
+          association_instance_set(reflection.name, association)
+          association
+        end
+      end
+    end
+
+    def association_instance_get(name)
+      ivar = "@#{name}"
+      if instance_variable_defined?(ivar)
+        association = instance_variable_get(ivar)
+        association if association.respond_to?(:loaded?)
+      end
+    end
+
+    def association_instance_set(name, association)
+      instance_variable_set("@#{name}", association)
+    end
+
+    def method_missing(method, *args)
+      if self.class.read_inheritable_attribute(:proxy) && proxy.respond_to?(method)
+        proxy.send(method, *args)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/ninja_model/attributes.rb

@@ -0,0 +1,134 @@
+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
+
+    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
+
+  module Attributes
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    module ClassMethods
+      def attribute(name, data_type, *args)
+        name = name.to_s
+        opts = args.extract_options!
+        default = args.first unless args.blank?
+        new_attr = Attribute.new(name, data_type, default, self, opts)
+        self.model_attributes << new_attr
+        new_attr.define_methods!
+      end
+
+      def define_attribute_methods(force = false)
+        return unless self.model_attributes
+        undefine_attribute_methods if force
+        super(self.model_attributes.map { |attr| attr.name })
+      end
+
+      def columns
+        model_attributes
+      end
+
+      def model_attributes_hash
+        @attributes_hash ||= HashWithIndifferentAccess[model_attributes.map { |attribute| [attribute.name, attribute] }]
+      end
+
+      alias :columns_hash :model_attributes_hash
+
+      def attribute_names
+        @attribute_names ||= model_attributes.map { |attribute| attribute.name }
+      end
+
+      alias :column_names :attribute_names
+    end
+
+    included do
+      class_inheritable_accessor :model_attributes
+      self.model_attributes = []
+      attribute_method_suffix('', '=')
+    end
+
+    def attributes_from_model_attributes
+      self.class.model_attributes.inject({}) do |result, attr|
+        result[attr.name] = attr.default unless attr.name == self.class.primary_key
+        result
+      end
+    end
+
+    def write_attribute(name, value)
+      name = name.to_s
+      if a = self.class.model_attributes_hash[name]
+        @attributes[name] = value
+      else
+        raise NoMethodError, "Unknown attribute #{name.inspect}"
+      end
+    end
+
+    def read_attribute(name)
+      name = name.to_s
+      if !(value = @attributes[name]).nil?
+        self.class.model_attributes_hash[name].convert(@attributes[name])
+      else
+        nil
+      end
+    end
+
+    def [](attr_name)
+      read_attribute(attr_name)
+    end
+
+    def []=(attr_name, value)
+      write_attribute(attr_name, value)
+    end
+
+    def attributes=(new_attributes)
+      return unless new_attributes.is_a?(Hash)
+      attributes = new_attributes.stringify_keys
+
+      attributes.each do |k,v|
+        respond_to?("#{k}=".to_sym) ? send("#{k}=".to_sym, v) : raise(UnknownAttributeError, "unknown attribute: #{k}")
+      end
+    end
+
+    def attribute_method?(name)
+      name = name.to_s
+      self.class.model_attributes_hash.key?(name)
+    end
+
+    private
+
+    def attribute(name)
+      read_attribute(name)
+    end
+
+    def attribute=(name, value)
+      write_attribute(name, value)
+    end
+  end
+end

data/lib/ninja_model/base.rb

@@ -0,0 +1,106 @@
+module NinjaModel
+  class Base
+    include Attributes
+    include Callbacks
+    include Identity
+    include Persistence
+    include Scoping
+    include Validation
+    include Adapters
+    include Associations
+    include Reflection
+    include ActiveRecord::Aggregations
+    extend ActiveModel::Translation
+    extend ActiveModel::Naming
+
+    class_inheritable_accessor :default_scoping, :instance_writer => false
+    self.default_scoping = []
+
+    class << self
+
+      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
+
+      def logger
+        ::NinjaModel.logger
+      end
+
+      def unscoped
+        block_given? ? relation.scoping { yield } : relation
+      end
+
+      def scoped_methods
+        key = "#{self}_scoped_methods".to_sym
+        Thread.current[key] = Thread.current[key].presence || self.default_scoping.dup
+      end
+
+      def default_scope(options = {})
+        reset_scoped_methods
+        self.default_scoping << build_finder_relation(options, default_scoping.pop)
+      end
+
+      def current_scoped_methods
+        last = scoped_methods.last
+        last.is_a?(Proc) ? unscoped(&last) : last
+      end
+
+      def reset_scoped_methods
+        Thread.current["#{self}_scoped_methods".to_sym] = nil
+      end
+
+      private
+
+      def build_finder_relation(options = {}, scope = nil)
+        relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
+        relation = scope.merge(relation) if scope
+        relation
+      end
+    end
+
+    def attributes
+      attrs = {}
+      self.class.attribute_names.each { |name|
+        attrs[name] = read_attribute(name)
+      }
+      attrs
+    end
+
+    def initialize(attributes = nil)
+      @attributes = attributes_from_model_attributes
+      self.attributes = attributes unless attributes.nil?
+      @persisted = false
+      @readonly = true
+      @destroyed = false
+      result = yield self if block_given?
+      _run_initialize_callbacks
+      result
+    end
+
+    def instantiate(record)
+      @attributes = record.stringify_keys
+      @readonly = @destroyed = false
+      @persisted = true
+      self
+    end
+  end
+end
+
+require 'ninja_model/core_ext/symbol'

data/lib/ninja_model/callbacks.rb

@@ -0,0 +1,14 @@
+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
+  end
+end

data/lib/ninja_model/configuration.rb

@@ -0,0 +1,20 @@
+module NinjaModel
+
+  mattr_accessor :configuration
+
+  class Configuration
+    attr_accessor :config_file_path, :adapter_path, :specs
+
+    def self.create
+      NinjaModel.configuration ||= new
+    end
+
+    private
+
+    def initialize
+      @config_file_path = 'config/ninja_model.yml'
+      @adapter_path = 'ninja_model/adapters'
+      @specs = {}
+    end
+  end
+end

data/lib/ninja_model/core_ext/symbol.rb

@@ -0,0 +1,7 @@
+class Symbol
+  NinjaModel::Predicate::PREDICATES.each do |predicate|
+    define_method(predicate) do |*args|
+      NinjaModel::Predicate.new(self, predicate, *args)
+    end
+  end
+end

data/lib/ninja_model/errors.rb

@@ -0,0 +1,5 @@
+module NinjaModel
+  class NinjaModelError < StandardError; end
+  class AdapterNotSpecified < NinjaModelError; end
+  class ConnectionTimeoutError < NinjaModelError; end
+end

data/lib/ninja_model/identity.rb

@@ -0,0 +1,24 @@
+require 'active_support'
+
+module NinjaModel
+  module Identity
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    included do
+      class_inheritable_accessor :primary_key
+      self.primary_key = :id
+      undef_method(:id) if method_defined?(:id)
+    end
+
+    def to_param
+      send(self.class.primary_key).to_s if persisted?
+    end
+
+    def to_key
+      key = nil
+      key = send(self.class.primary_key) if persisted?
+      [key] if key
+    end
+  end
+end

data/lib/ninja_model/log_subscriber.rb

@@ -0,0 +1,18 @@
+module NinjaModel
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def xml(event)
+      return unless logger.debug?
+
+      name = '%s (%.1fms)' % [event.payload[:name], event.duration]
+      xml = event.payload[:xml]
+
+      debug "  #{name}  #{xml}"
+    end
+
+    def logger
+      NinjaModel::Base.logger
+    end
+  end
+end
+
+ActiveRecord::LogSubscriber.attach_to :ninja_model

data/lib/ninja_model/persistence.rb

@@ -0,0 +1,76 @@
+require 'active_support'
+
+module NinjaModel
+  module Persistence
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    module ClassMethods
+      def get(rel)
+      end
+
+      def persist_with(adapter)
+
+      end
+    end
+
+    included do
+      class_inheritable_accessor :persistence_adapter
+    end
+
+    def save(*)
+      run_callbacks :save do
+        create_or_update
+      end
+    end
+
+    def create_or_update
+      if new_record?
+        create
+      else
+        update
+      end
+    end
+
+    def create
+      run_callbacks :create do
+        if self.class.adapter.create(self)
+          @persisted = true
+        end
+        @persisted
+      end
+    end
+
+    def update
+      self.class.adapter.update(self)
+    end
+
+    def new_record?
+      !@persisted
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def persisted?
+      @persisted && !destroyed?
+    end
+
+    def destroy
+      if self.class.adapter.destroy(self)
+        @destroyed = true
+      end
+      @destroyed
+    end
+
+    def reload
+      self.class.adapter.reload(self)
+    end
+
+    def update_attributes(attributes)
+      self.attributes = attributes
+      save
+    end
+  end
+end

data/lib/ninja_model/predicate.rb

@@ -0,0 +1,43 @@
+module NinjaModel
+  class Predicate
+
+    PREDICATES = [:eq, :ne, :gt, :gte, :lt, :lte, :in]
+
+    attr_reader :attribute, :method, :value
+
+    def initialize(attribute, method, *args)
+      @attribute = attribute
+      @method = method
+      @valued = !args.blank?
+      @value = args.blank? ? nil : args.first
+    end
+
+    def value=(value)
+      @value = value
+      @valued = true
+    end
+
+    def has_value?
+      @valued
+    end
+
+    def test(suspect)
+      case method
+      when :eq
+        suspect.eql?(value)
+      when :ne
+        !suspect.eql?(value)
+      when :gt
+        suspect > value
+      when :gte
+        suspect >= value
+      when :lt
+        suspect < value
+      when :lte
+        suspect <= value
+      when :in
+        value.include?(suspect)
+      end
+    end
+  end
+end