inch 0.0.1 → 0.1.0

data/lib/inch/cli.rb

@@ -0,0 +1,24 @@
+module Inch
+  module CLI
+    class << self
+      # Returns the columns of the terminal window
+      # (defaults to 80)
+      # @return [Fixnum]
+      def get_term_columns
+        str = `stty size`
+        rows_cols = str.split(' ').map(&:to_i)
+        rows_cols[1]
+      rescue
+        80
+      end
+    end
+    COLUMNS = get_term_columns
+  end
+end
+
+require_relative 'cli/arguments'
+require_relative 'cli/sparkline_helper'
+require_relative 'cli/trace_helper'
+require_relative 'cli/yardopts_helper'
+require_relative 'cli/command'
+require_relative 'cli/command_parser'

data/lib/inch/cli/arguments.rb

@@ -0,0 +1,45 @@
+module Inch
+  module CLI
+    class Arguments
+      attr_reader :files, :object_names, :switches
+
+      def initialize(args)
+        @files = []
+        @object_names = []
+        @switches = []
+        parse(args)
+      end
+
+      private
+
+      def parse(args)
+        if first_non_file = args.find_index { |e| !file_or_glob?(e) }
+          @files = args[0...first_non_file]
+          rest = args[first_non_file..-1]
+          if first_switch = rest.find_index { |e| switch?(e) }
+            @object_names = rest[0...first_switch]
+            @switches = rest[first_switch..-1]
+          else
+            # object_names only
+            @object_names = rest
+          end
+        else
+          # files only
+          @files = args
+        end
+      end
+
+      def file_or_glob?(f)
+        if f =~ /[\*\{]/
+          true
+        else
+          File.file?(f) || File.directory?(f)
+        end
+      end
+
+      def switch?(f)
+        f =~ /^\-/
+      end
+    end
+  end
+end

data/lib/inch/cli/command.rb

@@ -0,0 +1,29 @@
+require_relative 'command/base'
+require_relative 'command/base_list'
+require_relative 'command/base_object'
+
+require_relative 'command/console'
+require_relative 'command/inspect'
+require_relative 'command/list'
+require_relative 'command/show'
+require_relative 'command/stats'
+require_relative 'command/suggest'
+
+require_relative 'command/options/base'
+require_relative 'command/options/base_list'
+require_relative 'command/options/base_object'
+
+require_relative 'command/options/console'
+require_relative 'command/options/inspect'
+require_relative 'command/options/list'
+require_relative 'command/options/show'
+require_relative 'command/options/stats'
+require_relative 'command/options/suggest'
+
+require_relative 'command/output/base'
+require_relative 'command/output/console'
+require_relative 'command/output/inspect'
+require_relative 'command/output/list'
+require_relative 'command/output/show'
+require_relative 'command/output/stats'
+require_relative 'command/output/suggest'

data/lib/inch/cli/command/base.rb

@@ -0,0 +1,62 @@
+module Inch
+  module CLI
+    module Command
+      # Abstract base class for CLI utilities. Provides some helper methods for
+      # the option parser
+      #
+      # @abstract
+      # @note This was adapted from YARD.
+      # @see https://github.com/lsegal/yard/blob/master/lib/yard/cli/command.rb
+      class Base
+        include TraceHelper
+
+        attr_reader :source_parser
+
+        # Helper method to run the utility on an instance.
+        # @see #run
+        def self.run(*args)
+          command = new
+          command.run(*args)
+          command
+        end
+
+        def initialize
+          options_class = "Command::Options::#{self.class.to_s.split('::').last}"
+          @options = eval(options_class).new
+          @options.usage = usage
+        end
+
+        # Returns a description of the command
+        # @return [String]
+        def description
+          ""
+        end
+
+        # Returns the name of the command by which it is referenced
+        # in the command list.
+        # @return [String]
+        def name
+          CommandParser.commands.each do |name, klass|
+            return name if klass == self.class
+          end
+        end
+
+        # Returns a description of the command's usage pattern
+        # @return [String]
+        def usage
+          "Usage: inch #{name} [options]"
+        end
+
+        private
+
+        def run_source_parser(paths, excluded)
+          debug "Parsing:\n" \
+                "  files:    #{paths.inspect}\n" \
+                "  excluded: #{excluded.inspect}"
+
+          @source_parser = SourceParser.run(paths, excluded)
+        end
+      end
+    end
+  end
+end

data/lib/inch/cli/command/base_list.rb

@@ -0,0 +1,75 @@
+module Inch
+  module CLI
+    module Command
+      class BaseList < Base
+        attr_writer :objects
+
+        def initialize
+          super
+          @ranges = Evaluation.new_score_ranges
+        end
+
+        # Prepares the list of objects and ranges, parsing arguments and
+        # running the source parser.
+        #
+        # @param [Array<String>] args the list of arguments.
+        # @return [void]
+        def prepare_list(*args)
+          @options.parse(args)
+          @options.verify
+          run_source_parser(@options.paths, @options.excluded)
+          filter_objects
+          assign_objects_to_ranges
+        end
+
+        private
+
+        # Assigns the objects returned by {#objects} to the score ranges in
+        # @ranges based on their score
+        #
+        def assign_objects_to_ranges
+          @ranges.each do |range|
+            list = objects.select { |o| range.range.include?(o.score) }
+            range.objects = sort_by_priority(list)
+          end
+        end
+
+        def filter_objects
+          if @options.namespaces == :only
+            self.objects = objects.select(&:namespace?)
+          end
+          if @options.namespaces == :none
+            self.objects = objects.reject(&:namespace?)
+          end
+          if @options.undocumented == :only
+            self.objects = objects.select(&:undocumented?)
+          end
+          if @options.undocumented == :none
+            self.objects = objects.reject(&:undocumented?)
+          end
+          if @options.depth
+            self.objects = objects.select { |o| o.depth <= @depth }
+          end
+          self.objects = objects.select do |o|
+            @options.visibility.include?(o.visibility)
+          end
+          if !@options.visibility.include?(:private)
+            self.objects = objects.reject do |o|
+              o.private_tag?
+            end
+          end
+        end
+
+        def objects
+          @objects ||= sort_by_priority(source_parser.all_objects)
+        end
+
+        def sort_by_priority(objects)
+          objects.sort_by do |o|
+            [o.priority, o.score, o.path.size]
+          end.reverse
+        end
+      end
+    end
+  end
+end

data/lib/inch/cli/command/base_object.rb

@@ -0,0 +1,40 @@
+module Inch
+  module CLI
+    module Command
+      class BaseObject < Base
+        attr_accessor :object, :objects
+
+        def initialize
+          super
+          @ranges = Evaluation.new_score_ranges
+        end
+
+        # Prepares the (list of) objects, parsing arguments and
+        # running the source parser.
+        #
+        # @param [Array<String>] args the list of arguments.
+        # @return [void]
+        def prepare_objects(*args)
+          @options.parse(args)
+          @options.verify
+          run_source_parser(@options.paths, @options.excluded)
+
+          self.objects = find_object_names(@options.object_names)
+          self.object = @objects.first
+        end
+
+        private
+
+        def find_object_names(object_names)
+          object_names.map do |object_name|
+            if object = source_parser.find_object(object_name)
+              object
+            else
+              source_parser.find_objects(object_name)
+            end
+          end.flatten
+        end
+      end
+    end
+  end
+end

data/lib/inch/cli/command/console.rb

@@ -0,0 +1,22 @@
+require 'pry'
+
+module Inch
+  module CLI
+    module Command
+      class Console < BaseObject
+        def description
+          'Shows a console'
+        end
+
+        def usage
+          'Usage: inch console [paths] [OBJECT_NAME] [options]'
+        end
+
+        def run(*args)
+          prepare_objects(*args)
+          Output::Console.new(@options, @object, @objects, source_parser)
+        end
+      end
+    end
+  end
+end

data/lib/inch/cli/command/inspect.rb

@@ -0,0 +1,20 @@
+module Inch
+  module CLI
+    module Command
+      class Inspect < BaseObject
+        def description
+          'Inspects an object'
+        end
+
+        def usage
+          'Usage: inch inspect [paths] OBJECT_NAME [[OBJECT_NAME2] ...] [options]'
+        end
+
+        def run(*args)
+          prepare_objects(*args)
+          Output::Inspect.new(@options, objects)
+        end
+      end
+    end
+  end
+end

data/lib/inch/cli/command/list.rb

@@ -0,0 +1,25 @@
+module Inch
+  module CLI
+    module Command
+      class List < BaseList
+        def description
+          'Lists all objects with their results'
+        end
+
+        def usage
+          'Usage: inch list [paths] [options]'
+        end
+
+        # Runs the commandline utility, parsing arguments and displaying a
+        # list of objects
+        #
+        # @param [Array<String>] args the list of arguments.
+        # @return [void]
+        def run(*args)
+          prepare_list(*args)
+          Output::List.new(@options, objects, @ranges)
+        end
+      end
+    end
+  end
+end

data/lib/inch/cli/command/options/base.rb

@@ -0,0 +1,137 @@
+require 'optparse'
+
+module Inch
+  module CLI
+    module Command
+      module Options
+        # Abstract base class for CLI options. Provides some helper methods for
+        # the option parser
+        #
+        class Base
+          include TraceHelper
+          include YardoptsHelper
+
+          class << self
+            def attribute(name, default = nil)
+              define_method(name) do
+                instance_variable_get("@#{name}") || default
+              end
+              define_method("#{name}=") do |value|
+                instance_variable_set("@#{name}", value)
+              end
+            end
+          end
+
+          attribute :usage, ""
+          attribute :paths, []
+          attribute :excluded, []
+
+          def parse(args)
+            opts = OptionParser.new
+            opts.banner = usage
+
+            descriptions.each do |text|
+              opts.separator "  " + text
+            end
+
+            set_options(opts)
+            parse_options(opts, args)
+          end
+
+          def set_options(opts)
+            common_options(opts)
+          end
+
+          # Override and fill with validations
+          def verify
+          end
+
+          protected
+
+          # Override and fill with an array of descriptions that will be
+          # shown via the help switch.
+          def descriptions
+            []
+          end
+
+          def description_arrows
+            arrows = Output::Base::PRIORITY_ARROWS.join(' ')
+            "Arrows (#{arrows}) hint at the importance of the object " +
+              "being documented."
+          end
+
+          def description_grades
+            grades = Evaluation.new_score_ranges.map(&:grade)
+            "School grades (#{grades.join(', ')}) are assigned and " +
+              "displayed with each object."
+          end
+
+          DEFAULT_PATHS = ["{lib,app}/**/*.rb", "ext/**/*.c"]
+
+          # @yard_files is assigned by YardoptsHelper#parse_yardopts_options
+          def get_paths(args)
+            paths = @yard_files ? @yard_files : args.dup
+            if paths.empty?
+              DEFAULT_PATHS
+            else
+              paths
+            end
+          end
+
+          # Adds a set of common options to the tail of the OptionParser
+          #
+          # @param [OptionParser] opts the option parser object
+          # @return [void]
+          def common_options(opts)
+            opts.separator ""
+            opts.separator "Other options:"
+            opts.on("--[no-]color", "Run without color") do |v|
+              Term::ANSIColor::coloring = v
+            end
+            opts.on_tail('-v', '--version', 'Show version.') do
+              trace "inch #{Inch::VERSION}"
+              exit
+            end
+            opts.on_tail('-h', '--help', 'Show this help.') do
+              trace opts
+              exit
+            end
+          end
+
+          def kill(msg = nil)
+            warn usage
+            warn msg.red unless msg.nil?
+            warn "Try `--help' for more information."
+            exit 1
+          end
+
+          # Parses the option and handles invalid switches
+          #
+          # @param [OptionParser] opts the option parser object
+          # @param [Array<String>] args the arguments passed from input. This
+          #   array will be modified.
+          # @return [void]
+          def parse_options(opts, args)
+            reset
+            opts.parse!(args)
+          rescue OptionParser::ParseError => err
+            kill unrecognized_option(err)
+          end
+
+          def reset
+            # color is enabled by default, can be turned of by switch --no-color
+            Term::ANSIColor::coloring = true
+          end
+
+          # Callback when an unrecognize option is parsed
+          #
+          # @param [OptionParser::ParseError] err the exception raised by the
+          #   option parser
+          def unrecognized_option(err)
+            trace "Unrecognized/#{err.message}".red
+          end
+        end
+      end
+    end
+  end
+end