moguro 0.0.1

data/lib/moguro/method_reference.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Moguro
+  # MethodReference represents original method reference that was
+  # decorated by contracts.ruby. Used for instance methods.
+  # This class borrowed many source code from https://github.com/egonSchiele/contracts.ruby
+  # License:: https://github.com/egonSchiele/contracts.ruby/blob/master/LICENSE
+  class MethodReference
+    attr_reader :name
+
+    # name - name of the method
+    # method - method object
+    def initialize(method)
+      @name = method.name
+      @method = method
+    end
+
+    # Returns method_position, delegates to Support.method_position
+    def position
+      file, line = @method.source_location
+      if file.nil? || line.nil?
+        ''
+      else
+        "#{file}:#{line}"
+      end
+    end
+
+    def parameters
+      @method.parameters
+    end
+  end
+
+  # The same as MethodReference, but used for singleton methods.
+  class SingletonMethodReference < MethodReference
+    private
+
+    def private?(this)
+      this.private_methods.map(&:to_sym).include?(name)
+    end
+
+    def protected?(this)
+      this.protected_methods.map(&:to_sym).include?(name)
+    end
+  end
+end

data/lib/moguro/processors/arguments_processor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Processors
+    class ArgumentsProcessor < ::Parser::AST::Processor
+      attr_reader :rule
+
+      def initialize(klass, clause)
+        @klass = klass
+        @clause = clause
+        super()
+      end
+
+      def on_const(node)
+        symbol = node.children.last
+        validator = Moguro::Types.get_type_validator_from_const(get_const(symbol))
+        @array_processor = nil
+        @clause.add_type(validator)
+        super node
+      end
+
+      def on_nil(_node)
+        validator = Moguro::Types.get_type_validator_from_const(nil)
+        @clause.add_type(validator)
+      end
+
+      def on_send(node)
+        return unless node.children[1] == :[]
+        @clause.pop_type
+        @clause.add_type(
+          Moguro::Processors::EnumerableProcessor.generate_type_validator(node, @klass)
+        )
+      end
+
+      private
+
+      def get_const(symbol)
+        @klass.const_get(symbol)
+      end
+    end
+  end
+end

data/lib/moguro/processors/contract_processor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Processors
+    class ContractParser
+      def initialize(str)
+        @str = str
+      end
+
+      def parse
+        ::Parser::CurrentRuby.parse(@str)
+      end
+    end
+
+    class ContractProcessor < ::Parser::AST::Processor
+      attr_reader :clauses
+      Rule = Struct.new(:key, :clauses)
+
+      def initialize(klass)
+        @current_arg = nil
+        @klass = klass
+        @clauses = Clauses.new
+        super()
+      end
+
+      def on_kwarg(node)
+        process_args(node)
+        super node
+      end
+
+      def on_kwoptarg(node)
+        process_args(node)
+        super node
+      end
+
+      class << self
+        def generate_type_validator(function, klass)
+          ast = ContractParser.new(
+            function.source
+          ).parse
+
+          processor = ContractProcessor.new(klass)
+          processor.process(ast)
+          processor.clauses
+        end
+      end
+
+      private
+
+      def process_args(node)
+        argument_key, _other = *node
+        rotate_rule(argument_key)
+        processor = ArgumentsProcessor.new(@klass, current_clause)
+        processor.process(node)
+      end
+
+      def rotate_rule(argument_key)
+        @clauses.add_verified_argument(argument_key)
+      end
+
+      def current_clause
+        clauses.last
+      end
+    end
+  end
+end

data/lib/moguro/processors/enumerable_processor.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Processors
+    class EnumerableProcessor < ::Parser::AST::Processor
+      attr_reader :enumerate_validator
+
+      def initialize(klass)
+        @current_arg = nil
+        @klass = klass
+        @enumerate_validator = nil
+        super()
+      end
+
+      def on_const(node)
+        symbol = node.children.last
+        type = @klass.const_get(symbol)
+        if @enumerate_validator.nil?
+          @enumerate_validator ||= Moguro::Types::Enumerable.new(type)
+        else
+          validator = Moguro::Types.get_type_validator_from_const(type)
+          @enumerate_validator.add_content_type(validator)
+        end
+        super node
+      end
+
+      def on_send(node)
+        @base_type = false if node.children[1] == :[]
+        super node
+      end
+
+      private
+
+      class << self
+        def generate_type_validator(ast, klass)
+          processor = EnumerableProcessor.new(klass)
+          processor.process(ast)
+          processor.enumerate_validator
+        end
+      end
+    end
+  end
+end

data/lib/moguro/processros.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Processors
+  end
+end
+
+require_relative 'processors/contract_processor'
+require_relative 'processors/arguments_processor'
+require_relative 'processors/enumerable_processor'

data/lib/moguro/sandbox.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Moguro
+  class SandBox
+    include Test::Unit::Assertions
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def method_missing(method_name, *args, &blk)
+      @klass.__send__(method_name, *args, &blk)
+    end
+  end
+end

data/lib/moguro/types.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Types
+    Result = Struct.new(:emumerable_validator, :valid?)
+    class << self
+      def get_type_validator_from_const(type)
+        if type == Moguro::Types::Boolean
+          type.new
+        elsif type.nil?
+          Nil.new
+        elsif type == ::Array || type.include?(::Enumerable)
+          Enumerable.new(type)
+        else
+          Skin.new(type)
+        end
+      end
+    end
+
+    ###
+    # Type match class
+    # @private
+    # @since 0.0.1
+    # @abstract
+    class Base
+      def valid?(_p)
+        raise NotImplementedError
+      end
+    end
+  end
+end
+
+require_relative 'types/skin'
+require_relative 'types/enumerable'
+require_relative 'types/boolean'
+require_relative 'types/nil'
+require_relative 'types/any'

data/lib/moguro/types/any.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Types
+    ###
+    #
+    # @since 0.0.1
+    class Any < Base
+      def valid?(_val)
+        true
+      end
+
+      ###
+      # Type name for error message
+      # @since 0.0.1
+      # @private
+      ###
+      def type
+        'Any'
+      end
+    end
+  end
+end

data/lib/moguro/types/boolean.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Types
+    ###
+    # Fake Boolean class for type definition
+    # @since 0.0.1
+    ###
+    class Boolean < Base
+      ###
+      # validate value type
+      # TrueClass or FalseClass
+      # @since 0.0.1
+      ###
+      def valid?(val)
+        val.is_a?(TrueClass) || val.is_a?(FalseClass)
+      end
+
+      ###
+      # Type name for error message
+      # @since 0.0.1
+      # @private
+      ###
+      def type
+        'TrueClass or FalseClass'
+      end
+    end
+  end
+end

data/lib/moguro/types/enumerable.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Types
+    ###
+    # Array type validator
+    # @since 0.0.1
+    # @private
+    ###
+    class Enumerable < Base
+      def initialize(klass)
+        @content_type = []
+        @klass = klass
+      end
+
+      def add_content_type(type)
+        @content_type << type
+      end
+
+      def valid?(val)
+        eumerable?(val) && (val.empty? || content_type_valid?(val))
+      end
+
+      def type
+        if @content_type.empty?
+          @klass.to_s
+        else
+          "#{@klass}<#{@content_type.join('|')}>"
+        end
+      end
+
+      private
+
+      def eumerable?(val)
+        val.is_a?(@klass)
+      end
+
+      def content_type_valid?(val)
+        return true if @content_type.empty?
+
+        val.all? do |v|
+          @content_type.any? { |type| type.valid?(v) }
+        end
+      end
+    end
+  end
+end

data/lib/moguro/types/nil.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Types
+    ###
+    # @since 0.0.1
+    # NilClass Wrapper
+    class Nil < Base
+      def valid?(p)
+        p.nil?
+      end
+
+      def type
+        'nil'
+      end
+    end
+  end
+end

data/lib/moguro/types/skin.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Moguro
+  module Types
+    ###
+    # The thin wrapper class for some instance object
+    # @since 0.0.1
+    ###
+    class Skin < SimpleDelegator
+      def initialize(klass)
+        @klass = klass
+        super(@klass)
+      end
+
+      def valid?(val)
+        val.is_a?(@klass)
+      end
+
+      ###
+      # Class name for error message
+      # @since 0.0.1
+      # @private
+      ###
+      def type
+        @klass
+      end
+    end
+  end
+end

data/lib/moguro/values.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Moguro
+  ###
+  # Wrapper class for Arguments
+  # @since 0.0.1
+  # @private
+  ###
+  class Values < DelegateClass(Array)
+    def initialize
+      super([])
+    end
+
+    def to_h
+      each_with_object({}) do |value_class, hash|
+        hash[value_class.key] = value_class.value
+      end
+    end
+
+    def add_value(key, value, missing: false)
+      self << Value.new(key, value, missing: missing)
+    end
+
+    def inspect
+      map(&:inspect)
+    end
+  end
+
+  ###
+  # Wrapper class for Arguments value
+  # @since 0.0.1
+  # @private
+  ###
+  class Value < SimpleDelegator
+    attr_reader :key, :value
+
+    def initialize(key, value, missing: false)
+      @key = key
+      @value = value
+      @missing = missing
+      super(@value)
+    end
+
+    def missing?
+      @missing
+    end
+
+    def class
+      @value.class
+    end
+
+    def is_a?(val)
+      @value.is_a?(val)
+    end
+
+    def nil?
+      @value.nil?
+    end
+
+    def inspect
+      "#{key}: #{type_inspect}"
+    end
+
+    def type_inspect
+      if @value.class.include?(Enumerable) && !@value.empty?
+        "#{value}(#{value.class}<#{@value.map(&:class).uniq.join('|')}>)"
+      else
+        "#{value}(#{value.class})"
+      end
+    end
+  end
+end