rdist 0.0.1

data/ChangeLog

@@ -0,0 +1,5 @@
+2008-02-21  Yoshifumi Shimono  <yoshifumi.shimono@gmail.com>
+
+* 0.0.1 / 2008-02-21
+ * initial release
+

data/README

@@ -0,0 +1,71 @@
+
+= RDist - method length distribution reporter for Ruby.
+
+
+== Description
+
+RDist reports the distribution of method length in your Ruby codes.
+It helps you to find the longest methods by reporting the rankings together.
+
+RDist can also report the distribution of number of method definitions (or that of lines) in Class/Module.
+
+== Installation
+
+=== Archive Installation
+
+	rake install
+
+=== Gem Installation
+
+	gem install rdist
+
+
+== Features/Problems
+
+RDist simply check the indent level during the analysis, so it can't correctly analyze the code with incomplete indent.
+
+== Synopsis
+
+See the method length distribution.
+    $ rdist $GEM_HOME/gems/rdist-0.0.1/lib
+    Method length Distribution:
+      0-  4:  77%    71 ***************************************
+      5-  9:  96%    18 **********
+     10- 14: 100%     3 **
+      Total: 100%    92
+    
+    Ranking Top 5:
+         11: analyze (at lib/rdist/analyzer/base.rb:34)
+         10: find (at lib/rdist/targetfilefinder.rb:6)
+         10: analyze (at lib/rdist/analyzer/state/inblock.rb:13)
+          9: initialize (at lib/rdist/analyzer/base.rb:8)
+          8: initialize (at lib/rdist/commandlineinterface.rb:16)
+
+You can also see the distribution of number of method definitions in Class/Module (<code>-C</code>, <code>--num-methods-in-class</code> option).
+    $ rdist -C $GEM_HOME/gems/rdist-0.0.1/lib
+    Distribution of number of method definitons in Class/Module:
+      0-  4:  60%     9 ******************************
+      5-  9:  73%     2 *******
+     10- 14:  93%     3 **********
+     15- 19:  93%     0 
+     20- 24: 100%     1 ****
+      Total: 100%    15
+    
+    Ranking Top 5:
+         23: Histogram (at lib/rdist/histogram.rb:2)
+         13: Base (at lib/rdist/analyzer/base.rb:5)
+         12: InBlock (at lib/rdist/analyzer/state/inblock.rb:4)
+         10: CommandLineInterface (at lib/rdist/commandlineinterface.rb:2)
+          8: Setting (at lib/rdist/setting.rb:5)
+
+See <b>$ rdist -h</b> for more information.
+
+== See also
+
+* Flog - Seattle.rb (http://seattlerb.rubyforge.org)
+
+== Copyright
+
+Author::    Yoshifumi Shimono <yoshifumi.shimono@gmail.com>
+Copyright:: Copyright (c) 2008 Yoshifumi Shimono
+License::   Ruby's

data/Rakefile

@@ -0,0 +1,135 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/contrib/sshpublisher'
+require 'spec/rake/spectask'
+require 'rubyforge'
+require 'fileutils'
+include FileUtils
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/lib'
+require 'rdist'
+
+NAME              = "rdist"
+AUTHOR            = "Yoshifumi Shimono"
+EMAIL             = "yoshifumi.shimono@gmail.com"
+DESCRIPTION       = "reports the distribution of method length in your Ruby codes."
+RUBYFORGE_PROJECT = "rdist"
+HOMEPATH          = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+BIN_FILES         = %w( rdist )
+VERS              = RDist::VERSION
+
+REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = [
+	'--title', "#{NAME} documentation",
+	"--charset", "utf-8",
+	"--opname", "index.html",
+	"--line-numbers",
+	"--main", "README",
+	"--inline-source",
+]
+
+task :default => [:spec]
+task :package => [:clean]
+
+Spec::Rake::SpecTask.new do |t|
+	t.spec_opts = ['--options', "spec/spec.opts"]
+	t.spec_files = FileList['spec/*_spec.rb']
+	t.rcov = false
+	t.verbose = true
+end
+
+spec = Gem::Specification.new do |s|
+	s.name              = NAME
+	s.version           = VERS
+	s.platform          = Gem::Platform::RUBY
+	s.has_rdoc          = true
+	s.extra_rdoc_files  = ["README", "ChangeLog"]
+	s.rdoc_options     += RDOC_OPTS + ['--exclude', '^(examples|extras)/']
+	s.summary           = DESCRIPTION
+	s.description       = DESCRIPTION
+	s.author            = AUTHOR
+	s.email             = EMAIL
+	s.homepage          = HOMEPATH
+	s.executables       = BIN_FILES
+	s.rubyforge_project = RUBYFORGE_PROJECT
+	s.bindir            = "bin"
+	s.require_path      = "lib"
+	s.test_files        = Dir["test/test_*.rb"]
+
+	#s.add_dependency('activesupport', '>=1.3.1')
+	#s.required_ruby_version = '>= 1.8.2'
+
+	s.files = %w(README ChangeLog Rakefile) +
+		Dir.glob("{bin,doc,spec,test,lib,templates,generator,extras,website,script}/**/*") + 
+		Dir.glob("ext/**/*.{h,c,rb}") +
+		Dir.glob("examples/**/*.rb") +
+		Dir.glob("tools/*.rb")
+
+	s.extensions = FileList["ext/**/extconf.rb"].to_a
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+	p.need_tar = true
+	p.gem_spec = spec
+end
+
+task :install do
+	name = "#{NAME}-#{VERS}.gem"
+	sh %{rake package}
+	sh %{sudo gem install pkg/#{name}}
+end
+
+task :uninstall => [:clean] do
+	sh %{sudo gem uninstall #{NAME}}
+end
+
+
+Rake::RDocTask.new do |rdoc|
+	rdoc.rdoc_dir = 'html'
+	rdoc.options += RDOC_OPTS
+	rdoc.template = "resh"
+	#rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+	if ENV['DOC_FILES']
+		rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
+	else
+		rdoc.rdoc_files.include('README', 'ChangeLog')
+		rdoc.rdoc_files.include('lib/**/*.rb')
+		#rdoc.rdoc_files.include('ext/**/*.c')
+	end
+end
+
+desc "Publish to RubyForge"
+task :rubyforge => [:rdoc, :package] do
+	Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'shimono').upload
+end
+
+desc 'Package and upload the release to rubyforge.'
+task :release => [:clean, :package] do |t|
+	v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
+	abort "Versions don't match #{v} vs #{VERS}" unless v == VERS
+	pkg = "pkg/#{NAME}-#{VERS}"
+
+	rf = RubyForge.new
+	puts "Logging in"
+	rf.login
+
+	c = rf.userconfig
+#	c["release_notes"] = description if description
+#	c["release_changes"] = changes if changes
+	c["preformatted"] = true
+
+	files = [
+		"#{pkg}.tgz",
+		"#{pkg}.gem"
+	].compact
+
+	puts "Releasing #{NAME} v. #{VERS}"
+	rf.add_release RUBYFORGE_PROJECT, NAME, VERS, *files
+end

data/bin/rdist

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib'
+
+require 'rdist'
+
+RDist::CommandLineInterface.analyze(ARGV, $stdout)

data/lib/rdist/analyzer/base.rb

@@ -0,0 +1,109 @@
+require 'rdist/analyzer/macros'
+
+module RDist
+  module Analyzer
+    class Base
+      extend Macros
+
+      def initialize(pattern_open_token, pattern_count_target,
+                     pattern_close_token, allow_nesting,
+                     histogram_interval=5)
+        @pattern_open_token = pattern_open_token
+        @pattern_count_target = pattern_count_target
+        @pattern_close_token = pattern_close_token
+        @allow_nesting = allow_nesting
+        @histogram_interval = histogram_interval
+        init_count()
+        init_states()
+      end
+
+      attr_reader :pattern_open_token
+      attr_reader :pattern_count_target
+      attr_reader :pattern_close_token
+      attr_writer :histogram_interval
+
+      public
+      def analyze_all(pathes)
+        init_count()
+        pathes.each do |path|
+          analyze(path)
+        end
+      end
+
+      def analyze(path)
+        @path = path
+        DebugLogger.debug "Analyzing ``#{@path}''"
+        set_state_waiting_block()
+        open(path, 'r') do |input|
+          input.each_line do |line|
+            @current_line_id = input.lineno
+            analyze_line(line)
+          end
+        end
+        @current_line_id = nil
+        reset_states()
+      end
+
+      def histogram
+        Histogram.new(@count_of, @histogram_interval)
+      end
+
+      def ranking
+        Ranking.new(@count_of)
+      end
+
+      def reset
+        init_count()
+      end
+
+      def add_count_of(block_name, line_id)
+        block_id = "#{block_name} (at #{@path}:#{line_id})"
+        @count_of[block_id] ||= 0
+        @count_of[block_id]  += 1
+      end
+
+      def allow_nesting?
+        @allow_nesting
+      end
+
+      def deny_nesting?
+        not @allow_nesting
+      end
+
+      def_state_setter :waiting_block
+      def_state_setter :in_multi_line_comment
+      def_state_setter :in_block
+      alias __set_state_in_block__ set_state_in_block
+
+      def set_state_in_block(indent, block_name)
+        __set_state_in_block__()
+        @state.push_to_stacks(indent, block_name,
+                              @current_line_id)
+      end
+
+      private
+      def analyze_line(line)
+        @state.analyze(line)
+      end
+
+      def init_count
+        @count_of = {}
+      end
+
+      def init_states
+        @state_for = {
+          :waiting_block => State::WaitingBlock.new(self),
+          :in_block => State::InBlock.new(self),
+          :in_multi_line_comment \
+          => State::InMultiLineComment.new(self),
+        }
+      end
+
+      def reset_states
+        @state_for.each do |symbol, state|
+          state.reset
+        end
+      end
+    end
+  end
+end

data/lib/rdist/analyzer/macros.rb

@@ -0,0 +1,18 @@
+module RDist
+  module Analyzer
+    module Macros
+      private
+      def def_state_setter(state_symbol)
+        method_name = get_state_setter_name(state_symbol)
+        define_method(method_name) do
+          next_state = instance_variable_get(:@state_for)[state_symbol]
+          instance_variable_set(:@state, next_state)
+        end
+      end
+
+      def get_state_setter_name(state_symbol)
+      "set_state_#{state_symbol}"
+      end
+    end
+  end
+end

data/lib/rdist/analyzer/methodlength.rb

@@ -0,0 +1,9 @@
+module RDist
+  module Analyzer
+    class MethodLength < Base
+      def initialize
+        super(/def/, /$/, /end/, RDist::DENY_NESTING)
+      end
+    end
+  end
+end

data/lib/rdist/analyzer/numlinesinclass.rb

@@ -0,0 +1,12 @@
+module RDist
+  module Analyzer
+    class NumLinesInClass < Base
+      def initialize
+        open_tokens = %w{module class}
+        pattern_open_tokens = Regexp.union(*open_tokens)
+        super(pattern_open_tokens, /$/,
+              /end/, RDist::ALLOW_NESTING, 30)
+      end
+    end
+  end
+end

data/lib/rdist/analyzer/nummethodsinclass.rb

@@ -0,0 +1,12 @@
+module RDist
+  module Analyzer
+    class NumMethodsInClass < Base
+      def initialize
+        open_tokens = %w{module class}
+        pattern_open_tokens = Regexp.union(*open_tokens)
+        super(pattern_open_tokens, /(?:^|[^\w]+) def [^\w]+/nxm,
+              /end/, RDist::ALLOW_NESTING)
+      end
+    end
+  end
+end

data/lib/rdist/analyzer/state/base.rb

@@ -0,0 +1,23 @@
+module RDist
+  module Analyzer
+    module State
+      PATTERN_MULTI_LINE_COMMENT_BEGIN = /\A \=begin/nxm
+      PATTERN_MULTI_LINE_COMMENT_END = /\A \=end/nxm
+
+      class Base
+        def initialize(analyzer)
+          @analyzer = analyzer
+        end
+
+        public
+        def analyze(line)
+          raise 'Must be overridden in sub-class'
+        end
+
+        def reset
+          # do nothing
+        end
+      end
+    end
+  end
+end

data/lib/rdist/analyzer/state/inblock.rb

@@ -0,0 +1,85 @@
+module RDist
+  module Analyzer
+    module State
+      class InBlock < WaitingBlock
+        def initialize(analyzer)
+          super(analyzer)
+          @pattern_count_target = analyzer.pattern_count_target
+          @pattern_close_token = analyzer.pattern_close_token
+          init_stacks()
+        end
+
+        public
+        def analyze(line)
+          if have_close_token?(line)
+            return accept_close_token()
+          end
+          if have_open_token?(line)
+            return super(line) # call WaitingBlock#analyze(line)
+          end
+          if have_count_target?(line)
+            @analyzer.add_count_of(@block_names.last,
+                                   @line_ids.last)
+          end
+        end
+
+        def push_to_stacks(indent, block_name, line_id)
+          @indents << indent
+          @block_names << block_name
+          @line_ids << line_id
+        end
+
+        def reset
+          init_stacks()
+        end
+
+        private
+        def init_stacks
+          @indents = []
+          @block_names = []
+          @line_ids = []
+        end
+
+        def have_close_token?(line)
+          pattern_have_close_token.match(line)
+        end
+
+        PATTERN_SECOND_TOKEN = /[^\s]+/nxm
+        PATTERN_TOKEN_GAP = /[^\w]+/nxm
+        def pattern_have_close_token
+          %r/
+            \A
+            #{Regexp.escape(@indents.last)}
+            #{@pattern_close_token}
+            #{PATTERN_TOKEN_GAP}
+          /nxm
+        end
+
+        def have_count_target?(line)
+          pattern_have_count_target.match(line)
+        end
+
+        def pattern_have_count_target
+          @pattern_count_target
+        end
+
+        def accept_close_token
+          pop_stacks()
+          if analyzing_toplevel?
+            @analyzer.set_state_waiting_block
+          end
+        end
+
+        def pop_stacks
+          @indents.pop
+          @block_names.pop
+          @line_ids.pop
+        end
+
+        def analyzing_toplevel?
+          @analyzer.deny_nesting? || @indents.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rdist/analyzer/state/inmultilinecomment.rb

@@ -0,0 +1,18 @@
+module RDist
+  module Analyzer
+    module State
+      class InMultiLineComment < Base
+        public
+        def analyze(line)
+          return unless multi_line_comment_end?(line)
+          @analyzer.set_state_waiting_block
+        end
+
+        private
+        def multi_line_comment_end?(line)
+          PATTERN_MULTI_LINE_COMMENT_END =~ line
+        end
+      end
+    end
+  end
+end

data/lib/rdist/analyzer/state/waitingblock.rb

@@ -0,0 +1,52 @@
+module RDist
+  module Analyzer
+    module State
+      class WaitingBlock < Base
+        def initialize(analyzer)
+          super(analyzer)
+          @pattern_open_token = analyzer.pattern_open_token
+        end
+
+        public
+        def analyze(line)
+          if multi_line_comment_begin?(line)
+            return @analyzer.set_state_in_multi_line_comment
+          end
+          return unless (match_data = have_open_token?(line))
+          indent = get_indent_from(match_data)
+          block_name = get_block_name_from(match_data)
+          @analyzer.set_state_in_block(indent, block_name)
+        end
+
+        private
+        def multi_line_comment_begin?(line)
+          PATTERN_MULTI_LINE_COMMENT_BEGIN =~ line
+        end
+
+        def have_open_token?(line)
+          pattern_have_open_token.match(line)
+        end
+
+        PATTERN_INDENT = /\s*/nxm
+        PATTERN_SECOND_TOKEN = /[\w\.\:\=\?]+/nxm
+        def pattern_have_open_token
+          %r/
+            \A
+            (#{PATTERN_INDENT})
+            #{@pattern_open_token}
+            \s+
+            (#{PATTERN_SECOND_TOKEN})
+          /nxm
+        end
+
+        def get_indent_from(match_data)
+          match_data[1]
+        end
+
+        def get_block_name_from(match_data)
+          match_data[2]
+        end
+      end
+    end
+  end
+end

data/lib/rdist/analyzer/state.rb

@@ -0,0 +1,4 @@
+require 'rdist/analyzer/state/base'
+require 'rdist/analyzer/state/waitingblock'
+require 'rdist/analyzer/state/inblock'
+require 'rdist/analyzer/state/inmultilinecomment'

data/lib/rdist/analyzer.rb

@@ -0,0 +1,6 @@
+require 'rdist/analyzer/state'
+
+require 'rdist/analyzer/base'
+require 'rdist/analyzer/methodlength'
+require 'rdist/analyzer/numlinesinclass'
+require 'rdist/analyzer/nummethodsinclass'

data/lib/rdist/commandlineinterface.rb

@@ -0,0 +1,76 @@
+module RDist
+  # CommandLineInterface is the main class used for the rdist command.
+  class CommandLineInterface
+    DEFAULT_OUTPUT = $stdout
+
+    private_class_method :new
+
+    # Parses +argv+ and print analysis result to +output+.
+    # Analysis result is the distribution histogram and the rankings.
+    # If +argv+ includes '--verbose' option,
+    # then print all analyzing file names too.
+    def self.analyze(argv, output=DEFAULT_OUTPUT)
+      begin
+        new(argv, output)
+      rescue OptionParser::ParseError => err
+        puts err
+        exit 1
+      end
+    end
+
+    def initialize(argv, output) #:nodoc:
+      @output = output
+      @setting = Setting.for_argv(argv)
+      @analyzer = @setting.analyzer
+      @num_ranking = @setting.num_ranking
+
+      analyze_all_targets(argv)
+      print_banner()
+      print_result()
+    end
+
+    private
+    def print_banner
+      DebugLogger.debug ''
+      @output.puts @setting.banner
+    end
+
+    def analyze_all_targets(argv)
+      TargetFileFinder.find(argv) do |path|
+        @analyzer.analyze(path)
+      end
+      @histogram = @analyzer.histogram
+      @ranking   = @analyzer.ranking
+    end
+
+    def print_result
+      print_histogram()
+      print_ranking()
+    end
+
+    def print_histogram
+      @output.puts @histogram
+      @output.puts
+    end
+
+    def print_ranking
+      @output.puts ranking_banner()
+      if rank_all?
+        @output.puts @ranking.to_s
+      else
+        @output.puts @ranking.string_top(@num_ranking)
+      end
+    end
+
+    def ranking_banner
+      if rank_all?
+        return 'Entire Ranking:'
+      end
+      "Ranking Top #{@num_ranking}:"
+    end
+
+    def rank_all?
+      :all == @num_ranking
+    end
+  end
+end

data/lib/rdist/debuglogger.rb

@@ -0,0 +1,30 @@
+require 'logger'
+require 'singleton'
+require 'forwardable'
+
+module RDist
+  class DebugLogger
+    include Singleton
+    extend Forwardable
+
+    def self.debug(*s)
+      s.each{|x| instance.debug(x) }
+    end
+
+    def self.fatal(*s)
+      s.each{|x| instance.fatal(x) }
+    end
+
+    def initialize
+      @logger = Logger.new($stdout)
+      @logger.level = $DEBUG ? Logger::DEBUG : Logger::FATAL
+      @logger.progname = 'RDist'
+      @logger.formatter = Proc.new do
+        |severity, datetime, progname, msg| "#{msg}\n"
+      end
+    end
+
+    def_delegator :@logger, :debug, :debug
+    def_delegator :@logger, :fatal, :fatal
+  end
+end

data/lib/rdist/histogram.rb

@@ -0,0 +1,136 @@
+module RDist
+  class Histogram
+    DEFAULT_RANGE_UNIT_SIZE = 5
+    # Creates a new histogram from +count_of+.
+    # The keys of +count_of+ are divided into some ranges by its count.
+    # The size of each range is specified with +range_unit_size+.
+    def initialize(count_of,
+                   range_unit_size=DEFAULT_RANGE_UNIT_SIZE)
+      raise 'Initialized with illegal object' unless count_of
+      @count_of = count_of
+      @range_unit_size = range_unit_size
+      init_count_in_range()
+      init_cumulative_percentages()
+    end
+
+    public
+    WHITESPACE = ' '.freeze
+    PERCENTAGE_MAX = 100
+    def to_s
+      str = ''
+      @count_in_range.each_with_index do |count, range_id|
+        str << heading_of(range_id)
+        str << string_cumulative_percentage_at(range_id)
+        str << string_count(count) << WHITESPACE
+        str << bar(count) << NEWLINE
+      end
+      str << footer()
+    end
+
+    private
+    def init_count_in_range
+      @count_in_range = []
+      @count_of.each{|block_name, count|
+        range_id = range_id_of(count)
+        @count_in_range[range_id] ||= 0
+        @count_in_range[range_id]  += 1
+      }
+      replace_nil_by_zero(@count_in_range)
+      @count_in_range
+    end
+
+    def range_id_of(count)
+     (count / @range_unit_size).to_i
+    end
+
+    def init_cumulative_percentages
+      @cumulative_percentages = get_cumulative_percentages()
+    end
+
+    def get_cumulative_percentages
+      cumulative_counts \
+      = get_cumulative_counts_from(@count_in_range)
+      cumulative_counts.collect do |cumulative_count|
+        percentage_of(cumulative_count)
+      end
+    end
+
+    def get_cumulative_counts_from(ary)
+      cumulative_counts = []
+      prev = 0
+      ary.each_with_index do |item, index|
+        cumulative_counts[index] = prev += item
+      end
+      cumulative_counts
+    end
+
+    def replace_nil_by_zero(ary)
+      ary.each_index do |index|
+        ary[index] ||= 0
+      end
+    end
+
+    def sum_of_count
+      get_sum_of(@count_in_range)
+    end
+
+    def get_sum_of(ary)
+      sum = 0
+      ary.each do |item|
+        sum += item
+      end
+      sum
+    end
+
+    LENGTH_RANGE_MIN = 3
+    LENGTH_RANGE_MAX = LENGTH_RANGE_MIN
+    FORMAT_RANGE_HEADING \
+    = "%#{LENGTH_RANGE_MIN}d-%#{LENGTH_RANGE_MAX}d: ".freeze
+    def heading_of(range_id)
+      sprintf(FORMAT_RANGE_HEADING,
+              min_of(range_id), max_of(range_id))
+    end
+
+    def min_of(range_id)
+      range_id * @range_unit_size
+    end
+
+    def max_of(range_id)
+     (range_id + 1) * @range_unit_size - 1
+    end
+
+    def string_cumulative_percentage_at(range_id)
+      string_percentage(@cumulative_percentages[range_id])
+    end
+
+    FORMAT_PERCENTAGE  = '%3d%% '.freeze
+    def string_percentage(percentage)
+      sprintf(FORMAT_PERCENTAGE, percentage)
+    end
+
+    FORMAT_COUNT = '%5d'.freeze
+    def string_count(count)
+      sprintf(FORMAT_COUNT, count)
+    end
+
+    UNIT_CHAR_FOR_BAR = '*'.freeze
+    def bar(count)
+      UNIT_CHAR_FOR_BAR * bar_length_for(count)
+    end
+
+    def bar_length_for(count)
+     (percentage_of(count) / 2).ceil
+    end
+
+    def percentage_of(count)
+     (count.to_f / sum_of_count) * PERCENTAGE_MAX
+    end
+
+    def footer
+      str = '  Total: '
+      str << string_percentage(PERCENTAGE_MAX)
+      str << string_count(sum_of_count())
+      str << NEWLINE
+    end
+  end
+end

data/lib/rdist/ranking.rb

@@ -0,0 +1,34 @@
+module RDist
+  class Ranking
+    # Creates a new ranking from +score_of+.
+    # The items are sorted by ascending order.
+    def initialize(score_of)
+      @rankings = score_of.sort_by{|key, score| [-score, key] }
+    end
+
+    public
+    # Returns items from 1st to +n+-th.
+    # Each item is an Array as [key, score].
+    def top(n)
+      @rankings.first(n)
+    end
+
+    FORMAT = '%7d: %s'.freeze
+    FORMATTER = Proc.new{|key, score| sprintf(FORMAT, score, key) }
+    # Returns formatted string of top +n+ items.
+    def string_top(n)
+      str = ''
+      n.times do |i|
+        key, score = @rankings[i]
+        str << FORMATTER.call(key, score)
+        str << NEWLINE
+      end
+      str
+    end
+
+    # Returns formatted string of all items.
+    def to_s
+      string_top(@rankings.size)
+    end
+  end
+end

data/lib/rdist/setting/macros.rb

@@ -0,0 +1,20 @@
+module RDist
+  class Setting
+    module Marcos
+      private
+      def def_option(*args, &block)
+        method_symbol = method_symbol_of(args)
+        block = Proc.new{} unless block
+        define_method(method_symbol, &block)
+        const_get(:OPTION_SEEDS) << [args, method_symbol]
+      end
+
+      def method_symbol_of(option_args)
+        str_option = option_args.first
+        str_converted = str_option.split(/\s/).first
+        str_converted.gsub!(/-/, '_')
+        :"__option_switch#{str_converted}__"
+      end
+    end
+  end
+end

data/lib/rdist/setting.rb

@@ -0,0 +1,115 @@
+require 'optparse'
+require 'rdist/setting/macros'
+
+module RDist
+  class Setting
+    extend Marcos
+
+    private_class_method :new
+
+    def self.for_argv(argv)
+      new(argv)
+    end
+
+    def initialize(argv)
+      @argv = argv
+      init_attributes()
+      configure_option_parser()
+      parse_options()
+      init_analyzer()
+    end
+
+    attr_reader :analyzer
+    attr_reader :banner
+    attr_reader :num_ranking
+
+    private
+    DEFAULT_NUM_RANKING = 5
+    def init_attributes
+      @analyzer_class = Analyzer::MethodLength
+      @banner = 'Method length Distribution:'
+      @num_ranking = DEFAULT_NUM_RANKING
+      @interval = nil
+      init_parser()
+    end
+
+    def init_parser
+      @option_parser = OptionParser.new
+      @option_parser.banner = 'Usage: rdist [options] FILE...'
+      @option_parser.summary_width = 30
+      @option_parser.summary_indent = '  '
+    end
+
+    def parse_options
+      @option_parser.parse!(@argv)
+      @argv << '.' if @argv.empty?
+    end
+
+    def init_analyzer
+      @analyzer = @analyzer_class.new
+      @analyzer.histogram_interval = @interval if @interval
+    end
+
+    OPTION_SEEDS = [] # Do NOT freeze!!
+    def configure_option_parser
+      OPTION_SEEDS.each do |args, method_symbol|
+        method_call = method_call(method_symbol)
+        @option_parser.on(*args, &method_call)
+      end
+    end
+
+    def method_call(symbol)
+      Proc.new do |*args|
+        __send__(symbol, *args)
+      end
+    end
+
+    def_option('-m',
+               '--num-lines-in-method',
+               '--method-length',
+               'count number of lines in a method',
+               '  (default)')
+
+    def_option('-c',
+               '--num-lines-in-class',
+               'count number of lines in Class/Module') do
+      @analyzer_class = Analyzer::NumLinesInClass
+      @banner = 'Distribution of number of lines in Class/Module:'
+    end
+
+    def_option('-C',
+               '--num-methods-in-class',
+               'ount number of method definitions',
+               '  in Class/Module') do
+      @analyzer_class = Analyzer::NumMethodsInClass
+      @banner = 'Distribution of number of method definitons in Class/Module:'
+    end
+
+    def_option('-i', '--interval [N]', Integer,
+               'set histogram interval') do |n|
+      @interval = n if n
+    end
+
+    def_option('-r', '--rank [N]', Integer,
+               'show ranking up to Nth item (default 5)') do |n|
+      @num_ranking = n if n
+    end
+
+    def_option('--verbose',
+               'print verbose information to STDOUT',
+               '  (analysis process, entire ranking)') do
+      $DEBUG = true
+      @num_ranking = :all
+    end
+
+    def_option('-h', '--help', 'show this message') do
+      puts @option_parser.help
+      exit
+    end
+
+    def_option('-v', '--version', 'show version') do
+      puts "RDist-#{VERSION} - method length reporter for Ruby"
+      exit
+    end
+  end
+end

data/lib/rdist/targetfilefinder.rb

@@ -0,0 +1,43 @@
+require 'find'
+
+module RDist
+  module TargetFileFinder
+    module_function
+    def find(argv)
+      Find.find(*argv) do |path|
+        if FileTest.directory?(path)
+          Find.prune if hidden?(path)
+          next
+        end
+        next if hidden?(path)
+        next unless ruby_code?(path)
+        next if test_code?(path)
+        yield path
+      end
+    end
+
+    PATTERN_HIDDEN = %r/
+      \A
+      \.
+      [^\.] # pattern to accept parent directory: ``..''
+    /nxm
+    def hidden?(path)
+      PATTERN_HIDDEN =~ File.basename(path)
+    end
+
+    EXTNAME_RUBY_CODE = '.rb'.freeze
+    EXTNAME_RUBY_EXEC_CODE = '.rbw'.freeze
+    def ruby_code?(path)
+      case File.extname(path)
+        when EXTNAME_RUBY_CODE, EXTNAME_RUBY_EXEC_CODE then true
+      else false
+      end
+    end
+
+    PATTERN_TEST_CODE \
+    = /(?:\A test_ | _spec \z)/nxm.freeze
+    def test_code?(path)
+      PATTERN_TEST_CODE =~ File.basename(path)
+    end
+  end
+end

data/lib/rdist.rb

@@ -0,0 +1,16 @@
+require 'rdist/analyzer'
+require 'rdist/commandlineinterface'
+require 'rdist/debuglogger'
+require 'rdist/histogram'
+require 'rdist/ranking'
+require 'rdist/setting'
+require 'rdist/targetfilefinder'
+
+module RDist
+  VERSION  = '0.0.1'
+
+  ALLOW_NESTING = true
+  DENY_NESTING  = false
+
+  NEWLINE = "\n".freeze
+end

data/spec/commandlineinterface_spec.rb

@@ -0,0 +1,43 @@
+require 'stringio'
+
+describe CommandLineInterface, %q[when ``normal_code.rb'' given] do
+  def check_output(string_io, count_of,
+                   histogram_interval, num_ranking,
+                   banner='Method length Distribution:',
+                   ranking_banner='Ranking Top 5:')
+    histogram = Histogram.new(count_of, histogram_interval)
+    ranking = Ranking.new(count_of)
+    expected_string = "#{banner}\n"
+    expected_string << histogram.to_s
+    expected_string << "\n#{ranking_banner}\n"
+    expected_string << ranking.string_top(num_ranking)
+    string_io.string.should == expected_string
+  end
+
+  before do
+    @fixture_path = FIXTURE_DIR + '/normal_code.rb'
+    @string_io = StringIO.new
+    @expected_count_of = {
+      'initialize (at ./spec/../spec/fixtures/normal_code.rb:3)' => 4,
+      'each_vertex (at ./spec/../spec/fixtures/normal_code.rb:14)' => 3,
+      'surrounded? (at ./spec/../spec/fixtures/normal_code.rb:20)' => 1,
+      'concat (at ./spec/../spec/fixtures/normal_code.rb:24)' => 6,
+      'init_edge_vertices (at ./spec/../spec/fixtures/normal_code.rb:34)' => 10,
+      'dame_vertices (at ./spec/../spec/fixtures/normal_code.rb:47)' => 3,
+      'space? (at ./spec/../spec/fixtures/normal_code.rb:53)' => 1,
+    }
+  end
+
+  it 'should count number of method length correctly' do
+    CommandLineInterface.analyze(['--interval', '1', @fixture_path],
+                                 @string_io)
+    check_output(@string_io, @expected_count_of, 1, 5)
+  end
+
+  it %q[should show entire ranking if '--verbose' option is given] do
+    CommandLineInterface.analyze(['--verbose', @fixture_path], @string_io)
+    check_output(@string_io, @expected_count_of, 5, 7,
+                 'Method length Distribution:',
+                 'Entire Ranking:')
+  end
+end

data/spec/fixtures/normal_code.rb

@@ -0,0 +1,57 @@
+module Go
+  class Ren
+    def initialize(board, color, vertices)
+      @board = board
+      @color = color
+      @vertices = vertices
+      init_edge_vertices()
+    end
+
+    attr_reader :color
+    attr_reader :vertices
+
+    public
+    def each_vertex
+      @vertices.each do |vertex|
+        yield vertex
+      end
+    end
+
+    def surrounded?
+      dame_vertices.empty?
+    end
+
+    def concat(other)
+      if other.color != @color
+        raise %q[Can't contat enemy's ren]
+      end
+      @vertices.concat(other.vertices)
+      init_edge_vertices()
+      self
+    end
+
+    private
+    def init_edge_vertices
+      @edge_vertices = []
+      each_vertex do |vertex|
+        vertex.each_neighbor do |neighbor|
+          next unless @board.include?(neighbor)
+          next if @vertices.include?(neighbor)
+          next if @edge_vertices.include?(neighbor)
+          @edge_vertices << neighbor
+        end
+      end
+      @edge_vertices
+    end
+
+    def dame_vertices
+      @edge_vertices.select do |vertex|
+        space?(vertex)
+      end
+    end
+
+    def space?(vertex)
+      @board.have_space_on?(vertex)
+    end
+  end
+end

data/spec/ranking_spec.rb

@@ -0,0 +1,41 @@
+describe Ranking, 'when initialized with scores of 5 people' do
+  before do
+    score_of = {
+      'George' => 0,
+      'John'   => 100,
+      'Bob'    => 50,
+      'Peter'  => 0,
+      'Ben'    => 100,
+    }
+    @ranking = Ranking.new(score_of)
+  end
+
+  it 'should show top 3' do
+    ary = [
+      ['Ben',  100],
+      ['John', 100],
+      ['Bob',  50],
+    ]
+    @ranking.top(3).should == ary
+  end
+
+  it 'should serialize top 2' do
+    expected_string = <<-'END_STRING'
+    100: Ben
+    100: John
+     50: Bob
+    END_STRING
+    @ranking.string_top(3).should == expected_string
+  end
+
+  it 'should serialize entire rankings' do
+    expected_string = <<-'END_STRING'
+    100: Ben
+    100: John
+     50: Bob
+      0: George
+      0: Peter
+    END_STRING
+    @ranking.to_s.should == expected_string
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color --require spec/spec_helper

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+PROJECT_ROOT = File.dirname(__FILE__) + '/..'
+
+$LOAD_PATH.unshift PROJECT_ROOT + '/lib'
+
+SPEC_DIR = PROJECT_ROOT + '/spec'
+FIXTURE_DIR = SPEC_DIR + '/fixtures'
+
+require 'rdist'
+
+include RDist

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: rdist
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Yoshifumi Shimono
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-02-26 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: reports the distribution of method length in your Ruby codes.
+email: yoshifumi.shimono@gmail.com
+executables: 
+- rdist
+extensions: []
+
+extra_rdoc_files: 
+- README
+- ChangeLog
+files: 
+- README
+- ChangeLog
+- Rakefile
+- bin/rdist
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/commandlineinterface_spec.rb
+- spec/fixtures
+- spec/ranking_spec.rb
+- spec/fixtures/normal_code.rb
+- lib/rdist
+- lib/rdist.rb
+- lib/rdist/histogram.rb
+- lib/rdist/targetfilefinder.rb
+- lib/rdist/analyzer.rb
+- lib/rdist/setting.rb
+- lib/rdist/setting
+- lib/rdist/debuglogger.rb
+- lib/rdist/analyzer
+- lib/rdist/ranking.rb
+- lib/rdist/commandlineinterface.rb
+- lib/rdist/setting/macros.rb
+- lib/rdist/analyzer/macros.rb
+- lib/rdist/analyzer/methodlength.rb
+- lib/rdist/analyzer/state.rb
+- lib/rdist/analyzer/numlinesinclass.rb
+- lib/rdist/analyzer/base.rb
+- lib/rdist/analyzer/state
+- lib/rdist/analyzer/nummethodsinclass.rb
+- lib/rdist/analyzer/state/inmultilinecomment.rb
+- lib/rdist/analyzer/state/inblock.rb
+- lib/rdist/analyzer/state/waitingblock.rb
+- lib/rdist/analyzer/state/base.rb
+has_rdoc: true
+homepage: http://rdist.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --title
+- rdist documentation
+- --charset
+- utf-8
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README
+- --inline-source
+- --exclude
+- ^(examples|extras)/
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rdist
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: reports the distribution of method length in your Ruby codes.
+test_files: []
+