simple_set 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a89d5b1d434529dfd5e8496e9d3f6e276912068a
+  data.tar.gz: 431ecc28bbd8bf82a6ba765ab00e553ea6d77575
+SHA512:
+  metadata.gz: 58858c8bf1379593972d5b39f9173dcfe463a3166646f798d4d17754b56649d64069e0049846681e44d920853ee7bfb07067558089ddc73234c9509e8245d308
+  data.tar.gz: b567de32fd5286e4730086673e495088a2463974fe3b45eaf71ab213fa48c8ce8080eddfe32a82f48bb277c02d3e6f20e88589b97bc9d196e950cc1145a3127b

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Sven Fuchs <svenfuchs@artweb-design.de>
+Copyright (c) 2014 Romain Tartière <romain@blogreen.org>
+
+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,132 @@
+# SimpleSet
+
+A Rails plugin which brings easy-to-use set-like functionality to ActiveRecord models.
+
+This is based on [SimpleEnum](https://github.com/lwe/simple_enum).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'simple_set'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install simple_set
+
+## Usage
+
+Add this to a model:
+
+    class User < ActiveRecord::Base
+      as_set :roles, [:accounting, :management]
+    end
+
+Then create the required `roles_cd` column using migrations:
+
+    class AddRolesToUsers < ActiveRecord::Migration
+      def change
+        add_column :users, :roles_cd, :integer
+      end
+    end
+
+Now, it's possible to manage roles with maximum ease:
+
+    bob = User.new
+    bob.roles = [:accounting]
+    bob.accounting?           #=> true
+    bob.management?           #=> false
+    bob.roles                 #=> [:accounting]
+    bob.roles_cd              #=> 1
+
+## Gotchas
+
+1. Acceptable values can be provided as an `Array` or as a `Hash`, the
+   following lines are equivalent:
+
+        as_set :spoken_languages, [:english, :french, :german, :japanese]
+        as_set :spoken_languages, {english: 1, french: 2, german: 4, japanese: 8}
+
+   Reordering the array will change each element's value which is likely
+   unwanted.  Either only append new elements to the `Array` notation or use
+   the `Hash` notation.
+
+2. Although the `Hash` notation is less intuitive than the `Array` notation, it
+   allows some neat tricks:
+
+        class User
+          as_set :roles, {
+            management: 1,
+            accounting: 2,
+            human_resources: 4,
+
+            director: 7,
+          }
+        end
+
+        bob = User.create(roles: [:management, :accounting])
+        bob.director?                                         #=> false
+        bob.human_resources = true
+        bob.director?                                         #=> true
+
+3. If the shortcut methods (like `<symbol>?`, `<symbol>=` or `Klass.<symbol>`)
+   conflict with something in your class, it’s possible to define a prefix:
+
+        class Lp < ActiveRecord::Base
+          as_set :media_conditions, [:new, :sealed, :very_good, :good, :fair, :poor], prefix: true
+        end
+
+        Bug.media_condition_new #=> 1
+
+   When `:prefix` is set to `true`, shortcut methods are prefixed by the
+   _singularized name_ of the attribute.
+
+   The `:prefix` option not only takes a boolean value as an argument, but
+   instead can also be supplied a custom prefix (i.e. any string or symbol), so
+   with `prefix: 'foo'` all shortcut methods would look like: `foo_<symbol>...`
+
+4. Sometimes it might be useful to disable the generation of the shortcut
+   methods (`<symbol>?`, `<symbol>=` and `Klass.<symbol>`), to do so just add
+   the option `slim: true`:
+
+        class User
+          as_set :spoken_languages, [:english, :french, :german, :japanese], slim: true
+        end
+
+        bob = User.create(spoken_languages: [:english, :french]
+        bob.spoken_languages #=> [:english, :french]
+        bob.french?          #=> throws NoMethodError: undefined method `french?'
+        bob.french = false   #=> throws NoMethodError: undefined method `french='
+        User.french          #=> throws NoMethodError: undefined method `french'
+
+5. Easy Rails integration:
+
+Given a `User` is declared as:
+
+        class User < ActiveRecord::Base
+          as_set :roles, [:management, :accounting, :human_resources]
+        end
+
+Adjust strong parameters to allow roles assignment:
+
+        params.require(:user).permit(:roles => [])
+
+And then render a collection of checkboxes:
+
+        = form_for @user do |f|
+          = f.collection_check_boxes(:roles, User.roles, :to_sym, :to_sym) do |b|
+            = b.check_box
+            = b.label do
+              = t("application.roles.#{b.text}")
+
+## 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,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/simple_set/set_hash.rb

@@ -0,0 +1,18 @@
+require 'simple_enum/enum_hash'
+
+module SimpleSet
+  class SetHash < ::SimpleEnum::EnumHash
+    def initialize(args = [], strings = false)
+      super()
+
+      if args.is_a?(Hash) then
+        args.each { |k,v| set_value_for_reverse_lookup(k, v) }
+      else
+        ary = args.send(args.respond_to?(:enum_with_index) ? :enum_with_index : :each_with_index).map { |x,y| [ x, 2**y ] } unless args.first.respond_to?(:map)
+        ary = args.map { |e| [e, 2**e.id] } if args.first.respond_to?(:map) && !args.first.is_a?(Array)
+        ary ||= args
+        ary.each { |e| set_value_for_reverse_lookup(e[0], strings ? e[0].to_s : e[1]) }
+      end
+    end
+  end
+end

data/lib/simple_set/version.rb

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

data/lib/simple_set.rb

@@ -0,0 +1,141 @@
+require 'active_support'
+require 'active_support/inflector'
+
+require 'simple_set/version'
+require 'simple_set/set_hash'
+
+require 'active_support/deprecation'
+
+module SimpleSet
+  class << self
+    def default_options
+      @default_options ||= {
+        whiny: true,
+      }
+    end
+
+    def included(base)
+      base.send :class_attribute, :simple_set_definitions, instance_writer: false, instance_reader: false
+      base.send :extend, ClassMethods
+    end
+  end
+
+  module ClassMethods
+    # Provides ability to create simple sets based on hashes or arrays, backed
+    # by integer columns (but not limited to integer columns).
+    #
+    # Columns are supposed to be suffixed by <tt>_cd</tt>, if not, use
+    # <tt>:column => 'the_column_name'</tt>, so some example migrations:
+    #
+    #   add_column :users, :roles_cd, :integer
+    #   add_column :users, :permissions, :integer # and a custom column...
+    #
+    # and then in your model:
+    #
+    #   class User
+    #     as_set :roles, [:management, :accounting]
+    #   end
+    #
+    #   # or use a hash:
+    #
+    #   class User
+    #     as_set :user_permissions, { create_invoice: 1, send_invoice: 2, create_user: 4, all: 7 }, column: 'permissions'
+    #   end
+    #
+    # Now it's possible to access the set and the internally stored value like:
+    #
+    #   john_doe = User.new
+    #   john_doe.roles                         #=> []
+    #   john_doe.roles = [:accounting]
+    #   john_doe.roles                         #=> [:accounting]
+    #   john_doe.roles_cd                      #=> 2
+    #
+    # And to make life a tad easier: a few shortcut methods to work with the set are also created.
+    #
+    #   john_doe.accounting?                  #=> true
+    #   john_doe.accounting = false
+    #   john_doe.accounting?                  #=> false
+    #
+    # === Configuration options:
+    # * <tt>:column</tt> - Specifies a custom column name, instead of the
+    #   default suffixed <tt>_cd</tt> column.
+    # * <tt>:prefix</tt> - Define a prefix, which is prefixed to the shortcut
+    #   methods (e.g. <tt><symbol>=</tt> and <tt><symbol>?</tt>), if it's set
+    #   to <tt>true</tt> the enumeration name is used as a prefix, else a
+    #   custom prefix (symbol or string) (default is <tt>nil</tt> => no prefix)
+    # * <tt>:slim</tt> - If set to <tt>true</tt> no shortcut methods for all
+    #   enumeration values are being generated, if set to <tt>:class</tt> only
+    #   class-level shortcut methods are disabled (default is <tt>nil</tt> =>
+    #   they are generated)
+    # * <tt>:whiny</tt> - Boolean value which if set to <tt>true</tt> will
+    #   throw an <tt>ArgumentError</tt> if an invalid value is passed to the
+    #   setter (e.g. a value for which no enumeration exists). if set to
+    #   <tt>false</tt> no exception is thrown and the internal value is left
+    #   untouched (default is <tt>true</tt>)
+    def as_set(set_cd, values, options = {})
+      options = SimpleSet.default_options.merge({column: "#{set_cd}_cd"}).merge(options)
+      options.assert_valid_keys(:column, :prefix, :slim, :whiny)
+
+      metaclass = (class << self; self; end)
+
+      values = SimpleSet::SetHash.new(values)
+
+      define_method("#{set_cd}") do
+        current = send(options[:column])
+        return nil if current.nil?
+        values.select { |k,v| v == current & v }.keys
+      end
+
+      define_method("#{set_cd}=") do |new_values|
+        real = nil
+        if ! new_values.nil? then
+          new_values = new_values.reject { |x| x == ''}.collect { |x| x.to_sym }
+          real = new_values.collect do |k|
+            if values.has_key?(k) then
+              values[k]
+            else
+              raise(ArgumentError, "Invalid set value : #{k}") if options[:whiny]
+              0
+            end
+          end.inject(:|)
+        end
+        send("#{options[:column]}=", real)
+      end
+
+      metaclass.send :define_method, "#{set_cd}" do
+        return values.keys
+      end
+
+      if options[:slim] != true then
+        prefix = options[:prefix] && "#{options[:prefix] == true ? set_cd.to_s.singularize : options[:prefix]}_"
+        values.each do |k,code|
+          sym = SetHash.symbolize(k)
+
+          define_method("#{prefix}#{sym}?") do
+            current = send(options[:column]) || 0
+            code == (code & current)
+          end
+
+          define_method("#{prefix}#{sym}=") do |value|
+            current = send(options[:column]) || 0
+            if value then
+              current |= code
+            else
+              current &= ~code
+            end
+            send("#{options[:column]}=", current)
+            code == (current & code)
+          end
+
+          unless options[:slim] == :class then
+            metaclass.send(:define_method, "#{prefix}#{sym}", Proc.new { |*args| args.first ? k : code })
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.send(:include, SimpleSet)
+end

data/simple_set.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'simple_set/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "simple_set"
+  spec.version       = SimpleSet::VERSION
+  spec.authors       = ["Romain Tartière"]
+  spec.email         = ["romain@blogreen.org"]
+  spec.summary       = %q{Simple set-like field support for ActiveModel}
+  spec.homepage      = "https://github.com/smortex/simple_set"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "simple_enum", "~> 1.6.8"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/simple_set_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+
+describe SimpleSet do
+  it 'should raise on error when manipulating invalid values' do
+    named_model('TestExceptions') do
+      as_set :values, [:a, :b]
+    end
+
+    sample = TestExceptions.new
+    expect { sample.values = [:a] }.to_not raise_error
+    expect { sample.values = [:b] }.to_not raise_error
+    expect { sample.values = [:c] }.to raise_error(ArgumentError)
+  end
+
+  it 'should accept an array of symbols' do
+    named_model('InitWithArrayOfSymbol') do
+      as_set :values, [:a, :b, :c, :d, :e, :f]
+    end
+
+    InitWithArrayOfSymbol.a.should == 1
+    InitWithArrayOfSymbol.b.should == 2
+    InitWithArrayOfSymbol.c.should == 4
+    InitWithArrayOfSymbol.d.should == 8
+    InitWithArrayOfSymbol.e.should == 16
+    InitWithArrayOfSymbol.f.should == 32
+  end
+
+  it 'should accept a hash' do
+    named_model('InitWithHash') do
+      as_set :values, { a: 1, b: 2, c: 4, d: 8, all: 15 }
+    end
+
+    InitWithHash.a.should == 1
+    InitWithHash.b.should == 2
+    InitWithHash.c.should == 4
+    InitWithHash.d.should == 8
+    InitWithHash.all.should == 15
+
+    sample = InitWithHash.new
+    sample.all = true
+    sample.a?.should be_true
+    sample.b?.should be_true
+    sample.c?.should be_true
+    sample.d?.should be_true
+    sample.all?.should be_true
+    sample.b = false
+    sample.all?.should be_false
+    sample.b = true
+    sample.all?.should be_true
+  end
+
+  it 'should distinguish nil from empty set' do
+    named_model('NilOrEmpty') do
+      as_set :values, [:a, :b]
+    end
+
+    sample = NilOrEmpty.new
+
+    sample.a?.should be_false
+    sample.b?.should be_false
+    sample.values_cd.should == nil
+    sample.values.should == nil
+
+    sample.values = [:a]
+    sample.values.should == [:a]
+    sample.values = nil
+    sample.values.should == nil
+
+    sample.a = true
+    sample.values.should == [:a]
+    sample.a = false
+    sample.values.should == []
+
+    sample.values = nil
+    sample.values.should == nil
+    sample.a = false
+    sample.values.should == []
+  end
+
+  it 'should support fields with a default value' do
+    named_model('FieldWithDefaultValue') do
+      as_set :values_with_default, [:x, :y]
+    end
+
+    sample = FieldWithDefaultValue.new
+    sample.values_with_default_cd.should == 2
+    sample.values_with_default.should == [:y]
+
+    sample.values_with_default = nil
+    sample.values_with_default.should == nil
+  end
+
+  it 'should work outside activerecord' do
+    class FruitsEater
+      include SimpleSet
+      as_set :fruits_i_like, [:apples, :bananas, :pinaple]
+      attr_accessor :fruits_i_like_cd
+    end
+
+    sample = FruitsEater.new
+    sample.fruits_i_like = [:apples, :pinaple]
+    sample.fruits_i_like_cd.should == 5
+  end
+
+  it 'should return acceptable values' do
+    named_model('AcceptableValues') do
+      as_set :spoken_languages, [:english, :french, :german, :japanese]
+    end
+
+    AcceptableValues.spoken_languages.should == [:english, :french, :german, :japanese]
+  end
+
+  it 'should support Rails assignment' do
+    named_model('User') do
+      as_set :values, [:foo_manager, :bar_manager, :baz_manager]
+    end
+
+    sample = User.new
+    sample.values = ["foo_manager", "baz_manager", ""]
+    sample.values.should == [:foo_manager, :baz_manager]
+  end
+
+  #   ___        _   _
+  #  / _ \ _ __ | |_(_) ___  _ __  ___
+  # | | | | '_ \| __| |/ _ \| '_ \/ __|
+  # | |_| | |_) | |_| | (_) | | | \__ \
+  #  \___/| .__/ \__|_|\___/|_| |_|___/
+  #       |_|
+
+  describe 'options' do
+
+    #  _        _
+    # (_)__ ___| |_  _ _ __  _ _
+    #  _/ _/ _ \ | || | '  \| ' \
+    # (_)__\___/_|\_,_|_|_|_|_||_|
+    #
+
+    describe ":column" do
+      it 'should support a custom column name' do
+        named_model('TestOptionColumn1') do
+          as_set :languages, [:english, :french, :german, :japanese], column: 'custom_name'
+        end
+
+        sample = TestOptionColumn1.new
+        sample.languages = [:french, :german]
+        sample.english?.should be_false
+        sample.french?.should be_true
+        sample.german?.should be_true
+        sample.japanese?.should be_false
+        sample.custom_name.should == 6
+      end
+    end
+
+    #  _               __ _
+    # (_)_ __ _ _ ___ / _(_)_ __
+    #  _| '_ \ '_/ -_)  _| \ \ /
+    # (_) .__/_| \___|_| |_/_\_\
+    #   |_|
+
+    describe ':prefix' do
+      it "should support automatic prefix in getters and setters" do
+        named_model('TestOptionPrefix1') do
+          as_set :spoken_languages, [:english, :french, :german, :japanese], prefix: true
+        end
+
+        sample = TestOptionPrefix1.new
+        sample.should respond_to(:spoken_language_english?)
+        sample.should respond_to(:spoken_language_french?)
+        sample.should respond_to(:spoken_language_german?)
+        sample.should respond_to(:spoken_language_japanese?)
+
+        sample.should respond_to(:spoken_language_english=)
+        sample.should respond_to(:spoken_language_french=)
+        sample.should respond_to(:spoken_language_german=)
+        sample.should respond_to(:spoken_language_japanese=)
+
+        TestOptionPrefix1.should respond_to(:spoken_language_english)
+        TestOptionPrefix1.should respond_to(:spoken_language_french)
+        TestOptionPrefix1.should respond_to(:spoken_language_german)
+        TestOptionPrefix1.should respond_to(:spoken_language_japanese)
+
+        sample.should_not respond_to(:japanese?)
+      end
+
+      it "should support custom prefix in getters and setters" do
+        named_model('TestOptionPrefix2') do
+          as_set :spoken_languages, [:english, :french, :german, :japanese], prefix: 'speaks'
+        end
+
+        sample = TestOptionPrefix2.new
+        sample.should respond_to(:speaks_english?)
+        sample.should respond_to(:speaks_french?)
+        sample.should respond_to(:speaks_german?)
+        sample.should respond_to(:speaks_japanese?)
+
+        sample.should respond_to(:speaks_english=)
+        sample.should respond_to(:speaks_french=)
+        sample.should respond_to(:speaks_german=)
+        sample.should respond_to(:speaks_japanese=)
+
+        TestOptionPrefix2.should respond_to(:speaks_english)
+        TestOptionPrefix2.should respond_to(:speaks_french)
+        TestOptionPrefix2.should respond_to(:speaks_german)
+        TestOptionPrefix2.should respond_to(:speaks_japanese)
+
+        sample.should_not respond_to(:japanese?)
+      end
+    end
+
+    #  _    _ _
+    # (_)__| (_)_ __
+    #  _(_-< | | '  \
+    # (_)__/_|_|_|_|_|
+    #
+
+    describe ":slim" do
+      it 'should not generate instance nor class members when true is passed' do
+        named_model('TestOptionSlim1') do
+          as_set :spoken_languages, [:english, :french, :german, :japanese], slim: true
+        end
+
+        TestOptionSlim1.should_not respond_to(:english)
+        TestOptionSlim1.should_not respond_to(:french)
+        TestOptionSlim1.should_not respond_to(:german)
+        TestOptionSlim1.should_not respond_to(:japanese)
+
+        sample = TestOptionSlim1.new
+        sample.should_not respond_to(:english?)
+        sample.should_not respond_to(:french?)
+        sample.should_not respond_to(:german?)
+        sample.should_not respond_to(:japanese?)
+
+        sample.should_not respond_to(:english=)
+        sample.should_not respond_to(:french=)
+        sample.should_not respond_to(:german=)
+        sample.should_not respond_to(:japanese=)
+      end
+
+      it 'should only generate instance members when :class is passed' do
+        named_model('TestOptionSlim2') do
+          as_set :spoken_languages, [:english, :french, :german, :japanese], slim: :class
+        end
+
+        TestOptionSlim2.should_not respond_to(:english)
+        TestOptionSlim2.should_not respond_to(:french)
+        TestOptionSlim2.should_not respond_to(:german)
+        TestOptionSlim2.should_not respond_to(:japanese)
+
+        sample = TestOptionSlim2.new
+        sample.should respond_to(:english?)
+        sample.should respond_to(:french?)
+        sample.should respond_to(:german?)
+        sample.should respond_to(:japanese?)
+
+        sample.should respond_to(:english=)
+        sample.should respond_to(:french=)
+        sample.should respond_to(:german=)
+        sample.should respond_to(:japanese=)
+      end
+    end
+
+    #  _        _    _
+    # (_)_ __ _| |_ (_)_ _ _  _
+    #  _\ V  V / ' \| | ' \ || |
+    # (_)\_/\_/|_||_|_|_||_\_, |
+    #                      |__/
+
+    describe ':whiny' do
+      it 'should not raise exception on invalid value' do
+        named_model('TestOptionWhiny1') do
+          as_set :spoken_languages, [:english, :french, :german, :japanese], whiny: false
+        end
+
+        sample = TestOptionWhiny1.new
+        expect { sample.spoken_languages = [:french, :italian, :japanese] }.to_not raise_error
+        sample.spoken_languages.should == [:french, :japanese]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'simple_set'
+require 'support/models'

data/spec/support/models.rb

@@ -0,0 +1,23 @@
+require 'active_record'
+
+def named_model(class_name, &block)
+  begin
+    return class_name.constantize
+  rescue NameError
+    klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
+    klass.module_eval do
+      self.table_name = 'dummies'
+      instance_eval &block
+    end
+    klass
+  end
+end
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+ActiveRecord::Base.connection.create_table :dummies do |t|
+  t.integer :values_cd
+  t.integer :values_with_default_cd, default: 2
+  t.integer :spoken_languages_cd
+  t.integer :custom_name
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: simple_set
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Romain Tartière
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: simple_enum
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.8
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- romain@blogreen.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/simple_set.rb
+- lib/simple_set/set_hash.rb
+- lib/simple_set/version.rb
+- simple_set.gemspec
+- spec/simple_set_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+homepage: https://github.com/smortex/simple_set
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Simple set-like field support for ActiveModel
+test_files:
+- spec/simple_set_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+has_rdoc: