clean_model 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in clean_model.gemspec
+gemspec

data/README.md

@@ -0,0 +1,198 @@
+# CleanModel
+
+Extensions for ActiveModel to implement multiple types of models
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'clean_model'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install clean_model
+
+## Basic models
+
+### Class definitions
+
+    class Person
+      include CleanModel::Base
+
+      attribute :first_name
+      attribute :last_name
+    end
+
+### Usage
+
+    person = Person.new first_name: 'John', last_name: 'Doe'
+
+    person.first_name -> 'John'
+    person.last_name  -> 'Doe'
+
+    person.attributes -> {first_name: 'John', last_name: 'Doe'}
+
+    person.assign_attributes first_name: 'Jorge'
+
+    person.attributes -> {first_name: 'Jorge', last_name: 'Doe'}
+
+### Active Model validations
+
+    class Person
+      include CleanModel::Base
+
+      attribute :first_name
+      attribute :last_name
+
+      validates_presence_of :first_name, :last_name
+    end
+
+    person = Person.new
+    person.valid? -> false
+
+### Strong typing
+
+    class Engine
+      include CleanModel::Base
+
+      attribute :power, class_name: :numeric
+      attribute :cylinders, class_name: :integer
+      attribute :valves, class_name: 'Integer'
+    end
+
+    engine = Engine.new
+    engine.power = 130
+    engine.cylinders = 6.1 -> Raise error CleanModel::InvalidTypeAssignment
+
+### Transformations
+
+    class Car
+      include CleanModel::Base
+
+      attribute :brand
+      attribute :model
+      attribute :engine, class_name: 'Engine'
+      attribute :comfort, transformation: lambda { |v| v.is_a?(String) ? v.split(',').map(&:strip) : v }
+    end
+
+    car = Car.new do |c|
+      c.engine = {power: 110, cylinders: 16, valves: 6}
+    end
+    car.engine -> <Engine @power=110, @cylinders=16, @valves=6>
+
+    car = Car.new do |c|
+      c.comfort = 'bluetooth, gps, electric pack'
+    end
+    car.comfort -> ['bluetooth', 'gps', 'electric pack']
+
+### Collections
+
+    class Factory
+      include CleanModel::Base
+
+      attribute :cars, collection: 'Car'
+    end
+
+    factory = Factory.new do |f|
+      f.cars = [
+        {brand: 'Honda', model: 'Civic'},
+        {brand: 'Toyota', model: 'Corolla'},
+      ]
+    end
+
+    factory.cars -> [<Car @brand=Honda, @model=Civic>, <Car @brand=Toyota, @model=Corolla>]
+
+## Models with custom persistence
+
+### Definition
+
+    class Post
+      include CleanModel::Persistent
+
+      attribute :subject
+      attribute :content
+
+      private
+
+      def create
+        ...
+      end
+
+      def update
+        ...
+      end
+
+      def delete
+        ...
+      end
+    end
+
+### Usage
+
+    Post.create(subject: 'Title', content: 'Some text')
+    or
+    post = Post.new subject: 'Title', content: 'Some text'
+    post.save
+
+    post.content = 'Another text'
+    post.save
+
+    post.update_attributes(title: 'Another title')
+
+    post.destroy
+
+## Remote models (for REST APIs)
+
+### Definition
+
+    class User
+      include CleanModel::Remote
+
+      connection host: 'localhost', port: 9999
+
+      attribute :first_name
+      attribute :last_name
+      attribute :email
+
+      def self.find(id)
+        http_get "/users/#{id}.json" do |response|
+          new JSON.parse(response.body)
+        emd
+      end
+
+      private
+
+      def create
+        http.post '/users/create.json', wrapped_attributes
+      end
+
+      def update
+        http.put "/users/#{id}.json", wrapped_attributes(except: :id)
+      end
+
+      def delete
+        http.delete("/users/#{id}.json")
+      end
+    end
+
+### Usage
+
+    User.create first_name: 'John', last_name: 'Doe'
+
+    user = User.find(1)
+
+    user.update_attributes(first_name: 'Jorge')
+
+    user.destroy
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/clean_model.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'clean_model/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'clean_model'
+  s.version     = CleanModel::VERSION
+  s.authors     = ['Gabriel Naiman']
+  s.email       = ['gabynaiman@gmail.com']
+  s.homepage    = 'https://github.com/gabynaiman/clean_model'
+  s.summary     = 'Extensions for ActiveModel to implement multiple types of models'
+  s.description = 'Extensions for ActiveModel to implement multiple types of models'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'activesupport', '>= 3.0.0'
+  s.add_dependency 'activemodel', '>= 3.0.0'
+  s.add_dependency 'web_client'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'webmock'
+end

data/lib/clean_model.rb

@@ -0,0 +1,11 @@
+require 'active_model'
+require 'active_support/all'
+require 'web_client'
+require 'json'
+
+require 'clean_model/version'
+require 'clean_model/attribute'
+require 'clean_model/exceptions'
+require 'clean_model/base'
+require 'clean_model/persistent'
+require 'clean_model/remote'

data/lib/clean_model/attribute.rb

@@ -0,0 +1,47 @@
+module CleanModel
+  class Attribute
+    attr_reader :name, :options
+
+    def initialize(name, options={})
+      @name = symbolize(name)
+      @options = options
+    end
+
+    def validate!(value)
+      raise InvalidTypeAssignment.new(name, value) unless value.is_a? klass
+    end
+
+    def transform(value)
+      if @options[:transformation]
+        @options[:transformation].call(value)
+      elsif value.is_a?(Hash) && klass.new.respond_to?(:assign_attributes)
+        obj = klass.new
+        obj.assign_attributes value
+        obj
+      elsif value.is_a?(Array) && collection_class.new.respond_to?(:assign_attributes)
+        value.map do |v|
+          obj = collection_class.new
+          obj.assign_attributes v
+          obj
+        end
+      else
+        value
+      end
+    end
+
+    private
+
+    def klass
+      @options[:class_name].to_s.classify.constantize
+    end
+
+    def collection_class
+      @options[:collection].to_s.classify.constantize
+    end
+
+    def symbolize(text)
+      text.is_a?(String) ? text.to_s.underscore.parameterize('_').to_sym : text
+    end
+
+  end
+end

data/lib/clean_model/base.rb

@@ -0,0 +1,62 @@
+module CleanModel
+  module Base
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+      base.send :extend, ActiveModel::Translation
+      base.send :include, ActiveModel::Validations
+    end
+
+    module ClassMethods
+
+      def attribute(name, options={})
+        attr = Attribute.new(name, options)
+        attributes << attr
+
+        define_method name do
+          instance_variable_get "@#{name}"
+        end
+
+        define_method "#{name}=" do |value|
+          value = attr.transform(value)
+          attr.validate!(value)
+          instance_variable_set "@#{name}", value
+        end
+      end
+
+      def attributes
+        @attributes ||= []
+      end
+
+      def attribute_names
+        attributes.map(&:name)
+      end
+
+    end
+
+    module InstanceMethods
+
+      def initialize(attributes={})
+        if block_given?
+          yield(self)
+        else
+          assign_attributes attributes
+        end
+      end
+
+      def assign_attributes(attributes)
+        return nil unless attributes
+        attributes.each do |name, value|
+          send("#{name}=", value) if respond_to?("#{name}=")
+        end
+      end
+
+      def attributes
+        Hash[self.class.attribute_names.map { |a| [a, send(a)] }]
+      end
+
+    end
+
+  end
+end

data/lib/clean_model/exceptions.rb

@@ -0,0 +1,30 @@
+module CleanModel
+
+  class Error < StandardError
+  end
+
+  class InvalidTypeAssignment < Error
+    def initialize(attribute, value)
+      super "#{value} is not valid for #{attribute}"
+    end
+  end
+
+  class UndefinedPersistenceMethod < Error
+    def initialize(klass, method)
+      super "#{klass} must define method [#{method}]"
+    end
+  end
+
+  class InvalidResponse < Error
+    def initialize(response)
+      super response.content_type == 'application/json' ? response.body : "#{response.code} - Unexpected error"
+    end
+  end
+
+  class ConnectionFail < Error
+    def initialize(exception)
+      super exception.message
+    end
+  end
+
+end

data/lib/clean_model/persistent.rb

@@ -0,0 +1,76 @@
+module CleanModel
+  module Persistent
+
+    def self.included(base)
+      base.send :include, Base
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+      base.send :include, ActiveModel::Conversion
+
+      base.attribute :id
+    end
+
+    module ClassMethods
+
+      def create(attributes={})
+        begin
+          create! attributes
+        rescue
+          nil
+        end
+      end
+
+      def create!(attributes={})
+        model = new attributes
+        model.save!
+        model
+      end
+
+    end
+
+    module InstanceMethods
+
+      def new_record?
+        id.nil?
+      end
+
+      def persisted?
+        !new_record?
+      end
+
+      def save!
+        raise errors.full_messages.join("\n") unless save
+      end
+
+      def save
+        return false unless valid?
+        new_record? ? create : update
+      end
+
+      def update_attributes(attributes)
+        assign_attributes attributes
+        save
+      end
+
+      def destroy
+        delete
+      end
+
+      private
+
+      def create
+        raise UndefinedPersistenceMethod.new(self.class, :create)
+      end
+
+      def update
+        raise UndefinedPersistenceMethod.new(self.class, :update)
+      end
+
+      def delete
+        raise UndefinedPersistenceMethod.new(self.class, :delete)
+      end
+
+    end
+
+  end
+end

data/lib/clean_model/remote.rb

@@ -0,0 +1,87 @@
+module CleanModel
+  module Remote
+
+    def self.included(base)
+      base.send :include, Persistent
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    module ClassMethods
+
+      def connection(connection=nil)
+        connection ? @connection = connection : @connection
+      end
+
+      def http
+        WebClient::Base.new(connection)
+      end
+
+      def http_get(path, data={})
+        begin
+          response = http.get(path, data)
+          if response.is_a?(Net::HTTPOK)
+            block_given? ? yield(response) : response
+          else
+            raise InvalidResponse.new(response)
+          end
+        rescue WebClient::Error => ex
+          raise ConnectionFail.new(ex)
+        end
+      end
+
+    end
+
+    module InstanceMethods
+
+      def http
+        self.class.http
+      end
+
+      def http_get(path, data={}, &block)
+        self.class.http_get(path, data, &block)
+      end
+
+      def wrapped_attributes(options={})
+        exceptions = options[:except] ? [options[:except]].flatten.map(&:to_sym) : []
+        attributes.reject { |k, v| v.nil? || exceptions.include?(k) }.inject({}) { |h, (k, v)| h["#{options[:wrapper] || self.class.to_s.demodulize.underscore}[#{k}]"] = v; h }
+      end
+
+      def save
+        return false unless valid?
+        begin
+          response = new_record? ? create : update
+          if response.is_a?(Net::HTTPSuccess)
+            assign_attributes JSON.parse(response.body) if response.body
+          else
+            if response.code.to_i == 422 #:unprocessable_entity
+              JSON.parse(response.body).each do |attribute, messages|
+                messages.each { |m| errors[attribute.to_sym] << m }
+              end
+            else
+              errors[:base] = response.content_type == 'application/json' ? response.body : "#{response.code} - Unexpected error"
+            end
+          end
+        rescue WebClient::Error => ex
+          errors[:base] = ex.message
+        end
+        errors.empty?
+      end
+
+      def destroy
+        return true if new_record?
+        begin
+          response = delete
+          unless response.is_a?(Net::HTTPSuccess)
+            errors[:base] = response.content_type == 'application/json' ? response.body : "#{response.code} - Unexpected error"
+          end
+        rescue WebClient::Error => ex
+          errors[:base] = ex.message
+        end
+        errors.empty?
+      end
+
+    end
+
+  end
+end

data/lib/clean_model/version.rb

@@ -0,0 +1,3 @@
+module CleanModel
+  VERSION = "0.0.1"
+end

data/spec/base_model_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+include BaseModels
+
+describe CleanModel::Base do
+
+  context 'Basic attributes access' do
+
+    subject { Person.new }
+
+    it 'Respond to each defined attribute' do
+      should respond_to 'first_name'
+      should respond_to 'first_name='
+      should respond_to 'last_name'
+      should respond_to 'last_name='
+    end
+
+    it 'Keep value of attributes' do
+      person = Person.new
+
+      person.first_name.should be_nil
+      person.first_name = 'John'
+      person.first_name.should eq 'John'
+
+      person.last_name.should be_nil
+      person.last_name = 'Doe'
+      person.last_name.should eq 'Doe'
+    end
+
+    it 'Can assign attributes via constructor hash' do
+      person = Person.new first_name: 'John', last_name: 'Doe'
+      person.first_name.should eq 'John'
+      person.last_name.should eq 'Doe'
+    end
+
+    it 'Can assign attributes via constructor block' do
+      person = Person.new do |p|
+        p.first_name = 'John'
+        p.last_name = 'Doe'
+      end
+      person.first_name.should eq 'John'
+      person.last_name.should eq 'Doe'
+    end
+
+    it 'Get attributes hash' do
+      person = Person.new first_name: 'John', last_name: 'Doe'
+      person.attributes.keys.should eq [:first_name, :last_name]
+      person.attributes[:first_name].should eq 'John'
+      person.attributes[:last_name].should eq 'Doe'
+    end
+
+  end
+
+  context 'Strong typed attributes restrictions' do
+
+    it 'Type defined with a symbol' do
+      engine = Engine.new
+      engine.cylinders = 6
+      expect { engine.cylinders = 6.5 }.to raise_error CleanModel::InvalidTypeAssignment
+    end
+
+    it 'Type defined with a string' do
+      engine = Engine.new
+      engine.valves = 16
+      expect { engine.valves = 16.5 }.to raise_error CleanModel::InvalidTypeAssignment
+    end
+
+    it 'Type defined with a super class' do
+      engine = Engine.new
+      engine.power = 130
+      expect { engine.power = '130hp' }.to raise_error CleanModel::InvalidTypeAssignment
+    end
+
+  end
+
+  context 'Attribute type conversions' do
+
+    it 'Transform to model when assign a hash' do
+      car = Car.new do |c|
+        c.engine = {power: 110, cylinders: 16, valves: 6}
+      end
+      car.engine.should be_a Engine
+      car.engine.power.should eq 110
+      car.engine.cylinders.should eq 16
+      car.engine.valves.should eq 6
+    end
+
+    it 'Apply custom transformation' do
+      car = Car.new do |c|
+        c.comfort = 'bluetooth, gps, electric pack'
+      end
+      car.comfort.should be_a Array
+      car.comfort.should eq ['bluetooth', 'gps', 'electric pack']
+    end
+
+    it 'Transform array elements when collection defined' do
+      factory = Factory.new do |f|
+        f.cars = [
+            {brand: 'Honda', model: 'Civic'},
+            {brand: 'Toyota', model: 'Corolla'},
+        ]
+      end
+
+      factory.cars.should be_a Array
+      factory.cars.should have(2).items
+
+      factory.cars[0].should be_a Car
+      factory.cars[0].brand.should eq 'Honda'
+      factory.cars[0].model.should eq 'Civic'
+
+      factory.cars[1].should be_a Car
+      factory.cars[1].brand.should eq 'Toyota'
+      factory.cars[1].model.should eq 'Corolla'
+    end
+
+  end
+
+  context 'Active model naming and translation' do
+
+    it 'Get a model name' do
+      Person.model_name.should eq 'BaseModels::Person'
+      Person.model_name.human.should eq 'Person'
+    end
+
+    it 'Get a human attribute names' do
+      Person.human_attribute_name(:first_name).should eq 'First name'
+      Person.human_attribute_name(:last_name).should eq 'Last name'
+    end
+
+  end
+
+  context 'Active model validations' do
+
+    it 'Validates presence' do
+      Person.new(first_name: 'John', last_name: 'Doe').should be_valid
+
+      person = Person.new
+      person.should_not be_valid
+      person.errors[:first_name].should have(1).items
+      person.errors[:last_name].should have(1).items
+    end
+
+  end
+
+end

data/spec/persistent_model_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+include PersistentModels
+
+describe CleanModel::Persistent do
+
+  context 'Respond to persistence methods' do
+
+    subject { Post.new }
+
+    it 'Class methods ' do
+      Post.should respond_to :create
+      Post.should respond_to :create!
+    end
+
+    it 'Instance methods' do
+      should respond_to :id
+      should respond_to :id=
+      should respond_to :save
+      should respond_to :save!
+      should respond_to :update_attributes
+      should respond_to :destroy
+      should respond_to :new_record?
+      should respond_to :persisted?
+    end
+
+  end
+
+  context 'Undefined persistence methods' do
+
+    it 'Can not create' do
+      expect { Post.new.send :create }.to raise_error CleanModel::UndefinedPersistenceMethod
+    end
+
+    it 'Can not update' do
+      expect { Post.new.send :update }.to raise_error CleanModel::UndefinedPersistenceMethod
+    end
+
+    it 'Can not destroy' do
+      expect { Post.new.send :destroy }.to raise_error CleanModel::UndefinedPersistenceMethod
+    end
+
+  end
+
+  context 'Defined persistence methods' do
+
+    it 'Create with class method' do
+      Post.any_instance.stub(:create).and_return(:true)
+      Post.any_instance.should_receive :create
+
+      Post.create(subject: 'Title', content: 'Some text').should be_a Post
+    end
+
+    it 'Create with instance method' do
+      post = Post.new subject: 'Title', content: 'Some text'
+
+      post.stub(:create) { true }
+      post.should_receive :create
+
+      post.save.should be_true
+
+      post.stub(:id) { rand(1000) }
+
+      post.should be_persisted
+      post.should_not be_new_record
+    end
+
+    it 'Save persisted model' do
+      post = Post.new id: 1, subject: 'Title', content: 'Some text'
+      post.should be_persisted
+      post.should_not be_new_record
+
+      post.stub(:update) { true }
+      post.should_receive :update
+
+      post.save.should be_true
+    end
+
+    it 'Update attributes' do
+      post = Post.new id: 1, subject: 'Title', content: 'Some text'
+
+      post.stub(:update) { true }
+      post.should_receive :update
+
+      post.update_attributes(content: 'Other text').should be_true
+    end
+
+    it 'Destroy persisted model' do
+      post = Post.new id: 1, subject: 'Title', content: 'Some text'
+
+      post.stub(:delete) { true }
+      post.should_receive :delete
+
+      post.destroy.should be_true
+    end
+
+  end
+
+  context 'Active model conversion' do
+
+    let(:post) { Post.new id: 1 }
+
+    it 'Respond to instance methods' do
+      post.to_model.should eq post
+      post.to_key.should eq [1]
+      post.to_param.should eq '1'
+      post.to_partial_path.should eq 'persistent_models/posts/post'
+    end
+
+  end
+
+end

data/spec/remote_models_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+include RemoteModels
+
+describe CleanModel::Persistent do
+
+  context 'Successful operations' do
+
+    it 'Create' do
+      user = User.new first_name: 'John', last_name: 'Doe', email: 'john.doe@mail.com'
+
+      user.stub(:create) { user.http.post('/users/create.json', user.wrapped_attributes) }
+      user.should_receive :create
+
+      stub_request(:post, 'http://localhost:9999/users/create.json').
+          with(body: {user: {first_name: 'John', last_name: 'Doe', email: 'john.doe@mail.com'}}).
+          to_return(body: {id: 1}.to_json)
+
+      user.save.should be_true
+      user.should be_persisted
+    end
+
+    it 'Update' do
+      user = User.new id: 1, first_name: 'John', last_name: 'Doe', email: 'john.doe@mail.com'
+
+      user.stub(:update) { user.http.put("/users/#{user.id}.json", user.wrapped_attributes(except: :id)) }
+      user.should_receive :update
+
+      stub_request(:put, 'http://localhost:9999/users/1.json').
+          with(body: {user: {first_name: 'Jorge', last_name: 'Doe', email: 'john.doe@mail.com'}})
+
+      user.update_attributes(first_name: 'Jorge').should be_true
+      user.first_name.should eq 'Jorge'
+    end
+
+    it 'Destroy' do
+      user = User.new id: 1, first_name: 'John', last_name: 'Doe', email: 'john.doe@mail.com'
+
+      user.stub(:delete) { user.http.delete("/users/#{user.id}.json") }
+      user.should_receive :delete
+
+      stub_request(:delete, 'http://localhost:9999/users/1.json')
+
+      user.destroy.should be_true
+    end
+
+  end
+
+  context 'Failed operations' do
+
+    it 'Save validation errors' do
+      user = User.new first_name: 'John', last_name: 'Doe'
+
+      user.stub(:create) { user.http.post('/users/create.json', user.wrapped_attributes) }
+
+      stub_request(:post, 'http://localhost:9999/users/create.json').
+          to_return(status: 422, body: {email: ["can't be blank"]}.to_json)
+
+      user.save.should_not be_true
+      user.errors[:email].should have(1).items
+    end
+
+    it 'Save with unexpected error' do
+      user = User.new first_name: 'John', last_name: 'Doe', email: 'john.doe@mail.com'
+
+      user.stub(:create) { user.http.post('/users/create.json', user.wrapped_attributes) }
+
+      stub_request(:post, 'http://localhost:9999/users/create.json').
+          to_return(status: 500, body: 'Internal Server Error')
+
+      user.save.should_not be_true
+      user.errors[:base].should have(1).items
+    end
+
+    it 'Save with timeout error' do
+      user = User.new first_name: 'John', last_name: 'Doe', email: 'john.doe@mail.com'
+
+      user.stub(:create) { user.http.post('/users/create.json', user.wrapped_attributes) }
+
+      stub_request(:post, 'http://localhost:9999/users/create.json').to_timeout
+
+      user.save.should_not be_true
+      user.errors[:base].should have(1).items
+    end
+
+    it 'Destroy with unexpected error' do
+      user = User.new id: 1, first_name: 'John', last_name: 'Doe', email: 'john.doe@mail.com'
+
+      user.stub(:delete) { user.http.delete("/users/#{user.id}.json") }
+
+      stub_request(:delete, 'http://localhost:9999/users/1.json').
+          to_return(status: 500, body: 'Internal Server Error')
+
+      user.destroy.should_not be_true
+      user.errors[:base].should have(1).items
+    end
+
+    it 'Destroy with timeout error' do
+      user = User.new id: 1, first_name: 'John', last_name: 'Doe', email: 'john.doe@mail.com'
+
+      user.stub(:delete) { user.http.delete("/users/#{user.id}.json") }
+
+      stub_request(:delete, 'http://localhost:9999/users/1.json').to_timeout
+
+      user.destroy.should_not be_true
+      user.errors[:base].should have(1).items
+    end
+
+  end
+
+  context 'Http get safe' do
+
+    before :each do
+      User.stub(:find) do
+        User.http_get '/users/1.json' do |response|
+          User.new JSON.parse(response.body)
+        end
+      end
+    end
+
+    it 'Successful' do
+      stub_request(:get, 'http://localhost:9999/users/1.json').
+          to_return(body: {id: 1, first_name: 'John', last_name: 'Doe', email: 'john.doe@mail.com'}.to_json)
+
+      user = User.find(1)
+
+      user.id.should eq 1
+      user.first_name.should eq 'John'
+      user.last_name.should eq 'Doe'
+      user.email.should eq 'john.doe@mail.com'
+    end
+
+    it 'Invalid response' do
+      stub_request(:get, 'http://localhost:9999/users/1.json').
+          to_return(status: 500, body: 'Internal Server Error')
+
+      expect{User.find(1)}.to raise_error CleanModel::InvalidResponse
+    end
+
+    it 'Connection fail' do
+      stub_request(:get, 'http://localhost:9999/users/1.json').to_timeout
+
+      expect{User.find(1)}.to raise_error CleanModel::ConnectionFail
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'webmock/rspec'
+require 'clean_model'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end

data/spec/support/models/base_models.rb

@@ -0,0 +1,35 @@
+module BaseModels
+
+  class Person
+    include CleanModel::Base
+
+    attribute :first_name
+    attribute :last_name
+
+    validates_presence_of :first_name, :last_name
+  end
+
+  class Engine
+    include CleanModel::Base
+
+    attribute :power, class_name: :numeric
+    attribute :cylinders, class_name: :integer
+    attribute :valves, class_name: 'Integer'
+  end
+
+  class Car
+    include CleanModel::Base
+
+    attribute :brand
+    attribute :model
+    attribute :engine, class_name: 'BaseModels::Engine'
+    attribute :comfort, transformation: lambda { |v| v.is_a?(String) ? v.split(',').map(&:strip) : v }
+  end
+
+  class Factory
+    include CleanModel::Base
+
+    attribute :cars, collection: 'BaseModels::Car'
+  end
+
+end

data/spec/support/models/persistent_models.rb

@@ -0,0 +1,10 @@
+module PersistentModels
+
+  class Post
+    include CleanModel::Persistent
+
+    attribute :subject
+    attribute :content
+  end
+
+end

data/spec/support/models/remote_models.rb

@@ -0,0 +1,13 @@
+module RemoteModels
+
+  class User
+    include CleanModel::Remote
+
+    connection host: 'localhost', port: 9999
+
+    attribute :first_name
+    attribute :last_name
+    attribute :email
+  end
+
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: clean_model
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gabriel Naiman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &24823776 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *24823776
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &24823476 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *24823476
+- !ruby/object:Gem::Dependency
+  name: web_client
+  requirement: &24823236 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *24823236
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &24822924 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *24822924
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &24822660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *24822660
+description: Extensions for ActiveModel to implement multiple types of models
+email:
+- gabynaiman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- clean_model.gemspec
+- lib/clean_model.rb
+- lib/clean_model/attribute.rb
+- lib/clean_model/base.rb
+- lib/clean_model/exceptions.rb
+- lib/clean_model/persistent.rb
+- lib/clean_model/remote.rb
+- lib/clean_model/version.rb
+- spec/base_model_spec.rb
+- spec/persistent_model_spec.rb
+- spec/remote_models_spec.rb
+- spec/spec_helper.rb
+- spec/support/models/base_models.rb
+- spec/support/models/persistent_models.rb
+- spec/support/models/remote_models.rb
+homepage: https://github.com/gabynaiman/clean_model
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: Extensions for ActiveModel to implement multiple types of models
+test_files: []