inch 0.5.0.rc3 → 0.5.0.rc4

data/lib/inch/evaluation/role.rb

@@ -0,0 +1,99 @@
+module Inch
+  module Evaluation
+    # Role objects are assigned to evaluations of code objects. They describe
+    # the object they are attached to.
+    # @abstract
+    class Role
+      attr_reader :object
+
+      class << self
+        def applicable_if(symbol = nil, &block)
+          @applicable_procs ||= {}
+          @applicable_procs[to_s] = block || symbol.to_proc
+        end
+
+        def applicable_unless(symbol = nil, &block)
+          @applicable_procs ||= {}
+          @applicable_procs[to_s] = proc do |object|
+            !(block || symbol.to_proc).call(object)
+          end
+        end
+
+        def applicable?(object)
+          @applicable_procs ||= {}
+          @applicable_procs[to_s].call(object)
+        end
+
+        def priority(value)
+          define_method(:priority) { value }
+        end
+      end
+
+      # @param object [Codebase::Object] the object to evaluate
+      # @param value [Float] a score that might be added by this role
+      def initialize(object, value = nil)
+        @object = object
+        @value = value
+      end
+
+      # Returns a maximal score for the object.
+      # The final score can not be higher than this.
+      # @note Override this method to that a max_score for the evaluation.
+      # @return [Float]
+      def max_score
+      end
+
+      # Returns a minimal score for the object.
+      # The final score can not be lower than this.
+      # @note Override this method to that a min_score for the evaluation.
+      # @return [Float]
+      def min_score
+      end
+
+      # Returns a score that will be added to the associated object's
+      # overall score.
+      #
+      # @note Override this method to assign a score for the role
+      # @return [Float]
+      def score
+        @value.to_f
+      end
+
+      # Returns a potential score that would be added to the overall score
+      # if the object had implemented the Role's subject.
+      #
+      # @see Role::Missing
+      # @note Override this method to assign a potential score for the role
+      # @return [Float]
+      def potential_score
+        nil
+      end
+
+      # Returns a priority that will be added to the associated object's
+      # overall priority.
+      #
+      # @note Override this method to assign a priority for the role
+      # @return [Fixnum]
+      def priority
+        0
+      end
+
+      # Returns a suggestion to achieve the potential score that would be
+      # added to the overall score if the object had implemented the Role's
+      # subject.
+      #
+      # @see Role::Missing
+      # @return [String]
+      def suggestion
+        nil
+      end
+
+      # Returns the type of the +object+ that is being evaluated.
+      #
+      # @return [String]
+      def object_type
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/inch/language.rb

@@ -0,0 +1,3 @@
+require 'inch/language/ruby/import'
+require 'inch/language/elixir/import'
+require 'inch/language/nodejs/import'

data/lib/inch/language/elixir/code_object/base.rb

@@ -0,0 +1,197 @@
+require "forwardable"
+
+module Inch
+  module Language
+    module Elixir
+      # This is the base class for code object proxies.
+      # Code object proxies are via an attributes Hash and provide all methods
+      # necessary for the evaluation of its documentation.
+      #
+      # @abstract
+      module CodeObject
+        class Base < Inch::CodeObject::Proxy
+          def language
+            :elixir
+          end
+
+          # @return [Boolean] if the current object is an alias for something else
+          def alias?
+            !aliased_object.nil?
+          end
+
+          # @return [CodeObject::Proxy] the object the current object is an
+          #   alias of
+          def aliased_object
+            object_lookup.find(self[:aliased_object_fullname])
+          end
+
+          # @return [Boolean] +true+ if the object has an @api tag
+          def api_tag?
+            self[:api_tag?]
+          end
+
+          # @return [Array] the children of the current object
+          def children
+            @children ||= self[:children_fullnames].map do |fullname|
+              object_lookup.find(fullname)
+            end
+          end
+
+          # @return [Boolean] +true+ if the object represents a constant
+          def constant?
+            self[:constant?]
+          end
+
+          def core?
+            self[:core?]
+          end
+
+          # The depth of the following is 4:
+          #
+          #   Foo::Bar::Baz#initialize
+          #    ^    ^    ^      ^
+          #    1 << 2 << 3  <<  4
+          #
+          # +depth+ answers the question "how many layers of code objects are
+          # above this one?"
+          #
+          # @note top-level counts, that's why Foo has depth 1!
+          #
+          # @return [Fixnum] the depth of the object in terms of namespace
+          def depth
+            self[:depth]
+          end
+
+          # @return [Docstring]
+          def docstring
+            self[:docstring]
+          end
+
+          def files
+            self[:files]
+          end
+
+          # Returns the name of the file where the object is declared first
+          # @return [String] a filename
+          def filename
+            # just checking the first file (which is the file where an object
+            # is first declared)
+            files.first
+          end
+
+          # @return [String] the name of an object, e.g.
+          #   "Docstring"
+          def name
+            self[:name]
+          end
+
+          # @return [String] the fully qualified name of an object, e.g.
+          #   "Inch::CodeObject::Provider::YARD::Docstring"
+          def fullname
+            self[:fullname]
+          end
+
+          def has_alias?
+            !self[:aliases_fullnames].empty?
+          end
+
+          def has_children?
+            self[:has_children?]
+          end
+
+          def has_code_example?
+            self[:has_code_example?]
+          end
+
+          def has_doc?
+            self[:has_doc?]
+          end
+
+          def has_multiple_code_examples?
+            self[:has_multiple_code_examples?]
+          end
+
+          def has_unconsidered_tags?
+            self[:has_unconsidered_tags?]
+          end
+
+          def in_root?
+            self[:in_root?]
+          end
+
+          # @return [Boolean] +true+ if the object represents a method
+          def method?
+            self[:method?]
+          end
+
+          # @return [Boolean] +true+ if the object represents a namespace
+          def namespace?
+            self[:namespace?]
+          end
+
+          def original_docstring
+            self[:original_docstring]
+          end
+
+          # @return [Boolean] +true+ if the object was tagged not to be documented
+          def nodoc?
+            self[:nodoc?]
+          end
+
+          # @return [CodeObject::Proxy,nil] the parent of the current object
+          #   or +nil+
+          def parent
+            object_lookup.find(self[:parent_fullname])
+          end
+
+          def private?
+            self[:private?]
+          end
+
+          # @return [Boolean]
+          #   +true+ if the object or its parent is tagged as @private
+          def tagged_as_private?
+            self[:tagged_as_private?]
+          end
+
+          # @return [Boolean]
+          #   +true+ if the object or its parent is tagged as part of an
+          #   internal api
+          def tagged_as_internal_api?
+            self[:tagged_as_internal_api?]
+          end
+
+          def protected?
+            self[:protected?]
+          end
+
+          def public?
+            self[:public?]
+          end
+
+          def source
+            self[:source]
+          end
+
+          def type
+            self.class.to_s.gsub(/Object$/, "")
+          end
+
+          # @return [Boolean] +true+ if the object has no documentation at all
+          def undocumented?
+            self[:undocumented?]
+          end
+
+          # @return [Fixnum] the amount of tags not considered for this object
+          def unconsidered_tag_count
+            self[:unconsidered_tag_count]
+          end
+
+          def visibility
+            self[:visibility]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inch/language/elixir/code_object/function_object.rb

@@ -0,0 +1,74 @@
+module Inch
+  module Language
+    module Elixir
+      module CodeObject
+        # Proxy class for functions
+        class FunctionObject < Base
+          def bang_name?
+            self[:bang_name?]
+          end
+
+          def getter?
+            self[:getter?]
+          end
+
+          def has_parameters?
+            !parameters.empty?
+          end
+
+          MANY_PARAMETERS_THRESHOLD = 3
+          def has_many_parameters?
+            parameters.size > MANY_PARAMETERS_THRESHOLD
+          end
+
+          def has_many_lines?
+            false
+          end
+
+          def parameter(name)
+            parameters.find { |p| p.name == name.to_s }
+          end
+
+          def parameters
+            @parameters ||= self[:parameters].map do |param_attr|
+              MethodParameterObject.new(param_attr)
+            end
+          end
+
+          def overridden?
+            self[:overridden?]
+          end
+
+          def overridden_method
+            @overridden_method ||=
+              object_lookup.find(self[:overridden_method_fullname])
+          end
+
+          def return_mentioned?
+            self[:return_mentioned?]
+          end
+
+          def return_described?
+            self[:return_described?]
+          end
+
+          def return_typed?
+            self[:return_typed?]
+          end
+
+          def setter?
+            self[:setter?]
+          end
+
+          def source
+            self[:source?]
+          end
+
+          def questioning_name?
+            self[:questioning_name?]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inch/language/elixir/code_object/module_object.rb

@@ -0,0 +1,23 @@
+module Inch
+  module Language
+    module Elixir
+      module CodeObject
+        # Proxy class for modules
+        class ModuleObject < Base
+          MANY_CHILDREN_THRESHOLD = 20
+          def has_many_children?
+            children.size > MANY_CHILDREN_THRESHOLD
+          end
+
+          def has_methods?
+            children.any?(&:method?)
+          end
+
+          def pure_namespace?
+            children.all?(&:namespace?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inch/language/elixir/code_object/type_object.rb

@@ -0,0 +1,11 @@
+module Inch
+  module Language
+    module Elixir
+      module CodeObject
+        # Proxy class for types
+        class TypeObject < Base
+        end
+      end
+    end
+  end
+end

data/lib/inch/language/elixir/evaluation/base.rb

@@ -0,0 +1,28 @@
+module Inch
+  module Language
+    module Elixir
+      module Evaluation
+        # Base class for all Elixir related evaluations
+        #
+        # @abstract
+        class Base < Inch::Evaluation::Proxy
+          protected
+
+          def relevant_base_roles
+            {
+              Role::Object::InRoot => nil,
+              Role::Object::Public => nil,
+              Role::Object::TaggedAsNodoc => nil,
+              Role::Object::WithDoc => score_for(:docstring),
+              Role::Object::WithoutDoc => score_for(:docstring),
+              Role::Object::WithCodeExample => score_for(:code_example_single),
+              Role::Object::WithMultipleCodeExamples =>
+                score_for(:code_example_multi),
+              Role::Object::WithoutCodeExample => score_for(:code_example_single)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inch/language/elixir/evaluation/function_object.rb

@@ -0,0 +1,31 @@
+module Inch
+  module Language
+    module Elixir
+      module Evaluation
+        # Proxy class for functions
+        class FunctionObject < Base
+          protected
+
+          def relevant_roles
+            relevant_base_roles.merge(relevant_function_roles)
+          end
+
+          def relevant_function_roles
+            {
+              Role::Function::Getter => nil,
+              Role::Function::Setter => nil,
+              Role::Function::Overridden =>
+                if object.overridden?
+                  object.overridden_method.score
+                else
+                  nil
+                end,
+              Role::Function::WithBangName => nil,
+              Role::Function::WithQuestioningName => nil,
+            }
+          end
+        end
+      end
+    end
+  end
+end