store_attribute 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 36243b5e350010855d95f5104c95dead8d0f6f8a
+  data.tar.gz: d28d7d37b5db4a62a7ee363acdfb7b2d18e599c1
+SHA512:
+  metadata.gz: 9cd64959ebac0572406300a1f3f350dc54232d8ed05639d03a9f941fdf8c0703d9ac2f23b40b589fca9b696da42e263f262231f84c613c04fd6a13c18ef68c17
+  data.tar.gz: 61693d8113e5f3f419e558a3f40877cdbe6ae03e1b3a7a27d5f3097d51a08540f581cd0e7f5a89ad626169fb3d4d71c6c48796df346f56e94ba2a0d88f1406e8

data/.gitignore

@@ -0,0 +1,36 @@
+# Numerous always-ignore extensions
+*.diff
+*.err
+*.orig
+*.log
+*.rej
+*.swo
+*.swp
+*.vi
+*~
+*.sass-cache
+*.iml
+.idea/
+
+# Sublime
+*.sublime-project
+*.sublime-workspace
+
+# OS or Editor folders
+.DS_Store
+.cache
+.project
+.settings
+.tmproj
+Thumbs.db
+coverage/
+
+.bundle/
+*.log
+*.gem
+pkg/
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.sass-cache
+Gemfile.local
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rubocop.yml

@@ -0,0 +1,51 @@
+AllCops:
+  # Include gemspec and Rakefile
+  Include:
+    - 'lib/**/*.rb'
+    - 'lib/**/*.rake'
+    - 'spec/**/*.rb'
+  Exclude:
+    - 'bin/**/*'
+    - 'spec/dummy/**/*'
+    - 'tmp/**/*'
+    - 'bench/**/*'
+  DisplayCopNames: true
+  StyleGuideCopsOnly: false
+
+Style/AccessorMethodName:
+  Enabled: false
+
+Style/TrivialAccessors:
+  Enabled: false
+
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Style/StringLiterals: 
+  Enabled: false
+
+Style/SpaceInsideStringInterpolation:
+  EnforcedStyle: no_space
+
+Style/BlockDelimiters:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false
+
+Metrics/MethodLength:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Metrics/LineLength:
+  Max: 100
+  Exclude:
+    - 'spec/**/*.rb'
+
+Rails/Date:
+  Enabled: false
+
+Rails/TimeZone:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+cache: bundler
+
+addons:
+  postgresql: "9.4"
+
+before_script:
+  - createdb store_attribute_test
+  - psql -U postgres -d store_attribute_test -c 'CREATE EXTENSION IF NOT EXISTS hstore;'
+
+matrix:
+  include:
+    - rvm: 2.3.0
+      gemfile: gemfiles/rails42.gemfile

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+local_gemfile = 'Gemfile.local'
+
+if File.exist?(local_gemfile)
+  eval(File.read(local_gemfile)) # rubocop:disable Lint/Eval
+else
+  gem 'activerecord', '~>4.2'
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 palkan
+
+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,84 @@
+[![Gem Version](https://badge.fury.io/rb/store_attribute.svg)](https://rubygems.org/gems/store_attribute) [![Build Status](https://travis-ci.org/palkan/store_attribute.svg?branch=master)](https://travis-ci.org/palkan/store_attribute)
+
+## Store Attribute
+
+ActiveRecord extension which adds typecasting to store accessors.
+
+Compatible with **Rails** ~> 4.2.
+
+
+### Install
+
+In your Gemfile:
+
+```ruby
+gem "store_attribute", "~>0.4.0" # version 0.4.x is for Rails 4.2.x and 0.5.x is for Rails 5
+```
+
+### Usage
+
+You can use `store_attribute` method to add additional accessors with a type to an existing store on a model.
+
+```ruby
+  .store_attribute(store_name, name, type, options = {})
+```
+
+Where:
+- `store_name` The name of the store.
+- `name` The name of the accessor to the store.
+- `type` A symbol such as `:string` or `:integer`, or a type object to be used for the accessor.
+- `options` A hash of cast type options such as `precision`, `limit`, `scale`.
+
+Type casting occurs every time you write data through accessor or update store itself
+and when object is loaded from database.
+
+Note that if you update store explicitly then value isn't  type casted.
+
+Examples:
+
+```ruby
+class MegaUser < User
+  store_attribute :settings, :ratio, :integer, limit: 1
+  store_attribute :settings, :login_at, :datetime
+  store_attribute :settings, :active, :boolean
+end
+
+u = MegaUser.new(active: false, login_at: '2015-01-01 00:01', ratio: "63.4608")
+
+u.login_at.is_a?(DateTime) # => true
+u.login_at = DateTime.new(2015,1,1,11,0,0)
+u.ratio # => 63
+u.active # => false
+# And we also have a predicate method
+u.active? # => false
+u.reload
+
+# After loading record from db store contains casted data
+u.settings['login_at'] == DateTime.new(2015,1,1,11,0,0) # => true
+
+# If you update store explicitly then the value returned
+# by accessor isn't type casted
+u.settings['ration'] = "3.141592653"
+u.ratio # => "3.141592653"
+
+# On the other hand, writing through accessor set correct data within store
+u.ratio = "3.14.1592653"
+u.ratio # => 3
+u.settings['ratio'] # => 3
+```
+
+You can also specify type using usual `store_accessor` method:
+
+```ruby
+class SuperUser < User
+  store_accessor :settings, :privileges, login_at: :datetime
+end
+```
+
+Or through `store`:
+
+```ruby
+class User < ActiveRecord::Base
+  store :settings, accessors: [:color, :homepage, login_at: :datetime], coder: JSON
+end
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bench/bench.rb

@@ -0,0 +1,38 @@
+require 'benchmark/ips'
+require './setup'
+
+Benchmark.ips do |x|
+  x.report('SA initialize') do
+    User.new(public: '1', published_at: '2016-01-01', age: '23')
+  end
+
+  x.report('AR-T initialize') do
+    Looser.new(public: '1', published_at: '2016-01-01', age: '23')
+  end
+end
+
+Benchmark.ips do |x|
+  x.report('SA accessors') do
+    u = User.new
+    u.public = '1'
+    u.published_at = '2016-01-01'
+    u.age = '23'
+  end
+
+  x.report('AR-T accessors') do
+    u = Looser.new
+    u.public = '1'
+    u.published_at = '2016-01-01'
+    u.age = '23'
+  end
+end
+
+Benchmark.ips do |x|
+  x.report('SA create') do
+    User.create!(public: '1', published_at: '2016-01-01', age: '23')
+  end
+
+  x.report('AR-T create') do
+    Looser.create(public: '1', published_at: '2016-01-01', age: '23')
+  end
+end

data/bench/setup.rb

@@ -0,0 +1,67 @@
+begin
+  require 'bundler/inline'
+rescue LoadError => e
+  $stderr.puts 'Bundler version 1.10 or later is required. Please update your Bundler'
+  raise e
+end
+
+gemfile(true) do
+  source 'https://rubygems.org'
+  gem 'activerecord', '~>4.2'
+  gem 'pg'
+  gem 'activerecord-typedstore', require: false
+  gem 'pry-byebug'
+  gem 'benchmark-ips'
+  gem 'memory_profiler'
+end
+
+DB_NAME = ENV['DB_NAME'] || 'sa_bench'
+
+begin
+  system("createdb #{DB_NAME}")
+rescue
+  $stdout.puts "DB already exists"
+end
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'active_record'
+require 'logger'
+require 'store_attribute'
+require 'activerecord-typedstore'
+
+ActiveRecord::Base.establish_connection(adapter: 'postgresql', database: DB_NAME)
+
+at_exit do
+  ActiveRecord::Base.connection.disconnect!
+end
+
+module Bench
+  module_function
+  def setup_db
+    ActiveRecord::Schema.define do
+      create_table :users, force: true do |t|
+        t.jsonb :data
+      end
+
+      create_table :loosers, force: true do |t|
+        t.jsonb :data
+      end
+    end
+  end
+end
+
+class User < ActiveRecord::Base
+  store_accessor :data, public: :boolean, published_at: :datetime, age: :integer
+end
+
+class Looser < ActiveRecord::Base
+  typed_store :data, coder: JSON do |s|
+    s.boolean :public
+    s.datetime :published_at
+    s.integer :age
+  end
+end
+
+# Run migration only if neccessary
+Bench.setup_db if ENV['FORCE'].present? || !ActiveRecord::Base.connection.tables.include?('users')

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "store_attribute"
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+set -e
+
+gem install bundler --conservative
+bundle check || bundle install
+
+createdb store_attribute_test

data/gemfiles/rails-edge.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'rack', github: "rack/rack"
+gem 'arel', github: 'rails/arel'
+gem 'rails', github: 'rails/rails'
+
+gemspec path: '..'

data/gemfiles/rails42.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', "~>4.2"
+
+gemspec path: '..'

data/lib/store_attribute/active_record/store.rb

@@ -0,0 +1,139 @@
+require 'active_record/store'
+require 'store_attribute/active_record/type/typed_store'
+
+module ActiveRecord
+  module Store
+    module ClassMethods # :nodoc:
+      # Defines store on this model.
+      #
+      # +store_name+ The name of the store.
+      #
+      # ==== Options
+      # The following options are accepted:
+      #
+      # +coder+ The coder of the store.
+      #
+      # +accessors+ An array of the accessors to the store.
+      #
+      # Examples:
+      #
+      #   class User < ActiveRecord::Base
+      #     store :settings, accessors: [:color, :homepage, login_at: :datetime], coder: JSON
+      #   end
+      def store(store_name, options = {})
+        serialize store_name, IndifferentCoder.new(options[:coder])
+        store_accessor(store_name, *options[:accessors]) if options.key?(:accessors)
+      end
+      # Adds additional accessors to an existing store on this model.
+      #
+      # +store_name+ The name of the store.
+      #
+      # +keys+ The array of the accessors to the store.
+      #
+      # +typed_keys+ The key-to-type hash of the accesors with type to the store.
+      #
+      # Examples:
+      #
+      #   class SuperUser < User
+      #     store_accessor :settings, :privileges, login_at: :datetime
+      #   end
+      def store_accessor(store_name, *keys, **typed_keys)
+        keys = keys.flatten
+        typed_keys = typed_keys.except(keys)
+
+        _define_accessors_methods(store_name, *keys)
+
+        _prepare_local_stored_attributes(store_name, *keys)
+
+        typed_keys.each do |key, type|
+          store_attribute(store_name, key, type)
+        end
+      end
+
+      # Adds additional accessors with a type to an existing store on this model.
+      # Type casting occurs every time you write data through accessor or update store itself
+      # and when object is loaded from database.
+      #
+      # Note that if you update store explicitly then value isn't  type casted.
+      #
+      # +store_name+ The name of the store.
+      #
+      # +name+ The name of the accessor to the store.
+      #
+      # +type+ A symbol such as +:string+ or +:integer+, or a type object
+      # to be used for the accessor.
+      #
+      # +options+ A hash of cast type options such as +precision+, +limit+, +scale+.
+      #
+      # Examples:
+      #
+      #   class MegaUser < User
+      #     store_attribute :settings, :ratio, :integer, limit: 1
+      #     store_attribute :settings, :login_at, :datetime
+      #   end
+      #
+      #   u = MegaUser.new(active: false, login_at: '2015-01-01 00:01', ratio: "63.4608")
+      #
+      #   u.login_at.is_a?(DateTime) # => true
+      #   u.login_at = DateTime.new(2015,1,1,11,0,0)
+      #   u.ratio # => 63
+      #   u.reload
+      #
+      #   # After loading record from db store contains casted data
+      #   u.settings['login_at'] == DateTime.new(2015,1,1,11,0,0) # => true
+      #
+      #   # If you update store explicitly then the value returned
+      #   # by accessor isn't type casted
+      #   u.settings['ration'] = "3.141592653"
+      #   u.ratio # => "3.141592653"
+      #
+      #   # On the other hand, writing through accessor set correct data within store
+      #   u.ratio = "3.14.1592653"
+      #   u.ratio # => 3
+      #   u.settings['ratio'] # => 3
+      #
+      # For more examples on using types, see documentation for ActiveRecord::Attributes.
+      def store_attribute(store_name, name, type, **options)
+        _define_accessors_methods(store_name, name)
+
+        _define_predicate_method(name) if type == :boolean
+
+        decorate_attribute_type(store_name, "typed_accessor_for_#{name}") do |subtype|
+          Type::TypedStore.create_from_type(subtype, name, type, **options)
+        end
+
+        _prepare_local_stored_attributes(store_name, name)
+      end
+
+      def _prepare_local_stored_attributes(store_name, *keys) # :nodoc:
+        # assign new store attribute and create new hash to ensure that each class in the hierarchy
+        # has its own hash of stored attributes.
+        self.local_stored_attributes ||= {}
+        self.local_stored_attributes[store_name] ||= []
+        self.local_stored_attributes[store_name] |= keys
+      end
+
+      def _define_accessors_methods(store_name, *keys) # :nodoc:
+        _store_accessors_module.module_eval do
+          keys.each do |key|
+            define_method("#{key}=") do |value|
+              write_store_attribute(store_name, key, value)
+            end
+
+            define_method(key) do
+              read_store_attribute(store_name, key)
+            end
+          end
+        end
+      end
+
+      def _define_predicate_method(name)
+        _store_accessors_module.module_eval do
+          define_method("#{name}?") do
+            send(name) == true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/store_attribute/active_record/type/typed_store.rb

@@ -0,0 +1,95 @@
+require 'active_record/type'
+
+module ActiveRecord
+  module Type # :nodoc:
+    BASE_TYPES = {
+      boolean: ::ActiveRecord::Type::Boolean,
+      integer: ::ActiveRecord::Type::Integer,
+      string: ::ActiveRecord::Type::String,
+      float: ::ActiveRecord::Type::Float,
+      date: ::ActiveRecord::Type::Date,
+      datetime: ::ActiveRecord::Type::DateTime,
+      decimal: ::ActiveRecord::Type::Decimal
+    }.freeze
+
+    def self.lookup_type(type, options)
+      BASE_TYPES[type.to_sym].try(:new, options) ||
+        ActiveRecord::Base.connection.type_map.lookup(type.to_s, options)
+    end
+
+    class TypedStore < DelegateClass(ActiveRecord::Type::Value) # :nodoc:
+      # Creates +TypedStore+ type instance and specifies type caster
+      # for key.
+      def self.create_from_type(basetype, key, type, **options)
+        typed_store = new(basetype)
+        typed_store.add_typed_key(key, type, **options)
+        typed_store
+      end
+
+      def initialize(subtype)
+        @accessor_types = {}
+        @store_accessor = subtype.accessor
+        super(subtype)
+      end
+
+      def add_typed_key(key, type, **options)
+        type = Type.lookup_type(type, options) if type.is_a?(Symbol)
+        @accessor_types[key.to_s] = type
+      end
+
+      def type_cast_from_database(value)
+        hash = super
+        type_cast_from_user(hash)
+      end
+
+      def type_cast_for_database(value)
+        if value
+          accessor_types.each do |key, type|
+            k = key_to_cast(value, key)
+            value[k] = type.type_cast_for_database(value[k]) unless k.nil?
+          end
+        end
+        super(value)
+      end
+
+      def type_cast_from_user(value)
+        hash = super
+        if hash
+          accessor_types.each do |key, type|
+            hash[key] = type.type_cast_from_user(hash[key]) if hash.key?(key)
+          end
+        end
+        hash
+      end
+
+      def accessor
+        self
+      end
+
+      def write(object, attribute, key, value)
+        value = type_for(key).type_cast_from_user(value) if typed?(key)
+        store_accessor.write(object, attribute, key, value)
+      end
+
+      delegate :read, :prepare, to: :store_accessor
+
+      protected
+
+      # We cannot rely on string keys 'cause user input can contain symbol keys
+      def key_to_cast(val, key)
+        return key if val.key?(key)
+        return key.to_sym if val.key?(key.to_sym)
+      end
+
+      def typed?(key)
+        accessor_types.key?(key.to_s)
+      end
+
+      def type_for(key)
+        accessor_types.fetch(key.to_s)
+      end
+
+      attr_reader :accessor_types, :store_accessor
+    end
+  end
+end

data/lib/store_attribute/active_record.rb

@@ -0,0 +1 @@
+require 'store_attribute/active_record/store'

data/lib/store_attribute/version.rb

@@ -0,0 +1,3 @@
+module StoreAttribute # :nodoc:
+  VERSION = "0.4.0".freeze
+end

data/lib/store_attribute.rb

@@ -0,0 +1,2 @@
+require 'store_attribute/version'
+require 'store_attribute/active_record'

data/spec/cases/store_attribute_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe StoreAttribute do
+  before do
+    @connection = ActiveRecord::Base.connection
+
+    @connection.transaction do
+      @connection.create_table('users') do |t|
+        t.jsonb :jparams, default: {}, null: false
+        t.text :custom
+        t.hstore :hdata, default: {}, null: false
+      end
+    end
+
+    User.reset_column_information
+  end
+
+  after do
+    @connection.drop_table 'users', if_exists: true
+  end
+
+  let(:time) { DateTime.new(2015, 2, 14, 17, 0, 0) }
+  let(:time_str) { '2015-02-14 17:00' }
+  let(:time_str_utc) { '2015-02-14 17:00:00 UTC' }
+
+  context "hstore" do
+    it "typecasts on build" do
+      user = User.new(visible: 't', login_at: time_str)
+      expect(user.visible).to eq true
+      expect(user).to be_visible
+      expect(user.login_at).to eq time
+    end
+
+    it "typecasts on reload" do
+      user = User.new(visible: 't', login_at: time_str)
+      user.save!
+      user = User.find(user.id)
+
+      expect(user.visible).to eq true
+      expect(user).to be_visible
+      expect(user.login_at).to eq time
+    end
+
+    it "works with accessors" do
+      user = User.new
+      user.visible = false
+      user.login_at = time_str
+      user.save!
+
+      user = User.find(user.id)
+
+      expect(user.visible).to be false
+      expect(user).not_to be_visible
+      expect(user.login_at).to eq time
+
+      ron = RawUser.find(user.id)
+      expect(ron.hdata['visible']).to eq 'false'
+      expect(ron.hdata['login_at']).to eq time_str_utc
+    end
+
+    it "handles options" do
+      expect { User.create!(ratio: 1024) }.to raise_error(RangeError)
+    end
+
+    it "YAML roundtrip" do
+      user = User.create!(visible: '0', login_at: time_str)
+      dumped = YAML.load(YAML.dump(user))
+
+      expect(dumped.visible).to be false
+      expect(dumped.login_at).to eq time
+    end
+  end
+
+  context "jsonb" do
+    it "typecasts on build" do
+      jamie = User.new(
+        active: 'true',
+        salary: 3.1999,
+        birthday: '2000-01-01'
+      )
+      expect(jamie).to be_active
+      expect(jamie.salary).to eq 3
+      expect(jamie.birthday).to eq Date.new(2000, 1, 1)
+      expect(jamie.jparams['birthday']).to eq Date.new(2000, 1, 1)
+      expect(jamie.jparams['active']).to eq true
+    end
+
+    it "typecasts on reload" do
+      jamie = User.create!(jparams: { 'active' => '1', 'birthday' => '01/01/2000', 'salary' => '3.14' })
+      jamie = User.find(jamie.id)
+
+      expect(jamie).to be_active
+      expect(jamie.salary).to eq 3
+      expect(jamie.birthday).to eq Date.new(2000, 1, 1)
+      expect(jamie.jparams['birthday']).to eq Date.new(2000, 1, 1)
+      expect(jamie.jparams['active']).to eq true
+    end
+
+    it "works with accessors" do
+      john = User.new
+      john.active = 1
+
+      expect(john).to be_active
+      expect(john.jparams['active']).to eq true
+
+      john.jparams = { active: 'true', salary: '123.123', birthday: '01/01/2012' }
+      expect(john).to be_active
+      expect(john.birthday).to eq Date.new(2012, 1, 1)
+      expect(john.salary).to eq 123
+
+      john.save!
+
+      ron = RawUser.find(john.id)
+      expect(ron.jparams['active']).to eq true
+      expect(ron.jparams['birthday']).to eq '2012-01-01'
+      expect(ron.jparams['salary']).to eq 123
+    end
+
+    it "re-typecast old data" do
+      jamie = User.create!
+      User.update_all('jparams = \'{"active":"1", "salary":"12.02"}\'::jsonb')
+
+      jamie = User.find(jamie.id)
+      expect(jamie).to be_active
+      expect(jamie.salary).to eq 12
+
+      jamie.save!
+
+      ron = RawUser.find(jamie.id)
+      expect(ron.jparams['active']).to eq true
+      expect(ron.jparams['salary']).to eq 12
+    end
+  end
+
+  context "custom types" do
+    it "typecasts on build" do
+      user = User.new(price: "$1")
+      expect(user.price).to eq 100
+    end
+
+    it "typecasts on reload" do
+      jamie = User.create!(custom: { price: '$12' })
+      jamie = User.find(jamie.id)
+
+      expect(jamie.price).to eq 1200
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+if ENV['COVER']
+  require 'simplecov'
+  SimpleCov.root File.join(File.dirname(__FILE__), '..')
+  SimpleCov.start
+end
+
+require 'rspec'
+require 'pry-byebug'
+require 'active_record'
+require 'pg'
+require 'store_attribute'
+
+ActiveRecord::Base.establish_connection(
+  adapter: 'postgresql',
+  database: 'store_attribute_test'
+)
+connection = ActiveRecord::Base.connection
+
+unless connection.extension_enabled?('hstore')
+  connection.enable_extension 'hstore'
+  connection.commit_db_transaction
+end
+
+connection.reconnect!
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/spec/store_attribute/typed_store_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe ActiveRecord::Type::TypedStore do
+  let(:json_type) { ActiveRecord::Type::Serialized.new(ActiveRecord::Type::Text.new, ActiveRecord::Coders::JSON) }
+  let(:yaml_type) do
+    ActiveRecord::Type::Serialized.new(
+      ActiveRecord::Type::Text.new,
+      ActiveRecord::Store::IndifferentCoder.new(
+        ActiveRecord::Coders::YAMLColumn.new(Hash)
+      )
+    )
+  end
+
+  context "with json store" do
+    subject { described_class.new(json_type) }
+
+    describe "#type_cast_from_user" do
+      it "without key types", :aggregate_failures do
+        expect(subject.type_cast_from_user([1, 2])).to eq [1, 2]
+        expect(subject.type_cast_from_user('a' => 'b')).to eq('a' => 'b')
+      end
+
+      it "with type keys" do
+        subject.add_typed_key('date', :date)
+
+        date = ::Date.new(2016, 6, 22)
+        expect(subject.type_cast_from_user(date: '2016-06-22')).to eq('date' => date)
+      end
+    end
+
+    describe "#type_cast_from_database" do
+      it "without key types", :aggregate_failures do
+        expect(subject.type_cast_from_database('[1,2]')).to eq [1, 2]
+        expect(subject.type_cast_from_database('{"a":"b"}')).to eq('a' => 'b')
+      end
+
+      it "with type keys" do
+        subject.add_typed_key('date', :date)
+
+        date = ::Date.new(2016, 6, 22)
+        expect(subject.type_cast_from_database('{"date":"2016-06-22"}')).to eq('date' => date)
+      end
+    end
+
+    describe "#type_cast_for_database" do
+      it "without key types", :aggregate_failures do
+        expect(subject.type_cast_for_database([1, 2])).to eq '[1,2]'
+        expect(subject.type_cast_for_database('a' => 'b')).to eq '{"a":"b"}'
+      end
+
+      it "with type keys" do
+        subject.add_typed_key('date', :date)
+
+        date = ::Date.new(2016, 6, 22)
+        expect(subject.type_cast_for_database(date: date)).to eq '{"date":"2016-06-22"}'
+      end
+
+      it "with type key with option" do
+        subject.add_typed_key('val', :integer, limit: 1)
+
+        expect { subject.type_cast_for_database(val: 1024) }.to raise_error(RangeError)
+      end
+    end
+
+    describe ".create_from_type" do
+      it "creates with valid types", :aggregate_failures do
+        type = described_class.create_from_type(json_type, 'date', :date)
+        new_type = described_class.create_from_type(type, 'val', :integer)
+
+        date = ::Date.new(2016, 6, 22)
+
+        expect(type.type_cast_from_user(date: '2016-06-22', val: '1.2')).to eq('date' => date, 'val' => '1.2')
+        expect(new_type.type_cast_from_user(date: '2016-06-22', val: '1.2')).to eq('date' => date, 'val' => 1)
+      end
+    end
+  end
+
+  context "with yaml coder" do
+    let(:subject) { described_class.new(yaml_type) }
+
+    it "works", :aggregate_failures do
+      subject.add_typed_key('date', :date)
+
+      date = ::Date.new(2016, 6, 22)
+
+      expect(subject.type_cast_from_user(date: '2016-06-22')).to eq('date' => date)
+      expect(subject.type_cast_from_user('date' => '2016-06-22')).to eq('date' => date)
+      expect(subject.type_cast_from_database("---\n:date: 2016-06-22\n")).to eq('date' => date)
+      expect(subject.type_cast_from_database("---\ndate: 2016-06-22\n")).to eq('date' => date)
+      expect(subject.type_cast_for_database(date: date)).to eq "--- !ruby/hash:ActiveSupport::HashWithIndifferentAccess\ndate: 2016-06-22\n"
+      expect(subject.type_cast_for_database('date' => date)).to eq "--- !ruby/hash:ActiveSupport::HashWithIndifferentAccess\ndate: 2016-06-22\n"
+    end
+  end
+end

data/spec/support/money_type.rb

@@ -0,0 +1,12 @@
+class MoneyType < ActiveRecord::Type::Integer
+  def type_cast_from_user(value)
+    if !value.is_a?(Numeric) && value.include?('$')
+      price_in_dollars = value.delete('$').to_f
+      super(price_in_dollars * 100)
+    else
+      super
+    end
+  end
+end
+
+ActiveRecord::Base.connection.type_map.register_type('money_type', MoneyType.new)

data/spec/support/user.rb

@@ -0,0 +1,15 @@
+class RawUser < ActiveRecord::Base
+  self.table_name = 'users'
+end
+
+class User < ActiveRecord::Base
+  store_accessor :jparams, :version, active: :boolean, salary: :integer
+  store_attribute :jparams, :birthday, :date
+
+  store :custom, accessors: [price: :money_type]
+
+  store_accessor :hdata, visible: :boolean
+
+  store_attribute :hdata, :ratio, :integer, limit: 1
+  store_attribute :hdata, :login_at, :datetime
+end

data/store_attribute.gemspec

@@ -0,0 +1,27 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "store_attribute/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "store_attribute"
+  s.version     = StoreAttribute::VERSION
+  s.authors     = ["palkan"]
+  s.email       = ["dementiev.vm@gmail.com"]
+  s.homepage    = "http://github.com/palkan/store_attribute"
+  s.summary     = "ActiveRecord extension which adds typecasting to store accessors"
+  s.description = "ActiveRecord extension which adds typecasting to store accessors"
+  s.license     = "MIT"
+
+  s.files         = `git ls-files`.split($/)
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "activerecord", ">=4.2.0"
+
+  s.add_development_dependency "pg", "~>0.18"
+  s.add_development_dependency "rake", "~> 10.1"
+  s.add_development_dependency "simplecov", ">= 0.3.8"
+  s.add_development_dependency "pry-byebug"
+  s.add_development_dependency "rspec", "~> 3.4.0"
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: store_attribute
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- palkan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.8
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  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: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+description: ActiveRecord extension which adds typecasting to store accessors
+email:
+- dementiev.vm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bench/bench.rb
+- bench/setup.rb
+- bin/console
+- bin/setup
+- gemfiles/rails-edge.gemfile
+- gemfiles/rails42.gemfile
+- lib/store_attribute.rb
+- lib/store_attribute/active_record.rb
+- lib/store_attribute/active_record/store.rb
+- lib/store_attribute/active_record/type/typed_store.rb
+- lib/store_attribute/version.rb
+- spec/cases/store_attribute_spec.rb
+- spec/spec_helper.rb
+- spec/store_attribute/typed_store_spec.rb
+- spec/support/money_type.rb
+- spec/support/user.rb
+- store_attribute.gemspec
+homepage: http://github.com/palkan/store_attribute
+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.6.4
+signing_key: 
+specification_version: 4
+summary: ActiveRecord extension which adds typecasting to store accessors
+test_files: []