active_store_accessor 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d80e0a2c9f3bf1d6fde04802b05c5d01f89f179
-  data.tar.gz: 92665c56d16926a3b909c0d45650f0a6032ffe26
+  metadata.gz: 3b01aee96903d6965851b7fe623f388deeae0bf2
+  data.tar.gz: 46265923f7da2f21da4cac1f6ccdaf164842ec73
 SHA512:
-  metadata.gz: b91de091930c91921061b8dd70713b3c568bb6e4c8c29009fa191f49ceac194782e27e2c3132cbff2ac542b97b6e563da4d54e73a5bd7e6d94772a567f29ed87
-  data.tar.gz: 82ea8763e58340fe731de04f2db72a2f6ed6bab7e1b1bfbba98199e89b9fee93a7e58639943bf8279f29734b2aeb2368951947b242690ecbd644583b9ac4f17d
+  metadata.gz: e166097b7ad612555e65b6693c6915224bc97a7d0a656349a7c5ba6084178a65399e16126e91a8fafd10a48dd4402edb2815c0e161e3dd2a63b5c87d75be7f89
+  data.tar.gz: 38594357276667ebf2e2728f6cb34b8ef31978beddb79bc95a19e13f8b0b4be00f65c745a593b28e57f995fd014dd696e2ab24c8bafd89f3bb4eb382836dac76

data/README.md

@@ -4,15 +4,14 @@
 [![Gem Version](https://badge.fury.io/rb/active_store_accessor.svg)](http://badge.fury.io/rb/active_store_accessor)
 [![Code Climate](https://codeclimate.com/github/jalkoby/active_store_accessor.png)](https://codeclimate.com/github/jalkoby/active_store_accessor)
 
-`active_store_accessor` makes work with store accessors more productive. There is no need to cast a serialized attribute to required type(boolean, time, float, etc). Just define it with a tiny wrapper method and everything is done for you.
+`active_store_accessor` makes a work with store accessors more productive. There is no need to cast a serialized attribute to a required type(boolean, time, float, etc). Just define it with a tiny wrapper method and everything is done for you.
 
 ## Usage
 
-Basic use case:
+The basic usage:
 
 ```ruby
 class Profile < ActiveRecord::Base
-  # basic usage(where `info` is a store column)
   active_store_accessor :info, age: :integer, birthday: :time
 
   # with default values
@@ -30,11 +29,11 @@ profile.score = 4.5
 profile.score # => 4.5
 ```
 
-Extra logic in property methods:
+The extra logic in a property methods:
 ```ruby
 # Story:
-#  users have a rank, but if an user was locked by admins
-#  nobody can change it rank & it's value should be equal to zero
+#  users have a rank, but if a user was locked by admins
+#  nobody can change a rank & it's value should be equal to zero
 class User
   active_store_accessor :info, rank: :float
 
@@ -49,6 +48,72 @@ class User
 end
 ```
 
+## Adding a custom type
+Add a custom type is easy enough:
+
+```ruby
+# using a block
+ActiveStoreAccessor.add_type(:even) do |builder|
+  builder.to_source { |value| (value.to_i / 2) * 2 }
+end
+
+# using a lambda
+ActiveStoreAccessor.add_type(:even) do |builder|
+  to_source = lambda { |value| (value.to_i / 2) * 2 }
+  builder.to_source(to_source)
+end
+
+# using a object with #call method
+class EvenConvert
+  def call(value)
+    (value.to_i / 2) * 2
+  end
+end
+
+ActiveStoreAccessor.add_type(:even) do |builder|
+  builder.to_source(EvenConvert.new)
+end
+```
+
+Sometimes you need to deserialize your value of a custom type. To do it look at the following example:
+
+```ruby
+ActiveStoreAccessor.add_type(:point) do |builder|
+  builder.to_source do |value|
+    "#{ value.x },#{ value.y }"
+  end
+
+  builder.from_source do |value|
+    parts = value.split(',')
+    Point.new(parts[0], parts[1])
+  end
+end
+```
+
+There is a common issue when you use `block`-style to define a custom type:
+
+```ruby
+ActiveStoreAccessor.add_type(:point) |builder|
+  builder.to_source do |value|
+    return unless value.is_a?(Point)
+    # ...
+  end
+end
+```
+
+Ruby will rise an error Unexpected Return (LocalJumpError). To avoid it replace a block by a lambda:
+
+```ruby
+ActiveStoreAccessor.add_type(:point) |builder|
+  to_source = lambda do |value|
+    return unless value.is_a?(Point)
+    # ...
+  end
+
+  builder.to_source(to_source)
+end
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -65,7 +130,7 @@ This library has been tested on ruby 1.9.3+ and activerecord 4.0+.
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/active_store_accessor/fork )
+1. Fork it ( https://github.com/jalkoby/active_store_accessor/fork )
 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`)

data/active_store_accessor.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "active_store_accessor"
-  spec.version       = "0.2.1"
+  spec.version       = "0.3.1"
   spec.authors       = ["Sergey Pchelincev"]
   spec.email         = ["mail@sergeyp.me"]
   spec.summary       = %q{Get more from ActiveRecord::Store}

data/lib/active_store_accessor.rb

@@ -1,63 +1,140 @@
+require_relative "active_store_accessor/builder"
+require_relative "active_store_accessor/rails"
+require_relative "active_store_accessor/type"
+
 module ActiveStoreAccessor
-  def active_store_attributes
-    return @active_store_attributes if @active_store_attributes
+  extend self
+
+  def types
+    @types ||= []
+  end
 
-    @active_store_attributes = superclass.respond_to?(:active_store_attributes) ? superclass.active_store_attributes : {}
+  def add_type(*names)
+    raise_arg_error("You could use only symbols for name") if names.any? { |name| !name.is_a?(Symbol) }
+    builder = Builder.new(names)
+    yield builder
+    types << builder.to_type
   end
 
-  def active_store_accessor(column_name, attrs)
-    column = columns.detect { |column| column.name == column_name.to_s }
-    if !column
-      raise "[active_store_accessor] The column '#{column_name}' does not exist in the model #{name}."
-    elsif column.type == :text
-      serialize(column_name) unless serialized_attributes.include?(column_name.to_s)
+  def find_type(name, options, model_name)
+    raise_arg_error("Please use a symbol for a setting type in #{ model_name }.") unless name.is_a?(Symbol)
+    type_args = types.detect { |type_args| type_args[0].include?(name) }
+    unless type_args
+      raise_arg_error("#{ name } is unknown. Please recheck a type's name or add it by `ActiveStoreAccessor.add_type`.")
     end
+    Type.new(type_args[1], type_args[2], options[:default])
+  end
+
+  def raise_error(klass, message)
+    raise klass, "[active_store_accessor] #{ message }"
+  end
 
-    store_accessor column_name, *attrs.keys
+  def raise_arg_error(message)
+    raise_error ArgumentError, message
+  end
 
-    attrs.each do |attr_name, options|
-      options = { type: options.to_s } unless options.is_a?(Hash)
-      type = options.fetch(:type) { raise ArgumentError, "please specify type of `#{ attr_name }` attribute" }.to_s
+  def raise_convertion_error(value, type)
+    raise_error klass, "ActiveStoreAccessor doesn't know how to convert #{ value.class } into #{ type }"
+  end
+
+  add_type(:integer) do |builder|
+    builder.to_source { |value| value.to_i rescue nil }
+  end
 
-      config = if connection.respond_to?(:lookup_cast_type)
-        column = connection.lookup_cast_type(type)
-        [column.method(:type_cast_from_database), column.method(:type_cast_for_database)]
+  add_type(:float, :double) do |builder|
+    builder.to_source { |value| value.to_f unless value.nil? }
+  end
+
+  add_type(:decimal) do |builder|
+    builder.from_source { |value| value.to_d unless value.nil? }
+
+    builder.to_source do |value|
+      if value.respond_to?(:to_d)
+        value.to_d.to_s
       else
-        # time for activerecord is only a hours and minutes without date part
-        # but for most rubist and rails developer it should contains a date too
-        type = 'datetime' if type == 'time'
-        args = [attr_name.to_s, options[:default], type]
-        column = ActiveRecord::ConnectionAdapters::Column.new(*args)
-        [column.method(:type_cast), column.method(:type_cast_for_write)]
+        value.to_s.presence
       end
+    end
+  end
 
-      config << options[:default]
-      active_store_attributes[attr_name] = config
+  # time for activerecord is only a hours and minutes without date part
+  # but for most rubist and rails developer it should contains a date too
+  add_type(:time, :datetime) do |builder|
+    builder.from_source { |value| Time.parse(value) if value }
 
-      _active_store_accessor_module.module_eval <<-RUBY
-        def #{ attr_name }
-          getter, _, default = self.class.active_store_attributes[:#{ attr_name }]
-          value = getter.call(super)
-          value.nil? ? default : value
-        end
+    to_source = lambda do |value|
+      return unless value.present?
 
-        def #{ attr_name }=(value)
-          _, setter, _ = self.class.active_store_attributes[:#{ attr_name }]
-          super setter.call(value)
-        end
-      RUBY
+      case value
+      when String then Time.parse(value).to_s
+      when Fixnum then Time.at(value).to_s
+      when Date, Time, DateTime, ActiveSupport::TimeZone then value.to_s
+      else
+        raise_convertion_error(value, "Time")
+      end
     end
+
+    builder.to_source(to_source)
+  end
+
+  add_type(:date) do |builder|
+    to_source = lambda do |value|
+      return if value.nil?
+      case value
+      when String then Date.parse(value).to_s
+      when Date then value.to_s
+      when Time, DateTime then value.to_date.to_s
+      else
+        raise_convertion_error(value, "Date")
+      end
+    end
+
+    builder.to_source(to_source)
   end
 
-  private
+  add_type(:text, :string, :binary) do |builder|
+    builder.to_source { |value| value.presence }
+  end
 
-  def _active_store_accessor_module
-    @_active_store_accessor_module ||= begin
-      mod = Module.new
-      include mod
-      mod
+  add_type(:boolean, :bool) do |builder|
+    true_values = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].to_set
+
+    builder.to_source do |value|
+      if value.nil? || (value.is_a?(String) && value.empty?)
+        nil
+      else
+        true_values.include?(value)
+      end
+    end
+  end
+
+  add_type(:array, :list) do |builder|
+    builder.to_source { |value| ActiveSupport::JSON.encode(Array(value)) unless value.nil? }
+    builder.from_source { |value| ActiveSupport::JSON.decode(value) unless value.nil? }
+  end
+
+  add_type(:hash, :dictonary) do |builder|
+    if RUBY_VERSION =~ /1\.9/
+      to_source = lambda do |value|
+        return if value.nil?
+
+        value = if value.is_a?(Hash)
+          value
+        elsif value.respond_to?(:to_h)
+          value.to_h
+        elsif value.respond_to?(:to_hash)
+          value.to_hash
+        else
+          raise_convertion_error(value, 'Hash')
+        end
+        ActiveSupport::JSON.encode(value)
+      end
+      builder.to_source(to_source)
+    else
+      builder.to_source { |value| ActiveSupport::JSON.encode(Hash(value)) unless value.nil? }
     end
+    builder.from_source { |value| ActiveSupport::JSON.decode(value) unless value.nil? }
   end
 end
 
-ActiveSupport.on_load(:active_record) { ActiveRecord::Base.extend(ActiveStoreAccessor) }
+ActiveSupport.on_load(:active_record) { ActiveRecord::Base.extend(ActiveStoreAccessor::Rails) }

data/lib/active_store_accessor/builder.rb

@@ -0,0 +1,21 @@
+module ActiveStoreAccessor
+  class Builder
+    DEFAULT_CASTER = lambda { |value| value }
+
+    def initialize(names)
+      @names = names
+    end
+
+    def from_source(caster = nil, &block)
+      @from_source = caster || block
+    end
+
+    def to_source(caster = nil, &block)
+      @to_source = caster || block
+    end
+
+    def to_type
+      [@names, (@from_source || DEFAULT_CASTER), (@to_source || DEFAULT_CASTER)]
+    end
+  end
+end

data/lib/active_store_accessor/rails.rb

@@ -0,0 +1,50 @@
+module ActiveStoreAccessor
+  module Rails
+    def active_store_attributes
+      return @active_store_attributes if @active_store_attributes
+
+      @active_store_attributes = superclass.respond_to?(:active_store_attributes) ? superclass.active_store_attributes : {}
+    end
+
+    def active_store_accessor(column_name, attrs)
+      column = columns.detect { |column| column.name == column_name.to_s }
+      if !column
+        ::ActiveStoreAccessor.raise_arg_error "The column `#{ column_name }` does not exist in the model #{ name }."
+      elsif column.type == :text
+        serialize(column_name) unless serialized_attributes.include?(column_name.to_s)
+      end
+
+      store_accessor column_name, *attrs.keys
+
+      attrs.each do |attr_name, options|
+        options = { type: options } unless options.is_a?(Hash)
+
+        type = options.fetch(:type) do
+          ::ActiveStoreAccessor.raise_arg_error "Please specify the type of `#{ attr_name }` attribute."
+        end
+
+        active_store_attributes[attr_name] = ::ActiveStoreAccessor.find_type(type, options, name)
+
+        _active_store_accessor_module.module_eval <<-RUBY
+          def #{ attr_name }
+            self.class.active_store_attributes.fetch(:#{ attr_name }).from_store(super)
+          end
+
+          def #{ attr_name }=(value)
+            super self.class.active_store_attributes.fetch(:#{ attr_name }).to_store(value)
+          end
+        RUBY
+      end
+    end
+
+    private
+
+    def _active_store_accessor_module
+      @_active_store_accessor_module ||= begin
+        mod = Module.new
+        include mod
+        mod
+      end
+    end
+  end
+end

data/lib/active_store_accessor/type.rb

@@ -0,0 +1,18 @@
+module ActiveStoreAccessor
+  class Type
+    def initialize(from, to, default)
+      @from = from
+      @to = to
+      @default = default
+    end
+
+    def from_store(value)
+      result = @from.call(value)
+      result.nil? ? @default : result
+    end
+
+    def to_store(value)
+      @to.call(value)
+    end
+  end
+end

data/tests/lib/active_store_accessor_test.rb

@@ -9,18 +9,24 @@ describe ActiveStoreAccessor do
     assert_equal profile.rank, nil
     assert_equal profile.birthday, nil
     assert_equal profile.confirmed, nil
+    assert_equal profile.photos, nil
+    assert_equal profile.scores, nil
 
     profile.age = "20"
     profile.score = 100.32
     profile.rank = "3213.317"
     profile.birthday = Time.utc(2014, 5, 12)
     profile.confirmed = "1"
+    profile.photos = 'my_doggy.png'
+    profile.scores = { woo: 2 }
 
     assert_equal profile.age, 20
     assert_equal profile.score, 100
     assert_equal profile.rank, 3213.32
     assert_equal profile.birthday, Time.utc(2014, 5, 12)
     assert profile.confirmed
+    assert_equal profile.photos, ['my_doggy.png']
+    assert_equal profile.scores, { 'woo' => 2 }
   end
 
   it "should support model inheritance" do

data/tests/test_helper.rb

@@ -25,6 +25,8 @@ class Profile < ActiveRecord::Base
 
   active_store_accessor :keys, active: :boolean
   active_store_accessor :keys, pi: :float
+  active_store_accessor :keys, photos: :list
+  active_store_accessor :keys, scores: :hash
 
   def rank=(value)
     super(value)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_store_accessor
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Sergey Pchelincev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-19 00:00:00.000000000 Z
+date: 2015-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -81,6 +81,9 @@ files:
 - Rakefile
 - active_store_accessor.gemspec
 - lib/active_store_accessor.rb
+- lib/active_store_accessor/builder.rb
+- lib/active_store_accessor/rails.rb
+- lib/active_store_accessor/type.rb
 - tests/lib/active_store_accessor_test.rb
 - tests/test_helper.rb
 homepage: ''