inch 0.0.1 → 0.1.0

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

@@ -0,0 +1,87 @@
+module Inch
+  module CLI
+    module Command
+      module Output
+        class List < Base
+          attr_reader :objects
+
+          PER_RANGE = 10
+
+          def initialize(options, objects, ranges)
+            @options = options
+            @objects = objects
+            @ranges = ranges
+            @omitted = 0
+
+            display_list
+          end
+
+          private
+
+          def display_list
+            @ranges.each do |range|
+              if range.objects.empty?
+                # pass
+              else
+                trace
+                trace_header(range.description, range.color, range.bg_color)
+                display_range(range)
+              end
+            end
+
+            if @omitted > 0
+              trace
+              trace "This output omitted #{@omitted} objects. ".dark +
+                "Use `--all` to display all objects.".dark
+            end
+          end
+
+          def display_range(range)
+            display_count = @options.full ? range.objects.size : PER_RANGE
+            list = range.objects[0...display_count]
+            list.each do |o|
+              echo range.color, result(o, range.color)
+            end
+
+            display_omitted_hint(range, display_count)
+          end
+
+          def display_omitted_hint(range, display_count)
+            omitted = range.objects.size - display_count
+            if omitted > 0
+              @omitted += omitted
+              echo range.color, "...  (omitting #{omitted} objects)".dark
+            end
+          end
+
+          def echo(color, msg)
+            trace edged(color, msg)
+          end
+
+          def result(object, color)
+            if @options.numbers
+              result_numbers(object, color)
+            else
+              result_grades(object, color)
+            end
+          end
+
+          def result_grades(object, color)
+            grade = object.grade.to_s
+            grade = grade.ljust(2).color(color)
+            priority = object.priority
+            " #{grade} #{priority_arrow(priority, color)}  #{object.path}"
+          end
+
+          def result_numbers(object, color)
+            score = object.score.to_i.to_s
+            score = score.rjust(3).color(color)
+            priority = object.priority
+            "#{score}  #{priority}  #{object.path}"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/inch/cli/command/output/show.rb

@@ -0,0 +1,79 @@
+module Inch
+  module CLI
+    module Command
+      module Output
+        class Show < Base
+          attr_reader :objects
+
+          COLOR = :color132
+          BG_COLOR = :color138
+          LJUST = 20
+
+          def initialize(options, objects)
+            @options = options
+            @objects = objects
+
+            display_objects
+          end
+
+          private
+
+          def display_objects
+            objects.each do |o|
+              print_object(o)
+            end
+          end
+
+          def print_object(o)
+            trace
+            trace_header(o.path, COLOR, BG_COLOR)
+
+            print_file_info(o)
+            print_grade_info(o)
+            print_roles_info(o)
+
+          end
+
+          def print_file_info(o)
+            o.files.each do |f|
+              echo "-> #{f[0]}:#{f[1]}".color(COLOR)
+            end
+            echo separator
+          end
+
+          def print_grade_info(o)
+            echo "Grade: #{grade(o.score)}".rjust(5)
+            echo separator
+          end
+
+          def print_roles_info(o)
+            if o.roles.empty?
+              echo "No roles assigned.".dark
+            else
+              o.roles.each_with_index do |role, index|
+                if role.suggestion
+                  echo "+".color(COLOR) + " #{role.suggestion}"
+                end
+              end
+            end
+            echo separator
+          end
+
+          def echo(msg = "")
+            trace edged(COLOR, msg)
+          end
+
+          def separator
+            "-".color(COLOR) * (CLI::COLUMNS - 2)
+          end
+
+          def grade(score)
+            ranges ||= Evaluation.new_score_ranges
+            r = ranges.detect { |r| r.range.include?(score) }
+            "#{r.grade} - #{r.description}".color(r.color)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inch/cli/command/output/stats.rb

@@ -0,0 +1,111 @@
+require 'json'
+require 'yaml'
+
+module Inch
+  module CLI
+    module Command
+      module Output
+        class Stats < Base
+          include SparklineHelper
+
+          attr_reader :objects
+
+          PRIORITY_COLORS = [
+              [213,212,211,210,210,209,209],
+              [177],
+              [203, 203, 204, 204, 205, 206, 207]
+            ].flatten.map { |s| :"color#{s}" }
+
+          def initialize(options, objects, ranges)
+            @options = options
+            @objects = objects
+            @ranges = ranges
+
+            method("display_#{@options.format}").call
+          end
+
+          private
+
+          def display_text
+            display_text_grades
+            display_text_priorities
+            puts
+            puts 'Try `--format json|yaml` for raw numbers.'.dark
+          end
+
+          def display_text_grades
+            sparkline = ranges_sparkline(@ranges).to_s(' ')
+            puts
+            puts 'Grade distribution: (undocumented, C, B, A)'
+            puts
+            puts "  Overall:  #{sparkline}  #{objects.size.to_s.rjust(5)} objects"
+            puts
+            puts 'Grade distribution by priority:'
+            puts
+            PRIORITY_MAP.each do |priority_range, arrow|
+              list = objects.select { |o| priority_range.include?(o.priority) }
+              sparkline = grades_sparkline(list).to_s(' ')
+              puts "        #{arrow}   #{sparkline}  " +
+                    "#{list.size.to_s.rjust(5)} objects"
+              puts
+            end
+          end
+
+          def display_text_priorities
+            puts "Priority distribution in grades: (low to high)"
+            puts
+            puts "      #{PRIORITY_MAP.values.reverse.join('      ')}"
+            @ranges.reverse.each do |range|
+              list = range.objects.map(&:priority)
+
+              priorities = {}
+              (-7..7).each do |key|
+                priorities[key.to_s] = list.select { |p| p == key }.size
+              end
+
+              sparkline = Sparkr::Sparkline.new(priorities.values)
+              sparkline.format do |tick, count, index|
+                tick.color( PRIORITY_COLORS[index] )
+              end
+              puts "  #{range.grade}:  " + sparkline.to_s(' ') +
+                    " #{range.objects.size.to_s.rjust(5)} objects"
+              puts
+            end
+          end
+
+          def display_json
+            puts JSON.pretty_generate(stats_hash)
+          end
+
+          def display_yaml
+            puts YAML.dump(stats_hash)
+          end
+
+          def stats_hash
+            hash = {}
+
+            hash['ranges'] = {}
+            @ranges.each do |r|
+              hash['ranges'][r.grade.to_s] = r.objects.size
+            end
+
+            hash['scores'] = {}
+            @objects.sort_by(&:score).each do |o|
+              hash['scores'][o.score.to_i] ||= 0
+              hash['scores'][o.score.to_i] += 1
+            end
+
+            hash['priorities'] = {}
+            @objects.sort_by(&:priority).each do |o|
+              hash['priorities'][o.priority.to_i] ||= 0
+              hash['priorities'][o.priority.to_i] += 1
+            end
+
+            hash
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/inch/cli/command/output/suggest.rb

@@ -0,0 +1,104 @@
+require 'sparkr'
+
+module Inch
+  module CLI
+    module Command
+      module Output
+        class Suggest < Base
+          include SparklineHelper
+
+          attr_reader :objects, :files
+
+          FILE_COLOR = :dark # TODO: store all colors somewhere
+          RANGE_LABELS = {
+            :A => "Nearly perfect:",
+            :B => "Properly documented, could be improved:",
+            :C => "Not properly documented:",
+            :U => "Undocumented:",
+          }
+
+          # @param options [Command::Options::Suggest]
+          # @param objects_to_display [Array<CodeObject::Proxy::Base>]
+          # @param relevant_objects [Array<CodeObject::Proxy::Base>] the objects meeting the criteria defined in +options+
+          # @param ranges [Array<Evaluation::ScoreRange>]
+          # @param files [Array<Evaluation::File>]
+          def initialize(options, objects_to_display, relevant_objects, ranges, files)
+            @options = options
+            @objects = objects_to_display
+            @relevant_objects = relevant_objects
+            @ranges = ranges
+            @files = files
+
+            if objects.empty?
+              # TODO: show hint
+            else
+              display_list
+              display_files
+              display_distribution
+            end
+          end
+
+          private
+
+          def display_distribution
+            sparkline = grades_sparkline(@relevant_objects).to_s(' ')
+            puts "Grade distribution (undocumented, C, B, A):  " + sparkline
+            puts
+            puts priority_filter_hint
+          end
+
+          def priority_filter_hint
+            arrows = min_priority_arrows
+            pretext = if @options.pedantic
+              "Considering priority objects: #{arrows}"
+            else
+              "Only considering priority objects: #{arrows}"
+            end
+            "#{pretext}  (use `--help` for options).".dark
+          end
+
+          def display_files
+            trace
+            trace "You might want to look at these files:"
+            trace
+
+            files.each do |f|
+              trace edged(FILE_COLOR, f.path.color(FILE_COLOR))
+            end
+            trace
+          end
+
+          def display_list
+            @options.grades_to_display.map do |grade|
+              r = range(grade)
+              grade_objects = objects.select { |o| o.grade == r.grade }
+              unless grade_objects.empty?
+                trace
+                trace_header(RANGE_LABELS[r.grade], r.color, r.bg_color)
+                grade_objects.each do |o|
+                  grade = o.grade.to_s.ljust(2).color(r.color)
+                  priority = o.priority
+                  trace edged(r.color, " #{grade} #{priority_arrow(priority, r.color)}  #{o.path}")
+                end
+              end
+            end
+          end
+
+          def min_priority_arrows
+            priority_arrows_gte(@options.object_min_priority).join(' ')
+          end
+
+          def priority_arrows_gte(min_priority)
+            PRIORITY_MAP.map do |range, str|
+              str if range.min >= min_priority
+            end.compact
+          end
+
+          def range(grade)
+            @ranges.detect { |r| r.grade == grade }
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+module Inch
+  module CLI
+    module Command
+      class Stats < List
+        def description
+          'Lists all objects with their results'
+        end
+
+        def usage
+          'Usage: inch stats [paths] [options]'
+        end
+
+        def run(*args)
+          prepare_list(*args)
+          Output::Stats.new(@options, objects, @ranges)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+module Inch
+  module CLI
+    module Command
+      class Suggest < List
+        def description
+          'Suggests some objects to be doucmented (better)'
+        end
+
+        def usage
+          'Usage: inch suggest [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::Suggest.new(@options, objects_to_display, relevant_objects, @ranges, files)
+        end
+
+        def objects_to_display
+          @objects_to_display ||= filter_objects_to_display
+        end
+
+        def filter_objects_to_display
+          list = []
+          @options.grades_to_display.map do |grade|
+            r = range(grade)
+            arr = select_by_priority(r.objects, @options.object_min_priority)
+            arr = arr.select { |o| o.score <= @options.object_max_score }
+            list.concat arr
+          end
+
+          list = sort_by_priority(list)
+
+          if list.size > @options.object_count
+            list = list[0...@options.object_count]
+          elsif list.size < @options.object_count
+            # should we add objects with lower priority to fill out the
+            # requested count?
+          end
+          list
+        end
+
+        def files
+          list = files_sorted_by_importance
+          how_many = @options.file_count || list.size
+          list[0...how_many]
+        end
+
+        def files_sorted_by_importance
+          list = all_filenames(relevant_objects).uniq.map do |filename|
+            f = Evaluation::File.for(filename, relevant_objects)
+          end
+
+          list = list.select do |f|
+            relevant_grades.include?(f.grade) &&
+              relevant_priorities.include?(f.priority)
+          end
+
+          sort_by_priority(list)
+        end
+
+        def all_filenames(objects)
+          objects.map do |o|
+            o.files.map(&:first)
+          end.flatten
+        end
+
+        # Returns the unique grades assigned to objects
+        #
+        #   grades # => [:A, :B, :C, :U]
+        #
+        # @return [Array<Symbol>]
+        def grades
+          objects.map(&:grade).uniq
+        end
+
+        def range(grade)
+          @ranges.detect { |r| r.grade == grade }
+        end
+
+        def relevant_objects
+          select_by_priority(objects, @options.object_min_priority)
+        end
+
+        def relevant_grades
+          grades.size >= 2 ? grades[-2..-1] : [grades.last].compact
+        end
+
+        def relevant_priorities
+          (@options.object_min_priority..99)
+        end
+
+        def select_by_priority(list, min_priority)
+          list.select { |o| o.priority >= min_priority }
+        end
+
+      end
+    end
+  end
+end