eapi 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65b2149ec39bedde36ad3c6305a7eee7fb8b37b6
-  data.tar.gz: 6dc257fc779aeb132e289e7e870364e163104118
+  metadata.gz: 4673ef60bc4acd96d0ae165935fab2e1b901cf53
+  data.tar.gz: d04635f645f8638fdb8a224dc5ae3320e5fe90fd
 SHA512:
-  metadata.gz: 1e36790d62876f6cda906ed3f1cf4b1f29338b1acdbb70fadeac7718119ec4382f78655e7026b5cc289b9a8be5df560d467f912f817a34ec6bb58743322bd4ff
-  data.tar.gz: 440261fc694e382d0664f83f6ecf0f619e7f4922388adea99640b0a9ada69ce31b2f652fc8d376f96d5f59d480fb5a4dbb1ac216a4ec7e2a2bc50f9464dbe7e8
+  metadata.gz: 4da861d047452f5057a2cc1f778ea2073198afab91a926fd7cdc1c36e35222ca6f7e02aa547b5683099d21020d2d1171825562a66a94c47663316f2fcf65240d
+  data.tar.gz: 8d9f6a3d3d5a8e18a07cf03f22b40724acd98a9a736985bf01093e2204f77a633b7d79c3a2603c4ab1ce1e5378dd32d4be47d3d9c82333aed375f4ff86971203

data/README.md

@@ -88,6 +88,106 @@ By default, each property will be converted into a simple element (Array, Hash,
 2. If a value is an Array or a Set, `to_a` will be invoked and all values will be converted in the same way.
 3. If a value respond to `to_h`, it will be called.
 
+#### Custom value conversion
+
+We can override the default value conversion using the `convert_with` option in the property definition. It will accept:
+
+* a symbol (message to be sent to the value) 
+* callable object (lambda, proc...) that accepts either 1 parameter (the value) or 2 parameters (the value and the object)
+  
+```ruby
+class ExampleItem
+  include Eapi::Item
+  
+  property :something, convert_with: :to_s
+  property :other, convert_with: ->(val) { "This is #{val}" }
+  property :third, convert_with: ->(val, obj) do
+    s = obj.something
+    c = obj.send :converted_value_for, :something
+    "I am #{val} with some #{s.inspect} as #{c.inspect}"
+  end
+end
+
+x = ExampleItem.new something: :x, other: 1, third: 'the third'
+x.render # => 
+# {
+#   # converted to string (`to_s` method called)
+#   something: 'x',                        
+# 
+#   # converted using the lambda
+#   other: 'This is 1',
+# 
+#   # converted using the lambda, with access to the context object
+#   third: "I am the third with some :x as \"x\""
+# }
+```
+
+On a `List` object, it will work as conversion for every element.
+
+```ruby
+class ExampleList
+  include Eapi::List
+  
+  elements convert_with: :to_s
+end
+
+x = ExampleItem.new.add(1).add(2)
+x.render # => ["1", "2"]
+```
+
+#### Convert values before validation using `convert_before_validation` option
+
+If `convert_before_validation` option is enabled, then the conversion will occur before validation
+
+```ruby
+class ExampleItem
+  include Eapi::Item
+  
+  property :something, convert_with: :to_i, convert_before_validation: true
+  property :normal, convert_with: :to_i
+  
+  validates :something, inclusion: { in: [1, 2, 3] }
+  validates :normal, inclusion: { in: [1, 2, 3] }
+end
+
+# the conversion happens before validation, so it passes
+x = ExampleItem.new something: '1', normal: 2
+x.valid? # => true
+
+# the conversion happens on rendering, after validation, so it fails
+x = ExampleItem.new something: 1, normal: '2'
+x.valid? # => false
+```
+
+In `List` it will work on elements.
+
+```ruby
+class ExampleListConvertBeforeValidationEnabled
+  include Eapi::List
+
+  elements convert_with: :to_i, convert_before_validation: true, validate_with: ->(record, attr, value) do
+    record.errors.add(attr, 'must pass my custom validation') unless value.kind_of?(Fixnum)
+  end
+end
+
+class ExampleListConvertBeforeValidationDisabled
+  include Eapi::List
+
+  elements convert_with: :to_i, validate_with: ->(record, attr, value) do
+    record.errors.add(attr, 'must pass my custom validation') unless value.kind_of?(Fixnum)
+  end
+end
+
+
+# the conversion happens before validation, so it passes
+x = ExampleListConvertBeforeValidationEnabled.new.add('1')
+x.valid? # => true
+
+# the conversion happens on rendering, after validation, so it fails
+x = ExampleListConvertBeforeValidationDisabled.new.add('1')
+x.valid? # => false
+```
+
 #### Ignoring values
 
 By default, any `nil` values will be omitted in the final structure by the `perform_render` method, in both `Item` and `List`.

data/lib/eapi/common.rb

@@ -23,6 +23,11 @@ module Eapi
         raise Eapi::Errors::InvalidElementError, "errors: #{errors.full_messages}, self: #{self.inspect}" unless valid?
       end
 
+      def valid?(*)
+        perform_before_validation
+        super
+      end
+
       def render
         validate!
         perform_render

data/lib/eapi/definition_runners/property.rb

@@ -94,6 +94,10 @@ module Eapi
         definition.fetch(:required, false)
       end
 
+      def allow_raw?
+        definition.fetch(:allow_raw, false)
+      end
+
       def validate_with
         definition.fetch(:validate_with, nil)
       end
@@ -110,9 +114,6 @@ module Eapi
         definition.fetch(:init_class, nil)
       end
 
-      def allow_raw?
-        definition.fetch(:allow_raw, false)
-      end
     end
   end
 end

data/lib/eapi/item.rb

@@ -16,6 +16,7 @@ module Eapi
       render
     end
 
+    private
     def perform_render
       {}.tap do |hash|
         _properties.each do |prop|
@@ -23,5 +24,13 @@ module Eapi
         end
       end
     end
+
+    def perform_before_validation
+      _properties.each do |property|
+        if self.class.convert_before_validation?(property)
+          self.set(property, converted_value_for(property))
+        end
+      end
+    end
   end
 end

data/lib/eapi/list.rb

@@ -13,6 +13,7 @@ module Eapi
     def self.add_features(klass)
       Eapi::Common.add_features klass
       klass.extend(ClassMethods)
+      klass.include(Eapi::Methods::Properties::ListInstanceMethods)
       klass.extend(Eapi::Methods::Properties::ListCLassMethods)
     end
 
@@ -34,10 +35,6 @@ module Eapi
       render
     end
 
-    def perform_render
-      _list.map { |val| convert_value val }.reject { |x| to_be_ignored x }
-    end
-
     def _list
       @_list ||= []
     end
@@ -75,8 +72,17 @@ module Eapi
     protected :initialize_copy
 
     private
-    def to_be_ignored(value)
-      Eapi::ValueIgnoreChecker.to_be_ignored? value, self.class.elements_ignore_definition
+    def perform_render
+      _list.reduce([]) do |array, value|
+        set_value_in_final_array(array, value)
+        array
+      end
+    end
+
+    def perform_before_validation
+      if self.class.elements_convert_before_validation?
+        _list.map! { |v| convert_value_for_element(v) }
+      end
     end
 
     # transpose, assoc, rassoc , permutation, combination, repeated_permutation, repeated_combination, product, pack ?? => do not use the methods

data/lib/eapi/methods/properties.rb

@@ -19,11 +19,11 @@ module Eapi
         end
 
         def converted_value_for(prop)
-          convert_value get(prop)
+          convert_value get(prop), self.class.defined_convert_with_for(prop)
         end
 
-        def convert_value(value)
-          Eapi::ValueConverter.convert_value(value)
+        def convert_value(value, convert_with = nil)
+          Eapi::ValueConverter.convert_value(value, self, convert_with)
         end
 
         def converted_or_default_value_for(property)
@@ -112,12 +112,40 @@ module Eapi
           definition_for(property).fetch(:default, nil)
         end
 
+        def defined_convert_with_for(property)
+          definition_for(property).fetch(:convert_with, nil)
+        end
+
+        def convert_before_validation?(property)
+          definition_for(property).fetch(:convert_before_validation, false)
+        end
+
         private :_property_allow_raw
         private :_property_definitions
         private :run_property_definition
         private :store_property_definition
       end
 
+      module ListInstanceMethods
+        def set_value_in_final_array(array, value)
+          yield_final_value_for_elements(value) do |val|
+            array << val
+          end
+        end
+
+        def yield_final_value_for_elements(value)
+          yield convert_value_for_element(value) unless to_be_ignored?(value)
+        end
+
+        def to_be_ignored?(value)
+          Eapi::ValueIgnoreChecker.to_be_ignored? value, self.class.elements_ignore_definition
+        end
+
+        def convert_value_for_element(value)
+          convert_value(value, self.class.elements_defined_convert_with_for)
+        end
+      end
+
       module ListCLassMethods
         def elements_allow_raw
           property_allow_raw(:_list)
@@ -135,11 +163,19 @@ module Eapi
           definition_for_elements.fetch(:ignore, :nil?)
         end
 
+        def elements_convert_before_validation?
+          definition_for_elements.fetch(:convert_before_validation, false)
+        end
+
         def elements(definition)
           run_list_definition definition
           store_list_definition definition
         end
 
+        def elements_defined_convert_with_for
+          definition_for_elements.fetch(:convert_with, nil)
+        end
+
         def definition_for_elements
           @_list_definition ||= {}
         end

data/lib/eapi/value_converter.rb

@@ -1,20 +1,47 @@
 module Eapi
   module ValueConverter
-    def self.convert_value(value)
-      if value.nil?
+    def self.convert_value(value, context, convert_with = nil)
+
+      if convert_with.present?
+        value_using_convert_with(value, context, convert_with)
+      elsif value.nil?
         nil
       elsif can_render? value
         value_from_render value
       elsif is_list? value
-        value_from_list value
+        value_from_list value, context
       elsif is_hash?(value)
-        value_from_hash value
+        value_from_hash value, context
       else
         value
       end
     end
 
     private
+    def self.value_using_convert_with(value, context, convert_with)
+      if convert_with.respond_to? :call
+        value_using_callable value, context, convert_with
+      else
+        value_using_message value, convert_with
+      end
+    end
+
+    def self.value_using_callable(value, context, callable)
+      a = callable.try(:arity) || callable.method(:call).arity
+      case a
+        when 0
+          callable.call
+        when 1
+          callable.call value
+        else
+          callable.call value, context
+      end
+    end
+
+    def self.value_using_message(value, message)
+      value.send message
+    end
+
     def self.can_render?(value)
       value.respond_to? :render
     end
@@ -33,14 +60,14 @@ module Eapi
       value.render
     end
 
-    def self.value_from_list(value)
-      value.to_a.map { |e| convert_value e }.compact
+    def self.value_from_list(value, context)
+      value.to_a.map { |e| convert_value e, context }.compact
     end
 
-    def self.value_from_hash(value)
+    def self.value_from_hash(value, context)
       {}.tap do |hash|
         value.to_h.each_pair do |k, v|
-          val     = convert_value v
+          val     = convert_value v, context
           hash[k] = val unless val.nil?
         end
         hash.deep_symbolize_keys!

data/lib/eapi/version.rb

@@ -1,3 +1,3 @@
 module Eapi
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/spec/conversion_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  describe 'convert_with' do
+
+    context 'Item' do
+
+      class ExampleItemConvertWith
+        include Eapi::Item
+
+        property :something, convert_with: :to_s
+        property :other, convert_with: ->(val) { "This is #{val}" }
+        property :third, convert_with: ->(val, obj) do
+          s = obj.something
+          c = obj.send :converted_value_for, :something
+          "I am #{val} with some #{s.inspect} as #{c.inspect}"
+        end
+      end
+
+      subject { ExampleItemConvertWith.new something: :x, other: 1, third: 'the third' }
+
+      context 'message (symbol or string)' do
+        it 'in the rendered hash, the value is converted by sending the message to the value' do
+          expect(subject.render[:something]).to eq 'x'
+        end
+      end
+
+      context 'callable object with 1 argument' do
+        it 'in the rendered hash, the value is converted by sending `call` to the callable object and passing the value as single argument' do
+          expect(subject.render[:other]).to eq 'This is 1'
+        end
+      end
+
+      context 'callable object with 2 arguments' do
+        it 'in the rendered hash, the value is converted by sending `call` to the callable object and passing the value as first argument and the context object (item) as second argument' do
+          expect(subject.render[:third]).to eq "I am the third with some :x as \"x\""
+        end
+      end
+    end
+
+    context 'List' do
+      class ExampleListConvertWith
+        include Eapi::List
+
+        elements convert_with: :to_s
+      end
+
+      subject { ExampleListConvertWith.new.add(1).add(2) }
+
+      it 'with a given option for `context_with`, it will use to convert all elements of the list' do
+        expect(subject.render).to eq ['1', '2']
+      end
+    end
+  end
+
+  describe 'convert_before_validation option' do
+
+    context 'Item' do
+      class ExampleItemConvertBeforeValidation
+        include Eapi::Item
+
+        property :something, convert_with: :to_i, convert_before_validation: true
+        property :normal, convert_with: :to_i
+
+        validates :something, inclusion: {in: [1, 2, 3]}
+        validates :normal, inclusion: {in: [1, 2, 3]}
+      end
+
+      context 'enabled' do
+        subject { ExampleItemConvertBeforeValidation.new something: '1', normal: 2 }
+        it 'the conversion happens before validation' do
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'disabled' do
+        subject { ExampleItemConvertBeforeValidation.new something: 1, normal: '2' }
+        it 'the conversion happens on rendering, after validation' do
+          expect(subject).not_to be_valid
+        end
+      end
+    end
+
+    context 'List' do
+      class ExampleListConvertBeforeValidationEnabled
+        include Eapi::List
+
+        elements convert_with: :to_i, convert_before_validation: true, validate_with: ->(record, attr, value) do
+          record.errors.add(attr, 'must pass my custom validation') unless value.kind_of?(Fixnum)
+        end
+      end
+
+      class ExampleListConvertBeforeValidationDisabled
+        include Eapi::List
+
+        elements convert_with: :to_i, validate_with: ->(record, attr, value) do
+          record.errors.add(attr, 'must pass my custom validation') unless value.kind_of?(Fixnum)
+        end
+      end
+
+      context 'enabled' do
+        subject { ExampleListConvertBeforeValidationEnabled.new.add('1') }
+        it 'the conversion happens before validation' do
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'disabled' do
+        subject { ExampleListConvertBeforeValidationDisabled.new.add('1') }
+        it 'the conversion happens on rendering, after validation' do
+          expect(subject).not_to be_valid
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eapi
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Eduardo Turiño
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-23 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -214,6 +214,7 @@ files:
 - lib/eapi/value_ignore_checker.rb
 - lib/eapi/version.rb
 - spec/basic_spec.rb
+- spec/conversion_spec.rb
 - spec/definition_spec.rb
 - spec/extension_spec.rb
 - spec/function_spec.rb
@@ -252,6 +253,7 @@ summary: ruby gem for building complex structures that will end up in hashes (in
   devised for ElasticSearch search requests)
 test_files:
 - spec/basic_spec.rb
+- spec/conversion_spec.rb
 - spec/definition_spec.rb
 - spec/extension_spec.rb
 - spec/function_spec.rb