soulless 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed8e30f22d775b7646b996ff1a6ecf92ec96fe98
-  data.tar.gz: 288d8bf2b2b3b077e0369477168f4ff6e1bdacd3
+  metadata.gz: b3a918d43aa402d0de13f3e8bcc28b1d4cbad074
+  data.tar.gz: a706a4c34294af699a1efdbda86dd649ffd278f5
 SHA512:
-  metadata.gz: bd80dec834541eb84183a91486b1e18d0dd5d35385b01a0cce3bf096ea8fa6d85f22eaeb181d2432bf3d90d1ce67086c53440ea0257fa3de90e7f0456d555cec
-  data.tar.gz: faa287251a4f8ceaf9ef077d02279ece8755c55517d685a1c57d4da3c9f441e5d24d2428a22994d18cb9efb011a5b9caab6b0a3799a3ecdd12f646a4609dee5f
+  metadata.gz: 0187eb34dda842f89d9be39593e3168c1189ae7abbe61343b1ec5e80e14bebbfeaaebfd357f0c1c2257edd643534795f901f91104b2765f5ed614005ec0dd94f
+  data.tar.gz: fab7de2ebac15f30943af023b644e93759131fc40e3a3a46523440e3da42980f88e55aaae551ee1aad1b00e64c705bd6d0e9931821f2b6a39340db62aa2abd1a

data/.travis.yml

@@ -5,4 +5,11 @@ rvm:
   - ruby-head
   - jruby-19mode
   - jruby-head
-  - rbx-19mode
+  - rbx-19mode
+env:
+  - "RAILS_VERSION=3.2.0"
+  - "RAILS_VERSION=4.0.0"
+  - "RAILS_VERSION=master"
+matrix:
+  allow_failures:
+    - env: "RAILS_VERSION=master"

data/Gemfile

@@ -3,13 +3,21 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in ar_book_finder.gemspec
 gemspec
 
-group :development do
-  gem 'bundler'
-  gem 'coveralls', require: false
-  gem 'rake'
+rails_version = case ENV['RAILS_VERSION'] || 'default'
+when 'master'
+  { git: 'https://github.com/rails/rails.git' }
+when 'default'
+  '~> 4.0'
+else
+  "~> #{ENV['RAILS_VERSION']}"
 end
 
-group :test do
-  gem 'rspec'
-  gem 'simplecov'
+gem 'rails', rails_version
+
+platforms :ruby do
+  gem 'sqlite3'
+end
+
+platforms :jruby do
+  gem "activerecord-jdbcsqlite3-adapter"
 end

data/README.md

@@ -1,12 +1,10 @@
 # Soulless
 
-Rails models without the database (and Rails).
+Rails models without the database (and Rails). Great for implementing the form object pattern.
 
 [![Build Status](https://travis-ci.org/anthonator/soulless.png?branch=master)](https://travis-ci.org/anthonator/soulless) [![Dependency Status](https://gemnasium.com/anthonator/soulless.png)](https://gemnasium.com/anthonator/soulless)
  [![Coverage Status](https://coveralls.io/repos/anthonator/soulless/badge.png?branch=master)](https://coveralls.io/r/anthonator/soulless?branch=master) [![Code Climate](https://codeclimate.com/github/anthonator/soulless.png)](https://codeclimate.com/github/anthonator/soulless)
 
-Great for implementing the form object pattern. [Check out #3](http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/) of this great article by @brynary for more information on the form object pattern.
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -23,77 +21,271 @@ Or install it yourself as:
 
 ## Usage
 
-Just define a plain-old-ruby-object and get crackin'!
+Just define a plain-old-ruby-object, include Soulless and get crackin'!
 
 ```ruby
 class UserSignupForm
   include Soulless.model
   
-  attribute :email, String
   attribute :name, String
-  attribute :password
-  attribute :super_awesome, Boolean, default: false
-  
-  validates :email, presence: true
+  attribute :email, String
+  attribute :password, String
   
   validates :name, presence: true
   
+  validates :email, presence: true,
+                    uniqueness: { model: User }
+  
   validates :password, presence: true,
                        lenght: { is_at_least: 8 }
 
   private
   def persist!
-    # You're gonna need this!
-	# Define what to do with this form when ready to save here.
+    # Define what to do when this form is ready to be saved.
   end
 end
 ```
 
-Awesome. Now let's do something with it.
+### Default Values
+
+When defining attributes it's possible to specify default values.
 
 ```ruby
-UsersController < ApplicationController
-  def create
-	@form = UserSignupForm.new(params.permit(user: [:email, :name, :password, :super_awesome]))
-	if @form.save
-	  # do something here
-	else
-	  render :new
-	end
-  end
+class UserSignupForm
+
+  ...
+  
+  attribute :name, String, default: 'Anthony'
+  
+  ...
 end
 ```
 
-### Configuration
+### Embedded Values
+
+It's possible to use other Soulless objects as attribute types.
 
 ```ruby
+class User
+  include Soulless.model
+
+  attribute :name, String
+  attribute :email, String
+  attribute :password, String
+end
+
 class UserSignupForm
-  # include attribute DSL + constructor + mass-assignment
   include Soulless.model
+  
+  attribute :user, User
 end
 ```
 
+### Collection Coercions
+
+Define collections with specific types.
+
+```ruby
+class PhoneNumber
+  include Soulless.model
+  
+  attribute :number, String
+end
+
+class Person
+  include Soulless.model
+  
+  attribute :phone_numbers, Array[PhoneNumber]
+end
+```
+
+### Processing an Object
+
+Soulless let's _you_ define what happens when your object is ready to be processed.
+
 ```ruby
 class UserSignupForm
-  # include attribute DSL + constructor
-  include Soulless.model(mass_assignment: false)
+
+  ...
+  
+  private
+  def persist!
+    user = User.create!(name: name, email: email, password: password)
+    UserMailer.send_activation_code(user).deliver
+    user.charge_card!
+  end
 end
 ```
 
+Process your Soulless object by calling ```save```. Just like a Rails model!
+
+```ruby
+form = UserSignupForm.new(name: name, email: email, password: passord)
+if form.save
+  # Called persist! and all is good!
+else
+  # Looks like a validation failed. Try again.
+end
+```
+
+### Validations and Errors
+
+Soulless lets you define your validations and manage your errors just like you did in Rails.
+
 ```ruby
 class UserSignupForm
-  # include attribute DSL
-  include Soulless.model(constructor: false, mass_assignment: false)
+
+  ...
+  
+  validates :name, presence: true
+  
+  validates :email, presence: true,
+                    uniqueness: { model: User }
+  
+  validates :password, presence: true,
+                       lenght: { minimum: 8 }
+
+  ...
+
 end
 ```
 
-### Batteries included...
+Check to see if your object is valid by calling ```valid?```.
 
-The great thing about Soulless? Rails isn't required.
+```ruby
+form = UserSignupForm.new(name: name, email: email)
+form.valid? # => false
+```
+
+See what errors are popping up using the ```errors``` attribute.
 
-### This looks familir...
+```ruby
+form = UserSignupForm.new(name: name, email: email)
+form.valid?
+form.errors[:password] # => ["is too short (minimum is 8 characters)"]
+```
 
-You noticed? We're using Virtus to power this gem. That means you get all the Virtus goodies for free. Check out [their GitHub page](https://github.com/solnic/virtus) to see what's up.
+#### Uniqueness Validations
+
+If you're using Soulless in Rails it's even possible to validate uniqueness.
+
+```ruby
+class UserSignupForm
+
+  ...
+  
+  validates :primary_email, presence: true,
+                            uniqueness: { model: User, attribute: :email }
+  
+  ...
+  
+end
+```
+
+Just let the validator know what ActiveRecord model to use when performing the validation using the ```model``` option.
+
+If your Soulless object attribute doesn't match up to the ActiveRecord model attribute just map it using the ```attribute``` option.
+
+### ```has_one``` and ```has_many``` Associations
+
+When you need associations use ```has_one``` and ```has_many```. Look familiar?
+
+```ruby
+class Person
+  include Soulless.model
+  
+  attribute :name, String
+  
+  validates :name, presence: true
+  
+  has_one :spouse do
+    attribute :name, String
+  end
+  
+  has_many :friends do
+    attribute :name, String
+  end
+end
+```
+
+You can set ```has_one``` and ```has_many``` attributes by setting their values hashes and hash arrays.
+
+```ruby
+person = Person.new(name: 'Anthony')
+person.spouse = { name: 'Megan' }
+person.friends = [{ name: 'Yaw' }, { name: 'Biff' }]
+```
+
+It's also possible for an association to inherit from a parent class and then extend functionality.
+
+```ruby
+class Person
+  include Soulless.model
+  
+  attribute :name, String
+  
+  validates :name, presence: true
+  
+  has_one :spouse, Person do # inherits 'name' and validation from Person
+    attribute :anniversary, DateTime
+    
+    validates :anniversary, presence: true
+  end
+  
+  has_many :friends, Person # just inherit from Person, don't extend
+end
+```
+
+When you need to make sure an association is valid before processing the object use ```validates_associated```.
+
+```ruby
+class Person
+
+  ...
+  
+  has_one :spouse do
+    attribute :name, String
+    
+    validates :name, presence: true
+  end
+  
+  ...
+  
+end
+
+person = Person.new(name: 'Anthony')
+person.spouse = { name: nil }
+person.valid? # => false
+person.errors[:spouse] # => ["is invalid"]
+person.spouse.errors[:name] # => ["can't be blank"]
+```
+
+### I18n
+
+Define locales similar to how you would define them in Rails.
+
+
+```yaml
+en:
+  soulless:
+    errors:
+      models:
+        person:
+          name:
+            blank: "there's nothing here"
+```
+
+For attributes defined as ```has_one``` and ```has_many``` associations use the enclosing class as the locale key's namespace.
+
+```yaml
+en:
+  soulless:
+    errors:
+      models:
+        person/spouse:
+          name:
+            blank: "there's nothing here"
+```
 
 ## Contributing
 

data/lib/soulless/associations.rb

@@ -0,0 +1,27 @@
+module Soulless
+  module Associations
+    def self.included(base)
+      base.instance_eval do |object|
+        def has_one(name, superclass = Object, &block)
+          klass = define_virtus_class(name, superclass, &block)
+          send(:attribute, name, klass)
+        end
+        
+        def has_many(name, superclass = Object, &block)
+          klass = define_virtus_class(name, superclass, &block)
+          send(:attribute, name, Array[klass])
+        end
+        
+        private
+        def define_virtus_class(name, superclass, &block)
+          klass_name = name.to_s.singularize.classify + '_' + SecureRandom.hex
+          klass = const_set(klass_name, Class.new(superclass))
+          klass.send(:include, Soulless.model) unless klass.included_modules.include?(Model)
+          klass.instance_eval(&block) if block_given?
+          klass.model_name.instance_variable_set(:@i18n_key, klass.model_name.i18n_key.to_s.gsub(/_[^_]+$/, '').underscore.to_sym)
+          klass
+        end
+      end
+    end
+  end
+end

data/lib/soulless/locale/en.yml

@@ -0,0 +1,30 @@
+en:
+  errors:
+    # The default format to use in full error messages.
+    format: "%{attribute} %{message}"
+
+    # The values :model, :attribute and :value are always available for interpolation
+    # The value :count is available when applicable. Can be used for pluralization.
+    messages:
+      inclusion: "is not included in the list"
+      exclusion: "is reserved"
+      invalid: "is invalid"
+      confirmation: "doesn't match %{attribute}"
+      accepted: "must be accepted"
+      empty: "can't be empty"
+      blank: "can't be blank"
+      present: "must be blank"
+      too_long: "is too long (maximum is %{count} characters)"
+      too_short: "is too short (minimum is %{count} characters)"
+      wrong_length: "is the wrong length (should be %{count} characters)"
+      not_a_number: "is not a number"
+      not_an_integer: "must be an integer"
+      greater_than: "must be greater than %{count}"
+      greater_than_or_equal_to: "must be greater than or equal to %{count}"
+      equal_to: "must be equal to %{count}"
+      less_than: "must be less than %{count}"
+      less_than_or_equal_to: "must be less than or equal to %{count}"
+      other_than: "must be other than %{count}"
+      odd: "must be odd"
+      even: "must be even"
+      taken: "has already been taken"

data/lib/soulless/model.rb

@@ -3,8 +3,15 @@ module Soulless
     def self.included(base)
       base.class_eval do
         extend ActiveModel::Naming
-        include ActiveModel::Conversion
+        extend ActiveModel::Translation
         include ActiveModel::Validations
+        include ActiveModel::Conversion
+        
+        class << self
+          def i18n_scope
+            :soulless
+          end
+        end
         
         def persisted?
           false

data/lib/soulless/validations/associated_validator.rb

@@ -0,0 +1,17 @@
+module Soulless
+  module Validations
+    class AssociatedValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if Array.wrap(value).reject { |r| r.valid? }.any?
+          record.errors.add(attribute, :invalid, options.merge(value: value))
+        end
+      end
+    end
+    
+    module ClassMethods
+      def validates_associated(*attr_names)
+        validates_with(AssociatedValidator, _merge_attributes(attr_names))
+      end
+    end
+  end
+end

data/lib/soulless/validations/uniqueness_validator.rb

@@ -0,0 +1,38 @@
+module Soulless
+  module Validations
+    class UniquenessValidator < ActiveModel::EachValidator
+      def initialize(options)
+        raise 'ActiveRecord is not defined. The Soulless uniqueness validator cannot be used when ActiveRecord is not present.' unless Object.const_defined?('ActiveRecord')
+        @model = options[:model]
+        @attribute = options[:attribute]
+        options.merge!(class: @model) if ActiveModel::VERSION::STRING >= '4.1.0'
+        @validator = ActiveRecord::Validations::UniquenessValidator.new(options)
+        super(options)
+      end
+      
+      def validate_each(record, attribute, value)
+        if !@model
+          raise ArgumentError, 'Missing required argument "model"'
+        else
+          record_orig, attribute_orig = record, attribute
+          
+          attribute = @attribute if @attribute
+          record = @model.new(attribute => value)
+          
+          @validator.setup(@model) if ActiveModel::VERSION::STRING < '4.1'
+          @validator.validate_each(record, attribute, value)
+          
+          if record.errors.any?
+            record_orig.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(value: value))
+          end
+        end
+      end
+    end
+    
+    module ClassMethods
+      def validates_uniqueness_of(*attr_name)
+        validates_with(UniquenessValidator, _merge_attributes(attr_name))
+      end
+    end
+  end
+end

data/lib/soulless/validations.rb

@@ -0,0 +1,10 @@
+require 'soulless/validations/associated_validator'
+require 'soulless/validations/uniqueness_validator'
+
+module Soulless
+  module Validations
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+  end
+end

data/lib/soulless/version.rb

@@ -1,3 +1,3 @@
 module Soulless
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/soulless.rb

@@ -1,8 +1,11 @@
 require 'virtus'
+require 'securerandom'
+require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/callbacks'
 require 'active_support/concern'
+require 'active_support/inflector'
 require 'active_model/naming'
 require 'active_model/translation'
 require 'active_model/callbacks'
@@ -10,16 +13,23 @@ require 'active_model/validator'
 require 'active_model/errors'
 require 'active_model/validations'
 require 'active_model/conversion'
+require 'active_model/version'
 
 require 'soulless/model'
+require 'soulless/associations'
+require 'soulless/validations'
 require 'soulless/version'
 
 module Soulless
+  I18n.load_path += Dir.glob('lib/soulless/locale/*.{rb,yml}')
+  
   def self.model(options = {})
     mod = Module.new
     mod.define_singleton_method :included do |object|
       object.send(:include, Virtus.model(options))
       object.send(:include, Model)
+      object.send(:include, Associations)
+      object.send(:include, Validations)
     end
     mod
   end

data/soulless.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = Soulless::VERSION
   spec.authors       = ['Anthony Smith']
   spec.email         = ['anthony@sticksnleaves.com']
-  spec.description   = %q{Models without a soul.}
+  spec.description   = %q{Rails models without a database (and Rails).}
   spec.summary       = %q{Create Rails style models without the database.}
   spec.homepage      = ''
   spec.license       = 'MIT'
@@ -22,6 +22,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'activemodel', '>= 3.2'
   spec.add_runtime_dependency 'virtus', '>= 1.0'
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'database_cleaner'
   spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
 end

data/spec/associated_validator_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Soulless::Validations::AssociatedValidator do
+  it 'should not be valid if has_one associations are invalid' do
+    dummy_association = DummyAssociation.new
+    dummy_association.spouse = { name: nil }
+    dummy_association.valid?.should be_false
+    dummy_association.errors[:spouse].should include('is invalid')
+    dummy_association.spouse.errors[:name].should include("can't be blank")
+  end
+  
+  it 'should be valid if has_one associations are valid' do
+    dummy_association = DummyAssociation.new
+    dummy_association.spouse = { name: 'Megan' }
+    dummy_association.valid?.should be_true
+  end
+  
+  it 'should not be valid if has_many associations are invalid' do
+    dummy_association = DummyAssociation.new
+    dummy_association.friends = [{ name: nil }, { name: nil }]
+    dummy_association.valid?.should be_false
+    dummy_association.errors[:friends].should include('is invalid')
+    dummy_association.friends[0].errors[:name].should include("can't be blank")
+  end
+  
+  it 'should be valid if has_many associations are valid' do
+    dummy_association = DummyAssociation.new
+    dummy_association.friends = [{ name: 'Yaw' }, { name: 'Biff' }]
+    dummy_association.valid?.should be_true
+  end
+end

data/spec/associations_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Soulless::Associations do
+  before(:each) do
+    @dummy_class = DummyAssociation.new
+  end
+  
+  describe 'has_one' do
+    it 'should allow hash values' do
+      @dummy_class.spouse = { name: 'Megan' }
+      @dummy_class.spouse.name.should == 'Megan'
+    end
+    
+    it 'should allow a class type to be defined' do
+      @dummy_class.dummy_clone = { name: 'Megan' }
+      @dummy_class.dummy_clone.class.name.should match(/\ADummyAssociation::DummyClone/)
+    end
+    
+    it 'should properly pull down error translations' do
+      @dummy_class.dummy_clone = { name: nil }
+      @dummy_class.dummy_clone.save
+      @dummy_class.dummy_clone.errors[:name][0].should == "can't be blank"
+    end
+    
+    it 'should properly pull down custom error translations' do
+      I18n.load_path += Dir.glob(File.dirname(__FILE__) + '/support/en.yml')
+      I18n.backend.load_translations
+      @dummy_class.dummy_clone = { name: nil }
+      @dummy_class.dummy_clone.save
+      @dummy_class.dummy_clone.errors[:name][0].should == 'this is a test'
+    end
+  end
+  
+  describe 'has_many' do
+    it 'should allow array values' do
+      @dummy_class.friends = [{ name: 'Biff' }]
+      @dummy_class.friends[0].name.should == 'Biff'
+    end
+    
+    it 'should allow a class type to be defined' do
+      @dummy_class.dummy_clones = [{ name: 'Biff' }]
+      @dummy_class.dummy_clones[0].class.name.should match(/\ADummyAssociation::DummyClone/)
+    end
+  end
+end

data/spec/dummy/.gitignore

@@ -0,0 +1,17 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/development.sqlite3
+/db/production.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp