activerecord-typedstore 0.6.1 → 1.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 855709ac9aceae5da46732cf436026babd98f1da
-  data.tar.gz: 33046bf44a228c713084a6858e27dca3a9a94602
+  metadata.gz: 64a197e045ec0a6c19581176c6a62aaf1800ce77
+  data.tar.gz: ffcf6bcc94d684da15ed877cf9bda5244934145d
 SHA512:
-  metadata.gz: 79c9e26d0c8b8ce37186c2e7dcc2ed0e9757f227dec41ee55510d3363834b458c87502c6852058e1dc6f3b0fae285fd686350691ec6f32d38ed36441ed05f822
-  data.tar.gz: 449c5e918d80c979e4af8940c3aeea7097edb82b46c9d6ec55ae1182787e6090fc5861b770c75b85c5df0a2b915b785d274b19eb01e6139abb991d7e43f7d4ed
+  metadata.gz: ac1eca590e2d1e0daea3a72281219ae43d0ad47c1376bd5f155b1e66ef93e8a6cd3f0403d94d7a92de1791846b9b9df19cf1c017138eb37e767d1ad46dda2da5
+  data.tar.gz: 99169aeeafe4c40c39357d16e8cf6dd54de65fa97a9213635a686d5afe0da1848b00735f55fd73c77b4bd8be165c2b949b287d76334a2a82200732800be36f25

data/.travis.yml

@@ -1,13 +1,10 @@
 language: ruby
 
 rvm:
-  - 2.0
   - 2.1
-  - 2.2
+  - 2.2.3
+  - 2.3.0
 gemfile:
-  - gemfiles/Gemfile.ar-3.2
-  - gemfiles/Gemfile.ar-4.0
-  - gemfiles/Gemfile.ar-4.1
   - gemfiles/Gemfile.ar-4.2
   - gemfiles/Gemfile.ar-edge
 
@@ -19,16 +16,8 @@ addons:
   postgresql: 9.3
 
 sudo: false
+cache: bundler
 
 before_script:
   - mysql -e 'create database typed_store_test;'
   - psql -c 'create database typed_store_test;' -U postgres
-
-matrix:
-  allow_failures:
-    - gemfile: gemfiles/Gemfile.ar-edge
-  exclude:
-   - gemfile: gemfiles/Gemfile.ar-edge
-     rvm: 2.1
-   - gemfile: gemfiles/Gemfile.ar-edge
-     rvm: 2.0

data/activerecord-typedstore.gemspec

@@ -18,14 +18,14 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'activerecord', '>= 3.2', '< 5'
+  spec.add_dependency 'activerecord', '>= 4.2', '< 5.1'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake', '~> 10'
   spec.add_development_dependency 'rspec', '~> 3'
   spec.add_development_dependency 'coveralls', '~> 0'
-  spec.add_development_dependency 'sqlite3', '~> 0'
-  spec.add_development_dependency 'pg', '~> 0'
-  spec.add_development_dependency 'mysql2', '~> 0'
-  spec.add_development_dependency 'database_cleaner', '~> 0'
+  spec.add_development_dependency 'sqlite3', '~> 1'
+  spec.add_development_dependency 'pg', '~> 0.18'
+  spec.add_development_dependency 'mysql2', '> 0.3'
+  spec.add_development_dependency 'database_cleaner', '~> 1'
 end

data/gemfiles/Gemfile.ar-3.2

@@ -6,6 +6,6 @@ gem 'rake'
 gem 'rspec'
 gem 'sqlite3'
 gem 'pg', '~> 0.11'
-gem 'mysql2'
+gem 'mysql2', '~> 0.3.10'
 gem 'database_cleaner'
 gem 'coveralls', require: false

data/gemfiles/Gemfile.ar-4.0

@@ -6,6 +6,6 @@ gem 'rake'
 gem 'rspec'
 gem 'sqlite3'
 gem 'pg', '~> 0.11'
-gem 'mysql2'
+gem 'mysql2', '~> 0.3.10'
 gem 'database_cleaner'
 gem 'coveralls', require: false

data/gemfiles/Gemfile.ar-4.1

@@ -6,6 +6,6 @@ gem 'rake'
 gem 'rspec'
 gem 'sqlite3'
 gem 'pg', '~> 0.11'
-gem 'mysql2'
+gem 'mysql2', '~> 0.3.13'
 gem 'database_cleaner'
 gem 'coveralls', require: false

data/gemfiles/Gemfile.ar-4.2

@@ -6,6 +6,6 @@ gem 'rake'
 gem 'rspec'
 gem 'sqlite3'
 gem 'pg', '~> 0.11'
-gem 'mysql2'
+gem 'mysql2', ['>= 0.3.13', '< 0.5']
 gem 'database_cleaner'
 gem 'coveralls', require: false

data/gemfiles/Gemfile.ar-edge

@@ -1,11 +1,12 @@
 source 'https://rubygems.org'
 
-gem 'rails', github: 'rails/rails'
+gem 'activerecord', github: 'rails/rails'
+gem 'arel', github: 'rails/arel'
 gem 'bundler', '~> 1.3'
 gem 'rake'
 gem 'rspec'
 gem 'sqlite3'
 gem 'pg', '~> 0.11'
-gem 'mysql2'
+gem 'mysql2', ['>= 0.3.13', '< 0.5']
 gem 'database_cleaner'
 gem 'coveralls', require: false

data/lib/active_record/typed_store/dsl.rb

@@ -1,29 +1,31 @@
-module ActiveRecord::TypedStore
+require 'active_record/typed_store/field'
 
+module ActiveRecord::TypedStore
   class DSL
+    attr_reader :fields, :coder
 
-    attr_reader :columns
-
-    def initialize(accessors=true)
-      @accessors = accessors
-      @columns = []
+    def initialize(options)
+      @coder = options.fetch(:coder) { default_coder }
+      @fields = {}
       yield self
     end
 
-    def accessors
-      @columns.select(&:accessor?).map(&:name)
+    def default_coder
+      ActiveRecord::Coders::YAMLColumn.new
     end
 
-    [:string, :text, :integer, :float, :datetime, :date, :boolean, :any].each do |type|
-      define_method(type) do |name, options = {}|
-        @columns << Column.new(name, type, {accessor: @accessors}.merge(options))
-      end
+    def accessors
+      @fields.values.select { |v| v.accessor }.map(&:name)
     end
 
-    def decimal(name, options = {})
-      @columns << Column.new(name, :decimal, {accessor: @accessors, limit: 20, scale: 6}.merge(options))
-    end
+    delegate :keys, to: :@fields
 
+    NO_DEFAULT_GIVEN = Object.new
+    [:string, :text, :integer, :float, :datetime, :date, :boolean, :decimal, :any].each do |type|
+      define_method(type) do |name, **options|
+        @fields[name] = Field.new(name, type, options)
+      end
+    end
+    alias_method :date_time, :datetime
   end
-
 end

data/lib/active_record/typed_store/extension.rb

@@ -1,40 +1,36 @@
-require 'active_record/typed_store/column'
 require 'active_record/typed_store/dsl'
+require 'active_record/typed_store/type'
 require 'active_record/typed_store/typed_hash'
 
 module ActiveRecord::TypedStore
-  AR_VERSION = Gem::Version.new(ActiveRecord::VERSION::STRING)
-  IS_AR_3_2 = AR_VERSION < Gem::Version.new('4.0')
-  IS_AR_4_1 = AR_VERSION >= Gem::Version.new('4.1') && AR_VERSION < Gem::Version.new('4.2.0')
-  IS_AR_4_2 = AR_VERSION >= Gem::Version.new('4.2.0')
-
   module Extension
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :typed_stores, instance_accessor: false
-      class_attribute :typed_store_attributes, instance_accessor: false
+      class_attribute :typed_stores
     end
 
     module ClassMethods
+      def store_accessors
+        return [] unless typed_stores
+        typed_stores.values.map(&:accessors).flatten
+      end
 
       def typed_store(store_attribute, options={}, &block)
-        dsl = DSL.new(options.fetch(:accessors, true), &block)
+        dsl = DSL.new(options, &block)
+        self.typed_stores = {}
+        self.typed_stores[store_attribute] = dsl
 
-        serialize store_attribute, create_coder(store_attribute, dsl.columns).new(options[:coder])
-        store_accessor(store_attribute, dsl.accessors)
+        typed_klass = TypedHash.create(dsl.fields.values)
+        const_set("#{store_attribute}_hash".camelize, typed_klass)
 
-        register_typed_store_columns(store_attribute, dsl.columns)
-        super(store_attribute, dsl) if defined?(super)
-
-        dsl.accessors.each { |c| define_store_attribute_queries(store_attribute, c) }
-
-        dsl
+        attribute(store_attribute, Type.new(typed_klass, dsl.coder))
+        store_accessor(store_attribute, dsl.accessors)
       end
 
       def define_attribute_methods
         super
-        define_typed_store_attribute_methods
+        define_typed_store_attribute_methods if typed_stores
       end
 
       def undefine_attribute_methods # :nodoc:
@@ -42,28 +38,10 @@ module ActiveRecord::TypedStore
         @typed_store_attribute_methods_generated = false
       end
 
-      private
-
-      def create_coder(store_attribute, columns)
-        store_class = TypedHash.create(columns)
-        const_set("#{store_attribute}_hash".camelize, store_class)
-        coder_class = Coder.create(store_class)
-        const_set("#{store_attribute}_coder".camelize, coder_class)
-        coder_class
-      end
-
-      def register_typed_store_columns(store_attribute, columns)
-        self.typed_stores ||= {}
-        self.typed_store_attributes ||= {}
-        typed_stores[store_attribute] ||= {}
-        typed_stores[store_attribute].merge!(columns.index_by(&:name))
-        typed_store_attributes.merge!(columns.index_by { |c| c.name.to_s })
-      end
-
       def define_typed_store_attribute_methods
         return if @typed_store_attribute_methods_generated
         store_accessors.each do |attribute|
-          define_virtual_attribute_method(attribute)
+          define_attribute_method(attribute.to_s)
           undefine_before_type_cast_method(attribute)
         end
         @typed_store_attribute_methods_generated = true
@@ -74,120 +52,40 @@ module ActiveRecord::TypedStore
         method = "#{attribute}_before_type_cast"
         undef_method(method) if method_defined?(method)
       end
-
-      def store_accessors
-        return [] unless typed_store_attributes
-        typed_store_attributes.values.select(&:accessor?).map(&:name).map(&:to_s)
-      end
-
-      def create_time_zone_conversion_attribute?(name, column)
-        column ||= typed_store_attributes[name]
-        super(name, column)
-      end
-
-      def define_store_attribute_queries(store_attribute, column_name)
-        define_method("#{column_name}?") do
-          query_store_attribute(store_attribute, column_name)
-        end
-      end
-
-    end
-
-    protected
-
-    if IS_AR_4_2
-      def attribute_method?(attr_name)
-        super || store_attribute_method?(attr_name)
-      end
-    end
-
-    def store_attribute_method?(attr_name)
-      return unless self.class.typed_store_attributes
-      store_attribute = self.class.typed_store_attributes[attr_name]
-      store_attribute && store_attribute.accessor?
     end
 
-    def write_store_attribute(store_attribute, key, value)
-      column = store_column(store_attribute, key)
-      if column.try(:type) == :datetime && self.class.time_zone_aware_attributes && value.respond_to?(:in_time_zone)
-        value = value.in_time_zone
-      end
-
-      previous_value = read_store_attribute(store_attribute, key)
-      new_value = column ? column.type_cast(value) : value
-      attribute_will_change!(key.to_s) if new_value != previous_value
+    def clear_attribute_change(attr_name)
+      return if self.class.store_accessors.include?(attr_name.to_sym)
       super
     end
 
-    private
-
-    if IS_AR_4_2
-      def match_attribute_method?(method_name)
-        match = super
-        return unless match
-        return if match.target == 'attribute_before_type_cast'.freeze && store_attribute_method?(match.attr_name)
-        match
-      end
-
-      def coder_for(attr_name)
-        column = self.class.columns_hash[attr_name.to_s]
-        return unless column && column.cast_type.is_a?(::ActiveRecord::Type::Serialized)
-        column.cast_type.coder
-      end
-    else
-      def coder_for(attr_name)
-        self.class.serialized_attributes[attr_name]
-      end
-    end
-
-    def write_attribute(attr_name, value)
-      if coder = coder_for(attr_name)
-        if coder.is_a?(ActiveRecord::TypedStore::Coder)
-          return super(attr_name, coder.as_indifferent_hash(value))
-        end
+    def write_store_attribute(store_attribute, key, value)
+      if typed_stores && typed_stores[store_attribute]
+        prev_value = read_store_attribute(store_attribute, key)
+        new_value = typed_stores[store_attribute].fields[key].cast(value)
+        attribute_will_change!(key.to_s) if new_value != prev_value
       end
 
       super
     end
 
-    def keys_for_partial_write
-      super & self.class.column_names
-    end
+    def query_attribute(attr_name)
+      if self.class.store_accessors.include?(attr_name.to_sym)
+        value = public_send(attr_name)
 
-    def store_column(store_attribute, key)
-      store = store_columns(store_attribute)
-      store && store[key]
-    end
-
-    def store_columns(store_attribute)
-      self.class.typed_stores.try(:[], store_attribute)
-    end
-
-    # heavilly inspired from ActiveRecord::Base#query_attribute
-    def query_store_attribute(store_attribute, key)
-      value = read_store_attribute(store_attribute, key)
-
-      case value
-      when true        then true
-      when false, nil  then false
-      else
-        column = store_column(store_attribute, key)
-
-        if column.number?
-          !value.zero?
+        case value
+        when true        then true
+        when false, nil  then false
         else
-          !value.blank?
+          if value.respond_to?(:zero?)
+            !value.zero?
+          else
+            !value.blank?
+          end
         end
+      else
+        super
       end
     end
-
-  end
-
-  require 'active_record/typed_store/ar_32_fallbacks' if IS_AR_3_2
-  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
-
 end

data/lib/active_record/typed_store/field.rb

@@ -0,0 +1,76 @@
+module ActiveRecord::TypedStore
+  class Field
+    attr_reader :array, :blank, :name, :default, :type, :null, :accessor, :type_sym
+
+    def initialize(name, type, options={})
+      type_options = options.slice(:scale, :limit, :precision)
+      @type = lookup_type(type, type_options)
+      @type_sym = type
+
+      @accessor = options.fetch(:accessor, true)
+      @name = name
+      if options.key?(:default)
+        @default = extract_default(options[:default])
+      end
+      @null = options.fetch(:null, true)
+      @blank = options.fetch(:blank, true)
+      @array = options.fetch(:array, false)
+    end
+
+    def has_default?
+      defined?(@default)
+    end
+
+    def cast(value)
+      casted_value = type_cast(value)
+      if !blank
+        casted_value = default if casted_value.blank?
+      elsif !null
+        casted_value = default if casted_value.nil?
+      end
+      casted_value
+    end
+
+    private
+
+    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,
+      any: ::ActiveRecord::Type::Value,
+    }
+
+    def lookup_type(type, options)
+      TYPES.fetch(type).new(**options)
+    end
+
+    def extract_default(value)
+      # 4.2 workaround
+      return value if (type_sym == :string || type_sym == :text) && value.nil?
+
+      type_cast(value)
+    end
+
+    def type_cast(value, arrayize: true)
+      if array && (arrayize || value.is_a?(Array))
+        return [] if arrayize && !value.is_a?(Array)
+        return value.map { |v| type_cast(v, arrayize: false) }
+      end
+
+      # 4.2 workaround
+      if type_sym == :string || type_sym == :text
+        return value.to_s unless value.blank? && (null || array)
+      end
+
+      if type.respond_to?(:cast)
+        type.cast(value)
+      else
+        type.type_cast_from_user(value)
+      end
+    end
+  end
+end