activerecord-typedstore 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8790af5ac7b68a121e6d5cd21305421b49b5799c
-  data.tar.gz: 0afe8bfce070b6f1d87f5c3f39334870ce9decc2
+  metadata.gz: 960e7c0f770dab59201ece58bcfa91927216eeea
+  data.tar.gz: 5a9f38f6153167050d7e5a57bfcba6fb717dd9e6
 SHA512:
-  metadata.gz: 10d34e86b936c3c9d1f85dd35c6d2414f18c0c4346784f39ce9e4e741c02b23a8657fed819b8ed39a63c9ffb5d36b8b78b559dd2a877e1be64352a5e3b9b9cc8
-  data.tar.gz: d9954012cc7fbec9501a19b7b10e8091c9d3447fc7413cbd09023d822e75f7a00ee505c3712720bac1b8de8d47d6a9ad8b4f5c7f1ca6265a09b454f0328c1621
+  metadata.gz: 363573dd39996321d853554cc49c1712966a515e8260bfaa9e6b6bf2763b8d5600b516e76559eff1e480c4527f43f472e403573b9a44b5b986307550345a3455
+  data.tar.gz: 2b7945d7a87685f0178cca67c84eb662feb21cafe2d944a4883265917508dacf70f75bb1cffef473338dd870c5f44c3069f2f16f2cc4cf3c34c0e66ce077707f

data/.travis.yml

@@ -4,6 +4,7 @@ rvm:
 gemfile:
   - gemfiles/Gemfile.ar-3.2
   - gemfiles/Gemfile.ar-4.0
+  - gemfiles/Gemfile.ar-4.1
   - gemfiles/Gemfile.ar-edge
 
 before_script:
@@ -12,3 +13,7 @@ before_script:
 env:
   - TIMEZONE_AWARE=1 POSTGRES=1 MYSQL=1 POSTGRES_URL=$(curl http://api.postgression.com)
   - TIMEZONE_AWARE=0 POSTGRES=1 MYSQL=1 POSTGRES_URL=$(curl http://api.postgression.com)
+
+matrix:
+  allow_failures:
+    - gemfile: gemfiles/Gemfile.ar-edge

data/README.md

@@ -3,6 +3,7 @@
 [![Build Status](https://secure.travis-ci.org/byroot/activerecord-typedstore.png)](http://travis-ci.org/byroot/activerecord-typedstore)
 [![Code Climate](https://codeclimate.com/github/byroot/activerecord-typedstore.png)](https://codeclimate.com/github/byroot/activerecord-typedstore)
 [![Coverage Status](https://coveralls.io/repos/byroot/activerecord-typedstore/badge.png)](https://coveralls.io/r/byroot/activerecord-typedstore)
+[![Gem Version](https://badge.fury.io/rb/activerecord-typedstore.png)](http://badge.fury.io/rb/activerecord-typedstore)
 
 [ActiveRecord::Store](http://api.rubyonrails.org/classes/ActiveRecord/Store.html) but with typed attributes.
 
@@ -78,6 +79,19 @@ shop.save
 shop.reload
 shop.settings[:unknown] # => 'Hello World'
 
+# If you only want type casting and default handling without accessors
+
+# you can disable them store wide
+typed_store :settings, accessors: false do |s|
+  # ...
+end
+
+# or on a per attribute basis
+typed_store :settings do |s|
+  s.integer :age
+  s.string :postal_code, accessor: false
+end
+
 ```
 
 Type casting rules and attribute behavior are exactly the same as a for real database columns.
@@ -92,8 +106,3 @@ If not, please fill an issue.
 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
-
-## TODO
-
-- HStore support with ActiveRecord 4.1.0.beta (master)
-- Handle casting and default at the store layer, so accessors are not mandatory anymore. See #4

data/gemfiles/Gemfile.ar-4.1

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 4.1.0.beta1'
+gem 'bundler', '~> 1.3'
+gem 'rake'
+gem 'rspec'
+gem 'sqlite3'
+gem 'pg', '~> 0.11'
+gem 'mysql2'
+gem 'database_cleaner'
+gem 'coveralls', require: false
+gem 'debugger'

data/lib/active_record/typed_store/ar_32_fallbacks.rb

@@ -1,3 +1,24 @@
+class ActiveRecord::Store::IndifferentCoder
+  # Backport from rails 4.0
+  def initialize(coder_or_class_name)
+    @coder =
+      if coder_or_class_name.respond_to?(:load) && coder_or_class_name.respond_to?(:dump)
+        coder_or_class_name
+      else
+        ActiveRecord::Coders::YAMLColumn.new(coder_or_class_name || Object)
+      end
+  end
+
+  def dump(obj)
+    @coder.dump self.class.as_indifferent_hash(obj)
+  end
+
+  def load(yaml)
+    self.class.as_indifferent_hash @coder.load(yaml)
+  end
+
+end
+
 module ActiveRecord::TypedStore
 
   module AR32Fallbacks
@@ -11,7 +32,7 @@ module ActiveRecord::TypedStore
     module ClassMethods
 
       def typed_store(store_attribute, dsl)
-        _ar_32_fallback_accessors(store_attribute, dsl.column_names)
+        _ar_32_fallback_accessors(store_attribute, dsl.accessors)
       end
 
       protected
@@ -34,9 +55,9 @@ module ActiveRecord::TypedStore
         attribute_method_matchers_cache.clear
       end
 
-      def _ar_32_fallback_accessors(store_attribute, column_names)
-        column_names.each do |name|
-          _ar_32_fallback_accessor(store_attribute, name)
+      def _ar_32_fallback_accessors(store_attribute, accessors)
+        accessors.each do |accessor|
+          _ar_32_fallback_accessor(store_attribute, accessor)
         end
       end
 

data/lib/active_record/typed_store/coder.rb

@@ -0,0 +1,22 @@
+module ActiveRecord::TypedStore
+
+  class Coder < ::ActiveRecord::Store::IndifferentCoder
+
+    class << self
+
+      def create(store_class)
+        Class.new(self) do
+          @store_class = store_class
+        end
+      end
+
+      def as_indifferent_hash(obj)
+        return obj if obj.is_a?(@store_class)
+        @store_class.new(obj)
+      end
+
+    end
+
+  end
+
+end

data/lib/active_record/typed_store/column.rb

@@ -10,6 +10,11 @@ module ActiveRecord::TypedStore
       @default = extract_default(options.fetch(:default, nil))
       @null = options.fetch(:null, true)
       @blank = options.fetch(:blank, true)
+      @accessor = options.fetch(:accessor, true)
+    end
+
+    def accessor?
+      @accessor
     end
 
     def cast(value)

data/lib/active_record/typed_store/dsl.rb

@@ -4,18 +4,19 @@ module ActiveRecord::TypedStore
 
     attr_reader :columns
 
-    def initialize
+    def initialize(accessors=true)
+      @accessors = accessors
       @columns = []
       yield self
     end
 
-    def column_names
-      @columns.map(&:name)
+    def accessors
+      @columns.select(&:accessor?).map(&:name)
     end
 
     [:string, :integer, :float, :decimal, :datetime, :date, :boolean, :any].each do |type|
       define_method(type) do |name, options={}|
-        @columns << Column.new(name, type, options)
+        @columns << Column.new(name, type, options.reverse_merge(accessor: @accessors))
       end
     end
 

data/lib/active_record/typed_store/extension.rb

@@ -1,5 +1,6 @@
 require 'active_record/typed_store/column'
 require 'active_record/typed_store/dsl'
+require 'active_record/typed_store/typed_hash'
 
 module ActiveRecord::TypedStore
   AR_VERSION = Gem::Version.new(ActiveRecord::VERSION::STRING)
@@ -17,18 +18,15 @@ module ActiveRecord::TypedStore
     module ClassMethods
 
       def typed_store(store_attribute, options={}, &block)
-        dsl = DSL.new(&block)
+        dsl = DSL.new(options.fetch(:accessors, true), &block)
 
-        if hstore?(store_attribute)
-          store_accessor(store_attribute, dsl.column_names)
-        else
-          store(store_attribute, options.merge(accessors: dsl.column_names))
-        end
+        serialize store_attribute, create_coder(store_attribute, dsl.columns).new(options[:coder])
+        store_accessor(store_attribute, dsl.accessors)
 
         register_typed_store_columns(store_attribute, dsl.columns)
         super(store_attribute, dsl) if defined?(super)
 
-        dsl.column_names.each { |c| define_store_attribute_queries(store_attribute, c) }
+        dsl.accessors.each { |c| define_store_attribute_queries(store_attribute, c) }
 
         dsl
       end
@@ -40,6 +38,12 @@ module ActiveRecord::TypedStore
 
       private
 
+      def create_coder(store_attribute, columns)
+        store_class = TypedHash.create(columns)
+        const_set("#{store_attribute}_hash".camelize, store_class)
+        Coder.create(store_class)
+      end
+
       def register_typed_store_columns(store_attribute, columns)
         self.typed_stores ||= {}
         self.typed_store_attributes ||= {}
@@ -49,12 +53,16 @@ module ActiveRecord::TypedStore
       end
 
       def define_typed_store_attribute_methods
-        return unless typed_store_attributes
-        typed_store_attributes.keys.each do |attribute|
+        store_accessors.each do |attribute|
           define_virtual_attribute_method(attribute)
         end
       end
 
+      def store_accessors
+        return [] unless typed_store_attributes
+        typed_store_attributes.values.select(&:accessor?).map(&:name).map(&:to_s)
+      end
+
       def hstore?(store_attribute)
         columns_hash[store_attribute.to_s].try(:type) == :hstore
       end
@@ -72,11 +80,6 @@ module ActiveRecord::TypedStore
 
     end
 
-    def reload(*)
-      reload_stores!
-      super
-    end
-
     protected
 
     def write_store_attribute(store_attribute, key, value)
@@ -86,18 +89,12 @@ module ActiveRecord::TypedStore
       end
 
       previous_value = read_store_attribute(store_attribute, key)
-      casted_value = cast_store_attribute(store_attribute, key, value)
-      attribute_will_change!(key.to_s) if casted_value != previous_value
-      super(store_attribute, key, casted_value)
+      attribute_will_change!(key.to_s) if value != previous_value
+      super
     end
 
     private
 
-    def cast_store_attribute(store_attribute, key, value)
-      column = store_column(store_attribute, key)
-      column ? column.cast(value) : value
-    end
-
     def store_column(store_attribute, key)
       store = store_columns(store_attribute)
       store && store[key]
@@ -107,43 +104,6 @@ module ActiveRecord::TypedStore
       self.class.typed_stores.try(:[], store_attribute)
     end
 
-    def if_store_uninitialized(store_attribute)
-      initialized = "@_#{store_attribute}_initialized"
-      unless instance_variable_get(initialized)
-        yield
-        instance_variable_set(initialized, true)
-      end
-    end
-
-    def reload_stores!
-      return unless self.class.typed_stores
-      self.class.typed_stores.keys.each do |store_attribute|
-        instance_variable_set("@_#{store_attribute}_initialized", false)
-      end
-    end
-
-    def initialize_store_attribute(store_attribute)
-      store = defined?(super) ? super : send(store_attribute)
-      store.tap do |store|
-        if_store_uninitialized(store_attribute) do
-          if columns = store_columns(store_attribute)
-            initialize_store(store, columns.values)
-          end
-        end
-      end
-    end
-
-    def initialize_store(store, columns)
-      columns.each do |column|
-        if store.has_key?(column.name)
-          store[column.name] = column.cast(store[column.name])
-        else
-          store[column.name] = column.default if column.has_default?
-        end
-      end
-      store
-    end
-
     # heavilly inspired from ActiveRecord::Base#query_attribute
     def query_store_attribute(store_attribute, key)
       value = read_store_attribute(store_attribute, key)
@@ -165,7 +125,8 @@ module ActiveRecord::TypedStore
   end
 
   require 'active_record/typed_store/ar_32_fallbacks' if IS_AR_3_2
-  require 'active_record/typed_store/ar_41_fallbacks' if IS_AR_4_1
+  require 'active_record/typed_store/coder'
+
   unless IS_AR_3_2
     ActiveModel::AttributeMethods::ClassMethods.send(:alias_method, :define_virtual_attribute_method, :define_attribute_method)
   end

data/lib/active_record/typed_store/typed_hash.rb

@@ -0,0 +1,63 @@
+module ActiveRecord::TypedStore
+
+  class TypedHash < HashWithIndifferentAccess
+
+    class << self
+
+      attr_reader :columns
+
+      def create(columns)
+        Class.new(self) do
+          @columns = columns.index_by { |c| c.name.to_s }
+        end
+      end
+
+    end
+
+    def initialize(constructor={})
+      super()
+      update(defaults_hash)
+      update(constructor) if constructor.is_a?(Hash)
+    end
+
+    def []=(key, value)
+      super(key, cast_value(key, value))
+    end
+    alias_method :store, :[]=
+
+    def merge!(other_hash)
+      other_hash.each_pair do |key, value|
+        if block_given? && key?(key)
+          value = yield(convert_key(key), self[key], value)
+        end
+        self[convert_key(key)] = convert_value(value)
+      end
+      self
+    end
+    alias_method :update, :merge!
+
+    private
+
+    delegate :columns, to: 'self.class'
+
+    def defaults_hash
+      Hash[self.class.columns.values.select(&:has_default?).map { |c| [c.name, c.default] }]
+    end
+
+    def cast_value(key, value)
+      key = convert_key(key)
+      column = columns[key]
+      return value unless columns
+
+      casted_value = column.cast(value)
+
+      if casted_value.nil? && !column.null && column.has_default?
+        return column.default
+      end
+
+      casted_value
+    end
+
+  end
+
+end

data/lib/active_record/typed_store/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module TypedStore
-    VERSION = '0.3.2'
+    VERSION = '0.4.0'
   end
 end

data/spec/active_record/typed_store/typed_hash_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+describe ActiveRecord::TypedStore::TypedHash do
+
+  def create_hash_class(*args)
+    described_class.create([ActiveRecord::TypedStore::Column.new(*args)])
+  end
+
+  def build_hash(*args)
+    create_hash_class(*args).new
+  end
+
+  let(:hash) { build_hash(*column) }
+
+  let(:hash_class) { create_hash_class(*column) }
+
+  context 'nullable column without default' do
+
+    let(:column) { ['age', :integer] }
+
+    describe '.new' do
+
+      it 'apply casting' do
+        hash = hash_class.new(age: '24')
+        expect(hash[:age]).to be == 24
+      end
+
+    end
+
+    describe '#initialize' do
+
+      it 'has nil as default value' do
+        expect(hash[:age]).to be_nil
+      end
+
+    end
+
+    describe '#[]=' do
+
+      it 'apply casting' do
+        hash[:age] = '24'
+        expect(hash[:age]).to be == 24
+      end
+
+      it 'can be nil' do
+        hash[:age] = nil
+        expect(hash[:age]).to be_nil
+      end
+
+    end
+
+    describe '#merge!' do
+
+      it 'apply casting' do
+        hash.merge!(age: '24')
+        expect(hash[:age]).to be == 24
+      end
+
+      it 'can be nil' do
+        hash.merge!(age: nil)
+        expect(hash[:age]).to be_nil
+      end
+
+    end
+
+  end
+
+  context 'nullable column with default' do
+
+    let(:column) { ['age', :integer, default: 42] }
+
+    describe '#initialize' do
+
+      it 'has the default value' do
+        expect(hash[:age]).to be == 42
+      end
+
+    end
+
+    describe '#[]=' do
+
+      it 'apply casting' do
+        hash[:age] = '24'
+        expect(hash[:age]).to be == 24
+      end
+
+      it 'can be nil' do
+        hash[:age] = nil
+        expect(hash[:age]).to be_nil
+      end
+
+    end
+
+    describe '#merge!' do
+
+      it 'apply casting' do
+        hash.merge!(age: '24')
+        expect(hash[:age]).to be == 24
+      end
+
+      it 'can be nil' do
+        hash.merge!(age: nil)
+        expect(hash[:age]).to be_nil
+      end
+
+    end
+
+  end
+
+  context 'non nullable column with default' do
+
+    let(:column) { ['age', :integer, null: false, default: 42] }
+
+    describe '#intialize' do
+
+      it 'has the default value' do
+        expect(hash[:age]).to be == 42
+      end
+
+    end
+
+    describe '#[]=' do
+
+      it 'apply casting' do
+        hash[:age] = '24'
+        expect(hash[:age]).to be == 24
+      end
+
+      it 'cannot be nil' do
+        hash[:age] = nil
+        expect(hash[:age]).to be == 42
+      end
+
+    end
+
+    describe '#merge!' do
+
+      it 'apply casting' do
+        hash.merge!(age: '24')
+        expect(hash[:age]).to be == 24
+      end
+
+      it 'cannot be nil' do
+        hash.merge!(age: nil)
+        expect(hash[:age]).to be == 42
+      end
+
+    end
+
+  end
+
+  context 'non blankable column with default' do
+
+    let(:column) { ['source', :string, blank: false, default: 'web'] }
+
+    describe '#intialize' do
+
+      it 'has the default value' do
+        expect(hash[:source]).to be == 'web'
+      end
+
+    end
+
+    describe '#[]=' do
+
+      it 'apply casting' do
+        hash[:source] = :mailing
+        expect(hash[:source]).to be == 'mailing'
+      end
+
+      it 'cannot be nil' do
+        hash[:source] = nil
+        expect(hash[:source]).to be == 'web'
+      end
+
+      it 'cannot be blank' do
+        hash[:source] = ''
+        expect(hash[:source]).to be == 'web'
+      end
+
+    end
+
+    describe '#merge!' do
+
+      it 'apply casting' do
+        hash.merge!(source: :mailing)
+        expect(hash[:source]).to be == 'mailing'
+      end
+
+      it 'cannot be nil' do
+        hash.merge!(source: nil)
+        expect(hash[:source]).to be == 'web'
+      end
+
+      it 'cannot be blank' do
+        hash.merge!(source: '')
+        expect(hash[:source]).to be == 'web'
+      end
+
+    end
+
+  end
+
+end

data/spec/active_record/typed_store_spec.rb

@@ -447,39 +447,6 @@ shared_examples 'a store' do |retain_type=true|
 
   let(:model) { described_class.new }
 
-  describe 'initialization' do
-
-    it 'is done only once' do
-      model.should_receive(:initialize_store).once
-      3.times do
-        model.age = (rand * 100).to_i
-        model.age
-      end
-    end
-
-    it 'is done again after a reload' do
-      model.save
-
-      model.should_receive(:initialize_store).twice
-      3.times do
-        model.age = (rand * 100).to_i
-        model.age
-      end
-      model.reload
-      3.times do
-        model.age = (rand * 100).to_i
-        model.age
-      end
-    end
-
-    it 'is not performe if no store attributes are accessed' do
-      model.should_not_receive(:initialize_store)
-      model.update_attributes(untyped_settings: {foo: :bar})
-      model.update_attributes(untyped_settings: {})
-    end
-
-  end
-
   describe 'attributes' do
 
     it 'retrieve default if assigned nil and null not allowed' do
@@ -494,6 +461,27 @@ shared_examples 'a store' do |retain_type=true|
 
   end
 
+  describe 'attributes without accessors' do
+
+    it 'cannot be accessed as a model attribute' do
+      expect(model).to_not respond_to :country
+      expect(model).to_not respond_to :country=
+    end
+
+    it 'cannot be queried' do
+      expect(model).to_not respond_to :country?
+    end
+
+    it 'cannot be reset' do
+      expect(model).to_not respond_to :reset_country!
+    end
+
+    it 'still has casting a default handling' do
+      expect(model.settings[:country]).to be == 'Canada'
+    end
+
+  end
+
   describe '`any` attributes' do
 
     it 'accept any type' do

data/spec/support/models.rb

@@ -48,6 +48,7 @@ def define_store_columns(t)
   define_columns(t)
   t.any :author
   t.any :source, blank: false, default: 'web'
+  t.string :country, blank: false, default: 'Canada', accessor: false
 end
 
 class CreateAllTables < ActiveRecord::Migration
@@ -171,10 +172,23 @@ class JsonTypedStoreModel < ActiveRecord::Base
   end
 end
 
+module MarshalCoder
+  extend self
+
+  def load(serial)
+    Marshal.load(Base64.decode64(serial))
+  end
+
+  def dump(value)
+    Base64.encode64(Marshal.dump(value))
+  end
+
+end
+
 class MarshalTypedStoreModel < ActiveRecord::Base
   establish_connection 'test_sqlite3'
   store :untyped_settings, accessors: [:title]
-  typed_store :settings, coder: ColumnCoder.new(Marshal) do |s|
+  typed_store :settings, coder: ColumnCoder.new(MarshalCoder) do |s|
     define_store_columns(s)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-typedstore
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Jean Boussier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-14 00:00:00.000000000 Z
+date: 2013-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -153,15 +153,18 @@ files:
 - activerecord-typedstore.gemspec
 - gemfiles/Gemfile.ar-3.2
 - gemfiles/Gemfile.ar-4.0
+- gemfiles/Gemfile.ar-4.1
 - gemfiles/Gemfile.ar-edge
 - lib/active_record/typed_store.rb
 - lib/active_record/typed_store/ar_32_fallbacks.rb
-- lib/active_record/typed_store/ar_41_fallbacks.rb
+- lib/active_record/typed_store/coder.rb
 - lib/active_record/typed_store/column.rb
 - lib/active_record/typed_store/dsl.rb
 - lib/active_record/typed_store/extension.rb
+- lib/active_record/typed_store/typed_hash.rb
 - lib/active_record/typed_store/version.rb
 - lib/activerecord-typedstore.rb
+- spec/active_record/typed_store/typed_hash_spec.rb
 - spec/active_record/typed_store_spec.rb
 - spec/spec_helper.rb
 - spec/support/database_cleaner.rb
@@ -191,6 +194,7 @@ signing_key:
 specification_version: 4
 summary: ActiveRecord::Store but with type definition
 test_files:
+- spec/active_record/typed_store/typed_hash_spec.rb
 - spec/active_record/typed_store_spec.rb
 - spec/spec_helper.rb
 - spec/support/database_cleaner.rb

data/lib/active_record/typed_store/ar_41_fallbacks.rb

@@ -1,26 +0,0 @@
-module ActiveRecord::TypedStore
-
-  module AR41Fallbacks
-
-    private
-
-    module HashAccessorPatch
-
-      def self.extended(hash_accessor)
-        hash_accessor.singleton_class.alias_method_chain :prepare, :initialization
-      end
-
-      protected
-
-      def prepare_with_initialization(object, store_attribute)
-        prepare_without_initialization(object, store_attribute)
-        object.send(:initialize_store_attribute, store_attribute)
-      end
-
-    end
-
-    ActiveRecord::Store::HashAccessor.extend(HashAccessorPatch)
-    ActiveRecord::Store::IndifferentHashAccessor.extend(HashAccessorPatch)
-  end
-
-end