ninja-model 0.4.2

data/spec/ninja_model/attributes_spec.rb

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

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe NinjaModel::Base do
+  it_should_behave_like "ActiveModel"
+  before(:each) do
+    @klass = Class.new(NinjaModel::Base) do
+    end
+    @klass.send :attribute, :width, :integer
+    @klass.send :attribute, :height, :integer
+    @klass.send :attribute, :color, :string
+  end
+
+  it 'should return a configuration path' do
+    Rails.stubs(:root).returns('/')
+    @klass.configuration_path.should be_kind_of(String)
+  end
+
+  it 'should accept a configuration path' do
+    @klass.configuration_path = 'foo'
+    @klass.configuration_path.should eql('foo')
+  end
+
+  it 'should return NinjaModel\'s logger' do
+    logger = mock('logger')
+    NinjaModel.stubs(:logger).returns(logger)
+    @klass.logger.should eql(logger)
+  end
+
+  it { @klass.should respond_to(:logger) }
+
+  it 'should generate a relation' do
+    @klass.relation.should be_kind_of(NinjaModel::Relation)
+  end
+
+  it 'should instantiate from an existing data structure' do
+    attrs = {:width => 100, :height => 200, :color => 'red'}
+    @obj = @klass.new
+    @obj.instantiate(attrs)
+    @obj.attributes[:width].should eql(100)
+  end
+
+  it 'should return a configuration' do
+    @klass.stubs(:configuration_path)
+    IO.stubs(:read).returns('foo: bar')
+    @klass.configuration.should be_kind_of(Hash)
+    @klass.configuration[:foo].should eql('bar')
+  end
+
+  describe 'scoping' do
+    it 'should return a stock relation for unscoped' do
+      @klass.unscoped.predicates.should be_empty
+      @klass.unscoped.limit_value.should be_nil
+      @klass.unscoped.offset_value.should be_nil
+      @klass.unscoped.ordering.should be_empty
+      @klass.unscoped.predicates.should be_empty
+    end
+
+    it 'should handle default scoping' do
+      @klass.default_scope(@klass.where(:width => 100))
+      rel = @klass.default_scoping.first
+      rel.should be_kind_of(NinjaModel::Relation)
+      rel.predicates.first.should be_kind_of(NinjaModel::Predicate)
+      rel.predicates.first.value.should eql(100)
+    end
+  end
+end

data/spec/ninja_model/identity_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe NinjaModel::Identity do
+  before(:each) do
+    @klass = Class.new
+    @klass.send :include, NinjaModel::Identity
+  end
+
+  def persisted
+    obj = @klass.new
+    obj.stubs(:id).returns(123)
+    obj.stubs(:persisted?).returns(true)
+    obj
+  end
+
+  def unpersisted
+    obj = @klass.new
+    obj.stubs(:persisted?).returns(false)
+    obj
+  end
+
+  describe 'to_key' do
+    it 'should generate a key when persisted' do
+      persisted.to_key.should eql([123])
+    end
+
+    it 'should return nil when not persisted' do
+      unpersisted.to_key.should be_nil
+    end
+  end
+
+  describe 'to_param' do
+    it 'should generate a param when persisted' do
+      persisted.to_param.should eql('123')
+    end
+
+    it 'should return nil when not persisted' do
+      unpersisted.to_param.should be_nil
+    end
+  end
+end

data/spec/ninja_model/persistence_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe NinjaModel::Persistence do
+  before(:each) do
+    @klass = Class.new
+    @klass.send :include, NinjaModel::Persistence
+  end
+  it { @klass.should respond_to(:get) }
+end

data/spec/ninja_model/predicate_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe NinjaModel::Predicate do
+  before(:each) do
+    @pred = NinjaModel::Predicate.new(:var, :ge)
+  end
+
+  it { @pred.has_value?.should be_false }
+  it 'should have value after update' do
+    @pred.value = 'value'
+    @pred.has_value?.should be_true
+  end
+end

data/spec/ninja_model/query_methods_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe NinjaModel::QueryMethods do
+  before(:each) do
+    @model = mock('model')
+    @attribute = NinjaModel::Attribute.new(:valid, :integer, @model, {})
+    @model.stubs(:model_attributes).returns({:valid => @attribute}.with_indifferent_access)
+    @rel = NinjaModel::Relation.new(@model)
+  end
+
+  describe 'order' do
+    it 'should update the relations\'s order_values' do
+      new_rel = @rel.order(:new_order)
+      new_rel.ordering.first.should eql(:new_order)
+    end
+  end
+
+  describe 'where' do
+    it 'should update the relation\'s where_values' do
+      new_rel = @rel.where(:valid => 2)
+      new_rel.predicates.first.should be_kind_of(NinjaModel::Predicate)
+      new_rel.predicates.first.value.should eql(2)
+    end
+  end
+
+  describe 'limit' do
+    it 'should update the relation\'s limit' do
+      new_rel = @rel.limit(5)
+      new_rel.limit_value.should eql(5)
+    end
+  end
+
+  describe 'build_predicates' do
+    it 'should reject a string' do
+      lambda { @rel.send :build_predicates, 'foo < 1' }.should raise_error(ArgumentError)
+    end
+
+    describe 'with an array' do
+      it 'should return an array of NinjaModel::Predicates' do
+        res = @rel.send :build_predicates, [{:valid => 1}]
+        res.should be_kind_of(Array)
+        res.first.should be_kind_of(NinjaModel::Predicate)
+        res.first.value.should eql(1)
+      end
+    end
+    describe 'with a hash' do
+      it 'should handle a valid symbol' do
+        res = @rel.send :build_predicates, {:valid => 1}
+        res.should be_kind_of(Array)
+        res.first.should be_kind_of(NinjaModel::Predicate)
+        res.first.value.should eql(1)
+      end
+
+      it 'should reject an invalid symbol' do
+        lambda { @rel.send :build_predicates, {:invalid => 2} }.should raise_error(ArgumentError)
+      end
+
+      it 'should handle a predicate' do
+        rel = NinjaModel::Predicate.new(:valid, :eq)
+        res = @rel.send :build_predicates, {rel => 1}
+        res.should be_kind_of(Array)
+        res.first.should be_kind_of(NinjaModel::Predicate)
+        res.first.value.should eql(1)
+      end
+      it 'should reject an unkrecognized key' do
+        lambda { @rel.send :build_predicates, {'bad' => 12} }.should raise_error(ArgumentError)
+      end
+    end
+
+    it 'should reject an unprocessable argument' do
+      lambda { @rel.send :build_predicates, 5 }.should raise_error(ArgumentError)
+    end
+
+  end
+
+end

data/spec/ninja_model/relation_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe NinjaModel::Relation do
+  describe 'with an instance' do
+    before(:each) do
+      @model = mock('NinjaModel')
+      @model.stubs(:adapter => stub('NinjaAdapter', :read => 'object_list'))
+      @rel = NinjaModel::Relation.new(@model)
+    end
+    it { @rel.should respond_to(:klass) }
+    it { @rel.should respond_to(:loaded?) }
+    it { @rel.should respond_to(:limit_value) }
+    it { @rel.limit_value.should be_nil }
+    it { @rel.should respond_to(:offset_value) }
+    it { @rel.offset_value.should be_nil }
+    it { @rel.should respond_to(:ordering) }
+    it { @rel.ordering.should eql([]) }
+    it { @rel.should respond_to(:predicates) }
+    it { @rel.predicates.should eql([]) }
+    it { @rel.loaded?.should be_false }
+
+    it 'should try to read when to_a is called' do
+      @rel.to_a.should eql('object_list')
+    end
+  end
+end

data/spec/ninja_model/scoping_spec.rb

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

data/spec/ninja_model_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe NinjaModel do
+  it { NinjaModel.should respond_to(:logger) }
+
+  it 'should accept a logger' do
+    logger = mock('logger')
+    NinjaModel.set_logger(logger)
+    NinjaModel.logger.should eql(logger)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+Bundler.require(:default)
+require 'rspec/core'
+
+Dir[File.join(File.expand_path('../', __FILE__), 'support/**/*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/support/active_model_lint.rb

@@ -0,0 +1,17 @@
+require 'test/unit/assertions'
+require 'active_model/lint'
+
+shared_examples_for "ActiveModel" do
+  include Test::Unit::Assertions
+  include ActiveModel::Lint::Tests
+
+  ActiveModel::Lint::Tests.public_instance_methods.map { |m| m.to_s }.grep(/^test/).each do |m|
+    example m.gsub('_', '') do
+      send m
+    end
+  end
+
+  def model
+    subject
+  end
+end

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification 
+name: ninja-model
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 2
+  version: 0.4.2
+platform: ruby
+authors: 
+- Josh Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-30 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 3
+        - 0
+        - 3
+        version: 3.0.3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 0
+        - 9
+        - 9
+        version: 0.9.9
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 51
+        segments: 
+        - 0
+        - 9
+        - 4
+        version: 0.9.4
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 4
+        - 4
+        version: 1.4.4
+  type: :development
+  version_requirements: *id006
+description: Write a gem description
+email: theprime@codingprime.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ninja_model.rb
+- lib/generators/ninja_model.rb
+- lib/generators/ninja_model/model/model_generator.rb
+- lib/generators/ninja_model/model/templates/model.rb
+- lib/generators/ninja_model/scaffold/scaffold_generator.rb
+- lib/ninja-model.rb
+- lib/ninja_model/configuration.rb
+- lib/ninja_model/reflection.rb
+- lib/ninja_model/associations/has_many_association.rb
+- lib/ninja_model/associations/ninja_model_proxy.rb
+- lib/ninja_model/associations/has_one_association.rb
+- lib/ninja_model/associations/association_proxy.rb
+- lib/ninja_model/associations/active_record_proxy.rb
+- lib/ninja_model/associations/belongs_to_association.rb
+- lib/ninja_model/version.rb
+- lib/ninja_model/attributes.rb
+- lib/ninja_model/associations.rb
+- lib/ninja_model/log_subscriber.rb
+- lib/ninja_model/persistence.rb
+- lib/ninja_model/callbacks.rb
+- lib/ninja_model/predicate.rb
+- lib/ninja_model/core_ext/symbol.rb
+- lib/ninja_model/errors.rb
+- lib/ninja_model/adapters.rb
+- lib/ninja_model/base.rb
+- lib/ninja_model/identity.rb
+- lib/ninja_model/relation.rb
+- lib/ninja_model/adapters/adapter_specification.rb
+- lib/ninja_model/adapters/abstract_adapter.rb
+- lib/ninja_model/adapters/adapter_manager.rb
+- lib/ninja_model/adapters/adapter_pool.rb
+- lib/ninja_model/validation.rb
+- lib/ninja_model/relation/finder_methods.rb
+- lib/ninja_model/relation/query_methods.rb
+- lib/ninja_model/relation/spawn_methods.rb
+- lib/ninja_model/railtie.rb
+- lib/ninja_model/scoping.rb
+- spec/spec_helper.rb
+- spec/support/active_model_lint.rb
+- spec/ninja_model_spec.rb
+- spec/ninja_model/identity_spec.rb
+- spec/ninja_model/attributes_spec.rb
+- spec/ninja_model/base_spec.rb
+- spec/ninja_model/predicate_spec.rb
+- spec/ninja_model/persistence_spec.rb
+- spec/ninja_model/relation_spec.rb
+- spec/ninja_model/adapters/adapter_pool_spec.rb
+- spec/ninja_model/adapters_spec.rb
+- spec/ninja_model/query_methods_spec.rb
+- spec/ninja_model/scoping_spec.rb
+- Rakefile
+- Gemfile
+- README.md
+has_rdoc: true
+homepage: http://github.com/t3hpr1m3/ninja-model.git
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ninja-model
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Write a gem summary
+test_files: []
+