eapi 0.2.1 → 0.3.0

data/lib/eapi/definition_runners/property.rb

@@ -4,6 +4,7 @@ module Eapi
     class Property < Struct.new(:klass, :field, :definition)
       def run
         run_multiple_accessor
+        run_multiple_clearer
         run_init
         run_validations
         run_allow_raw
@@ -53,8 +54,10 @@ module Eapi
       end
 
       def run_init
-        if type || multiple?
-          Runner.init(klass: klass, field: field, type: type || Array)
+        if init_class
+          Runner.init(klass: klass, field: field, type: init_class)
+        elsif multiple? && (type.blank? || type.to_s == 'Array')
+          Runner.init(klass: klass, field: field, type: Array)
         end
       end
 
@@ -64,11 +67,19 @@ module Eapi
         end
       end
 
+      def run_multiple_clearer
+        if multiple?
+          Runner.multiple_clearer(klass: klass, field: field)
+        end
+      end
+
       def type_multiple?(type)
-        return false if type.nil?
-        return true if type == Array || type == Set
+        type_class = Eapi::TypeChecker.constant_for_type type
 
-        type.respond_to?(:is_multiple?) && type.is_multiple?
+        return false if type_class.nil?
+        return true if type_class == Array || type_class == Set
+
+        type_class.respond_to?(:is_multiple?) && type_class.is_multiple?
       end
 
       def validate_element_with
@@ -76,7 +87,7 @@ module Eapi
       end
 
       def multiple?
-        definition.fetch(:multiple, false) || type_multiple?(type)
+        definition.fetch(:multiple, false) || type_multiple?(type) || type_multiple?(init_class)
       end
 
       def required?
@@ -95,6 +106,10 @@ module Eapi
         definition.fetch(:type, nil)
       end
 
+      def init_class
+        definition.fetch(:init_class, nil)
+      end
+
       def allow_raw?
         definition.fetch(:allow_raw, false)
       end

data/lib/eapi/definition_runners/runner.rb

@@ -71,6 +71,10 @@ module Eapi
       def self.multiple_accessor(klass:, field:)
         klass.send :define_multiple_accessor, field
       end
+
+      def self.multiple_clearer(klass:, field:)
+        klass.send :define_multiple_clearer, field
+      end
     end
   end
 end

data/lib/eapi/errors.rb

@@ -2,5 +2,11 @@ module Eapi
   module Errors
     class InvalidElementError < StandardError
     end
+
+    class InvalidInitClass < StandardError
+    end
+
+    class CannotClearFieldError < StandardError
+    end
   end
 end

data/lib/eapi/methods/accessor.rb

@@ -15,12 +15,35 @@ module Eapi
         end
       end
 
-      def define_init(field, type_class)
+      def define_multiple_clearer(field)
+        init           = Eapi::Methods::Names.init field
+        fluent_clearer = Eapi::Methods::Names.clearer field
+        getter         = Eapi::Methods::Names.getter field
+
+        define_method fluent_clearer do
+          current = send(getter)
+          if current.nil?
+            # NOOP
+          elsif current.respond_to?(:clear)
+            current.clear
+          elsif respond_to?(init)
+            send(init)
+          else
+            raise Eapi::Errors::CannotClearFieldError, "#{self} can't clear #{field}: it does not respond to `clear` nor we have defined a `init_#{field}` method"
+          end
+
+          self
+        end
+      end
+
+      def define_init(field, init_class)
         init         = Eapi::Methods::Names.init field
         instance_var = Eapi::Methods::Names.instance_var field
 
         define_method init do
-          value = type_class.new
+          klass = Eapi::TypeChecker.constant_for_type init_class
+          raise Eapi::Errors::InvalidInitClass, "init_class: #{init_class}" if klass.nil?
+          value = klass.new
           instance_variable_set instance_var, value
         end
       end

data/lib/eapi/methods/names.rb

@@ -10,6 +10,10 @@ module Eapi
         "add_#{field}"
       end
 
+      def self.clearer(field)
+        "clear_#{field}"
+      end
+
       def self.getter(field)
         "#{field}"
       end

data/lib/eapi/methods/properties.rb

@@ -29,21 +29,15 @@ module Eapi
 
       module ClassMethods
         def property_allow_raw(field)
-          @_property_allow_raw ||= {}
-
-          @_property_allow_raw[field.to_sym] = true
+          _property_allow_raw[field.to_sym] = true
         end
 
         def property_disallow_raw(field)
-          @_property_allow_raw ||= {}
-
-          @_property_allow_raw[field.to_sym] = false
+          _property_allow_raw[field.to_sym] = false
         end
 
         def property_allow_raw?(field)
-          @_property_allow_raw ||= {}
-
-          @_property_allow_raw.fetch(field.to_sym, false)
+          _property_allow_raw.fetch(field.to_sym, false)
         end
 
         def property(field, definition = {})
@@ -54,23 +48,31 @@ module Eapi
         end
 
         def properties
-          @_property_definitions.keys
+          _property_definitions.keys
         end
 
         def definition_for(field)
-          @_property_definitions ||= {}
-          @_property_definitions.fetch(field.to_sym, {}).dup
+          _property_definitions.fetch(field.to_sym, {}).dup
         end
 
         def store_property_definition(field, definition)
-          @_property_definitions        ||= {}
-          @_property_definitions[field] = definition
+          _property_definitions[field] = definition.tap { |x| x.freeze }
         end
 
         def run_property_definition(property_field, definition)
           Eapi::DefinitionRunners::Property.new(self, property_field, definition).run
         end
 
+        def _property_allow_raw
+          @_property_allow_raw ||= {}
+        end
+
+        def _property_definitions
+          @_property_definitions ||= {}
+        end
+
+        private :_property_allow_raw
+        private :_property_definitions
         private :run_property_definition
         private :store_property_definition
       end
@@ -98,7 +100,7 @@ module Eapi
         end
 
         def store_list_definition(definition)
-          @_list_definition = definition
+          @_list_definition = definition.tap { |x| x.freeze }
         end
 
         def run_list_definition(definition)

data/lib/eapi/methods/types.rb

@@ -47,6 +47,7 @@ module Eapi
 
       module InstanceMethods
         def is?(type)
+          return true if type.kind_of?(Module) && kind_of?(type)
           self.class.is?(type)
         end
 
@@ -61,11 +62,12 @@ module Eapi
         end
 
         def is?(type)
+          return true if Checker._is_type_module?(self, type)
+
           type_sym = Types.to_type_sym type
+          return true if Checker._is_type_module_sym?(self, type_sym)
 
-          return true if self == type || Types.to_type_sym(self) == type_sym
           return false unless @i_am_a.present?
-
           !!@i_am_a.include?(type_sym) # force it to be a bool
         end
 
@@ -77,6 +79,16 @@ module Eapi
         end
       end
 
+      module Checker
+        def self._is_type_module?(klass, mod_or_class)
+          return false unless mod_or_class.kind_of?(Module)
+          klass == mod_or_class || klass.ancestors.include?(mod_or_class)
+        end
+
+        def self._is_type_module_sym?(klass, type_sym)
+          Types.to_type_sym(self) == type_sym || klass.ancestors.any? { |a| Types.to_type_sym(a) == type_sym }
+        end
+      end
     end
   end
 end

data/lib/eapi/type_checker.rb

@@ -1,6 +1,18 @@
 module Eapi
   class TypeChecker
 
+    def self.constant_for_type(type)
+      if type.kind_of? Module
+        type
+      else
+        begin
+          type.to_s.constantize
+        rescue NameError
+          nil
+        end
+      end
+    end
+
     attr_reader :given_type, :allow_raw
 
     def initialize(given_type, allow_raw = false)
@@ -9,7 +21,7 @@ module Eapi
     end
 
     def is_valid_type?(value)
-      value.nil? || is_same_type?(value) || poses_as_type?(value) || valid_raw?(value)
+      value.nil? || valid_raw?(value) || is_same_type?(value) || poses_as_type?(value)
     end
 
     private
@@ -20,7 +32,7 @@ module Eapi
     end
 
     def is_same_type?(value)
-      value.kind_of?(type)
+      value.kind_of?(type_class) if type_class.present?
     end
 
     def poses_as_type?(value)
@@ -28,11 +40,15 @@ module Eapi
     end
 
     def type
-      if given_type.kind_of? Module
-        given_type
-      else
-        given_type.to_s.constantize
-      end
+      given_type
+    end
+
+    def type_class
+      @type_class ||= load_type_class
+    end
+
+    def load_type_class
+      Eapi::TypeChecker.constant_for_type given_type
     end
 
     def allow_raw?

data/lib/eapi/value_converter.rb

@@ -3,6 +3,8 @@ module Eapi
     def self.convert_value(value)
       if value.nil?
         nil
+      elsif can_render? value
+        value_from_render value
       elsif is_list? value
         value_from_list value
       elsif is_hash?(value)
@@ -13,6 +15,10 @@ module Eapi
     end
 
     private
+    def self.can_render?(value)
+      value.respond_to? :render
+    end
+
     def self.is_hash?(value)
       value.respond_to? :to_h
     end
@@ -23,6 +29,10 @@ module Eapi
       value.respond_to? :to_a
     end
 
+    def self.value_from_render(value)
+      value.render
+    end
+
     def self.value_from_list(value)
       value.to_a.map { |e| convert_value e }.compact
     end

data/lib/eapi/version.rb

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

data/spec/list_elements_spec.rb

@@ -2,74 +2,103 @@ require 'spec_helper'
 
 RSpec.describe Eapi do
 
-  context 'list elements' do
-    class MyTestClassValMult
-      include Eapi::Item
-
-      property :something, multiple: true
+  class MyMultiple
+    def self.is_multiple?
+      true
     end
 
-    it '#add_something' do
-      eapi = MyTestClassValMult.new something: [1, 2]
-      res  = eapi.add_something 3
-      expect(res).to be eapi
-      expect(eapi.something).to eq [1, 2, 3]
+    def <<(x)
+      @elements ||= []
+      @elements << x
     end
 
-    it '#init_something called on first add if element is nil' do
-      eapi = MyTestClassValMult.new
-      res  = eapi.add_something :a
-      expect(res).to be eapi
-      expect(eapi.something.to_a).to eq [:a]
+    def to_a
+      @elements.to_a
     end
+  end
 
-    class MyTestClassValMultImpl
-      include Eapi::Item
+  class MyMultipleValueTestKlass
+    include Eapi::MultipleValue
 
-      property :something, type: Set
+    def <<(x)
+      @elements ||= []
+      @elements << x
     end
 
-    class MyMultiple
-      def self.is_multiple?
-        true
-      end
+    def to_a
+      @elements.to_a
+    end
+  end
 
-      def <<(x)
-        @elements ||= []
-        @elements << x
-      end
+  class MyTestClassValMult
+    include Eapi::Item
 
-      def to_a
-        @elements.to_a
-      end
-    end
+    property :something, multiple: true
+  end
 
-    class MyTestClassValMultImpl2
-      include Eapi::Item
+  class MyTestClassValMultImpl
+    include Eapi::Item
 
-      property :something, type: MyMultiple
-    end
+    property :something, init_class: Set
+  end
 
-    class MyMultipleValueTestKlass
-      include Eapi::MultipleValue
+  class MyTestClassValMultImpl2
+    include Eapi::Item
 
-      def <<(x)
-        @elements ||= []
-        @elements << x
-      end
+    property :something, init_class: :MyMultiple
+  end
 
-      def to_a
-        @elements.to_a
-      end
-    end
 
-    class MyTestClassValMultImpl3
-      include Eapi::Item
+  class MyTestClassValMultImpl3
+    include Eapi::Item
+
+    property :something, init_class: "MyMultipleValueTestKlass"
+  end
+
+
+  class MyTestClassValMultTypeTest
+    include Eapi::Item
+
+    property :something, multiple: true
+  end
+
+  class MyTestClassValMultImplTypeTest
+    include Eapi::Item
+
+    property :something, type: Set
+  end
+
+  class MyTestClassValMultImpl2TypeTest
+    include Eapi::Item
+
+    property :something, type: :MyMultiple
+  end
+
+
+  class MyTestClassValMultImpl3TypeTest
+    include Eapi::Item
+
+    property :something, type: "MyMultipleValueTestKlass"
+  end
 
-      property :something, type: MyMultipleValueTestKlass
+
+  context 'list elements' do
+    it '#add_something' do
+      eapi = MyTestClassValMult.new something: [1, 2]
+      res  = eapi.add_something 3
+      expect(res).to be eapi
+      expect(eapi.something).to eq [1, 2, 3]
     end
 
-    it 'if type is Array or Set, or responds true to is_multiple?, it is multiple implicitly + uses that class to initialize the property when adding' do
+    it '#init_something called on first add if element is nil' do
+      eapi = MyTestClassValMult.new
+      res  = eapi.add_something :a
+      expect(res).to be eapi
+      expect(eapi.something.to_a).to eq [:a]
+    end
+
+
+    it 'if init_class is Array or Set, or responds true to is_multiple?, it is multiple implicitly + uses that class to initialize the property when adding' do
       [
         [MyTestClassValMult, Array],
         [MyTestClassValMultImpl, Set],
@@ -84,6 +113,78 @@ RSpec.describe Eapi do
       end
     end
 
+    it 'if type is Array or Set, or responds true to is_multiple?, it is multiple implicitly but it does not use it to initialize the property when adding (unless type == Array)' do
+      [
+        [MyTestClassValMultTypeTest, Array],
+        [MyTestClassValMultImplTypeTest, Set],
+        [MyTestClassValMultImpl2TypeTest, MyMultiple],
+        [MyTestClassValMultImpl3TypeTest, MyMultipleValueTestKlass],
+      ].each do |(eapi_class, type_class)|
+        eapi = eapi_class.new
+
+        unless type_class == Array
+          expect { eapi.add_something :a }.to raise_exception
+        end
+
+        eapi.something type_class.new
+
+        res = eapi.add_something :a
+        expect(res).to be eapi
+        expect(eapi.something.to_a).to eq [:a]
+        expect(eapi.something).to be_a_kind_of type_class
+      end
+    end
+
+    context '#clear_something' do
+      it 'if value is nil, returns self' do
+        [
+          MyTestClassValMultTypeTest,
+          MyTestClassValMultImplTypeTest,
+          MyTestClassValMultImpl2TypeTest,
+          MyTestClassValMultImpl3TypeTest,
+        ].each do |eapi_class|
+          eapi = eapi_class.new
+          expect(eapi.clear_something).to be eapi
+          expect(eapi.something).to be_nil
+        end
+      end
+
+      it 'if value respond to clear, it will call it' do
+        [
+          MyTestClassValMultTypeTest,
+          MyTestClassValMultImplTypeTest,
+          MyTestClassValMultImpl2TypeTest,
+          MyTestClassValMultImpl3TypeTest,
+        ].each do |eapi_class|
+          o = double()
+          expect(o).to receive(:clear)
+
+          eapi = eapi_class.new something: o
+          expect(eapi.clear_something).to be eapi
+        end
+      end
+
+      it 'if value do not respond to clear, it will call the `init_something` method' do
+        [
+          MyTestClassValMultTypeTest,
+          MyTestClassValMultImplTypeTest,
+          MyTestClassValMultImpl2TypeTest,
+          MyTestClassValMultImpl3TypeTest,
+        ].each do |eapi_class|
+          o    = double()
+          eapi = eapi_class.new something: o
+          expect(eapi).to receive(:init_something)
+          expect(eapi.clear_something).to be eapi
+        end
+      end
+
+      it 'if value do not respond to clear and we do not have `init_something` method, raise exception' do
+        eapi = MyTestClassValMultImpl3TypeTest.new something: MyMultipleValueTestKlass.new
+        expect { eapi.clear_something }.to raise_exception()
+      end
+
+    end
+
     describe 'element validation' do
       class MyTestClassValElements
         include Eapi::Item