vinaigrette 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+bin
+vendor/bundle

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Yvan BARTHÉLEMY
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# vinaigrette
+
+vinaigrette is a gem providing a custom `ActiveModel` object that can be used
+as a serialized attribute of an `ActiveRecord` object.
+
+## Features
+
+- Serializable `ActiveModel` objects.
+- Custom accessors with casting support default values.
+- Support for Rails validations.
+- Support for Rails belongs_to associations.
+- Casting of ruby booleans from strings.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vinaigrette'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vinaigrette
+
+## Usage
+
+Create a custom `Vinaigrette::Base` subclass:
+
+```ruby
+class AnethSauce < Vinaigrette::Base
+end
+```
+
+Add your attributes using `vinaigrette_accessor`:
+
+```ruby
+# Simple string attribute
+vinaigrette_accessor :name, String
+
+# With a default value
+vinaigrette_accessor :description, String, "Nothing here!"
+
+# A Boolean
+vinaigrette_accessor :spicy?, "Boolean", false
+
+# With support for callables
+vinaigrette_accessor :secret, String, lambda { something_secret }
+
+# You can also create belongs_to associations
+vinaigrette_accessor :sauce_id, Integer
+belongs_to :sauce
+```
+
+Use `vinaigrette_serialize` method to include it in your `ActiveRecord` object:
+
+```ruby
+class SalmonDish < ActiveRecord::Base
+    include Vinaigrette::Serialize
+
+    ...
+
+    vinaigrette_serialize :sauce, AnethSauce
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << 'lib/vinaigrette'
+  t.test_files = FileList['test/lib/vinaigrette/*_test.rb']
+  t.verbose = true
+end
+task :default => :test

data/lib/vinaigrette/base.rb

@@ -0,0 +1,19 @@
+require 'vinaigrette/model/serialization'
+require 'vinaigrette/model/belongs_to'
+require 'vinaigrette/model/accessor'
+
+class Vinaigrette::Base
+  include ActiveModel::Validations
+
+  include Vinaigrette::Model::Serialization
+  include Vinaigrette::Model::BelongsTo
+  include Vinaigrette::Model::Accessor
+
+  def initialize attributes = {}
+    initialize_attributes attributes
+    initialize_association_cache
+  end
+
+  #include ActiveModel::Conversion
+  #extend  ActiveModel::Naming
+end

data/lib/vinaigrette/model/accessor.rb

@@ -0,0 +1,47 @@
+# Support for casting string to boolean
+module Kernel
+  def Boolean(string)
+    return true if string== true || string =~ (/^(true|t|yes|y|1)$/i)
+    return false if string== false || string.nil? || string =~ (/^(false|f|no|n|0)$/i)
+    raise ArgumentError.new("invalid value for Boolean: \"#{string}\"")
+  end
+end
+
+module Vinaigrette::Model
+  module Accessor
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def vinaigrette_accessor(accessor, type, default = nil)
+        supported_attributes = instance_variable_get("@supported_attributes") || []
+        supported_attributes.push accessor
+        instance_variable_set("@supported_attributes", supported_attributes)
+
+        @attributes_names ||= []
+        @attributes_names.push accessor
+
+        define_method(accessor) do
+          instance_variable_get("@#{accessor}")
+        end
+
+        define_method("reset_#{accessor}") do
+          value = default.kind_of?(Proc) ? default.call : default
+          instance_variable_set("@#{accessor}", value)
+        end
+
+        define_method("#{accessor}=") do |val|
+          if !val.nil?
+            begin
+              value = Kernel.send(type.to_s, val)
+              instance_variable_set("@#{accessor}", value)
+            rescue Exception => e
+              send("reset_#{accessor}")
+            end
+          else
+            send("reset_#{accessor}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vinaigrette/model/belongs_to.rb

@@ -0,0 +1,41 @@
+module Vinaigrette::Model
+  module BelongsTo
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveRecord::Associations
+      include ActiveRecord::Reflection          # belongs_to uses create_reflection
+
+      # Used when fetching an actual record
+      include ActiveRecord::Inheritance         # association calls use compute_type
+      include ActiveRecord::AutosaveAssociation # add_autosave_association_callback
+      include ActiveRecord::Callbacks           # add_autosave_association_callback
+    end
+
+    # Associations calls [] to retrieve attributes.
+    def [] name
+      attributes[name]
+    end
+
+    # association_cache is assumed to exist by ActiveRecord::Associations
+    def initialize_association_cache
+      @association_cache = {}
+    end
+
+    module ClassMethods
+      # Reflection initialization uses pluralize_table_names
+      def pluralize_table_names
+        false
+      end
+
+      # generated_feature_methods is used when building the association
+      def generated_feature_methods
+        @generated_feature_methods ||= begin
+          mod = const_set(:GeneratedFeatureMethods, Module.new)
+          include mod
+          mod
+        end
+      end
+    end
+  end
+end

data/lib/vinaigrette/model/serialization.rb

@@ -0,0 +1,34 @@
+module Vinaigrette::Model
+  module Serialization
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Serializers::JSON
+    end
+
+    def initialize_attributes attributes
+      self.class.attributes_names.each do |k|
+        reset_method = "reset_#{k}".to_sym
+        send(reset_method) if respond_to?(reset_method)
+      end
+
+      attributes.each { |k,v| send("#{k}=".to_sym, v) }
+    end
+
+    def attributes
+      Hash[self.class.attributes_names.map { |name| [name, send(name)] }]
+    end
+
+    module ClassMethods
+      def attributes_names
+        @attributes_names
+      end
+
+      def attr_accessor(*vars)
+        @attributes_names ||= []
+        @attributes_names.concat vars
+        super(*vars)
+      end
+    end
+  end
+end

data/lib/vinaigrette/serialize.rb

@@ -0,0 +1,27 @@
+require 'active_model'
+
+module Vinaigrette::Serialize
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def vinaigrette_serialize attribute_name, klass
+      validation_method = "__validate_#{attribute_name}".to_sym
+      accessor_method = attribute_name.to_sym
+
+      send(:serialize, attribute_name, Hash)
+      send(:before_validation, validation_method)
+
+      define_method accessor_method do
+        klass.new(attributes[attribute_name.to_s])
+      end
+
+      define_method validation_method do
+        options = klass.new(attributes[attribute_name.to_s])
+        options.valid?
+        options.errors.each do |field, message|
+          errors.add(attribute_name.to_sym, "#{field} #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/vinaigrette/version.rb

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

data/lib/vinaigrette.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+
+require 'vinaigrette/version'
+
+require 'vinaigrette/serialize'
+require 'vinaigrette/base'
+
+module Vinaigrette
+  # Your code goes here...
+
+end

data/test/lib/vinaigrette/base_test.rb

@@ -0,0 +1,110 @@
+require_relative '../../test_helper'
+
+describe Vinaigrette::Base do
+  before do
+    Object.send(:remove_const, :DeliciousSauce) if Object.const_defined?(:DeliciousSauce)
+    class DeliciousSauce < Vinaigrette::Base; end
+  end
+
+  it 'should be able to use active model validations' do
+    DeliciousSauce.must_respond_to(:validates)
+  end
+
+  it 'should allow using belongs_to associations' do
+    DeliciousSauce.must_respond_to(:belongs_to)
+  end
+
+  it 'should have required active_record dependencies' do
+    klass = Class.new(Vinaigrette::Base) do
+      attr_accessor :recipe_id
+      belongs_to :recipe
+    end
+    Object.const_set(:AnethSauce, klass)
+
+    klass = Class.new(ActiveRecord::Base)
+    Object.const_set(:Recipe, klass)
+
+    assert_respond_to(AnethSauce, :compute_type)
+
+    sauce = AnethSauce.new
+    assert_respond_to(sauce, :autosave_associated_records_for_recipe)
+    assert_respond_to(sauce, :recipe)
+    sauce.recipe
+  end
+
+  it 'should actually search the associated record' do
+    # TODO: Find a way to test this
+  end
+
+  it 'should serialize its attributes' do
+    DeliciousSauce.send(:attr_accessor, :recipe_id)
+    sauce = DeliciousSauce.new
+
+    assert_equal({recipe_id: nil}, sauce.serializable_hash)
+
+    sauce.recipe_id = 42
+    assert_equal({recipe_id: 42}, sauce.serializable_hash)
+
+    sauce.recipe_id = "MyRecipe"
+    assert_equal({recipe_id: "MyRecipe"}, sauce.serializable_hash)
+  end
+
+  it 'should support vinaigrette_accessor' do
+    DeliciousSauce.send(:vinaigrette_accessor, :recipe_id, Integer)
+    sauce = DeliciousSauce.new
+
+    sauce.recipe_id = "42"
+    assert_equal({recipe_id: 42}, sauce.serializable_hash)
+  end
+
+  it 'should support default values' do
+    DeliciousSauce.send(:vinaigrette_accessor, :recipe_id, Integer, 42)
+    sauce = DeliciousSauce.new
+    assert_equal({recipe_id: 42}, sauce.serializable_hash)
+  end
+
+  it 'should support invalid casts' do
+    DeliciousSauce.send(:vinaigrette_accessor, :recipe_id, Integer, 42)
+    sauce = DeliciousSauce.new
+    sauce.recipe_id = false
+    assert_equal({recipe_id: 42}, sauce.serializable_hash)
+  end
+
+  it 'should support default values' do
+    DeliciousSauce.send(:vinaigrette_accessor, :name, String, "")
+    sauce = DeliciousSauce.new
+    sauce.name = nil
+    assert_equal({name: ""}, sauce.serializable_hash)
+  end
+
+  it 'should support boolean values' do
+    DeliciousSauce.send(:vinaigrette_accessor, :has_recipe, 'Boolean', nil)
+    sauce = DeliciousSauce.new
+
+    assert_equal({has_recipe: nil}, sauce.serializable_hash)
+    sauce.has_recipe = false
+    assert_equal({has_recipe: false}, sauce.serializable_hash)
+  end
+
+  it 'should fail casting invalid booleans' do
+    assert_raises ArgumentError do
+      Kernel.Boolean("should not become a boolean")
+    end
+  end
+
+  it 'should cast valid booleans' do
+    assert_equal(false, Kernel.Boolean("false"))
+    assert_equal(false, Kernel.Boolean("no"))
+    assert_equal(false, Kernel.Boolean("0"))
+    assert_equal(true, Kernel.Boolean("true"))
+    assert_equal(true, Kernel.Boolean("yes"))
+    assert_equal(true, Kernel.Boolean("1"))
+  end
+
+  it 'should support procs' do
+    DeliciousSauce.send(:vinaigrette_accessor, :recipe_id, Integer, lambda { 42 })
+
+    sauce = DeliciousSauce.new
+    assert_equal({recipe_id: 42}, sauce.serializable_hash)
+  end
+end

data/test/lib/vinaigrette/serialize_test.rb

@@ -0,0 +1,58 @@
+require_relative '../../test_helper'
+
+describe Vinaigrette::Serialize do
+  before do
+    Object.send(:remove_const, :DeliciousSauce) if Object.const_defined?(:DeliciousSauce)
+    Object.send(:remove_const, :SalmonDish) if Object.const_defined?(:SalmonDish)
+
+    class DeliciousSauce
+      def initialize attributes={}
+      end
+    end
+    class SalmonDish
+      include Vinaigrette::Serialize
+    end
+
+    # Mock an ActiveRecord object with validations
+    SalmonDish.stubs(:serialize)
+    SalmonDish.stubs(:before_validation)
+  end
+
+  it 'should call successfully vinaigrette_serialize method' do
+    SalmonDish.send(:vinaigrette_serialize, :sauce, DeliciousSauce)
+  end
+
+  it 'should call serialize with Hash' do
+    SalmonDish.expects(:serialize).with(:sauce, Hash).once
+    SalmonDish.send(:vinaigrette_serialize, :sauce, DeliciousSauce)
+  end
+
+  it 'should add errors to outer model' do
+    SalmonDish.send(:attr_accessor, :sauce)
+    SalmonDish.send(:vinaigrette_serialize, :sauce, DeliciousSauce)
+
+    dish = SalmonDish.new
+    dish.stubs(:attributes).returns({})
+
+    sauce = DeliciousSauce.new
+    sauce.stubs(:valid?).returns(false)
+    sauce.stubs(:errors).returns([[:taste, 'should be delicious']])
+    DeliciousSauce.stubs(:new).returns(sauce)
+
+    error_mock = mock()
+    error_mock.stubs(:add).with(:sauce, 'taste should be delicious').once
+    dish.stubs(:errors).returns(error_mock)
+
+    dish.__validate_sauce
+  end
+
+  it 'should override default Hash accessor' do
+    SalmonDish.send(:attr_accessor, :sauce)
+    SalmonDish.send(:vinaigrette_serialize, :sauce, DeliciousSauce)
+
+    dish = SalmonDish.new
+    dish.stubs(:attributes).returns({})
+
+    assert_equal(DeliciousSauce, dish.sauce.class)
+  end
+end

data/test/lib/vinaigrette/version_test.rb

@@ -0,0 +1,7 @@
+require_relative '../../test_helper'
+
+describe Vinaigrette do
+  it "must be defined" do
+    Vinaigrette::VERSION.wont_be_nil
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter 'vendor'
+  add_filter 'test'
+end
+
+require 'minitest/autorun'
+require 'minitest/pride'
+require "minitest/hell"
+
+require File.expand_path('../../lib/vinaigrette.rb', __FILE__)
+
+require 'mocha/setup'

data/vinaigrette.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vinaigrette/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "vinaigrette"
+  gem.version       = Vinaigrette::VERSION
+  gem.authors       = ["Yvan BARTHÉLEMY"]
+  gem.email         = ["ybarthelemy@direct-streams.com"]
+  gem.description   = %q{Custom serializable ActiveModel object.}
+  gem.summary       = %q{Provides a custom serializable ActiveModel object with ActiveModel validations and ActiveRecord associations.}
+  gem.homepage      = "http://ybart.github.com/vinaigrette"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'minitest',  '>= 4.2.0'
+  gem.add_development_dependency 'simplecov', '>= 0.3.8'
+  gem.add_development_dependency 'mocha',     '>= 0.13.1'
+
+  gem.add_dependency 'activerecord',          '>= 3.0.0'
+  # gem.add_dependency 'activesupport',       '>= 3.0.0' # ActiveSupport::Concern
+  # gem.add_dependency 'activemodel',         '>= 3.0.0' # ActiveModel::Validations
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: vinaigrette
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Yvan BARTHÉLEMY
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.8
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Custom serializable ActiveModel object.
+email:
+- ybarthelemy@direct-streams.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/vinaigrette.rb
+- lib/vinaigrette/base.rb
+- lib/vinaigrette/model/accessor.rb
+- lib/vinaigrette/model/belongs_to.rb
+- lib/vinaigrette/model/serialization.rb
+- lib/vinaigrette/serialize.rb
+- lib/vinaigrette/version.rb
+- test/lib/vinaigrette/base_test.rb
+- test/lib/vinaigrette/serialize_test.rb
+- test/lib/vinaigrette/version_test.rb
+- test/test_helper.rb
+- vinaigrette.gemspec
+homepage: http://ybart.github.com/vinaigrette
+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.24
+signing_key: 
+specification_version: 3
+summary: Provides a custom serializable ActiveModel object with ActiveModel validations
+  and ActiveRecord associations.
+test_files:
+- test/lib/vinaigrette/base_test.rb
+- test/lib/vinaigrette/serialize_test.rb
+- test/lib/vinaigrette/version_test.rb
+- test/test_helper.rb