ninja-model 0.4.2 → 0.5.1

data/lib/ninja_model/log_subscriber.rb

@@ -1,18 +0,0 @@
-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/scoping.rb

@@ -1,50 +0,0 @@
-require 'active_support'
-require 'active_support/core_ext/array'
-require 'active_support/core_ext/kernel/singleton_class'
-
-module NinjaModel
-  module Scoping
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def scoped(options = nil)
-        if options
-          scoped.apply_finder_options(options)
-        else
-          current_scoped_methods ? relation.merge(current_scoped_methods) : relation.clone
-        end
-      end
-
-      def scopes
-        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
-      end
-
-      def scope(name, scope_options = {}, &block)
-        name = name.to_sym
-        valid_scope_name?(name)
-        extension = Module.new(&block) if block_given?
-
-        scopes[name] = lambda do |*args|
-          options = scope_options.is_a?(Proc) ? scope_options.call(*args) : scope_options
-          relation = if options.is_a?(Hash)
-                       scoped.apply_finder_options(options)
-                     elsif options
-                       scoped.merge(options)
-                     else
-                       scoped
-                     end
-
-          extension ? relation.extending(extension) : relation
-        end
-
-        singleton_class.send(:redefine_method, name, &scopes[name])
-      end
-
-      def valid_scope_name?(name)
-        if !scopes[name] && respond_to?(name, true)
-          logger.warn "Creating scope :#{name}.  Overwriting existing method #{self.name}.#{name}."
-        end
-      end
-    end
-  end
-end

data/spec/ninja_model/attributes_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-require 'ninja_model/attributes'
-
-describe NinjaModel::Attributes do
-  before(:each) do
-    @klass = Class.new do
-      def initialize
-        @attributes = {}.with_indifferent_access
-      end
-    end
-    @klass.send :include, NinjaModel::Attributes
-    @klass.send :attr_reader, :attributes
-  end
-
-  describe 'adding an attribute' do
-    before(:each) do
-      @klass.attribute :var, :string
-      @obj = @klass.new
-    end
-
-    it 'should add a new attribute' do
-      @klass.model_attributes[:var].type.should eql(:string)
-    end
-
-    it 'should add a read method' do
-      lambda { @obj.send :var }.should_not raise_error(NoMethodError)
-    end
-
-    it 'should add a write method' do
-      lambda { @obj.send :var= }.should_not raise_error(NoMethodError)
-    end
-  end
-
-  describe 'with an instance' do
-    describe 'writing an attribute value' do
-      before(:each) do
-        @klass.attribute :valid, :string
-        @obj = @klass.new
-      end
-
-      it 'should raise an error when writing an invalid attribute' do
-        lambda { @obj.write_attribute(:invalid, 'test') }.should raise_error(NoMethodError)
-      end
-
-      it 'should properly update a valid attribute' do
-        @obj.write_attribute(:valid, 'test')
-        @obj.attributes['valid'].should eql('test')
-      end
-    end
-
-    describe 'assigning from a hash' do
-      before(:each) do
-        @klass.attribute :valid, :string
-        @obj = @klass.new
-      end
-
-      it 'should update instance attributes' do
-        attrs = {:valid => 'valid value'}
-        @obj.send :attributes=, attrs
-        @obj.valid.should eql('valid value')
-      end
-    end
-
-    describe 'checking existence of an attribute' do
-      before(:each) do
-        @klass.attribute :valid, :string
-        @obj = @klass.new
-      end
-      it { (@obj.send :attribute_method?, :valid).should be_true }
-      it { (@obj.send :attribute_method?, 'valid').should be_true }
-      it { (@obj.send :attribute_method?, :invalid).should be_false }
-    end
-
-    describe 'assigining default attributes from model' do
-      before(:each) do
-        @klass.attribute :valid, :string, {:default => 'foobar'}
-        @klass.send :class_inheritable_accessor, :primary_key
-        @obj = @klass.new
-        @attrs = @obj.attributes_from_model_attributes
-      end
-      it { @attrs.should have_key('valid') }
-      it { @attrs[:valid].should eql('foobar') }
-    end
-  end
-end

data/spec/ninja_model/scoping_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe NinjaModel::Scoping do
-  before(:each) do
-    @klass = Class.new
-    @klass.send :include, NinjaModel::Scoping
-    @relation = mock('Relation') do
-      stubs(:apply_finder_options).returns(self)
-    end
-    @klass.stubs(:relation).returns(@relation)
-    @klass.stubs(:current_scoped_methods).returns(nil)
-  end
-
-  describe 'scoped' do
-    it 'should return a relation when no options are sent' do
-      @klass.scoped.should be_instance_of(@relation.class)
-    end
-
-    it 'should accept scoping options' do
-      @klass.scoped(:conditions => {:key => 'value'}).should be_instance_of(@relation.class)
-
-    end
-  end
-
-  describe 'scopes' do
-    it 'should return an empty hash when no scopes have been set' do
-      @klass.scopes.should eql({})
-    end
-
-    it 'should return existing scopes' do
-      scopes = mock('scopes')
-      @klass.stubs(:read_inheritable_attribute).returns(scopes)
-      @klass.scopes.should eql(scopes)
-    end
-  end
-
-  describe 'defining a scope' do
-    
-  end
-end