inch 0.0.1 → 0.1.0

data/lib/inch/code_object/proxy/class_object.rb

@@ -0,0 +1,9 @@
+module Inch
+  module CodeObject
+    module Proxy
+      class ClassObject < NamespaceObject
+        def_delegators :object, :superclass
+      end
+    end
+  end
+end

data/lib/inch/code_object/proxy/constant_object.rb

@@ -0,0 +1,8 @@
+module Inch
+  module CodeObject
+    module Proxy
+      class ConstantObject < Base
+      end
+    end
+  end
+end

data/lib/inch/code_object/proxy/method_object.rb

@@ -0,0 +1,118 @@
+module Inch
+  module CodeObject
+    module Proxy
+      class MethodObject < Base
+        def comment_and_abbrev_source
+          comments.join('') + abbrev_source
+        end
+
+        def bang_name?
+          name =~ /\!$/
+        end
+
+        def has_parameters?
+          !parameters.empty?
+        end
+
+        MANY_PARAMETERS_THRESHOLD = 3
+        def has_many_parameters?
+          parameters.size > MANY_PARAMETERS_THRESHOLD
+        end
+
+        MANY_LINES_THRESHOLD = 20
+        def has_many_lines?
+          # for now, this includes the 'def' line and comments
+          if source = object.source
+            size = source.lines.count
+            size > MANY_LINES_THRESHOLD
+          else
+            false
+          end
+        end
+
+        def method?
+          true
+        end
+
+        def parameters
+          @parameters ||= all_parameter_names.map do |name|
+            in_signature = signature_parameter_names.include?(name)
+            tag = parameter_tag(name)
+            MethodParameterObject.new(self, name, tag, in_signature)
+          end
+        end
+
+        def parameter(name)
+          parameters.detect { |p| p.name == name.to_s }
+        end
+
+        def overridden?
+          !!object.overridden_method
+        end
+
+        def overridden_method
+          @overridden_method ||= Proxy.for(object.overridden_method)
+        end
+
+        def return_mentioned?
+          !!return_tag || docstring.mentions_return?
+        end
+
+        private
+
+        def all_parameter_names
+          names = signature_parameter_names
+          names.concat parameter_tags.map(&:name)
+          names.compact.uniq
+        end
+
+        def abbrev_source
+          lines = object.source.to_s.lines
+          if lines.size >= 5
+            indent = lines[1].scan(/^(\s+)/).flatten.join('')
+            lines = lines[0..1] +
+                    ["#{indent}# ... snip ...\n"] +
+                    lines[-2..-1]
+          end
+          lines.join('')
+        end
+
+        def comments
+          @comments ||= files.map do |(filename, line_no)|
+            get_lines_up_while(filename, line_no - 1) do |line|
+              line =~ /^\s*#/
+            end.flatten.join('')
+          end
+        end
+
+        def get_lines_up_while(filename, line_no, &block)
+          lines = []
+          line = get_line_no(filename, line_no)
+          if yield(line) && line_no > 0
+            lines << line.gsub(/^(\s+)/, '')
+            lines << get_lines_up_while(filename, line_no - 1, &block)
+          end
+          lines.reverse
+        end
+
+        def signature_parameter_names
+          object.parameters.map(&:first)
+        end
+
+        def parameter_tag(param_name)
+          parameter_tags.detect do |tag|
+            tag.name == param_name
+          end
+        end
+
+        def parameter_tags
+          object.tags(:param)
+        end
+
+        def return_tag
+          object.tags(:return).first
+        end
+      end
+    end
+  end
+end

data/lib/inch/code_object/proxy/method_parameter_object.rb

@@ -0,0 +1,81 @@
+module Inch
+  module CodeObject
+    module Proxy
+      class MethodParameterObject
+        attr_reader :name
+
+        # @param method [Inch::CodeObject::Proxy::MethodObject] the method the parameter belongs_to
+        # @param name [String] the name of the parameter
+        # @param tag [YARD::Tags::Tag] the Tag object for the parameter
+        # @param in_signature [Boolean] +true+ if the method's signature contains the parameter
+        def initialize(method, name, tag, in_signature)
+          @method = method
+          @name = name
+          @tag = tag
+          @in_signature = in_signature
+        end
+
+        BAD_NAME_EXCEPTIONS = %w(id)
+        BAD_NAME_THRESHOLD = 3
+        def bad_name?
+          return false if BAD_NAME_EXCEPTIONS.include?(name)
+          name.size < BAD_NAME_THRESHOLD || name =~ /[0-9]$/
+        end
+
+        # @return [Boolean] +true+ if the parameter is a block
+        def block?
+          name =~ /^\&/
+        end
+
+        # @return [Boolean] +true+ if an additional description given?
+        def described?
+          described_by_tag? || described_by_docstring?
+        end
+
+        # @return [Boolean] +true+ if the parameter is mentioned in the docs
+        def mentioned?
+          !!@tag || mentioned_by_docstring?
+        end
+
+        # @return [Boolean] +true+ if the parameter is a splat argument
+        def splat?
+          name =~ /^\*/
+        end
+
+        # @return [Boolean] +true+ if the type of the parameter is defined
+        def typed?
+          @tag && @tag.types && !@tag.types.empty?
+        end
+
+        # @return [Boolean] +true+ if the parameter is mentioned in the docs, but not present in the method's signature
+        def wrongly_mentioned?
+          mentioned? && !@in_signature
+        end
+
+        private
+
+        def described_by_tag?
+          @tag && !@tag.text.empty?
+        end
+
+        def described_by_docstring?
+          if @method.docstring.describes_parameter?(name)
+            true
+          else
+            unsplatted = name.gsub(/^[\&\*]/, '')
+            @method.docstring.describes_parameter?(unsplatted)
+          end
+        end
+
+        def mentioned_by_docstring?
+          if @method.docstring.mentions_parameter?(name)
+            true
+          else
+            unsplatted = name.gsub(/^[\&\*]/, '')
+            @method.docstring.mentions_parameter?(unsplatted)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inch/code_object/proxy/module_object.rb

@@ -0,0 +1,8 @@
+module Inch
+  module CodeObject
+    module Proxy
+      class ModuleObject < NamespaceObject
+      end
+    end
+  end
+end

data/lib/inch/code_object/proxy/namespace_object.rb

@@ -0,0 +1,38 @@
+module Inch
+  module CodeObject
+    module Proxy
+      # a namespace object can have methods and other namespace objects
+      # inside itself (e.g. classes and modules)
+      class NamespaceObject < Base
+        def children
+          object.children.map do |o|
+            Proxy.for(o)
+          end
+        end
+
+        MANY_ATTRIBUTES_THRESHOLD = 5
+        def has_many_attributes?
+          n = object.class_attributes.size + object.instance_attributes.size
+          n > MANY_ATTRIBUTES_THRESHOLD
+        end
+
+        MANY_CHILDREN_THRESHOLD = 20
+        def has_many_children?
+          children.size > MANY_CHILDREN_THRESHOLD
+        end
+
+        def namespace?
+          true
+        end
+
+        def no_methods?
+          !children.any?(&:method?)
+        end
+
+        def pure_namespace?
+          children.all?(&:namespace?)
+        end
+      end
+    end
+  end
+end

data/lib/inch/core_ext.rb

@@ -0,0 +1,2 @@
+require_relative 'core_ext/yard'
+require_relative 'core_ext/string'

data/lib/inch/core_ext/string.rb

@@ -0,0 +1,3 @@
+require 'term/ansicolor'
+
+String.send(:include, Term::ANSIColor)

data/lib/inch/core_ext/yard.rb

@@ -0,0 +1,4 @@
+require 'logger'
+require 'yard'
+
+log.level = ::Logger::UNKNOWN # basically disable YARD's logging

data/lib/inch/evaluation.rb

@@ -0,0 +1,35 @@
+module Inch
+  module Evaluation
+    def self.for(code_object)
+      class_for(code_object).new(code_object)
+    end
+
+    private
+
+    def self.class_for(code_object)
+      class_name = code_object.class.to_s.split('::').last
+      eval(class_name)
+    rescue
+      Base
+    end
+  end
+end
+
+require_relative 'evaluation/file'
+
+require_relative 'evaluation/score_range'
+
+require_relative 'evaluation/role/base'
+require_relative 'evaluation/role/missing'
+require_relative 'evaluation/role/object'
+require_relative 'evaluation/role/method'
+require_relative 'evaluation/role/method_parameter'
+require_relative 'evaluation/role/namespace'
+require_relative 'evaluation/role/constant'
+
+require_relative 'evaluation/base'
+require_relative 'evaluation/namespace_object'
+require_relative 'evaluation/class_object'
+require_relative 'evaluation/constant_object'
+require_relative 'evaluation/method_object'
+require_relative 'evaluation/module_object'

data/lib/inch/evaluation/base.rb

@@ -0,0 +1,60 @@
+module Inch
+  module Evaluation
+    class Base
+      extend Forwardable
+
+      MIN_SCORE = 0
+      MAX_SCORE = 100
+
+      TAGGED_SCORE = 20 # assigned per unconsidered tag
+
+
+      attr_accessor :object
+      attr_reader :min_score, :max_score
+
+      def initialize(object)
+        self.object = object
+        @roles = []
+        evaluate
+      end
+
+      def evaluate
+      end
+
+      def max_score
+        arr = @roles.map(&:max_score).compact
+        [MAX_SCORE].concat(arr).min
+      end
+
+      def min_score
+        arr = @roles.map(&:min_score).compact
+        [MIN_SCORE].concat(arr).max
+      end
+
+      def score
+        value = @roles.inject(0) { |sum,r| sum + r.score.to_f }
+        if value < min_score
+          min_score
+        elsif value > max_score
+          max_score
+        else
+          value
+        end
+      end
+
+      def priority
+        @roles.inject(0) { |sum,r| sum + r.priority.to_i }
+      end
+
+      def roles
+        @roles
+      end
+
+      protected
+
+      def add_role(role)
+        @roles << role
+      end
+    end
+  end
+end

data/lib/inch/evaluation/class_object.rb

@@ -0,0 +1,6 @@
+module Inch
+  module Evaluation
+    class ClassObject < NamespaceObject
+    end
+  end
+end

data/lib/inch/evaluation/constant_object.rb

@@ -0,0 +1,34 @@
+module Inch
+  module Evaluation
+    class ConstantObject < Base
+      DOC_SCORE = MAX_SCORE
+
+      def evaluate
+        if object.has_doc?
+          add_role Role::Constant::WithDoc.new(object, DOC_SCORE)
+        else
+          add_role Role::Constant::WithoutDoc.new(object, DOC_SCORE)
+        end
+        if object.nodoc?
+          add_role Role::Constant::TaggedAsNodoc.new(object)
+        end
+        if object.has_unconsidered_tags?
+          count = object.unconsidered_tags.size
+          add_role Role::Object::Tagged.new(object, TAGGED_SCORE * count)
+        end
+        if object.in_root?
+          add_role Role::Constant::InRoot.new(object)
+        end
+        if object.public?
+          add_role Role::Constant::Public.new(object)
+        end
+        if object.protected?
+          add_role Role::Constant::Protected.new(object)
+        end
+        if object.private?
+          add_role Role::Constant::Private.new(object)
+        end
+      end
+    end
+  end
+end

data/lib/inch/evaluation/file.rb

@@ -0,0 +1,66 @@
+module Inch
+  module Evaluation
+    class File
+      attr_accessor :filename, :objects
+
+      def initialize(filename, objects)
+        self.filename = filename
+        self.objects = objects.select do |o|
+          o.filename == filename
+        end
+      end
+
+      # @note added to be compatible with code objects
+      def path
+        filename
+      end
+
+      #
+      # grade, priority, and score are not meant to be displayed in the CLI
+      # they are just for internal evaluation purposes
+      #
+
+      def grade
+        median(grades.sort)
+      end
+
+      def priority
+        median(priorities.sort)
+      end
+
+      def score
+        objects.select(&:undocumented?).size
+      end
+
+      private
+
+      def grades
+        objects.map(&:grade)
+      end
+
+      def priorities
+        objects.map(&:priority)
+      end
+
+      def scores
+        objects.map(&:score)
+      end
+
+      def median(sorted_list)
+        index = (sorted_list.size / 2).round
+        sorted_list[index]
+      end
+
+      class << self
+        def for(filename, objects)
+          @cache ||= {}
+          if file = @cache[filename]
+            file
+          else
+            @cache[filename] = new(filename, objects)
+          end
+        end
+      end
+    end
+  end
+end