eapi 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24226b6df180842850c926be63af60c33803e6e0
-  data.tar.gz: 1764202eb7a457a16bde2590b25909af05d4d17b
+  metadata.gz: 63f4151b5dc72b051cea9b0c448472007841deaa
+  data.tar.gz: a0f4c037e605fd4ca96e6c1d8518accaee6d9509
 SHA512:
-  metadata.gz: abef4e5a06756f1f32db42e60e0358451d524620ea0d7dc21af6f4929da5eea21f86a74a9930142164b219ba68ecb362cefe6f7115baffda67ba93a2477d7ec2
-  data.tar.gz: d67597321bb8c496167825f17b558c2e0e6e02b2bd75064eee1a7126146d2ffa0ecdb42742f5f912c19cce4ee45c5ef43e6d81158a5081dfbda353bab9960a09
+  metadata.gz: b06d56359371a02be843a0bc48b11f8fb9c873656e08d7d877427c95840d58b1595ea07d0faa1c9a176a7cfbb2432a2b67e74ace65f113c0836c51bde87d0147
+  data.tar.gz: 24e712cec447d69b9a65202b946d6a73e23aaa35334c0e92b46a9aba15fa119245e6cde824da3c0a34c9daff0dbf3e233e8747f7061dbc44c73aebedba855858

data/README.md

@@ -316,6 +316,87 @@ eapi.something # => {}
 
 To trigger the error, the value must not be an instance of the given Type, and also must not respond `true` to `value.is?(type)`
 
+#### Skip type validation with 'raw' values with `allow_raw` option
+
+If we want to check for the type of the elements, but still want the flexibility of using raw `Hash` or `Array` in case we want something specific there, we can specify it with the `allow_raw` option.
+
+With this, eapi will let you skip the type validation when the value is either a `Hash` or an `Array`, assuming that "you know what you are doing".
+
+```ruby
+class ValueKlass
+  include Eapi::Item
+  
+  property :value
+end
+
+class TestKlass
+  include Eapi::Item
+  
+  property :something, type: ValueKlass, allow_raw: true
+  property :somelist, multiple: true, element_type: ValueKlass, allow_raw: true
+end
+
+class TestList
+  include Eapi::List
+  
+  elements type: ValueKlass, allow_raw: true
+end
+
+i = TestKlass.new
+i.something 1
+i.valid? # => false
+
+i.something ValueKlass.new
+i.valid? # => true
+
+i.something({some: :hash})
+i.valid? # => true
+
+i.add_somelist 1
+i.valid? # => false
+
+i.clear_somelist.add_somelist({a: :hash}).add_somelist([:an, :array])
+i.valid? # => true
+
+l = TestList.new
+l.add 1
+l.valid? # => false
+
+i.clear.add(ValueKlass.new).add({a: :hash}).add([:an, :array])
+l.valid? # => true
+```
+
+You can also enable this option after defining the property, with the `property_allow_raw` and `property_disallow_raw` methods and check if it is enabled with `property_allow_raw?`. In `List`s, the methods are `elements_allow_raw`, `elements_disallow_raw` and `elements_allow_raw?`.
+
+```ruby
+class TestKlass
+  include Eapi::Item
+  
+  property :something, type: ValueKlass
+end
+
+TestKlass.property_allow_raw?(:something) # => false
+
+TestKlass.property_allow_raw(:something)
+TestKlass.property_allow_raw?(:something) # => true
+
+TestKlass.property_disallow_raw(:something)
+TestKlass.property_allow_raw?(:something) # => false
+
+class TestList
+  include Eapi::List
+  elements type: ValueKlass
+end
+
+TestList.elements_allow_raw? # => false
+
+TestList.elements_allow_raw
+TestList.elements_allow_raw? # => true
+
+TestList.elements_disallow_raw
+TestList.elements_allow_raw? # => false
+```
+
 #### Custom validation with `validate_with` option
 
 A more specific validation can be used using `validate_with`, that works the same way as `ActiveModel::Validations`. 

data/lib/eapi/definition_runners/list.rb

@@ -13,6 +13,7 @@ module Eapi
         run_validate_element_type
         run_validate_element_with
         run_validate_uniqueness
+        run_allow_raw
       end
 
       def run_validate_uniqueness
@@ -39,6 +40,10 @@ module Eapi
         end
       end
 
+      def run_allow_raw
+        Runner.allow_raw(klass: klass, field: :_list, allow_raw: allow_raw?)
+      end
+
       def required?
         definition.fetch(:required, false)
       end
@@ -54,6 +59,10 @@ module Eapi
       def element_type
         definition.fetch(:element_type, nil) || definition.fetch(:type, nil)
       end
+
+      def allow_raw?
+        definition.fetch(:allow_raw, false)
+      end
     end
 
   end

data/lib/eapi/definition_runners/property.rb

@@ -6,6 +6,7 @@ module Eapi
         run_multiple_accessor
         run_init
         run_validations
+        run_allow_raw
       end
 
       private
@@ -37,31 +38,29 @@ module Eapi
 
       def run_validate_type
         if type
-          klass.send :validates_each, field do |record, attr, value|
-            unless Eapi::TypeChecker.new(type).is_valid_type?(value)
-              record.errors.add(attr, "must be a #{type}")
-            end
-          end
+          Runner.validate_type(klass: klass, field: field, type: type)
         end
       end
 
       def run_validate_with
         if validate_with
-          klass.send :validates_each, field do |record, attr, value|
-            validate_with.call(record, attr, value)
-          end
+          Runner.validate_with(klass: klass, field: field, validate_with: validate_with)
         end
       end
 
+      def run_allow_raw
+        Runner.allow_raw(klass: klass, field: field, allow_raw: allow_raw?)
+      end
+
       def run_init
         if type || multiple?
-          klass.send :define_init, field, type || Array
+          Runner.init(klass: klass, field: field, type: type || Array)
         end
       end
 
       def run_multiple_accessor
         if multiple?
-          klass.send :define_multiple_accessor, field
+          Runner.multiple_accessor(klass: klass, field: field)
         end
       end
 
@@ -95,6 +94,10 @@ module Eapi
       def type
         definition.fetch(:type, nil)
       end
+
+      def allow_raw?
+        definition.fetch(:allow_raw, false)
+      end
     end
   end
 end

data/lib/eapi/definition_runners/runner.rb

@@ -11,11 +11,27 @@ module Eapi
         end
       end
 
+      def self.validate_type(klass:, field:, type:)
+        klass.send :validates_each, field do |record, attr, value|
+          allow_raw = klass.property_allow_raw?(field)
+          unless Eapi::TypeChecker.new(type, allow_raw).is_valid_type?(value)
+            record.errors.add(attr, "must be a #{type}")
+          end
+        end
+      end
+
+      def self.validate_with(klass:, field:, validate_with:)
+        klass.send :validates_each, field do |record, attr, value|
+          validate_with.call(record, attr, value)
+        end
+      end
+
       def self.validate_element_type(klass:, field:, element_type:)
         klass.send :validates_each, field do |record, attr, value|
+          allow_raw = klass.property_allow_raw?(field)
           if value.respond_to?(:each)
             value.each do |v|
-              unless Eapi::TypeChecker.new(element_type).is_valid_type?(v)
+              unless Eapi::TypeChecker.new(element_type, allow_raw).is_valid_type?(v)
                 record.errors.add(attr, "element must be a #{element_type}")
               end
             end
@@ -39,6 +55,22 @@ module Eapi
           end
         end
       end
+
+      def self.allow_raw(klass:, field:, allow_raw:)
+        if allow_raw
+          klass.send :property_allow_raw, field
+        else
+          klass.send :property_disallow_raw, field
+        end
+      end
+
+      def self.init(klass:, field:, type:)
+        klass.send :define_init, field, type
+      end
+
+      def self.multiple_accessor(klass:, field:)
+        klass.send :define_multiple_accessor, field
+      end
     end
   end
 end

data/lib/eapi/methods/properties.rb

@@ -28,6 +28,24 @@ module Eapi
       end
 
       module ClassMethods
+        def property_allow_raw(field)
+          @_property_allow_raw ||= {}
+
+          @_property_allow_raw[field.to_sym] = true
+        end
+
+        def property_disallow_raw(field)
+          @_property_allow_raw ||= {}
+
+          @_property_allow_raw[field.to_sym] = false
+        end
+
+        def property_allow_raw?(field)
+          @_property_allow_raw ||= {}
+
+          @_property_allow_raw.fetch(field.to_sym, false)
+        end
+
         def property(field, definition = {})
           fs = field.to_sym
           define_accessors fs
@@ -58,6 +76,18 @@ module Eapi
       end
 
       module ListCLassMethods
+        def elements_allow_raw
+          property_allow_raw(:_list)
+        end
+
+        def elements_disallow_raw
+          property_disallow_raw(:_list)
+        end
+
+        def elements_allow_raw?
+          property_allow_raw?(:_list)
+        end
+
         def elements(definition)
           run_list_definition definition
           store_list_definition definition

data/lib/eapi/type_checker.rb

@@ -1,10 +1,24 @@
 module Eapi
-  class TypeChecker < Struct.new(:given_type)
+  class TypeChecker
+
+    attr_reader :given_type, :allow_raw
+
+    def initialize(given_type, allow_raw = false)
+      @given_type = given_type
+      @allow_raw  = allow_raw
+    end
+
     def is_valid_type?(value)
-      value.nil? || is_same_type?(value) || poses_as_type?(value)
+      value.nil? || is_same_type?(value) || poses_as_type?(value) || valid_raw?(value)
     end
 
     private
+    def valid_raw?(value)
+      return false unless allow_raw?
+
+      value.kind_of?(Array) || value.kind_of?(Hash)
+    end
+
     def is_same_type?(value)
       value.kind_of?(type)
     end
@@ -20,5 +34,9 @@ module Eapi
         given_type.to_s.constantize
       end
     end
+
+    def allow_raw?
+      allow_raw
+    end
   end
 end

data/lib/eapi/version.rb

@@ -1,3 +1,3 @@
 module Eapi
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/spec/list_spec.rb

@@ -373,6 +373,46 @@ RSpec.describe Eapi do
           subject.add "Many Strings"
           expect(subject).to be_valid
         end
+
+        context 'with option allow_raw (default false)' do
+          class AllowRawValueKlass
+            include Eapi::Item
+            property :something
+          end
+
+          class ListAllowRawTestKlass
+            include Eapi::List
+
+            elements type: AllowRawValueKlass, allow_raw: true
+          end
+
+          subject { ListAllowRawTestKlass.new }
+
+          it 'allows a Hash or Array value with type check' do
+            subject.add(1)
+            expect(subject).not_to be_valid
+
+            subject.clear.add(AllowRawValueKlass.new)
+            expect(subject).to be_valid
+
+            subject.clear.add([1, 2, 3]).add({a: :hash})
+            expect(subject).to be_valid
+          end
+
+          it 'can be allowed and disallowed after definition' do
+            orig = ListAllowRawTestKlass.elements_allow_raw?
+            ListAllowRawTestKlass.elements_allow_raw
+            expect(ListAllowRawTestKlass).to be_elements_allow_raw
+            ListAllowRawTestKlass.elements_disallow_raw
+            expect(ListAllowRawTestKlass).not_to be_elements_allow_raw
+
+            if orig
+              ListAllowRawTestKlass.elements_allow_raw
+            else
+              ListAllowRawTestKlass.elements_disallow_raw
+            end
+          end
+        end
       end
 
       context 'unique' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eapi
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Eduardo Turiño