inch 0.2.3 → 0.3.0.rc1

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

@@ -2,7 +2,6 @@ module Inch
   module CodeObject
     module Proxy
       class ClassObject < NamespaceObject
-        def_delegators :object, :superclass
       end
     end
   end

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

@@ -3,31 +3,16 @@ module Inch
     module Proxy
       # Proxy class for methods
       class MethodObject < Base
-
         def constructor?
-          name == :initialize
-        end
-        
-        def comment_and_abbrev_source
-          comments.join('') + abbrev_source
+          self[:constructor?]
         end
 
         def bang_name?
-          name =~ /\!$/
+          self[:bang_name?]
         end
 
         def getter?
-          attr_info = object.attr_info || {}
-          read_info = attr_info[:read]
-          if read_info
-            read_info.path == path
-          else
-            parent.child(:"#{name}=")
-          end
-        end
-
-        def has_doc?
-          super && !implicit_docstring?
+          self[:getter?]
         end
 
         def has_parameters?
@@ -42,7 +27,7 @@ module Inch
         MANY_LINES_THRESHOLD = 20
         def has_many_lines?
           # for now, this includes the 'def' line and comments
-          if source = object.source
+          if source
             size = source.lines.count
             size > MANY_LINES_THRESHOLD
           else
@@ -50,110 +35,46 @@ module Inch
           end
         end
 
-        def method?
-          true
+        def parameter(name)
+          parameters.detect { |p| p.name == name.to_s }
         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)
+          @parameters ||= self[:parameters].map do |param_attr|
+            MethodParameterObject.new(param_attr)
           end
         end
 
-        def parameter(name)
-          parameters.detect { |p| p.name == name.to_s }
-        end
-
         def overridden?
-          !!object.overridden_method
+          self[:overridden?]
         end
 
         def overridden_method
-          @overridden_method ||= Proxy.for(object.overridden_method)
+          @overridden_method ||= object_lookup.find(self[:overridden_method_fullname])
         end
 
         def return_mentioned?
-          !!return_tag || docstring.mentions_return?
+          self[:return_mentioned?]
         end
 
         def return_described?
-          (return_tag && !return_tag.text.empty?) || docstring.describes_return?
-        end
-
-        def setter?
-          name =~ /\=$/ && parameters.size == 1
-        end
-
-        def questioning_name?
-          name =~ /\?$/
-        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.to_a
-          if lines.size >= 5
-            indent = lines[1].scan(/^(\s+)/).flatten.join('')
-            lines = lines[0..1] +
-                    ["#{indent}# ... snip ...\n"] +
-                    lines[-2..-1]
-          end
-          lines.join('')
+          self[:return_described?]
         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
+        def return_typed?
+          self[:return_typed?]
         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 implicit_docstring?
-          if getter?
-            docstring == "Returns the value of attribute #{name}"
-          elsif setter?
-            basename = name.to_s.gsub(/(\=)$/, '')
-            docstring == "Sets the attribute #{basename}"
-          else
-            false
-          end
-        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
+        def setter?
+          self[:setter?]
         end
 
-        def parameter_tags
-          object.tags(:param)
+        def source
+          self[:source?]
         end
 
-        def return_tag
-          object.tags(:return).first
+        def questioning_name?
+          self[:questioning_name?]
         end
       end
     end

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

@@ -3,17 +3,12 @@ module Inch
     module Proxy
       # Proxy class for method parameters
       class MethodParameterObject
-        attr_reader :name # @return [String]
+        def initialize(attributes)
+          @attributes = attributes
+        end
 
-        # @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
+        def [](key)
+          @attributes[key]
         end
 
         BAD_NAME_EXCEPTIONS = %w(id)
@@ -27,57 +22,38 @@ module Inch
 
         # @return [Boolean] +true+ if the parameter is a block
         def block?
-          name =~ /^\&/
+          self[:block?]
         end
 
         # @return [Boolean] +true+ if an additional description given?
         def described?
-          described_by_tag? || described_by_docstring?
+          self[:described?]
         end
 
         # @return [Boolean] +true+ if the parameter is mentioned in the docs
         def mentioned?
-          !!@tag || mentioned_by_docstring?
+          self[:mentioned?]
+        end
+
+        def name
+          self[:name]
         end
 
         # @return [Boolean] +true+ if the parameter is a splat argument
         def splat?
-          name =~ /^\*/
+          self[:splat?]
         end
 
         # @return [Boolean] +true+ if the type of the parameter is defined
         def typed?
-          @tag && @tag.types && !@tag.types.empty?
+          self[:typed?]
         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
+          self[:wrongly_mentioned?]
         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

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

@@ -4,22 +4,15 @@ module Inch
       # a namespace object can have methods and other namespace objects
       # inside itself (e.g. classes and modules)
       class NamespaceObject < Base
-        def child(name)
-          if children
-            children.detect { |child| child.name == name }
-          end
-        end
-
-        def children
-          object.children.map do |o|
-            Proxy.for(o)
-          end
+        # The wording is a bit redundant, but this means the class and
+        # instance attributes of the namespace
+        def attributes
+          self[:attributes]
         end
 
         MANY_ATTRIBUTES_THRESHOLD = 5
         def has_many_attributes?
-          n = object.class_attributes.size + object.instance_attributes.size
-          n > MANY_ATTRIBUTES_THRESHOLD
+          attributes.size > MANY_ATTRIBUTES_THRESHOLD
         end
 
         MANY_CHILDREN_THRESHOLD = 20
@@ -27,12 +20,8 @@ module Inch
           children.size > MANY_CHILDREN_THRESHOLD
         end
 
-        def namespace?
-          true
-        end
-
-        def no_methods?
-          !children.any?(&:method?)
+        def has_methods?
+          children.any?(&:method?)
         end
 
         def pure_namespace?

data/lib/inch/codebase.rb

@@ -0,0 +1,19 @@
+module Inch
+  # Codebases are one of the building blocks of Inch's analysis (the other
+  # being "code objects" inside these "codebases").
+  module Codebase
+    # Parses a codebase
+    #
+    # @param dir [String]
+    # @param paths [Array<String>]
+    # @param excluded [Array<String>]
+    # @return [Codebase::Proxy]
+    def self.parse(dir, paths = nil, excluded = nil)
+      Proxy.new(dir, paths, excluded)
+    end
+  end
+end
+
+require_relative 'codebase/proxy'
+require_relative 'codebase/objects'
+require_relative 'codebase/objects_filter'

data/lib/inch/codebase/objects.rb

@@ -0,0 +1,73 @@
+module Inch
+  module Codebase
+    class Objects
+      include Enumerable
+      extend Forwardable
+
+      def_delegators :@list, :each, :empty?, :size
+
+      # @param objects [Array<CodeObject::Proxy::Base>]
+      # @return [Array<CodeObject::Proxy::Base>]
+      def self.sort_by_priority(objects)
+        objects.sort_by do |o|
+          [o.priority, o.score, o.fullname.size]
+        end.reverse
+      end
+
+      def initialize(objects)
+        list = objects.map do |o|
+          proxy = CodeObject::Proxy.for(o)
+          proxy.object_lookup = self
+          proxy
+        end
+        @list = list
+        # the @list has to be set for the priority sorting
+        # since the priority needs the object_lookup, which
+        # in turn depends on @list - it's a crazy world
+        @list = self.class.sort_by_priority(@list)
+      end
+
+      # Returns all parsed objects as code object proxies
+      #
+      # @see CodeObject::Proxy.for
+      # @return [Array<CodeObject::Proxy::Base>]
+      def all
+        @list
+      end
+
+      # Returns the object with the given +fullname+
+      #
+      # @example
+      #
+      #   find("Foo#bar")
+      #   # => returns the code object proxy for Foo#bar
+      #
+      # @param fullname [String] partial fullname/name of an object
+      # @return [CodeObject::Proxy::Base]
+      def find(fullname)
+        all.detect { |o| o.fullname == fullname }
+      end
+
+      # Returns all objects where the +fullname+ starts_with the given
+      # +partial_name+
+      #
+      # @example
+      #
+      #   find("Foo#")
+      #   # => returns the code object proxies for all instance methods of Foo
+      #
+      # @param partial_name [String] partial name of an object
+      # @return [Array<CodeObject::Proxy::Base>]
+      def starting_with(partial_name)
+        all.select { |o| o.fullname.start_with?(partial_name) }
+      end
+
+      # Filters the list based on the settings in +options+
+      #
+      # @return [void]
+      def filter!(options)
+        @list = ObjectsFilter.new(all, options).objects
+      end
+    end
+  end
+end

data/lib/inch/codebase/objects_filter.rb

@@ -0,0 +1,61 @@
+module Inch
+  module Codebase
+    # ObjectsFilter can be used to filter a list of objects by given a set of
+    # given +options+
+    class ObjectsFilter
+      attr_reader :options
+
+      def initialize(list, options)
+        @list = list
+        @options = options
+        filter
+      end
+
+      def objects
+        @list
+      end
+
+      private
+
+      def filter
+        filter_namespaces
+        filter_undocumented
+        filter_depth
+        filter_visibility
+      end
+
+      def filter_namespaces
+        if options.namespaces == :only
+          @list = @list.select(&:namespace?)
+        elsif options.namespaces == :none
+          @list = @list.reject(&:namespace?)
+        end
+      end
+
+      def filter_undocumented
+        if options.undocumented == :only
+          @list = @list.select(&:undocumented?)
+        elsif options.undocumented == :none
+          @list = @list.reject(&:undocumented?)
+        end
+      end
+
+      def filter_depth
+        if options.depth
+          @list = @list.select { |o| o.depth <= options.depth }
+        end
+      end
+
+      def filter_visibility
+        @list = @list.select do |o|
+          options.visibility.include?(o.visibility)
+        end
+        if !options.visibility.include?(:private)
+          @list = @list.reject do |o|
+            o.private_tag?
+          end
+        end
+      end
+    end
+  end
+end