calificador 0.1.0 → 0.2.0

data/lib/calificador/util/call_formatter.rb

@@ -5,11 +5,11 @@ require "pp"
 module Calificador
   module Util
     class CallFormatter
-      def method(method:, arguments: [], options: {})
+      def format_method(name:, arguments: [], keywords: {})
         info = ::StringIO.new
-        info << method
+        info << name
 
-        unless arguments.empty? && options.empty?
+        unless arguments.empty? && keywords.empty?
           info << "("
 
           arguments.each_with_index do |argument, i|
@@ -17,7 +17,7 @@ module Calificador
             append_value(value: argument, out: info)
           end
 
-          options.each_with_index do |(name, value), i|
+          keywords.each_with_index do |(name, value), i|
             info << ", " unless i.zero? && arguments.empty?
             info << name << ": "
             append_value(value: value, out: info)
@@ -29,7 +29,7 @@ module Calificador
         info.string
       end
 
-      def value(value:)
+      def format_value(value:)
         append_value(value: value, out: StringIO.new).string
       end
 

data/lib/calificador/util/core_extensions.rb

@@ -1,72 +1,20 @@
 # frozen_string_literal: true
 
-require "docile"
 require "ostruct"
 
 module Calificador
   module Util
     # Extensions to core classes
     module CoreExtensions
-      module_function
-
-      def map_call_arguments(signature:, arguments:, options:)
-        min_argument_count = 0
-        max_argument_count = 0
-        option_names = Set.new
-
-        signature.each do |type, name|
-          case type
-          when :req
-            min_argument_count += 1
-            max_argument_count += 1
-          when :opt
-            max_argument_count += 1
-          when :rest
-            max_argument_count = nil
-          when :keyreq
-            raise ArgumentError, "Required option #{name} missing for #{self} #{signature}" unless options.key?(name)
-
-            option_names << name
-          when :key
-            option_names << name
-          when :keyrest
-            option_names += options.keys
-          when :block
-            # ignore
-          else
-            raise ArgumentError, "Illegal parameter type #{type} for #{self} #{signature}"
-          end
-        end
-
-        argument_count = arguments.size
-        argument_count = max_argument_count if max_argument_count && argument_count > max_argument_count
-
-        raise ArgumentError, "Not enough parameters to call proc with #{signature}" if argument_count < min_argument_count
-
-        arguments = arguments[0...argument_count]
-        options = options.slice(*option_names)
-
-        [arguments, options]
-      end
-
-      refine Object do
+      module ObjectMixins
         def to_bool
           self ? true : false
         end
-
-        def dsl_config(&block)
-          target = self
-
-          if block
-            dsl = self.class.const_get(:Dsl).new(delegate: target)
-            Docile.dsl_eval(dsl, &block)
-          end
-
-          target
-        end
       end
 
-      refine String do
+      Object.include(ObjectMixins)
+
+      module StringMixins
         def snake_case
           gsub(%r{(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])}, "_").downcase
         end
@@ -78,9 +26,14 @@ module Calificador
         end
       end
 
-      refine Module do
+      String.include(StringMixins)
+
+      module ModuleMixins
         def parent_module
-          @__calificador_parent_module ||= Nil[parent_name&.then { |m| const_get(m) }]
+          if !instance_variable_defined?(:@__calificador_parent_module) || @__calificador_parent_module.nil?
+            @__calificador_parent_module = Nil[parent_name&.then { |m| const_get(m) }]
+          end
+
           @__calificador_parent_module.unmask_nil
         end
 
@@ -89,47 +42,119 @@ module Calificador
         end
 
         def base_name
-          @__calificador_base_name ||= if %r{(?:^|::)(?<base_name>(?:[^:]|:[^:])+)\z} =~ name
-            %r{\A#<.+>\z} =~ base_name ? Nil.instance : base_name
-          else
-            Nil.instance
+          if !instance_variable_defined?(:@__calificador_base_name) || @__calificador_base_name.nil?
+            @__calificador_base_name = if %r{(?:^|::)(?<base_name>(?:[^:]|:[^:])+)\z} =~ name
+              Nil[base_name]
+            else
+              Nil.instance
+            end
           end
 
           @__calificador_base_name.unmask_nil
         end
 
         def parent_name
-          @__calificador_parent_name ||= if %r{(?<parent_name>\A.*)::} =~ name
-            %r{#<} =~ parent_name ? Nil.instance : parent_name
-          else
-            Nil.instance
+          if !instance_variable_defined?(:@__calificador_parent_name) || @__calificador_parent_name.nil?
+            @__calificador_parent_name = if %r{(?<parent_name>\A.*)::} =~ name
+              parent_name
+            else
+              Nil.instance
+            end
           end
 
           @__calificador_parent_name.unmask_nil
         end
-      end
 
-      [Method, Proc].each do |callable|
-        refine callable do
-          def map_call_arguments(*arguments, **options)
-            CoreExtensions.map_call_arguments(signature: parameters, arguments: arguments, options: options)
+        def name_without_common_parents(base:)
+          path = name&.split("::")
+
+          result = if path
+            base_path = base&.name&.split("::")
+            path.remove_common_prefix(base_path).join("::") if base_path
           end
 
-          def invoke(*arguments, **options, &block)
-            arguments, options = map_call_arguments(*arguments, **options)
-            call(*arguments, **options, &block)
+          result || name
+        end
+      end
+
+      Module.include(ModuleMixins)
+
+      module ArrayMixins
+        def remove_common_prefix(other)
+          drop_while.with_index do |element, index|
+            index < size && element == other[index]
           end
+        end
+      end
 
-          def invoke_with_target(target, *arguments, **options)
-            arguments, options = map_call_arguments(*arguments, **options)
-            target.instance_exec(*arguments, **options, &self)
+      Array.include(ArrayMixins)
+
+      module CallableMixins
+        REQUIRED_ARGUMENT_TYPES = %i[req keyreq].freeze
+
+        def map_call_arguments(arguments:, keywords:)
+          min_argument_count = 0
+          max_argument_count = 0
+          option_names = Set.new
+
+          parameters.each do |type, name|
+            case type
+            when :req
+              min_argument_count += 1
+              max_argument_count += 1
+            when :opt
+              max_argument_count += 1
+            when :rest
+              max_argument_count = nil
+            when :keyreq
+              raise ArgumentError, "Required option #{name} missing for #{self} #{parameters}" unless keywords.key?(name)
+
+              option_names << name
+            when :key
+              option_names << name
+            when :keyrest
+              option_names += keywords.keys
+            when :block
+              # ignore
+            else
+              raise ArgumentError, "Illegal parameter type #{type} for #{self} #{parameters}"
+            end
           end
 
-          def source_location_info
-            source_location ? source_location.join(":") : nil
+          argument_count = arguments.size
+          argument_count = max_argument_count if max_argument_count && argument_count > max_argument_count
+
+          if argument_count < min_argument_count
+            raise ArgumentError, "Not enough parameters to call proc with #{parameters}"
           end
+
+          arguments = arguments[0...argument_count]
+          keywords = keywords.slice(*option_names)
+
+          [arguments, keywords]
+        end
+
+        def invoke(*arguments, **keywords, &block)
+          arguments, keywords = map_call_arguments(arguments: arguments, keywords: keywords)
+          call(*arguments, **keywords, &block)
+        end
+
+        def invoke_with_target(target, *arguments, **keywords)
+          arguments, keywords = map_call_arguments(arguments: arguments, keywords: keywords)
+          target.instance_exec(*arguments, **keywords, &self)
+        end
+
+        def source_location_info
+          source_location ? source_location.join(":") : nil
+        end
+
+        def required_arguments?
+          parameters.any? { |type, _name| REQUIRED_ARGUMENT_TYPES.include?(type) }
         end
       end
+
+      Method.include(CallableMixins)
+      Proc.include(CallableMixins)
     end
   end
 end

data/lib/calificador/util/proxy_object.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Calificador
+  module Util
+    # Base class for proxy objects
+    class ProxyObject < BasicObject
+      FALLBACK_METHODS = %i[class to_s inspect eval].freeze
+
+      def respond_to?(name, include_all = false) # rubocop:disable Style/OptionalBooleanParameter
+        __class.public_instance_methods(true).include?(name) ||
+          include_all && (
+            __class.protected_instance_methods(true).include?(name) ||
+            __class.private_instance_methods(true).include?(name)
+          ) ||
+          respond_to_missing?(name, include_all)
+      end
+
+      def respond_to_missing?(name, include_all)
+        name.start_with?("__") ? false : __respond_to_missing?(name: name, include_all: include_all)
+      end
+
+      def method_missing(name, *arguments, **keywords, &block)
+        if name.start_with?("__")
+          super(name, *arguments, **keywords, &block)
+        else
+          __method_missing(name: name, arguments: arguments, keywords: keywords, block: block)
+        end
+      end
+
+      protected
+
+      def __class
+        (class << self; self end).superclass
+      end
+
+      def __to_s
+        "#<#{__class}>"
+      end
+
+      def __inspect
+        "#<#{__class}>"
+      end
+
+      def __eval(*arguments)
+        instance_eval(*arguments)
+      end
+
+      def __respond_to_missing?(name:, include_all:)
+        false
+      end
+
+      def __method_missing(name:, arguments:, keywords:, block:)
+        if ::Kernel.respond_to?(name)
+          ::Kernel.send(name, *arguments, **keywords, &block)
+        elsif FALLBACK_METHODS.include?(name)
+          __send__(:"__#{name}", *arguments, **keywords, &block)
+        else
+          ::Kernel.raise ::NoMethodError, "undefined name `#{name}' for #{__class}"
+        end
+      end
+    end
+  end
+end

data/lib/calificador/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Calificador
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: calificador
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jochen Seeber
 autorequire:
 bindir: cmd
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 2021-03-04 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: docile
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.3.5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.3.5
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -66,20 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.8.23.js
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.8.23.js
 - !ruby/object:Gem::Dependency
   name: debase
   requirement: !ruby/object:Gem::Requirement
@@ -201,25 +173,32 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
+- TODO.md
+- calificador.gemspec
 - lib/calificador.rb
+- lib/calificador/assert.rb
 - lib/calificador/assertor.rb
 - lib/calificador/build/attribute.rb
-- lib/calificador/build/attribute_container.rb
 - lib/calificador/build/attribute_evaluator.rb
-- lib/calificador/build/factory.rb
+- lib/calificador/build/basic_factory.rb
+- lib/calificador/build/mock_factory.rb
+- lib/calificador/build/object_factory.rb
 - lib/calificador/build/trait.rb
+- lib/calificador/context/basic_context.rb
+- lib/calificador/context/class_method_context.rb
+- lib/calificador/context/condition_context.rb
+- lib/calificador/context/instance_context.rb
+- lib/calificador/context/operation_context.rb
+- lib/calificador/context/override/argument_override.rb
+- lib/calificador/context/override/basic_override.rb
+- lib/calificador/context/override/factory_override.rb
+- lib/calificador/context/override/property_override.rb
+- lib/calificador/context/test_environment.rb
+- lib/calificador/context/test_method.rb
+- lib/calificador/context/test_root.rb
+- lib/calificador/context/type_context.rb
 - lib/calificador/key.rb
 - lib/calificador/minitest/minitest_patches.rb
-- lib/calificador/spec/basic_context.rb
-- lib/calificador/spec/class_method_context.rb
-- lib/calificador/spec/condition_context.rb
-- lib/calificador/spec/examine_context.rb
-- lib/calificador/spec/instance_method_context.rb
-- lib/calificador/spec/test_environment.rb
-- lib/calificador/spec/test_method.rb
-- lib/calificador/spec/test_root.rb
-- lib/calificador/spec/type_context.rb
-- lib/calificador/spec/value_override.rb
 - lib/calificador/test.rb
 - lib/calificador/test_mixin.rb
 - lib/calificador/util/call_formatter.rb
@@ -227,6 +206,7 @@ files:
 - lib/calificador/util/core_extensions.rb
 - lib/calificador/util/missing.rb
 - lib/calificador/util/nil.rb
+- lib/calificador/util/proxy_object.rb
 - lib/calificador/version.rb
 homepage: https://github.com/jochenseeber/calificador
 licenses: []

data/lib/calificador/build/attribute_container.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-using Calificador::Util::CoreExtensions
-
-module Calificador
-  module Build
-    # Factory calss
-    class AttributeContainer
-      class Dsl
-        def initialize(delegate:)
-          @delegate = delegate
-          @property_type = nil
-        end
-
-        def add_attribute(name, type: nil, &config)
-          type ||= @delegate.parent&.attribute(name: name)&.type || @property_type || :property
-          @delegate.add_attribute(Attribute.new(name: name, type: type, config: config))
-        end
-
-        def transient(&block)
-          raise ArgumentError, "Transient requires a block" if block.nil?
-
-          old_property_type = @property_type
-          @property_type = :transient
-
-          begin
-            instance_exec(self, &block)
-          ensure
-            @property_type = old_property_type
-          end
-        end
-
-        def init_with(&block)
-          raise "Initializer requires a block to create the object" if block.nil?
-
-          @delegate.init_with = block
-        end
-
-        def before_create(&block)
-          raise "Before requires a block to call" if block.nil?
-
-          @delegate.before_create = block
-        end
-
-        def after_create(&block)
-          raise "After requires a block to call" if block.nil?
-
-          @delegate.after_create = block
-        end
-
-        def respond_to_missing?(method, include_all = false)
-          if method.start_with?("__")
-            super
-          else
-            true
-          end
-        end
-
-        def method_missing(method, *arguments, &block)
-          if method.start_with?("__")
-            super
-          else
-            unless arguments.empty?
-              raise ::ArgumentError, <<~ERROR
-                Attribute #{method} cannot have arguments. Please use a block to configure the value
-              ERROR
-            end
-
-            raise ::ArgumentError, "Attribute #{method} must have a block to provide the value" if block.nil?
-
-            add_attribute(method, &block)
-          end
-        end
-      end
-
-      attr_reader :parent, :description
-      attr_accessor :init_with, :before_create, :after_create
-
-      def initialize(parent:, description:)
-        @parent = parent
-        @description = description.dup.freeze
-        @attributes = {}
-        @init_with = nil
-        @before_create = nil
-        @after_create = nil
-      end
-
-      def attributes
-        @attributes.dup.freeze
-      end
-
-      def attribute(name:)
-        @attributes[name]
-      end
-
-      def add_attribute(attribute)
-        raise KeyError, "Duplicate attribute name #{name}" if @attributes.key?(attribute.name)
-
-        @attributes[attribute.name] = attribute
-      end
-    end
-  end
-end