moguro 0.0.1

data/lib/moguro/contract.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Moguro
+  ###
+  # Contract of class state
+  # @since 0.0.1
+  # @abstract
+  ###
+  class Contract
+    attr_reader :method
+
+    def initialize(klass, callback, method)
+      @klass = klass
+      @type_clauses = Moguro::Processors::ContractProcessor.generate_type_validator(callback, klass)
+      @cb = callback
+      @method = method
+    end
+
+    def verify!(instance, args)
+      values = extractor.extract(args)
+      @type_clauses.verify!(values)
+      instance.instance_exec(values.to_h, &@cb)
+    end
+
+    def extractor
+      raise NotImplementedError
+    end
+  end
+
+  class PreconditionContract < Contract
+    def initialize(klass, callback, method)
+      super(klass, callback, method)
+    end
+
+    def verify!(instance, args)
+      super
+    rescue Moguro::Errors::TypeMismatchError => e
+      raise Moguro::Errors::ArgumentsTypeMismatchError.new(e, @klass, method)
+    rescue => e
+      raise e
+    end
+
+    def extractor
+      @extractor ||= Moguro::Extractor::ArgumentsExtractor.new(method.parameters)
+    end
+  end
+
+  class PostconditionContract < Contract
+    def initialize(klass, callback, method)
+      super(klass, callback, method)
+    end
+
+    def verify!(instance, args)
+      super
+    rescue Moguro::Errors::TypeMismatchError => e
+      raise Moguro::Errors::ReturnValueTypeMismatchError.new(e, @klass, method)
+    rescue => e
+      raise e
+    end
+
+    def extractor
+      @extractor ||= Moguro::Extractor::ReturnValueExtractor.new(
+        @cb.parameters
+      )
+    end
+  end
+end

data/lib/moguro/decorator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Moguro
+  ###
+  # Provide contract programming feature to the class that included this module.
+  # Validates the arguments to the method, and validates the return value of the method.
+  # And you arbitrary test possible by Assertion library.
+  # @since 0.0.1
+  ###
+  module Decorator
+    CONTRACT_CONTAINER = Struct.new(:pre, :post)
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.include(Moguro::Types)
+      # @todo
+      return unless Moguro.enabled?
+      require 'test/unit/assertions'
+      klass.include(Test::Unit::Assertions)
+      klass.extend(Test::Unit::Assertions)
+    end
+
+    module ClassMethods
+      def singleton_method_added(name)
+        return super unless Moguro.enabled? && contract_handler.validatable?
+        super
+        contract_handler.handle_singleton_method(name)
+      end
+
+      def method_added(name)
+        return super unless Moguro.enabled? && contract_handler.validatable?
+        super
+        contract_handler.handle_method(name)
+      end
+
+      ###
+      # Validates the arguments to the method
+      # @since 0.0.1
+      # @param [Lambda|Proc] callback
+      # @return [Void]
+      #
+      def pre_c(callback)
+        return unless Moguro.enabled?
+        contract_handler.contract_arguments(callback)
+      end
+
+      ###
+      # Validates the arguments to the method
+      # @since 0.0.1
+      # @param [Lambda|Proc] callback
+      # @return [Void]
+      ###
+      def post_c(callback)
+        return unless Moguro.enabled?
+        contract_handler.contract_return_value(callback)
+      end
+
+      ###
+      # Validates the arguments to the method
+      # @since 0.0.1
+      # @param [Lambda|Proc] callback
+      # @return [Void]
+      ##
+      def contract_handler
+        @contract_handler ||= Moguro::Handlers::ClassHandler.new(self)
+      end
+    end
+  end
+end

data/lib/moguro/errors.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Errors
+    ###
+    # @private
+    # Base class for Errors
+    # If default failure callback is used it stores failure data
+    ###
+    class BaseError < ::ArgumentError
+    end
+
+    ###
+    # Type miss match error class for Arguments and return value
+    # @attribute :actual, :expected
+    class TypeMismatchError < BaseError
+      attr_accessor :actual, :expected
+      attr_reader :failure_clause, :failure_value
+
+      def initialize(failure_clause, failure_value)
+        @failure_clause = failure_clause
+        @failure_value = failure_value
+        @actual = nil
+        @expected = nil
+      end
+
+      def failure_detail
+        <<~"DETAIL".chomp
+          Expected: #{@expected}
+            Actual: #{@actual}
+        DETAIL
+      end
+
+      def failure_summary
+        "Type MissMatch: #{@failure_clause.key} is expected #{@failure_clause.type_inspect} actual #{@failure_value.type_inspect}"
+      end
+    end
+
+    class ArgumentsTypeMismatchError < BaseError
+      def initialize(type_mismatch_error, klass, method)
+        @e = type_mismatch_error
+        @klass = klass
+        @method = method
+        super(failure_message)
+      end
+
+      def failure_title
+        'ArgumentsTypeError'
+      end
+
+      def failure_message
+        <<~"MESSAGE".chomp
+          #{failure_title} => #{@e.failure_summary}
+            #{@e.failure_detail}
+            #{failure_location}
+        MESSAGE
+      end
+
+      def failure_location
+        <<~"LOCATION".chomp
+          Value guarded in: #{@klass}::#{@method.name}
+            At: #{@method.position}
+        LOCATION
+      end
+    end
+
+    class ReturnValueTypeMismatchError < BaseError
+      def initialize(type_mismatch_error, klass, method)
+        @e = type_mismatch_error
+        @klass = klass
+        @method = method
+        super(failure_message)
+      end
+
+      def failure_title
+        'ReturnValueTypeError'
+      end
+
+      def failure_message
+        <<~"MESSAGE".chomp
+          #{failure_title} => #{@e.failure_summary}
+            #{@e.failure_detail}
+            #{failure_location}
+        MESSAGE
+      end
+
+      def failure_location
+        <<~"LOCATION".chomp
+          Value guarded in: #{@klass}::#{@method.name}
+            At: #{@method.position}
+        LOCATION
+      end
+    end
+    class ArgumentError < BaseError
+    end
+  end
+end

data/lib/moguro/extractor.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Extractor
+  end
+end
+
+require_relative 'extractors/arguments_extractor'
+require_relative 'extractors/return_value_extractor'

data/lib/moguro/extractors/arguments_extractor.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Extractor
+    class ArgumentsExtractor
+      def initialize(parameters)
+        @parameters = parameters
+      end
+
+      def extract(args)
+        opt = args.last.is_a?(Hash) ? args.last : nil
+        @parameters.each_with_object(Values.new).with_index do |(params, values), i|
+          arg_type = params[0]
+          key = params[1]
+          case arg_type
+          when :req
+            val = args[i]
+            values.add_value(key, val)
+          when :keyreq
+            if opt&.key?(key)
+              val = opt[key]
+              values.add_value(key, val)
+            else
+              values.add_value(key, val, missing: true)
+            end
+          when :key
+            val = opt[key]
+            values.add_value(key, val)
+          when :opt
+            values.add_value(key, args[i])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moguro/extractors/return_value_extractor.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Extractor
+    class ReturnValueExtractor
+      def initialize(parameters)
+        @parameters = parameters
+      end
+
+      def extract(return_value)
+        @parameters.each_with_object(Values.new).with_index do |(params, values), i|
+          key = params[1]
+          val = return_value[i]
+          values.add_value(key, val, missing: val.nil?)
+        end
+      end
+    end
+  end
+end

data/lib/moguro/handler.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Handlers
+  end
+end
+
+require_relative 'handlers/class_handler'
+require_relative 'handlers/method_handler'

data/lib/moguro/handlers/class_handler.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Handlers
+    # Handler for method added event
+    # @private
+    # @since 0.0.1
+    # @attr_reader [Class] binding class
+    class ClassHandler
+      attr_reader :klass
+
+      def initialize(klass)
+        @klass = klass
+        @instance_handlers = {}
+        @class_handlers = {}
+        @arguments_contract = nil
+        @return_value_contract = nil
+      end
+
+      def handle_singleton_method(name)
+        @class_handlers[name] ||= SingletonMethodHandler.new(
+          self,
+          name,
+          arguments_contract: @arguments_contract,
+          return_value_contract: @return_value_contract
+        )
+        clear_validator
+        m = @class_handlers[name].module
+        @klass.singleton_class.class_eval { prepend(m) }
+      end
+
+      def handle_method(name)
+        @instance_handlers[name] = MethodHandler.new(
+          self,
+          name,
+          arguments_contract: @arguments_contract,
+          return_value_contract: @return_value_contract
+        )
+        clear_validator
+        @klass.prepend(@instance_handlers[name].module)
+      end
+
+      def contract_arguments(callback)
+        @arguments_contract = callback
+      end
+
+      def contract_return_value(callback)
+        @return_value_contract = callback
+      end
+
+      def validatable?
+        !@arguments_contract.nil? || !@return_value_contract.nil?
+      end
+
+      def _get_class_method_handler(name)
+        @class_handlers[name]
+      end
+
+      def _get_instance_method_handler(name)
+        @instance_handlers[name]
+      end
+
+      private
+
+      def clear_validator
+        @arguments_contract = nil
+        @return_value_contract = nil
+      end
+    end
+  end
+end

data/lib/moguro/handlers/method_handler.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Handlers
+    class MethodHandler
+      def initialize(class_handler, name, arguments_contract: nil, return_value_contract: nil)
+        @class_handler = class_handler
+        @name = name
+        @arguments_contract =
+          if arguments_contract.nil?
+            arguments_contract
+          else
+            PreconditionContract.new(klass, arguments_contract, reference)
+          end
+        @return_value_contract =
+          if return_value_contract.nil?
+            return_value_contract
+          else
+            PostconditionContract.new(klass, return_value_contract, reference)
+          end
+      end
+
+      def module
+        m = Module.new
+
+        arguments_contract = @arguments_contract
+        return_value_contract = @return_value_contract
+
+        arguments_contract_cb = lambda { |klass, args|
+          arguments_contract&.verify!(klass, args)
+        }
+
+        return_value_contract_cb = lambda { |klass, results|
+          return_value_contract&.verify!(klass, results)
+        }
+        name = @name
+        m.module_eval do
+          define_method(name) do |*args, &block|
+            arguments_contract_cb.call(self, args)
+            *results = super(*args, &block)
+            return_value_contract_cb.call(self, results)
+          end
+        end
+        m
+      end
+
+      def reference
+        @reference ||= MethodReference.new(
+          method
+        )
+      end
+
+      private
+
+      def parameters
+        @parameters ||= method.parameters
+      end
+
+      def method
+        @method ||= klass.instance_method(@name)
+      end
+
+      def klass
+        @klass ||= @class_handler.klass
+      end
+    end
+
+    class SingletonMethodHandler < MethodHandler
+      def method
+        @method ||= klass.method(@name)
+      end
+    end
+  end
+end