eapi 0.0.1 → 0.1.0

data/eapi.gemspec

@@ -27,7 +27,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry-rescue"
   spec.add_development_dependency "pry-stack_explorer"
   spec.add_development_dependency "pry-doc"
-  spec.add_development_dependency "coveralls"
 
   spec.add_dependency 'activesupport', '~> 4'
   spec.add_dependency 'activemodel', '~> 4'

data/lib/eapi.rb

@@ -3,14 +3,22 @@ require 'active_model'
 
 require 'eapi/version'
 require 'eapi/errors'
+require 'eapi/children'
 require 'eapi/multiple'
+require 'eapi/definition_runner'
+require 'eapi/type_checker'
 require 'eapi/methods'
+require 'eapi/value_converter'
 require 'eapi/common'
 
 
 module Eapi
   def self.method_missing(method, *args, &block)
-    klass = const_get("Eapi::#{method}")
-    klass.new *args, &block
+    klass = Eapi::Children.get(method)
+    if klass
+      klass.new *args, &block
+    else
+      super
+    end
   end
 end

data/lib/eapi/children.rb

@@ -0,0 +1,30 @@
+module Eapi
+  module Children
+    CHILDREN = {}
+
+    def self.list
+      CHILDREN.values
+    end
+
+    def self.append(klass)
+      k           = self.key_for klass
+      CHILDREN[k] = klass
+    end
+
+    def self.get(klass_name)
+      k = self.key_for klass_name
+      CHILDREN[k] ||
+        CHILDREN[k.gsub('__', '/')] ||
+        CHILDREN.select { |key, _| key.gsub('/', '_') == k }.values.first
+    end
+
+    def self.has?(klass_name)
+      !!self.get(klass_name)
+    end
+
+    def self.key_for(klass_name)
+      k = klass_name.to_s
+      k.underscore
+    end
+  end
+end

data/lib/eapi/common.rb

@@ -1,28 +1,21 @@
 module Eapi
   module Common
     extend ActiveSupport::Concern
-    included do
-      include ActiveModel::Validations
-      include Eapi::Methods::Properties::InstanceMethods
+    included do |klass|
+      Eapi::Children.append klass
+      klass.send :include, ActiveModel::Validations
+      klass.send :include, Eapi::Methods::Properties::InstanceMethods
+      klass.send :include, Eapi::Methods::Types::InstanceMethods
     end
 
     def initialize(** properties)
       properties.each do |k, v|
-        normal_setter = "#{k}="
+        normal_setter = Eapi::Methods::Names.setter k
         #TODO: what to do with unrecognised properties
         send normal_setter, v if respond_to? normal_setter
       end
     end
 
-    def method_missing(method, *args)
-      catch(:response) do
-        Eapi::Methods::Types.check_asking_type method, self
-
-        # if nothing catch -> continue super
-        super
-      end
-    end
-
     def to_h
       raise Eapi::Errors::InvalidElementError, "errors: #{errors.full_messages}, self: #{self.inspect}" unless valid?
 
@@ -32,8 +25,7 @@ module Eapi
     def create_hash
       {}.tap do |hash|
         self.class.properties.each do |prop|
-          stored     = get(prop)
-          val        = (stored.present? && stored.respond_to?(:to_h)) ? stored.to_h : stored
+          val        = Eapi::ValueConverter.convert_value(get(prop))
           hash[prop] = val unless val.nil?
         end
       end
@@ -44,5 +36,6 @@ module Eapi
       include Eapi::Methods::Types::ClassMethods
       include Eapi::Methods::Properties::ClassMethods
     end
+
   end
 end

data/lib/eapi/definition_runner.rb

@@ -0,0 +1,109 @@
+module Eapi
+  class DefinitionRunner < Struct.new(:klass, :field, :definition)
+    def run
+      run_multiple_accessor
+      run_init
+      run_validations
+    end
+
+    private
+    def run_validations
+      run_required
+      run_validate_type
+      run_validate_with
+      run_validate_element_type
+      run_validate_element_with
+    end
+
+    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
+      end
+    end
+
+    def run_validate_element_with
+      if multiple && validate_element_with
+        klass.send :validates_each, field do |record, attr, value|
+          if value.respond_to?(:each)
+            value.each do |v|
+              validate_element_with.call(record, attr, v)
+            end
+          end
+        end
+      end
+    end
+
+    def run_validate_element_type
+      if multiple && element_type
+        klass.send :validates_each, field do |record, attr, value|
+          if value.respond_to?(:each)
+            value.each do |v|
+              record.errors.add(attr, "element must be a #{element_type}") unless v.kind_of?(element_type)
+            end
+          end
+        end
+      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
+      end
+    end
+
+    def run_required
+      if required
+        klass.send :validates_presence_of, field
+      end
+    end
+
+    def run_init
+      if type || multiple
+        klass.send :define_init, field, type || Array
+      end
+    end
+
+    def run_multiple_accessor
+      if multiple
+        klass.send :define_multiple_accessor, field
+      end
+    end
+
+    def type_multiple?(type)
+      return false if type.nil?
+      return true if type == Array || type == Set
+
+      type.respond_to?(:is_multiple?) && type.is_multiple?
+    end
+
+    def validate_element_with
+      definition.fetch(:validate_element_with, nil)
+    end
+
+    def multiple
+      definition.fetch(:multiple, false) || type_multiple?(type)
+    end
+
+    def required
+      definition.fetch(:required, false)
+    end
+
+    def validate_with
+      definition.fetch(:validate_with, nil)
+    end
+
+    def element_type
+      definition.fetch(:element_type, nil)
+    end
+
+    def type
+      definition.fetch(:type, nil)
+    end
+  end
+end

data/lib/eapi/methods/names.rb

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

data/lib/eapi/methods/properties.rb

@@ -37,7 +37,7 @@ module Eapi
         end
 
         def run_definition(field, definition)
-          DefinitionRunner.new(self, field, definition).run
+          Eapi::DefinitionRunner.new(self, field, definition).run
         end
 
         private :run_definition
@@ -45,113 +45,5 @@ module Eapi
       end
     end
 
-    class DefinitionRunner < Struct.new(:klass, :field, :definition)
-      def run
-        run_multiple_accessor
-        run_init
-        run_validations
-      end
-
-      private
-      def run_validations
-        run_required
-        run_validate_type
-        run_validate_with
-        run_validate_type_element
-        run_validate_element_with
-      end
-
-      def run_validate_type
-        if type
-          klass.send :validates_each, field do |record, attr, value|
-            return if value.nil? && !required
-
-            record.errors.add(attr, "must be a #{type}") unless value.kind_of?(type)
-          end
-        end
-      end
-
-      def run_validate_element_with
-        if multiple && validate_element_with
-          validates_each field do |record, attr, value|
-            if value.respond_to?(:each)
-              value.each do |v|
-                validate_element_with.call(record, attr, v)
-              end
-            end
-          end
-        end
-      end
-
-      def run_validate_type_element
-        if multiple && type_element
-          validates_each field do |record, attr, value|
-            if value.respond_to?(:each)
-              value.each do |v|
-                record.errors.add(attr, "element must be a #{type}") unless v.kind_of?(type)
-              end
-            end
-          end
-        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
-        end
-      end
-
-      def run_required
-        if required
-          klass.send :validates_presence_of, field
-        end
-      end
-
-      def run_init
-        if type || multiple
-          klass.send :define_init, field, type || Array
-        end
-      end
-
-      def run_multiple_accessor
-        if multiple
-          klass.send :define_multiple_accessor, field
-        end
-      end
-
-      def type_multiple?(type)
-        return false if type.nil?
-        return true if type == Array || type == Set
-
-        type.respond_to?(:is_multiple?) && type.is_multiple?
-      end
-
-      def validate_element_with
-        definition.fetch(:validate_element_with, nil)
-      end
-
-      def multiple
-        definition.fetch(:multiple, false) || type_multiple?(type)
-      end
-
-      def required
-        definition.fetch(:required, false)
-      end
-
-      def validate_with
-        definition.fetch(:validate_with, nil)
-      end
-
-      def type_element
-        definition.fetch(:type_element, nil)
-      end
-
-      def type
-        definition.fetch(:type, nil)
-      end
-    end
-
   end
 end

data/lib/eapi/methods/types.rb

@@ -1,11 +1,13 @@
 module Eapi
   module Methods
-
     module Types
       def self.type_question_method(method)
         ms = method.to_s
-        if ms.start_with?('is_a_') && ms.end_with?('?')
+        return false unless ms.end_with?('?')
+        if ms.start_with?('is_a_')
           ms.sub('is_a_', '').sub('?', '')
+        elsif ms.start_with?('is_an_')
+          ms.sub('is_an_', '').sub('?', '')
         else
           nil
         end
@@ -14,19 +16,64 @@ module Eapi
       def self.check_asking_type(method, obj)
         type = Types.type_question_method method
         if type
-          throw :response, obj.class.is?(type)
+          obj.is?(type)
+        else
+          nil
+        end
+      end
+
+      def self.to_type_sym(x)
+        x.to_s.underscore.to_sym
+      end
+
+      module IsAnOtherTypeMethods
+        def respond_to_missing?(method, include_all)
+          if Types.type_question_method(method).present?
+            true
+          else
+            super
+          end
+        end
+
+        def method_missing(method, *args, &block)
+          resp = Types.check_asking_type method, self
+          if resp.nil?
+            super
+          else
+            resp
+          end
         end
       end
 
+      module InstanceMethods
+        def is?(type)
+          self.class.is?(type)
+        end
+
+        def self.included(klass)
+          klass.send :include, IsAnOtherTypeMethods
+        end
+      end
 
       module ClassMethods
+        def self.included(klass)
+          klass.send :include, IsAnOtherTypeMethods
+        end
+
         def is?(type)
-          @i_am_a && @i_am_a.include?(type.to_sym)
+          type_sym = Types.to_type_sym type
+
+          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
 
         def is(*types)
+          ts = types.map { |t| Types.to_type_sym t }
+
           @i_am_a ||= []
-          @i_am_a.concat(types.map(&:to_sym))
+          @i_am_a.concat ts
         end
       end
 

data/lib/eapi/type_checker.rb

@@ -0,0 +1,16 @@
+module Eapi
+  class TypeChecker < Struct.new(:type)
+    def is_valid_type?(value)
+      value.nil? || is_same_type?(value) || poses_as_type?(value)
+    end
+
+    private
+    def is_same_type?(value)
+      value.kind_of?(type)
+    end
+
+    def poses_as_type?(value)
+      value.respond_to?(:is?) && value.is?(type)
+    end
+  end
+end