eapi 0.1.2 → 0.2.0

data/lib/eapi/definition_runners/property.rb

@@ -0,0 +1,100 @@
+module Eapi
+  module DefinitionRunners
+
+    class Property < 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_required
+        if required?
+          Runner.required klass: klass, field: field
+        end
+      end
+
+      def run_validate_element_with
+        if multiple? && validate_element_with
+          Runner.validate_element_with klass: klass, field: field, validate_element_with: validate_element_with
+        end
+      end
+
+      def run_validate_element_type
+        if multiple? && element_type
+          Runner.validate_element_type(klass: klass, field: field, element_type: element_type)
+        end
+      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_with
+        if validate_with
+          klass.send :validates_each, field do |record, attr, value|
+            validate_with.call(record, attr, value)
+          end
+        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
+end

data/lib/eapi/definition_runners/runner.rb

@@ -0,0 +1,44 @@
+module Eapi
+  module DefinitionRunners
+    class Runner
+      def self.validate_element_with(klass:, field:, 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
+
+      def self.validate_element_type(klass:, field:, element_type:)
+        klass.send :validates_each, field do |record, attr, value|
+          if value.respond_to?(:each)
+            value.each do |v|
+              unless Eapi::TypeChecker.new(element_type).is_valid_type?(v)
+                record.errors.add(attr, "element must be a #{element_type}")
+              end
+            end
+          end
+        end
+      end
+
+      def self.required(klass:, field:)
+        klass.send :validates_presence_of, field
+      end
+
+      def self.unique(klass:, field:)
+        klass.send :validates_each, field do |record, attr, value|
+          if value.respond_to?(:group_by)
+            grouped         = value.group_by { |i| i }
+            repeated_groups = grouped.select { |k, v| v.size > 1 }
+            unless repeated_groups.empty?
+              repeated = Hash[repeated_groups.map { |k, v| [k, v.size] }]
+              record.errors.add(attr, "elements must be unique (repeated elements: #{repeated})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eapi/item.rb

@@ -0,0 +1,31 @@
+module Eapi
+  module Item
+    extend Common
+
+    def self.extended(mod)
+      def mod.included(klass)
+        Eapi::Common.add_features klass
+      end
+    end
+
+    def self.included(klass)
+      Eapi::Common.add_features klass
+    end
+
+    def render
+      validate!
+      create_hash
+    end
+
+    alias_method :to_h, :render
+
+    def create_hash
+      {}.tap do |hash|
+        _properties.each do |prop|
+          val        = converted_value_for(prop)
+          hash[prop] = val unless val.nil?
+        end
+      end
+    end
+  end
+end

data/lib/eapi/list.rb

@@ -0,0 +1,145 @@
+module Eapi
+  module List
+    include Comparable
+    include Enumerable
+    extend Common
+
+    module ClassMethods
+      def is_multiple?
+        true
+      end
+    end
+
+    def self.add_features(klass)
+      Eapi::Common.add_features klass
+      klass.extend(ClassMethods)
+      klass.extend(Eapi::Methods::Properties::ListCLassMethods)
+    end
+
+    def self.extended(mod)
+      def mod.included(klass)
+        Eapi::List.add_features klass
+      end
+    end
+
+    def self.included(klass)
+      Eapi::List.add_features klass
+    end
+
+    def is_multiple?
+      true
+    end
+
+    def render
+      validate!
+      create_array
+    end
+
+    alias_method :to_a, :render
+
+    def create_array
+      _list.map { |val| convert_value val }
+    end
+
+    def _list
+      @_list ||= []
+    end
+
+    def add(value)
+      self << value
+      self
+    end
+
+    def <=>(other)
+      (_list <=> other) || (other.respond_to?(:_list) && _list <=> other._list)
+    end
+
+    # From Array
+
+    # ary.replace(other_ary)  -> ary
+    # ary.initialize_copy(other_ary)   -> ary
+    #
+    # Replaces the contents of +self+ with the contents of +other_ary+,
+    # truncating or expanding if necessary.
+    #
+    #    a = [ "a", "b", "c", "d", "e" ]
+    #    a.replace([ "x", "y", "z" ])   #=> ["x", "y", "z"]
+    #    a                              #=> ["x", "y", "z"]
+    def initialize_copy(other_ary)
+      if other_ary.kind_of? List
+        @_list = other_ary._list.dup
+      elsif other_ary.respond_to? :to_a
+        @_list = other_ary.to_a
+      else
+        raise ArgumentError, 'must be either a List or respond to `to_a`'
+      end
+    end
+
+    protected :initialize_copy
+
+    # transpose, assoc, rassoc , permutation, combination, repeated_permutation, repeated_combination, product, pack ?? => do not use the methods
+  end
+
+  class ListMethodDefiner
+
+    DESTRUCTIVE_SELF_OR_NIL = [:uniq!, :compact!, :flatten!, :shuffle!, :concat, :clear, :replace, :fill, :reverse!, :rotate!, :sort!, :keep_if]
+
+    DUP_METHODS = [:uniq, :compact, :flatten, :shuffle, :+, :-, :&, :|, :reverse, :rotate, :sort, :split, :in_groups, :in_groups_of, :from, :to]
+
+    DELEGATED_METHODS = [
+      # normal delegation
+      :frozen?, :[], :[]=, :at, :fetch, :first, :last, :<<, :push, :pop, :shift, :unshift, :insert, :length, :size, :empty?, :rindex, :join, :collect, :map, :select, :values_at, :delete, :delete_at, :delete_if, :reject, :include?, :count, :sample, :bsearch, :to_json_without_active_support_encoder, :slice, :slice!, :sort_by!, :shuffle, :shuffle!,
+
+      # for Enumerable
+      :each, :each_index,
+
+      # pose as array
+      :to_ary, :*,
+
+      # active support
+      :shelljoin, :append, :prepend, :extract_options!, :to_sentence, :to_formatted_s, :to_default_s, :to_xml, :second, :third, :fourth, :fifth, :forty_two, :to_param, :to_query,
+
+      # destructive that return selection
+      :collect!, :map!, :select!, :reject!,
+    ]
+
+    def self.finalise(klass)
+      delegate_methods_to_list klass
+      pose_as_array klass
+      destructive_self_or_nil klass
+      dup_methods klass
+    end
+
+    private
+    def self.delegate_methods_to_list(klass)
+      klass.send :delegate, *DELEGATED_METHODS, to: :_list
+    end
+
+
+    def self.destructive_self_or_nil(klass)
+      # Destructive methods that return self or nil
+      DESTRUCTIVE_SELF_OR_NIL.each do |m|
+        klass.send :define_method, m do |*args, &block|
+          res = _list.send m, *args, &block
+          res.nil? ? nil : self
+        end
+      end
+    end
+
+    def self.pose_as_array(klass)
+      klass.send :alias_method, :index, :find_index
+    end
+
+    def self.dup_methods(klass)
+      # Non destructive methods that return a new object
+      DUP_METHODS.each do |m|
+        klass.send :define_method, m do |*args, &block|
+          dup.tap { |n| n.initialize_copy(n._list.send m, *args, &block) }
+        end
+      end
+    end
+
+  end
+
+  ListMethodDefiner.finalise List
+end

data/lib/eapi/methods/accessor.rb

@@ -26,29 +26,7 @@ module Eapi
       end
 
       def define_accessors(field)
-        normal_setter = Eapi::Methods::Names.setter field
-        fluent_setter = Eapi::Methods::Names.fluent_setter field
-        getter        = Eapi::Methods::Names.getter field
-        instance_var  = Eapi::Methods::Names.instance_var field
-
-        define_method normal_setter do |value|
-          instance_variable_set instance_var, value
-        end
-
-        # fluent setter that calls the normal setter and returns self
-        define_method fluent_setter do |value|
-          send normal_setter, value
-          self
-        end
-
-        # special getter => if no arguments it is a getter, if arguments it calls the fluent setter
-        define_method getter do |*args|
-          if args.empty?
-            instance_variable_get instance_var
-          else
-            send fluent_setter, *args
-          end
-        end
+        fluent_accessor field
       end
     end
   end

data/lib/eapi/methods/properties.rb

@@ -3,6 +3,19 @@ module Eapi
 
     module Properties
       module InstanceMethods
+
+        def _properties
+          self.class.properties
+        end
+
+        def converted_value_for(prop)
+          convert_value get(prop)
+        end
+
+        def convert_value(value)
+          Eapi::ValueConverter.convert_value(value)
+        end
+
         def get(field)
           getter = Eapi::Methods::Names.getter field
           send(getter)
@@ -18,30 +31,52 @@ module Eapi
         def property(field, definition = {})
           fs = field.to_sym
           define_accessors fs
-          run_definition fs, definition
-          store_definition fs, definition
+          run_property_definition fs, definition
+          store_property_definition fs, definition
         end
 
         def properties
-          @_definitions.keys
+          @_property_definitions.keys
         end
 
         def definition_for(field)
-          @_definitions ||= {}
-          @_definitions.fetch(field.to_sym, {}).dup
+          @_property_definitions ||= {}
+          @_property_definitions.fetch(field.to_sym, {}).dup
+        end
+
+        def store_property_definition(field, definition)
+          @_property_definitions        ||= {}
+          @_property_definitions[field] = definition
+        end
+
+        def run_property_definition(property_field, definition)
+          Eapi::DefinitionRunners::Property.new(self, property_field, definition).run
+        end
+
+        private :run_property_definition
+        private :store_property_definition
+      end
+
+      module ListCLassMethods
+        def elements(definition)
+          run_list_definition definition
+          store_list_definition definition
+        end
+
+        def definition_for_elements
+          @_list_definition
         end
 
-        def store_definition(field, definition)
-          @_definitions        ||= {}
-          @_definitions[field] = definition
+        def store_list_definition(definition)
+          @_list_definition = definition
         end
 
-        def run_definition(field, definition)
-          Eapi::DefinitionRunner.new(self, field, definition).run
+        def run_list_definition(definition)
+          Eapi::DefinitionRunners::List.new(self, definition).run
         end
 
-        private :run_definition
-        private :store_definition
+        private :run_list_definition
+        private :store_list_definition
       end
     end
 

data/lib/eapi/{multiple.rb → multiple_value.rb}

@@ -1,5 +1,5 @@
 module Eapi
-  module Multiple
+  module MultipleValue
     extend ActiveSupport::Concern
     included do
     end

data/lib/eapi/version.rb

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