duck_testing 0.0.1

data/lib/duck_testing/type/duck_type.rb

@@ -0,0 +1,24 @@
+require "duck_testing/type/base"
+
+module DuckTesting
+  module Type
+    class DuckType < Base
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      # @param object [Object]
+      # @return [Boolean]
+      def match?(object)
+        object.respond_to?(name)
+      end
+
+      # @return [String]
+      def to_s
+        "##{name}"
+      end
+    end
+  end
+end

data/lib/duck_testing/type/hash.rb

@@ -0,0 +1,60 @@
+require "duck_testing/type/base"
+
+module DuckTesting
+  module Type
+    class Hash < Base
+      attr_reader :key_types, :value_types
+
+      # @param key_types [Array<DuckTesting::Type::Base>]
+      # @param value_types [Array<DuckTesting::Type::Base>]
+      def initialize(key_types, value_types)
+        @key_types = key_types
+        @value_types = value_types
+      end
+
+      # @param object [Object]
+      # @return [Boolean]
+      def match?(object)
+        return false unless object.is_a?(::Hash)
+        match_keys?(object) && match_values?(object)
+      end
+
+      # @return [String]
+      def to_s
+        "Hash{#{key_types_to_s} => #{value_types_to_s}}"
+      end
+
+      private
+
+      # @param hash [Hash]
+      # @return [Boolean]
+      def match_keys?(hash)
+        hash.keys.all? do |key|
+          key_types.all? do |type|
+            type.match?(key)
+          end
+        end
+      end
+
+      # @param hash [Hash]
+      # @return [Boolean]
+      def match_values?(hash)
+        hash.values.all? do |key|
+          value_types.all? do |type|
+            type.match?(key)
+          end
+        end
+      end
+
+      # @return [String]
+      def key_types_to_s
+        key_types.map(&:to_s).join(", ")
+      end
+
+      # @return [String]
+      def value_types_to_s
+        value_types.map(&:to_s).join(", ")
+      end
+    end
+  end
+end

data/lib/duck_testing/type/order_dependent_array.rb

@@ -0,0 +1,27 @@
+require "duck_testing/type/base"
+
+module DuckTesting
+  module Type
+    class OrderDependentArray < Base
+      attr_reader :types
+
+      def initialize(*types)
+        @types = types
+      end
+
+      # @param [Object] array
+      # @return [Boolean]
+      def match?(array)
+        return false unless array.is_a?(Array) && array.size == types.size
+        array.zip(types).all? do |array_element, type|
+          type.match?(array_element)
+        end
+      end
+
+      # @return [String]
+      def to_s
+        "Array<(#{types.map(&:to_s).join(', ')})>"
+      end
+    end
+  end
+end

data/lib/duck_testing/type/order_independent_array.rb

@@ -0,0 +1,27 @@
+require "duck_testing/type/base"
+
+module DuckTesting
+  module Type
+    class OrderIndependentArray < Base
+      attr_reader :types
+
+      def initialize(*types)
+        @types = types
+      end
+
+      # @param [Object] array
+      # @return [Boolean]
+      def match?(array)
+        return false unless array.is_a?(Array)
+        array.all? do |array_element|
+          types.any? { |type| type.match?(array_element) }
+        end
+      end
+
+      # @return [String]
+      def to_s
+        "Array<#{types.map(&:to_s).join(', ')}>"
+      end
+    end
+  end
+end

data/lib/duck_testing/version.rb

@@ -0,0 +1,3 @@
+module DuckTesting
+  VERSION = "0.0.1".freeze
+end

data/lib/duck_testing/violation.rb

@@ -0,0 +1,41 @@
+require "forwardable"
+
+module DuckTesting
+  class Violation
+    extend Forwardable
+
+    def_delegators :@call_data, :method_expr
+
+    attr_reader :param
+
+    # @param call_data [DuckTesting::MethodCallData]
+    # @param param [Object] the given object.
+    # @param expected_types [Array<DuckTesting::Type::Base>] the expected object types.
+    # @param param_or_return [Symbol] the report type, `:param` or `:return`
+    def initialize(call_data: nil, param: nil, expected_types: nil, param_or_return: nil)
+      @call_data = call_data
+      @param = param
+      @expected_types = expected_types
+      @param_or_return = param_or_return
+    end
+
+    # @return [Boolean]
+    def param?
+      param_or_return == :param
+    end
+
+    # @return [Boolean]
+    def return?
+      param_or_return == :return
+    end
+
+    # @return [String]
+    def expected
+      expected_types.map(&:to_s).join(", ")
+    end
+
+    private
+
+    attr_reader :call_data, :expected_types, :param_or_return
+  end
+end

data/lib/duck_testing/yard.rb

@@ -0,0 +1,51 @@
+require "duck_testing/yard/builder"
+require "duck_testing/yard/parser"
+
+module DuckTesting
+  module YARD
+    # The default glob of files to be parsed.
+    DEFAULT_PATH_GLOB = ["{lib,app}/**/*.rb"]
+
+    # Parses a path or set of paths then prepend them into corresponding classes..
+    #
+    # @param paths [String, Array<String>] a path, glob or list of paths to parse
+    # @param excluded [Array<String, Regexp>] a list of excluded path matchers
+    # @return [void]
+    def apply(paths: DEFAULT_PATH_GLOB, excluded: [])
+      Parser.parse(paths, excluded).each do |class_object|
+        builder = Builder.new(class_object)
+        begin
+          klass = Object.const_get(class_object.path)
+        rescue NameError
+          next
+        end
+        klass.send(:prepend, builder.build(:instance))
+        klass.singleton_class.send(:prepend, builder.build(:class))
+      end
+    end
+
+    # @param types [Array<String>]
+    # @return [Array<DuckTesting::Type::Base>]
+    def expected_types(types)
+      types.map do |type|
+        if type == "Boolean"
+          [
+            DuckTesting::Type::Constant.new(true),
+            DuckTesting::Type::Constant.new(false),
+          ]
+        elsif DuckTesting::Type::Constant::CONSTANTS.include?(type)
+          DuckTesting::Type::Constant.new(type)
+        elsif type == "void"
+          nil
+        elsif type.start_with?("Array")
+          # TODO: Support specifing types of array elements.
+          DuckTesting::Type::ClassInstance.new(Array)
+        else
+          DuckTesting::Type::ClassInstance.new(Object.const_get(type))
+        end
+      end.flatten.compact
+    end
+
+    module_function :apply, :expected_types
+  end
+end

data/lib/duck_testing/yard/builder.rb

@@ -0,0 +1,70 @@
+module DuckTesting
+  module YARD
+    class Builder
+      # @param class_object [DuckTesting::YARD::ClassObject]
+      def initialize(class_object)
+        @class_object = class_object
+      end
+
+      # Build duck testing for the `@class_object`.
+      #
+      # @param scope [Symbol] `:instance` or `:class`
+      # @return [Module] duck testing module of `class_object` in the `scope`.
+      def build(scope = :instance)
+        @building_module = prepare_module
+        @class_object.method_objects.each do |method_object|
+          next unless method_object.scope == scope
+          handle_method_object(method_object)
+        end
+        @building_module
+      ensure
+        remove_instance_variable :@building_module
+      end
+
+      # rubocop:disable Lint/NestedMethodDefinition, Metrics/AbcSize
+
+      private
+
+      def prepare_module
+        Module.new do
+          private
+
+          def __dk_test_normal_parameters(tester, method_object, parameters)
+            parameters.each_with_index do |parameter, index|
+              tester.test_param(
+                parameter,
+                method_object.method_parameters[index].expected_types
+              )
+            end
+          end
+
+          def __dk_test_keyword_parameters(tester, method_object, hash_parameter)
+            method_object.keyword_parameters.each do |method_parameter|
+              next unless hash_parameter.key?(method_parameter.key_name)
+              tester.test_param(
+                hash_parameter[method_parameter.key_name],
+                method_parameter.expected_types
+              )
+            end
+          end
+        end
+      end
+
+      # @param method_object [DuckTesting::YARD::MethodObject]
+      def handle_method_object(method_object)
+        @building_module.module_eval do
+          define_method method_object.name do |*parameters|
+            tester = DuckTesting::Tester.new(self, method_object.name)
+            if method_object.keyword_parameters.any? && parameters.last.is_a?(Hash)
+              __dk_test_normal_parameters(tester, method_object, parameters[0...-1])
+              __dk_test_keyword_parameters(tester, method_object, parameters.last)
+            else
+              __dk_test_normal_parameters(tester, method_object, parameters)
+            end
+            tester.test_return(super(*parameters), method_object.expected_return_types)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/duck_testing/yard/class_object.rb

@@ -0,0 +1,20 @@
+require "duck_testing/yard/code_object"
+
+module DuckTesting
+  module YARD
+    # Encapsulate `YARD::CodeObjects::ClassObject`.
+    class ClassObject < CodeObject
+      # @return [Array<DuckTesting::YARD::MethodObject>]
+      def method_objects
+        @method_objects ||= yard_object.meths.map do |method_object|
+          MethodObject.new(method_object)
+        end
+      end
+
+      # @return [String]
+      def verbose_name
+        @verbose_name ||= yard_object.path.gsub(/::/, "")
+      end
+    end
+  end
+end

data/lib/duck_testing/yard/code_object.rb

@@ -0,0 +1,22 @@
+require "forwardable"
+
+module DuckTesting
+  module YARD
+    class CodeObject
+      extend Forwardable
+
+      attr_reader :yard_object
+
+      # @!attribute [r] path
+      #   Represents the unique path of the object.
+      #
+      #   @return [String]
+      def_delegators :@yard_object, "path"
+
+      # @param yard_object [YARD::CodeObjects::Base]
+      def initialize(yard_object)
+        @yard_object = yard_object
+      end
+    end
+  end
+end

data/lib/duck_testing/yard/method_object.rb

@@ -0,0 +1,87 @@
+require "duck_testing/yard/code_object"
+
+module DuckTesting
+  module YARD
+    # Encapsulate `YARD::CodeObjects::MethodObject`.
+    class MethodObject < CodeObject
+      # @!attribute [r] name
+      #   Returns the name of the object.
+      #
+      #   @return [String]
+      # @!attribute [r] scope
+      #   Returns the scope of the object.
+      #
+      #   @return [Symbol]
+      def_delegators :@yard_object, "name", "scope"
+
+      # @return [String]
+      def signature
+        "#{name}(#{parameters_signature})"
+      end
+
+      # @return [Array<DuckTesting::YARD::MethodParameter>]
+      def method_parameters
+        @method_parameters ||= begin
+          if yard_object.parameters.any?
+            yard_object.parameters.map do |name, default|
+              MethodParameter.new(self, name, default, get_parameter_tag(name))
+            end
+          elsif parameter_tags.any?
+            # Maybe the method is defined using a DSL and its signature is
+            # declared with "@!method" directive.
+            parameter_tags.map do |tag|
+              MethodParameter.new(self, tag.name, nil, tag)
+            end
+          else
+            # The method does not take any arguments.
+            []
+          end
+        end
+      end
+
+      # @return [Array<DuckTesting::YARD::MethodParameter>]
+      def keyword_parameters
+        method_parameters.select(&:keyword?)
+      end
+
+      # @return [YARD::Tags::Tag]
+      def return_tag
+        @return_tag ||= yard_object.tags.find { |tag| tag.tag_name == "return" }
+      end
+
+      # @return [Array<DuckTesting::Type::Base>]
+      def expected_return_types
+        return_tag ? DuckTesting::YARD.expected_types(return_tag.types) : []
+      end
+
+      # @return [Boolean]
+      def public_instance_method?
+        yard_object.scope == :instance
+      end
+
+      # @return [Boolean]
+      def public_class_method?
+        yard_object.scope == :class
+      end
+
+      private
+
+      # @return [String]
+      def parameters_signature
+        method_parameters.map(&:to_s).join(", ")
+      end
+
+      # @return [YARD::Tags::Tag]
+      def get_parameter_tag(name)
+        parameter_tags.find do |tag|
+          name == (name.end_with?(":") ? "#{tag.name}:" : tag.name)
+        end
+      end
+
+      # @return [Array<YARD::Tags::Tag>]
+      def parameter_tags
+        @parameter_tags ||= yard_object.tags.select { |tag| tag.tag_name == "param" }
+      end
+    end
+  end
+end