doppelganger 0.8.0

data/CHANGELOG

@@ -0,0 +1,31 @@
+== 0.8.0 / 2008-11-18
+
+* Colorize CLI output
+* Add progress bar in CLI
+* Improve performance where possible
+* Change to using Ruby2Ruby in CLI output when verbose
+* Use custom UnifiedRuby instead of the one in ParseTree
+* Separate analysis into two independent classes
+  * +Extractor+ extracts block-like nodes from code
+  * +NodeAnalysis+ analyzes for duplicates/similar nodes
+
+== 0.7.0 / 2008-11-09
+
+* Exclude literals from comparison (from Flay)
+* Compare blocks as well as methods
+* Move RubyParser from ParseTree
+* Cleanup formating of CLI output
+* Remove Unique node reporting
+* Remove unneeded view/Ruby2Ruby functionality
+* Improve and Simplify tests
+* Change to using Test::Unit
+* Improve Documentation
+
+== 0.2.0 / 2008-11-06
+
+* Add percent different functionality
+* Name change to Doppelganger
+
+== 0.1.0 / 2008-10-01
+
+* Initial conversion to a gem

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2008 Brian Landau
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,32 @@
+CHANGELOG
+LICENSE
+Manifest.txt
+README.rdoc
+Rakefile
+bin/doppelganger
+doppelganger.gemspec
+lib/doppelganger.rb
+lib/doppelganger/extractor.rb
+lib/doppelganger/exts/array.rb
+lib/doppelganger/exts/sexp.rb
+lib/doppelganger/node_analysis.rb
+lib/doppelganger/unified_ruby.rb
+tasks/bones.rake
+tasks/gem.rake
+tasks/git.rake
+tasks/manifest.rake
+tasks/post_load.rake
+tasks/rdoc.rake
+tasks/rubyforge.rake
+tasks/setup.rb
+tasks/test.rake
+test/array_test.rb
+test/doppelganger_test.rb
+test/sample_files/duplicate_test_data/first_file.rb
+test/sample_files/duplicate_test_data/second_file.rb
+test/sample_files/larger_diff/first_file.rb
+test/sample_files/larger_diff/second_file.rb
+test/sample_files/repeats_removal_sample_file.rb
+test/sample_files/sexp_test_file.rb
+test/sexp_ext_test.rb
+test/test_helper.rb

data/README.rdoc

@@ -0,0 +1,67 @@
+= Doppelganger
+
+by Brian Landau of Viget Labs <brian.landau@viget.com>
+
+[<b>GitHub Project</b>] http://github.com/brianjlandau/doppelganger
+[<b>RubyForge Project</b>] http://rubyforge.org/projects/doppelganger/
+[<b>RDoc</b>] http://doppelganger.rubyforge.org/
+
+
+== DESCRIPTION:
+
+Doppelganger helps you to find areas of your code that are good places to refactor.
+
+It does this by finding methods and blocks that are duplicates or have less then
+a set threshold level of difference or be less then a specified percent different.
+This library can either be used with in another larger code metric/heuristic library, or
+called from the command line.
+
+
+== FEATURES:
+
+* Find duplicate methods and blocks.
+* Find methods and blocks similar by a threshold level of difference.
+* Find methods and blocks similar by threshold percentage.
+* Uses the Diff::LCS library for finding differences.
+* Uses RubyParser to compare methods.
+* Outputs the set of similar/duplicate nodes together and what files they are in and their line numbers.
+
+== CAVEATS:
+
+Doing the Diff::LCS on all the flattened Sexps is a very time consuming and processor 
+intense operation. This means doing the "diff" or "percent_diff" comparisons on large 
+libraries can take a very long time.
+
+
+== REQUIREMENTS:
+
+* ruby_parser
+* sexp_processor
+* Diff::LCS
+* Ruby2Ruby
+* HighLine
+* Facets
+
+
+== USAGE:
+
+Find duplicates and methods have 5 or less differences.
+
+   $ doppelganger -n 5 project_dir/lib
+
+Find duplicates and methods that are 10 percent different or less.
+
+   $ doppelganger -p 10 project_dir/lib
+
+
+== INSTALL:
+
+   sudo gem install doppelganger
+
+
+=== CREDITS:
+
+Inspired and based off of Giles Bowkett's Towelie.
+
+Parts also influenced or extracted by Ryan Davis' Flay.
+

data/Rakefile

@@ -0,0 +1,32 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+load 'tasks/setup.rb'
+
+ensure_in_path 'lib'
+require 'doppelganger'
+
+task :default => 'test:run'
+
+PROJ.name = 'doppelganger'
+PROJ.authors = 'Brian Landau'
+PROJ.email = 'brian.landau@viget.com'
+PROJ.url = 'http://doppelganger.rubyforge.org/'
+PROJ.version = Doppelganger::VERSION
+PROJ.rubyforge.name = 'doppelganger'
+
+PROJ.rcov.opts = ['--no-html', '-T', '--sort coverage',
+                  '-x "\/Library\/Ruby\/"', 
+                  '-x "\/opt\/local\/lib/ruby"',
+                  '-x "\/System\/Library\/"']
+
+
+PROJ.gem.development_dependencies = [['thoughtbot-shoulda', '~> 2.0']]
+depend_on 'sexp_processor', '~> 3.0.0'
+depend_on 'ruby_parser', '~> 2.0.0'
+depend_on 'ruby2ruby', '~> 1.2.0'
+depend_on 'diff-lcs', '~> 1.1'
+depend_on 'highline', '~> 1.4'
+depend_on 'facets', '~> 2.4'
+

data/bin/doppelganger

@@ -0,0 +1,189 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'ostruct'
+require 'facets/progressbar'
+require File.expand_path( File.join(File.dirname(__FILE__), %w[.. lib doppelganger]) )
+
+
+class Doppelganger::CLI
+  def self.parse(args)
+    options = OpenStruct.new
+    options.verbose = false
+    options.color = true
+    options.progress_bar = true
+    
+    opts = OptionParser.new do |opts|
+      opts.program_name = 'doppelganger'
+      opts.version = Doppelganger.version
+      opts.banner = "Usage: #{opts.program_name} [options] DIRECTORY"
+      
+      opts.separator " "
+      opts.separator "Options:"
+      
+      opts.on('-t', "--threshold [N]", Integer, "The number of node differences to print blocks for.") do |n|
+        options.threshold = n
+      end
+      
+      opts.on('-p', "--percentage [N]", Integer, "The percent difference to look for in two blocks.") do |n|
+        options.percentage = n
+      end
+      
+      opts.on('-v', "--[no-]verbose", "Display compared nodes when matched.") do |v|
+        options.verbose = v
+      end
+      
+      opts.on('--[no-]color', "Don't use color output.") do |c|
+        options.color = c
+      end
+      
+      opts.on('--[no-]progress-bar', "Don't show the progress bar on Diffs.") do |pb|
+        options.progress_bar = pb
+      end
+      
+      opts.separator " "
+      
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts.help
+        exit
+      end
+
+      opts.on_tail("--version", "Show version") do
+        puts opts.ver
+        exit
+      end
+    end
+    
+    opts.parse!(args)
+    if ARGV.length < 1
+      puts "ERROR: Missing expected arguments. ou must specify a directory parameter."
+      puts
+      puts opts.help
+      exit
+    elsif ARGV.length > 1
+      puts "ERROR: Too many arguments. Only a directory is needed."
+      puts
+      puts opts.help
+      exit
+    else
+      options.dir = ARGV.shift
+    end
+    
+    @options = options
+    @root_path = File.expand_path(@options.dir)
+  end
+  
+  def self.run(args)
+    parse(args)
+    
+    if @options.color
+      gem 'highline', '~> 1.4'
+      require 'highline'
+      HighLine.color_scheme = HighLine::ColorScheme.new do |cs|
+        cs[:headline] = [:bold, :magenta]
+        cs[:set_start] = [:cyan]
+        cs[:horizontal_line] = [:white]
+        cs[:block_item] = [:red]
+        cs[:code] = [:green]
+      end
+      @hl = HighLine.new
+    end
+    
+    @doppelganger = Doppelganger::Extractor.new
+    @sexp_blocks = @doppelganger.extract_blocks(@options.dir)
+    @analysis = Doppelganger::NodeAnalysis.new(@sexp_blocks)
+    @max_filename_length = longest_filename(@sexp_blocks)
+    
+    if @options.verbose
+      gem 'ruby2ruby', '~> 1.2.0'
+      require 'ruby2ruby'
+      @ruby2ruby = Ruby2Ruby.new
+    end
+    
+    duplicates = @analysis.duplicates
+    display_block_sets duplicates, "=== DUPLICATES: ===\n", ' -- [DUPLICATED BLOCK SET]:'
+    
+    if @options.threshold
+      compare_nodes(:diff, @options.threshold, "MAX DIFF of #{@options.threshold} NODES")
+    end
+    
+    if @options.percentage
+      compare_nodes(:percent_diff, @options.percentage, "PERCENT DIFF of #{@options.percentage}%")
+    end
+  end
+  
+  def self.compare_nodes(method, diff_size, title)
+    print_text('-' * 80, :horizontal_line)
+    puts
+    if @options.progress_bar
+      progress_bar = ProgressBar.new("DIFF Progress", @sexp_blocks.size**2)
+      progress_bar.bar_mark = '='
+      similar_methods = @analysis.send(method, diff_size, progress_bar)
+      progress_bar.finish
+      puts
+    else
+      similar_methods = @analysis.send(method, diff_size)
+    end
+    display_block_sets similar_methods, "=== #{title}: ===\n", ' -- [SIMILAR BLOCK PAIR]:'
+  end
+  
+  def self.display_block_sets(set, title, set_title)
+    unless set.empty?
+      print_text(title, :headline)
+      puts unless @options.color
+      set.each do |block_set|
+        print_text(set_title, :set_start)
+        block_set.each do |block_node|
+          if block_node.respond_to?(:name)
+            display_filename_line_and_method_name(block_node)
+          else
+            display_filename_and_line(block_node)
+          end
+          if @options.verbose
+            print_text(@ruby2ruby.process(block_node.node.deep_clone).gsub(/\n/, "\n"+(' '*6)).insert(0, ' '*6), :code)
+            puts
+          end
+        end
+      end
+      puts
+    end
+  end
+  
+  def self.display_filename_line_and_method_name(method_defn)
+    print_text(sprintf('   -> %1$*4$s:#%2$*5$d => `%3$s`', format_filename(method_defn.filename), 
+                                           method_defn.line.to_i, method_defn.name, 
+                                           @max_filename_length.to_i, -5), :block_item)
+  end
+  
+  def self.display_filename_and_line(block_node)
+    print_text(sprintf('   -> %1$*3$s:#%2$*4$d', format_filename(block_node.filename), 
+                                           block_node.line.to_i, @max_filename_length.to_i, -5), :block_item)
+  end
+  
+  def self.format_filename(filename)
+    relative_filename = filename.gsub(@root_path, '.')
+    if relative_filename.size > @max_filename_length
+      output_filename = relative_filename[-@max_filename_length, @max_filename_length]
+      output_filename[0..2] = '...'
+    else
+      output_filename = relative_filename
+    end
+    output_filename
+  end
+  
+  def self.longest_filename(nodes)
+    max_filename_length = nodes.map{|n| n.filename.gsub(@root_path, '.').size}.max
+    max_filename_length > 50 ? 50 : max_filename_length
+  end
+  
+  def self.print_text(text, color)
+    if @options.color
+      @hl.say(@hl.color(text, color))
+    else
+      puts text
+    end
+  end
+end
+
+Doppelganger::CLI.run(ARGV)
+

data/doppelganger.gemspec

@@ -0,0 +1,53 @@
+Gem::Specification.new do |s|
+  s.name = %q{doppelganger}
+  s.version = "0.8.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brian Landau"]
+  s.date = %q{2008-11-18}
+  s.default_executable = %q{doppelganger}
+  s.description = %q{Doppelganger helps you to find areas of your code that are good places to refactor.  It does this by finding methods and blocks that are duplicates or have less then a set threshold level of difference or be less then a specified percent different. This library can either be used with in another larger code metric/heuristic library, or called from the command line.}
+  s.email = %q{brian.landau@viget.com}
+  s.executables = ["doppelganger"]
+  s.extra_rdoc_files = ["CHANGELOG", "LICENSE", "README.rdoc"]
+  s.files = ["CHANGELOG", "LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "bin/doppelganger", "doppelganger.gemspec", "lib/doppelganger.rb", "lib/doppelganger/extractor.rb", "lib/doppelganger/exts/array.rb", "lib/doppelganger/exts/sexp.rb", "lib/doppelganger/node_analysis.rb", "lib/doppelganger/unified_ruby.rb", "tasks/bones.rake", "tasks/gem.rake", "tasks/git.rake", "tasks/manifest.rake", "tasks/post_load.rake", "tasks/rdoc.rake", "tasks/rubyforge.rake", "tasks/setup.rb", "tasks/test.rake", "test/array_test.rb", "test/doppelganger_test.rb", "test/sample_files/duplicate_test_data/first_file.rb", "test/sample_files/duplicate_test_data/second_file.rb", "test/sample_files/larger_diff/first_file.rb", "test/sample_files/larger_diff/second_file.rb", "test/sample_files/repeats_removal_sample_file.rb", "test/sample_files/sexp_test_file.rb", "test/sexp_ext_test.rb", "test/test_helper.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://doppelganger.rubyforge.org/}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{doppelganger}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Doppelganger helps you to find areas of your code that are good places to refactor}
+  s.test_files = ["test/array_test.rb", "test/doppelganger_test.rb", "test/sexp_ext_test.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sexp_processor>, ["~> 3.0.0"])
+      s.add_runtime_dependency(%q<ruby_parser>, ["~> 2.0.0"])
+      s.add_runtime_dependency(%q<ruby2ruby>, ["~> 1.2.0"])
+      s.add_runtime_dependency(%q<diff-lcs>, ["~> 1.1"])
+      s.add_runtime_dependency(%q<highline>, ["~> 1.4"])
+      s.add_runtime_dependency(%q<facets>, ["~> 2.4"])
+      s.add_development_dependency(%q<thoughtbot-shoulda>, ["~> 2.0"])
+    else
+      s.add_dependency(%q<sexp_processor>, ["~> 3.0.0"])
+      s.add_dependency(%q<ruby_parser>, ["~> 2.0.0"])
+      s.add_dependency(%q<ruby2ruby>, ["~> 1.2.0"])
+      s.add_dependency(%q<diff-lcs>, ["~> 1.1"])
+      s.add_dependency(%q<highline>, ["~> 1.4"])
+      s.add_dependency(%q<facets>, ["~> 2.4"])
+      s.add_dependency(%q<thoughtbot-shoulda>, ["~> 2.0"])
+    end
+  else
+    s.add_dependency(%q<sexp_processor>, ["~> 3.0.0"])
+    s.add_dependency(%q<ruby_parser>, ["~> 2.0.0"])
+    s.add_dependency(%q<ruby2ruby>, ["~> 1.2.0"])
+    s.add_dependency(%q<diff-lcs>, ["~> 1.1"])
+    s.add_dependency(%q<highline>, ["~> 1.4"])
+    s.add_dependency(%q<facets>, ["~> 2.4"])
+    s.add_dependency(%q<thoughtbot-shoulda>, ["~> 2.0"])
+  end
+end

data/lib/doppelganger.rb

@@ -0,0 +1,63 @@
+require 'find'
+require 'rubygems'
+gem 'sexp_processor', '~> 3.0.0'
+require 'sexp_processor'
+require 'composite_sexp_processor'
+gem 'ruby_parser', '~> 2.0.0'
+require 'ruby_parser'
+gem 'diff-lcs', '~> 1.1'
+require 'diff/lcs'
+
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? Doppelganger
+
+module Doppelganger
+  
+  # :stopdoc:
+  VERSION = '0.8.0'.freeze
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+  # :startdoc:
+  
+end  # module Doppelganger
+
+Doppelganger.require_all_libs_relative_to __FILE__
+
+end  # unless defined?
+