eapi 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af49a7ace939612da586885e144e872e26f9bab6
-  data.tar.gz: a55532d8fc6a2eb3350b19768e5ac403f3329b2b
+  metadata.gz: c1be90f666a6468f4f4e574b85edcf706d7336a7
+  data.tar.gz: c485bbe47dbd2ff849aad2b3c7dc4a9b8521cc0a
 SHA512:
-  metadata.gz: df2402e3c80c6d2ec64291d61a31f3c9e8c50dff4383f29b1f72e56bd801473a40daea2b9e97199f87a16a959ec63670af210fedbd4a343b68c0a5c7cbd34ecb
-  data.tar.gz: 5dd6bcb8988fb8a1add9932e038fd84df732f5c84c494efcfbe00be5ac3f549bc6f70a07cb34506fd23dd1ef30e7e0e274a7b53e1e3bbab281cf03a45ee4d3dc
+  metadata.gz: da17b4c132b4f45b868bf64eb1fde65faafe04e34fea500694b372aa057f7c1c21076c222e45169c7f45bdcfe5b66fed65e21bcfec86d2578f45c3fca423951a
+  data.tar.gz: 433e10ff4cd1bd992eef4a4779c003891d9c2f35d72e46ce4559ef83593c88b1e58731868519f538b13f63e10bf4a4f61b9e3d7b1e00f470144bdbab8ee9e46a

data/README.md

@@ -63,6 +63,201 @@ This will provide:
 
 We'll se this in detail.
 
+
+## Common behaviour to `Item` and `List`
+
+The following features are shared between `List`s and `Item`s.
+
+### Convert to hashes: `render` and `perform_render`
+
+All Eapi objects respond to `render` and return by default a hash (for `Item` objects) or an array (for `List` objects), as it is the main purpose of this gem. It will execute any validation (see property definition), and if everything is ok, it will convert it to the simple structure.
+
+`Item` objects will invoke `render` when receiving `to_h`, while `List` objects will do the same when receiving `to_a`.
+ 
+#### Methods involved
+
+Inside, `render` will call `valid?`, raise an error of type `Eapi::Errors::InvalidElementError` if something is not right, and if everything is ok it will call `perform_render`.
+
+On `Item` objects, the `perform_render` method will create a hash with the properties as keys. Each value will be "converted" (see "Values conversion" section). On `List` objects, the `perform_render` will create an array, with all 
+
+#### Values conversion
+
+By default, each property will be converted into a simple element (Array, Hash, or simple value).  
+
+1. If a value responds to `render`, it will call that method. That way, Eapi objects that are values of some properties or lists will be validated and rendered (converted) themselves (render / value conversion cascade).
+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.
+
+#### Ignoring values
+
+By default, any `nil` values will be omitted in the final structure by the `perform_render` method, in both `Item` and `List`.
+
+With the `ignore` option in the definition, that behaviour can be modified.
+
+* `ignore: false`: that no value will be ignored
+* `ignore: :blank?`: with a string or a symbol in the `ignore` option, the value will be ignored if it respond truthy to the message represented by that `ignore` option. (ie: `ignore: :blank?` => all values that return truthy to `value.blank?` will be ignored)
+* `ignore: Proc|Callable|Lambda`: with a callable object in the `ignore` option, the value will be ignored if the callable object respond truthy when invoked with the value as argument. 
+
+```ruby
+class ExampleItem
+  include Eapi::Item
+
+  # by default, ignored if value is `nil`
+  property :prop1 
+  
+  # ignored if value returns truthy to `.blank?`
+  property :prop2, ignore: :blank?
+  
+  # never ignored
+  property :prop3, ignore: false
+  
+  # ignored if the callable object returns true when `.call(value)` (in this case, if the value is equal to "i don't want you")
+  property :prop4, ignore: Proc.new {|val| val == "i don't want you"} 
+end
+```
+
+#### Example
+
+To demonstrate this behaviour we'll have an Eapi enabled class `ExampleEapi` and another `ComplexValue` class that responds to `to_h`. We'll set into the `ExampleEapi` object complex properties to demonstrate the conversion into a simple structure.
+
+```ruby
+class ComplexValue
+  def to_h
+    {
+      a: Set.new(['hello', 'world', MyTestObject.new])
+    }
+  end
+end
+
+class ExampleEapi
+  include Eapi::Item
+
+  property :something, required: true
+  property :other
+end
+
+# TESTING `render`
+
+list = Set.new [
+                 OpenStruct.new(a: 1, 'b' => 2),
+                 {c: 3, 'd' => 4},
+                 nil
+               ]
+
+eapi = ExampleEapi.new something: list, other: ComplexValue.new
+
+# same as eapi.to_h
+eapi.render # => 
+# {
+#   something: [
+#                {a: 1, b: 2},
+#                {c: 3, d: 4},
+#              ],
+# 
+#   other:     {
+#                a: [
+#                     'hello',
+#                     'world',
+#                     {a: 'hello'}
+#                   ]
+#              }
+# }
+```
+
+### Pose as other types
+
+An Eapi class can poses as other types, for purposes of `type` checking in a property definition. We use the class method `is` for this.
+
+the `is?` method is also available as an instance method. 
+
+Eapi also creates specific instance and class methods like `is_a_some_type?` or `is_an_another_type?`.
+
+example:
+
+```ruby
+class SuperTestKlass
+  include Eapi::Item
+end
+ 
+class TestKlass < SuperTestKlass
+  is :one_thing, :other_thing, OtherType
+end
+
+TestKlass.is? TestKlass # => true
+TestKlass.is? 'TestKlass' # => true
+TestKlass.is? :TestKlass # => true
+
+TestKlass.is? SuperTestKlass # => true
+TestKlass.is? 'SuperTestKlass' # => true
+TestKlass.is? :SuperTestKlass # => true
+
+TestKlass.is? :one_thing # => true
+TestKlass.is? :other_thing # => true
+TestKlass.is? :other_thing # => true
+TestKlass.is? OtherType # => true
+TestKlass.is? :OtherType # => true
+
+TestKlass.is? SomethingElse # => false
+TestKlass.is? :SomethingElse # => false
+
+# also works on instance
+obj = TestKlass.new
+obj.is? TestKlass # => true
+obj.is? :one_thing # => true
+
+# specific type test methods
+TestKlass.is_a_test_klass? # => true
+TestKlass.is_an_one_thing? # => true
+TestKlass.is_a_super_duper_thing? # => false
+
+obj.is_a_test_klass? # => true
+obj.is_an_one_thing? # => true
+obj.is_a_super_duper_thing? # => false
+```
+
+### Object creation shortcut: calling methods in Eapi
+
+Calling a method with the desired class name in `Eapi` module will do the same as `DesiredClass.new(...)`. The name can be the same as the class, or an underscorised version, or a simple underscored one.  
+
+The goal is to use `Eapi.esr_search(name: 'Paco')` as a shortcut to `Esr::Search.new(name: 'Paco')`. We can also use `Eapi.Esr_Search(...)` and other combinations.
+
+To show this feature and all the combinations for method names, we'll use the 2 example classes that are used in the actual test rspec.
+
+```ruby
+class MyTestKlassOutside
+  include Eapi::Item
+
+  property :something
+end
+
+module Somewhere
+  class TestKlassInModule
+    include Eapi::Item
+
+    property :something
+  end
+end
+```
+
+As shown by rspec run:
+
+```
+    initialise using method calls to Eapi
+      Eapi.MyTestKlassOutside(...)
+        calls MyTestKlassOutside.new
+      Eapi.my_test_klass_outside(...)
+        calls MyTestKlassOutside.new
+      Eapi.Somewhere__TestKlassInModule(...)
+        calls Somewhere::TestKlassInModule.new
+      Eapi.somewhere__test_klass_in_module(...)
+        calls Somewhere::TestKlassInModule.new
+      Eapi.Somewhere_TestKlassInModule(...)
+        calls Somewhere::TestKlassInModule.new
+      Eapi.somewhere_test_klass_in_module(...)
+        calls Somewhere::TestKlassInModule.new
+```
+
+
 ## `Eapi::Item`: Property based Item objects
 
 ### `initialize` method
@@ -141,76 +336,6 @@ x.one # => :fluent
 res.equal? x # => true
 ```
 
-### Convert to hashes: `render`, `to_h` and `create_hash`
-
-All Eapi classes respond to `render` and return a hash (for `Item` classes) or an array (for `List` classes), as it is the main purpose of this gem. It will execute any validation (see property definition), and if everything is ok, it will convert it to a simple hash structure.
-
-`Item` classes will invoke `render` when receiving `to_h`, while `List` classes will do the same when receiving `to_a`
- 
-#### Methods involved
-
-Inside, `render` will call `valid?`, raise an error of type `Eapi::Errors::InvalidElementError` if something is not right, and if everything is ok it will call `create_hash`.
-
-The `create_hash` method will create a hash with the properties as keys. Each value will be "converted" (see "Values conversion" section).
-
-#### Values conversion
-
-By default, each property will be converted into a simple element (Array, Hash, or simple value).  
-
-1. If a value responds to `render`, it will call that method. That way, Eapi objects that are values of some properties or lists will be validated and rendered (converted) themselves (render / value conversion cascade).
-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.
-
-important: *any nil value will be omitted* in the final hash.
-
-#### Example
-
-To demonstrate this behaviour we'll have an Eapi enabled class `ExampleEapi` and another `ComplexValue` class that responds to `to_h`. We'll set into the `ExampleEapi` object complex properties to demonstrate the conversion into a simple structure.
-
-```ruby
-class ComplexValue
-  def to_h
-    {
-      a: Set.new(['hello', 'world', MyTestObject.new])
-    }
-  end
-end
-
-class ExampleEapi
-  include Eapi::Item
-
-  property :something, required: true
-  property :other
-end
-
-# TESTING `render`
-
-list = Set.new [
-                 OpenStruct.new(a: 1, 'b' => 2),
-                 {c: 3, 'd' => 4},
-                 nil
-               ]
-
-eapi = ExampleEapi.new something: list, other: ComplexValue.new
-
-# same as eapi.to_h
-eapi.render # => 
-# {
-#   something: [
-#                {a: 1, b: 2},
-#                {c: 3, d: 4},
-#              ],
-# 
-#   other:     {
-#                a: [
-#                     'hello',
-#                     'world',
-#                     {a: 'hello'}
-#                   ]
-#              }
-# }
-```
-
 ### Property definition
 
 When defining the property, we can specify some options to specify what values are expected in that property. This serves for validation and automatic initialisation.
@@ -621,103 +746,6 @@ l.add(1)
 l.valid? # => false
 ```
 
-## Common to `Item` and `List`
-
-The following features are shared between `List`s and `Item`s.
-
-### Pose as other types
-
-An Eapi class can poses as other types, for purposes of `type` checking in a property definition. We use the class method `is` for this.
-
-the `is?` method is also available as an instance method. 
-
-Eapi also creates specific instance and class methods like `is_a_some_type?` or `is_an_another_type?`.
-
-example:
-
-```ruby
-class SuperTestKlass
-  include Eapi::Item
-end
- 
-class TestKlass < SuperTestKlass
-  is :one_thing, :other_thing, OtherType
-end
-
-TestKlass.is? TestKlass # => true
-TestKlass.is? 'TestKlass' # => true
-TestKlass.is? :TestKlass # => true
-
-TestKlass.is? SuperTestKlass # => true
-TestKlass.is? 'SuperTestKlass' # => true
-TestKlass.is? :SuperTestKlass # => true
-
-TestKlass.is? :one_thing # => true
-TestKlass.is? :other_thing # => true
-TestKlass.is? :other_thing # => true
-TestKlass.is? OtherType # => true
-TestKlass.is? :OtherType # => true
-
-TestKlass.is? SomethingElse # => false
-TestKlass.is? :SomethingElse # => false
-
-# also works on instance
-obj = TestKlass.new
-obj.is? TestKlass # => true
-obj.is? :one_thing # => true
-
-# specific type test methods
-TestKlass.is_a_test_klass? # => true
-TestKlass.is_an_one_thing? # => true
-TestKlass.is_a_super_duper_thing? # => false
-
-obj.is_a_test_klass? # => true
-obj.is_an_one_thing? # => true
-obj.is_a_super_duper_thing? # => false
-```
-
-### Object creation shortcut: calling methods in Eapi
-
-Calling a method with the desired class name in `Eapi` module will do the same as `DesiredClass.new(...)`. The name can be the same as the class, or an underscorised version, or a simple underscored one.  
-
-The goal is to use `Eapi.esr_search(name: 'Paco')` as a shortcut to `Esr::Search.new(name: 'Paco')`. We can also use `Eapi.Esr_Search(...)` and other combinations.
-
-To show this feature and all the combinations for method names, we'll use the 2 example classes that are used in the actual test rspec.
-
-```ruby
-class MyTestKlassOutside
-  include Eapi::Item
-
-  property :something
-end
-
-module Somewhere
-  class TestKlassInModule
-    include Eapi::Item
-
-    property :something
-  end
-end
-```
-
-As shown by rspec run:
-
-```
-    initialise using method calls to Eapi
-      Eapi.MyTestKlassOutside(...)
-        calls MyTestKlassOutside.new
-      Eapi.my_test_klass_outside(...)
-        calls MyTestKlassOutside.new
-      Eapi.Somewhere__TestKlassInModule(...)
-        calls Somewhere::TestKlassInModule.new
-      Eapi.somewhere__test_klass_in_module(...)
-        calls Somewhere::TestKlassInModule.new
-      Eapi.Somewhere_TestKlassInModule(...)
-        calls Somewhere::TestKlassInModule.new
-      Eapi.somewhere_test_klass_in_module(...)
-        calls Somewhere::TestKlassInModule.new
-```
-
 ## Using Eapi in your own library
 
 You can add the functionality of Eapi to your own library module, and use it instead of `Eapi::Item` or `Eapi::List`.

data/lib/eapi.rb

@@ -8,6 +8,7 @@ require 'eapi/children'
 require 'eapi/multiple_value'
 require 'eapi/definition_runners'
 require 'eapi/type_checker'
+require 'eapi/value_ignore_checker'
 require 'eapi/methods'
 require 'eapi/value_converter'
 require 'eapi/common'

data/lib/eapi/common.rb

@@ -22,6 +22,11 @@ module Eapi
       def validate!
         raise Eapi::Errors::InvalidElementError, "errors: #{errors.full_messages}, self: #{self.inspect}" unless valid?
       end
+
+      def render
+        validate!
+        perform_render
+      end
     end
 
     module ClassMethods

data/lib/eapi/item.rb

@@ -12,20 +12,22 @@ module Eapi
       Eapi::Common.add_features klass
     end
 
-    def render
-      validate!
-      create_hash
+    def to_h
+      render
     end
 
-    alias_method :to_h, :render
-
-    def create_hash
+    def perform_render
       {}.tap do |hash|
         _properties.each do |prop|
           val        = converted_value_for(prop)
-          hash[prop] = val unless val.nil?
+          hash[prop] = val unless to_be_ignored?(val, prop)
         end
       end
     end
+
+    private
+    def to_be_ignored?(value, property)
+      Eapi::ValueIgnoreChecker.to_be_ignored? value, self.class.ignore_definition(property)
+    end
   end
 end

data/lib/eapi/list.rb

@@ -30,15 +30,12 @@ module Eapi
       true
     end
 
-    def render
-      validate!
-      create_array
+    def to_a
+      render
     end
 
-    alias_method :to_a, :render
-
-    def create_array
-      _list.map { |val| convert_value val }
+    def perform_render
+      _list.map { |val| convert_value val }.reject { |x| to_be_ignored x }
     end
 
     def _list
@@ -77,6 +74,11 @@ module Eapi
 
     protected :initialize_copy
 
+    private
+    def to_be_ignored(value)
+      Eapi::ValueIgnoreChecker.to_be_ignored? value, self.class.elements_ignore_definition
+    end
+
     # transpose, assoc, rassoc , permutation, combination, repeated_permutation, repeated_combination, product, pack ?? => do not use the methods
   end
 

data/lib/eapi/methods/accessor.rb

@@ -10,7 +10,12 @@ module Eapi
 
         define_method fluent_adder do |value|
           current = send(getter) || send(init)
-          current << value
+          if current.respond_to? :add
+            current.add value
+          else
+            current << value
+          end
+
           send(fluent_setter, current)
         end
       end

data/lib/eapi/methods/properties.rb

@@ -71,6 +71,10 @@ module Eapi
           @_property_definitions ||= {}
         end
 
+        def ignore_definition(field)
+          definition_for(field).fetch(:ignore, :nil?)
+        end
+
         private :_property_allow_raw
         private :_property_definitions
         private :run_property_definition
@@ -90,13 +94,17 @@ module Eapi
           property_allow_raw?(:_list)
         end
 
+        def elements_ignore_definition
+          definition_for_elements.fetch(:ignore, :nil?)
+        end
+
         def elements(definition)
           run_list_definition definition
           store_list_definition definition
         end
 
         def definition_for_elements
-          @_list_definition
+          @_list_definition ||= {}
         end
 
         def store_list_definition(definition)

data/lib/eapi/value_ignore_checker.rb

@@ -0,0 +1,28 @@
+module Eapi
+  class ValueIgnoreChecker
+    def self.to_be_ignored?(value, ignore_definition = nil)
+      if ignore_definition.nil?
+        check_by_default value
+      elsif !ignore_definition
+        false
+      elsif ignore_definition.respond_to? :call
+        check_by_callable value, ignore_definition
+      else
+        check_by_message value, ignore_definition
+      end
+    end
+
+    private
+    def self.check_by_default(value)
+      value.nil?
+    end
+
+    def self.check_by_message(value, ignore_definition)
+      value.send ignore_definition
+    end
+
+    def self.check_by_callable(value, ignore_definition)
+      ignore_definition.call value
+    end
+  end
+end

data/lib/eapi/version.rb

@@ -1,3 +1,3 @@
 module Eapi
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/ignore_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  class IgnoreSpecTestItemDefault
+    include Eapi::Item
+    property :something
+  end
+
+  class IgnoreSpecTestItemFalse
+    include Eapi::Item
+    property :something, ignore: false
+  end
+
+  class IgnoreSpecTestItemSymbol
+    include Eapi::Item
+    property :something, ignore: :blank?
+  end
+
+  class IgnoreSpecTestItemProc
+    include Eapi::Item
+    property :something, ignore: Proc.new { |x| x.to_s == 'ignoreme' }
+  end
+
+  class IgnoreSpecTestListDefault
+    include Eapi::List
+  end
+
+  class IgnoreSpecTestListFalse
+    include Eapi::List
+
+    elements ignore: false
+  end
+
+  class IgnoreSpecTestListSymbol
+    include Eapi::List
+
+    elements ignore: :blank?
+  end
+
+  class IgnoreSpecTestListProc
+    include Eapi::List
+
+    elements ignore: Proc.new { |x| x.to_s == 'ignoreme' }
+  end
+
+
+  describe 'ignore values on render' do
+    describe 'default (no specification in definition)' do
+      describe 'Item' do
+        subject { IgnoreSpecTestItemDefault.new }
+        it 'ignore nil values' do
+          subject.something nil
+          expect_not_in_hash
+        end
+
+        it 'does not ignore any other value' do
+          subject.something 1
+          expect_in_hash
+        end
+      end
+
+      describe 'List' do
+        subject { IgnoreSpecTestListDefault.new }
+        it 'ignore nil values' do
+          subject.add nil
+          expect_not_in_array
+        end
+
+        it 'does not ignore any other value' do
+          subject.add 1
+          expect_in_array
+        end
+      end
+    end
+
+    describe 'message (symbol or string)' do
+      describe 'Item' do
+        subject { IgnoreSpecTestItemSymbol.new }
+        it 'ignore if sending the message to the value returns truthy' do
+          subject.something ""
+          expect_not_in_hash
+        end
+
+        it 'does not ignore any other value' do
+          subject.something 1
+          expect_in_hash
+        end
+      end
+
+      describe 'List' do
+        subject { IgnoreSpecTestListSymbol.new }
+        it 'ignore if sending the message to the value returns truthy' do
+          subject.add ""
+          expect_not_in_array
+        end
+
+        it 'does not ignore any other value' do
+          subject.add 1
+          expect_in_array
+        end
+      end
+    end
+
+    describe 'false' do
+      describe 'Item' do
+        subject { IgnoreSpecTestItemFalse.new }
+        it 'do not ignore any value (even nils)' do
+          subject.something nil
+          expect_in_hash
+        end
+
+        it 'does not ignore any other value' do
+          subject.something 1
+          expect_in_hash
+        end
+      end
+
+      describe 'List' do
+        subject { IgnoreSpecTestListFalse.new }
+        it 'do not ignore any value (even nils)' do
+          subject.add nil
+          expect_in_array
+        end
+
+        it 'does not ignore any other value' do
+          subject.add 1
+          expect_in_array
+        end
+      end
+    end
+
+    describe 'callable' do
+      describe 'Item' do
+        subject { IgnoreSpecTestItemProc.new }
+        it 'ignore if the callable element with the value returns truthy' do
+          subject.something :ignoreme
+          expect_not_in_hash
+        end
+
+        it 'does not ignore any other value' do
+          subject.something 1
+          expect_in_hash
+        end
+      end
+
+      describe 'List' do
+        subject { IgnoreSpecTestListProc.new }
+        it 'ignore if the callable element with the value returns truthy' do
+          subject.add :ignoreme
+          expect_not_in_array
+        end
+
+        it 'does not ignore any other value' do
+          subject.add 1
+          expect_in_array
+        end
+      end
+    end
+  end
+
+
+  def expect_not_in_hash
+    expect(subject.render.key? :something).to be false
+  end
+
+  def expect_in_hash
+    expect(subject.render.key? :something).to be true
+  end
+
+  def expect_not_in_array
+    expect(subject.render).to be_empty
+  end
+
+  def expect_in_array
+    expect(subject.render).not_to be_empty
+  end
+end

data/spec/{to_h_spec.rb → render_spec.rb}

@@ -8,6 +8,7 @@ RSpec.describe Eapi do
 
       property :something, required: true
       property :other
+      property :again
     end
 
     class MyTestObject
@@ -36,6 +37,24 @@ RSpec.describe Eapi do
       end
     end
 
+    class MyTestObjectComplexRender
+      def render
+        {
+          a: Set.new(['hello', 'world', MyTestObject.new])
+        }
+      end
+
+      def expected
+        {
+          a: [
+               'hello',
+               'world',
+               {a: 'hello'}
+             ]
+        }
+      end
+    end
+
     it 'raise error if invalid' do
       eapi = MyTestClassToH.new
       expect { eapi.to_h }.to raise_error do |error|
@@ -58,7 +77,7 @@ RSpec.describe Eapi do
       expect(eapi.to_h).to eq expected
     end
 
-    it 'hash with elements, all converted to basic Arrays and Hashes (keys as symbols), and exluding nils (if all validations pass)' do
+    it 'hash with elements, all converted to basic Arrays and Hashes (keys as symbols), and excluding nils (if all validations pass)' do
       list = Set.new [
                        OpenStruct.new(a: 1, 'b' => 2),
                        {c: 3, 'd' => 4},
@@ -66,6 +85,7 @@ RSpec.describe Eapi do
                      ]
 
       other = MyTestObjectComplex.new
+      again = MyTestObjectComplexRender.new
 
       expected = {
         something: [
@@ -73,12 +93,14 @@ RSpec.describe Eapi do
                      {c: 3, d: 4},
                    ],
 
-        other:     other.expected
+        other:     other.expected,
+        again:     again.expected
       }
 
       eapi = MyTestClassToH.new
       eapi.something list
       eapi.other other
+      eapi.again other
 
       expect(eapi.to_h).to eq expected
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eapi
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Eduardo Turiño
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-19 00:00:00.000000000 Z
+date: 2014-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -211,15 +211,17 @@ files:
 - lib/eapi/multiple_value.rb
 - lib/eapi/type_checker.rb
 - lib/eapi/value_converter.rb
+- lib/eapi/value_ignore_checker.rb
 - lib/eapi/version.rb
 - spec/basic_spec.rb
 - spec/definition_spec.rb
 - spec/extension_spec.rb
 - spec/function_spec.rb
+- spec/ignore_spec.rb
 - spec/list_elements_spec.rb
 - spec/list_spec.rb
+- spec/render_spec.rb
 - spec/spec_helper.rb
-- spec/to_h_spec.rb
 - spec/type_spec.rb
 - spec/validations_spec.rb
 homepage: ''
@@ -252,10 +254,11 @@ test_files:
 - spec/definition_spec.rb
 - spec/extension_spec.rb
 - spec/function_spec.rb
+- spec/ignore_spec.rb
 - spec/list_elements_spec.rb
 - spec/list_spec.rb
+- spec/render_spec.rb
 - spec/spec_helper.rb
-- spec/to_h_spec.rb
 - spec/type_spec.rb
 - spec/validations_spec.rb
 has_rdoc: