doppelganger 0.8.0

data/tasks/setup.rb

@@ -0,0 +1,239 @@
+# $Id$
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'fileutils'
+require 'ostruct'
+
+class OpenStruct; undef :gem; end
+
+PROJ = OpenStruct.new(
+  # Project Defaults
+  :name => nil,
+  :summary => nil,
+  :description => nil,
+  :changes => nil,
+  :authors => nil,
+  :email => nil,
+  :url => "\000",
+  :version => ENV['VERSION'] || '0.0.0',
+  :exclude => %w(tmp$ bak$ ~$ CVS \.svn/ \.git/ ^pkg/),
+  :release_name => ENV['RELEASE'],
+
+  # System Defaults
+  :ruby_opts => %w(-w),
+  :libs => [],
+  :history_file => 'CHANGELOG',
+  :manifest_file => 'Manifest.txt',
+  :readme_file => 'README.rdoc',
+
+  # Gem Packaging
+  :gem => OpenStruct.new(
+    :dependencies => [],
+    :development_dependencies => [],
+    :executables => nil,
+    :extensions => FileList['ext/**/extconf.rb'],
+    :files => nil,
+    :need_tar => true,
+    :need_zip => false,
+    :extras => {}
+  ),
+
+  # File Annotations
+  :notes => OpenStruct.new(
+    :exclude => %w(^tasks/setup\.rb$),
+    :extensions => %w(.txt .rb .erb) << '',
+    :tags => %w(FIXME OPTIMIZE TODO)
+  ),
+
+  # Rcov
+  :rcov => OpenStruct.new(
+    :dir => 'coverage',
+    :opts => %w[--sort coverage -T --no-html],
+    :threshold => 100.0,
+    :threshold_exact => false
+  ),
+
+  # Rdoc
+  :rdoc => OpenStruct.new(
+    :opts => [],
+    :include => %w((^lib/) (^ext/) (\.txt$) (\.rdoc$) (^LICENSE|CHANGELOG$)),
+    :exclude => %w((^bin/) (extconf\.rb$)),
+    :main => nil,
+    :dir => 'doc',
+    :remote_dir => nil
+  ),
+  
+  # Rubyforge
+  :rubyforge => OpenStruct.new(
+    :name => "\000"
+  ),
+  
+  # Test::Unit
+  :test => OpenStruct.new(
+    :files => FileList['test/**/*_test.rb'],
+    :file  => 'test/all.rb',
+    :opts  => []
+  )
+)
+
+# Load the other rake files in the tasks folder
+tasks_dir = File.expand_path(File.dirname(__FILE__))
+post_load_fn = File.join(tasks_dir, 'post_load.rake')
+rakefiles = Dir.glob(File.join(tasks_dir, '*.rake')).sort
+rakefiles.unshift(rakefiles.delete(post_load_fn)).compact!
+import(*rakefiles)
+
+# Setup the project libraries
+%w(lib ext).each {|dir| PROJ.libs << dir if test ?d, dir}
+
+# Setup some constants
+WIN32 = %r/djgpp|(cyg|ms|bcc)win|mingw/ =~ RUBY_PLATFORM unless defined? WIN32
+
+DEV_NULL = WIN32 ? 'NUL:' : '/dev/null'
+
+def quiet( &block )
+  io = [STDOUT.dup, STDERR.dup]
+  STDOUT.reopen DEV_NULL
+  STDERR.reopen DEV_NULL
+  block.call
+ensure
+  STDOUT.reopen io.first
+  STDERR.reopen io.last
+  $stdout, $stderr = STDOUT, STDERR
+end
+
+DIFF = if WIN32 then 'diff.exe'
+       else
+         if quiet {system "gdiff", __FILE__, __FILE__} then 'gdiff'
+         else 'diff' end
+       end unless defined? DIFF
+
+SUDO = if WIN32 then ''
+       else
+         if quiet {system 'which sudo'} then 'sudo'
+         else '' end
+       end
+
+RCOV = WIN32 ? 'rcov.bat' : 'rcov'
+RDOC = WIN32 ? 'rdoc.bat' : 'rdoc'
+GEM  = WIN32 ? 'gem.bat'  : 'gem'
+
+%w(rcov spec/rake/spectask rubyforge bones facets/ansicode).each do |lib|
+  begin
+    require lib
+    Object.instance_eval {const_set "HAVE_#{lib.tr('/','_').upcase}", true}
+  rescue LoadError
+    Object.instance_eval {const_set "HAVE_#{lib.tr('/','_').upcase}", false}
+  end
+end
+HAVE_SVN = (Dir.entries(Dir.pwd).include?('.svn') and
+            system("svn --version 2>&1 > #{DEV_NULL}"))
+HAVE_GIT = (Dir.entries(Dir.pwd).include?('.git') and
+            system("git --version 2>&1 > #{DEV_NULL}"))
+
+# Reads a file at +path+ and spits out an array of the +paragraphs+
+# specified.
+#
+#    changes = paragraphs_of('History.txt', 0..1).join("\n\n")
+#    summary, *description = paragraphs_of('README.txt', 3, 3..8)
+#
+def paragraphs_of( path, *paragraphs )
+  title = String === paragraphs.first ? paragraphs.shift : nil
+  ary = File.read(path).delete("\r").split(/\n\n+/)
+
+  result = if title
+    tmp, matching = [], false
+    rgxp = %r/^=+\s*#{Regexp.escape(title)}/i
+    paragraphs << (0..-1) if paragraphs.empty?
+
+    ary.each do |val|
+      if val =~ rgxp
+        break if matching
+        matching = true
+        rgxp = %r/^=+/i
+      elsif matching
+        tmp << val
+      end
+    end
+    tmp
+  else ary end
+
+  result.values_at(*paragraphs)
+end
+
+# Adds the given gem _name_ to the current project's dependency list. An
+# optional gem _version_ can be given. If omitted, the newest gem version
+# will be used.
+#
+def depend_on( name, version = nil )
+  spec = Gem.source_index.find_name(name).last
+  version = spec.version.to_s if version.nil? and !spec.nil?
+
+  PROJ.gem.dependencies << case version
+    when nil; [name]
+    when %r/^\d/; [name, ">= #{version}"]
+    else [name, version] end
+end
+
+# Adds the given arguments to the include path if they are not already there
+#
+def ensure_in_path( *args )
+  args.each do |path|
+    path = File.expand_path(path)
+    $:.unshift(path) if test(?d, path) and not $:.include?(path)
+  end
+end
+
+# Find a rake task using the task name and remove any description text. This
+# will prevent the task from being displayed in the list of available tasks.
+#
+def remove_desc_for_task( names )
+  Array(names).each do |task_name|
+    task = Rake.application.tasks.find {|t| t.name == task_name}
+    next if task.nil?
+    task.instance_variable_set :@comment, nil
+  end
+end
+
+# Change working directories to _dir_, call the _block_ of code, and then
+# change back to the original working directory (the current directory when
+# this method was called).
+#
+def in_directory( dir, &block )
+  curdir = pwd
+  begin
+    cd dir
+    return block.call
+  ensure
+    cd curdir
+  end
+end
+
+# Scans the current working directory and creates a list of files that are
+# candidates to be in the manifest.
+#
+def manifest_files
+  files = []
+  exclude = Regexp.new(PROJ.exclude.join('|'))
+  Find.find '.' do |path|
+    path.sub! %r/^(\.\/|\/)/o, ''
+    next unless test ?f, path
+    next if path =~ exclude
+    files << path
+  end
+  files.sort!
+end
+
+# We need a "valid" method thtat determines if a string is suitable for use
+# in the gem specification.
+#
+class Object
+  def valid?
+    return !(self.empty? or self == "\000") if self.respond_to?(:to_str)
+    return false
+  end
+end
+
+# EOF

data/tasks/test.rake

@@ -0,0 +1,34 @@
+
+if test(?e, PROJ.test.file) or not PROJ.test.files.to_a.empty?
+require 'rake/testtask'
+if HAVE_RCOV
+  require 'rcov/rcovtask'
+end
+
+namespace :test do
+
+  Rake::TestTask.new(:run) do |t|
+    t.libs = PROJ.libs
+    t.test_files = if test(?f, PROJ.test.file) then [PROJ.test.file]
+                   else PROJ.test.files end
+    t.ruby_opts += PROJ.ruby_opts
+    t.ruby_opts += PROJ.test.opts
+  end
+
+  if HAVE_RCOV
+    desc 'Run rcov on the unit tests'
+    Rcov::RcovTask.new do |t|
+      t.test_files = PROJ.test.files
+      opts = PROJ.rcov.opts.dup << '-o' << PROJ.rcov.dir
+      t.rcov_opts = PROJ.rcov.opts
+    end
+  end
+
+end  # namespace :test
+
+desc 'Alias to test:run'
+task :test => 'test:run'
+
+end
+
+# EOF

data/test/array_test.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class DoppelgangerArrayTest < Test::Unit::TestCase
+  
+  context 'extended array object' do
+    should "identify duplicate elements" do
+      assert ![1,1,2].duplicates?(4)
+      assert ![1,1,2].duplicates?(2)
+      assert [1,1,2].duplicates?(1)
+
+      assert ![].duplicates?(1)
+    end
+  end
+  
+end
+

data/test/doppelganger_test.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class DoppelgangerTest < DoppelgangerTestCase
+  
+  context 'normal analysis' do
+    setup do
+      duplicate_sample_file_path = File.expand_path(File.join(File.dirname(__FILE__), 'sample_files/duplicate_test_data'))
+      @sexps = @analyzer.extract_blocks(duplicate_sample_file_path)
+      @duplicate_analysis = Doppelganger::NodeAnalysis.new(@sexps)
+    end
+    
+    should "identify duplication" do
+      assert @duplicate_analysis.duplication?
+    end
+    
+    should "extract :defn nodes" do
+      method_arrays = @duplicate_analysis.sexp_blocks.map {|mdef| mdef.node.to_a}
+      @the_nodes.each do |node|
+        assert_contains method_arrays, node
+      end
+    end
+    
+    should "isolate duplicated blocks" do
+      duplicate_node_arrays = @duplicate_analysis.duplicates.inject([]) do |flattend_dups, dups|
+        flattend_dups << dups.first.node.to_a
+        flattend_dups << dups.last.node.to_a
+        flattend_dups
+      end
+      assert_contains duplicate_node_arrays, @the_nodes[0]
+      assert_contains duplicate_node_arrays, @the_nodes[3]
+    end
+    
+    should "attaches filenames to individual nodes" do
+      @duplicate_analysis.sexp_blocks.each do |mdef|
+        assert_match(/\/\w+_file\.rb$/, mdef.filename)
+      end
+    end
+    
+    should "attaches line numbers to individual nodes" do
+      @duplicate_analysis.sexp_blocks.each do |mdef|
+        assert_kind_of Integer, mdef.line
+      end
+    end
+    
+    teardown do
+      @sexps, @duplicate_analysis = nil
+    end
+  end
+  
+  context 'doing diff anlaysis' do
+    setup do
+      @sexps = @analyzer.extract_blocks("test/sample_files/larger_diff")
+      @larger_diff_analysis = Doppelganger::NodeAnalysis.new(@sexps)
+    end
+  
+    should "report methods which differ by arbitrary numbers of diffs" do
+      diff = @larger_diff_analysis.diff(5)
+      larger_diff_results = diff.inject([]) do |flattend_diffs, diff_pairs|
+        flattend_diffs << diff_pairs.first.node.to_a
+        flattend_diffs << diff_pairs.last.node.to_a
+        flattend_diffs
+      end
+      
+      @bigger_diff_blocks.each do |method_node|
+        assert_contains larger_diff_results, method_node
+      end
+    end
+  
+    should "report similar methods by a percent different threshold" do
+      diff = @larger_diff_analysis.percent_diff(25)
+      percent_diff_results = diff.inject([]) do |flattend_diffs, diff_pairs|
+        flattend_diffs << diff_pairs.first.node.to_a
+        flattend_diffs << diff_pairs.last.node.to_a
+        flattend_diffs
+      end
+      
+      @bigger_diff_blocks.each do |method_node|
+        assert_contains percent_diff_results, method_node
+      end
+    end
+    
+    teardown do
+      @larger_diff_analysis, @sexps = nil
+    end
+  end
+  
+  context "percent diff analysis" do
+    setup do
+      repeats_removal_file_path = File.expand_path(File.join(File.dirname(__FILE__), 'sample_files/repeats_removal_sample_file.rb'))
+      @sexps = @analyzer.extract_blocks(repeats_removal_file_path)
+      @repeats_removal_analysis = Doppelganger::NodeAnalysis.new(@sexps)
+      @repeats_diff = @repeats_removal_analysis.percent_diff(10)
+      @analysis_nodes = @repeats_diff.map {|pair|
+        [pair.first.node, pair.last.node]
+      }
+    end
+    
+    should 'ensure that repeated smaller nested nodes are noth included' do
+      @repeated_pairs.each do |pair|
+        assert !(@analysis_nodes.any? { |node_pair|
+          (node_pair.include?(pair.first.node) && node_pair.include?(pair.last.node))
+        })
+      end
+    end
+    
+    teardown do
+      @repeats_removal_analysis, @analysis_nodes, @repeats_diff, @sexps = nil
+    end
+  end
+  
+end
+

data/test/sample_files/duplicate_test_data/first_file.rb

@@ -0,0 +1,7 @@
+def foo
+  puts :something_unique
+end
+
+def bar
+  return "something not unique"
+end

data/test/sample_files/duplicate_test_data/second_file.rb

@@ -0,0 +1,7 @@
+def foo
+  return "also not unique"
+end
+
+def baz
+  (true || 'is unique')
+end

data/test/sample_files/larger_diff/first_file.rb

@@ -0,0 +1,7 @@
+def foo
+  puts "muppetfuckers"
+  @variable = "foo"
+  %w(this is some words).each do |word|
+    word.size
+  end
+end

data/test/sample_files/larger_diff/second_file.rb

@@ -0,0 +1,7 @@
+def bar
+  puts "muppetfuckers"
+  %w(this is bad words).each do |word|
+    puts word
+  end
+  @variable = "bar"
+end

data/test/sample_files/repeats_removal_sample_file.rb

@@ -0,0 +1,94 @@
+# The Sexp extension of this library excelent examples of repeated comparisons
+# between "blocks" that need to be trimmed from the output. So I've duplicated
+# and frozen it in this file.
+
+class Sexp
+  # Performs the block on every Sexp in this sexp.
+  def deep_each(&block)
+    self.each_sexp do |sexp|
+      block[sexp]
+      sexp.deep_each(&block)
+    end
+  end
+  
+  # Finds the last line of the Sexp if that information is available.
+  def last_line_number
+    line_number = nil
+    self.deep_each do |sub_node|
+      if sub_node.respond_to? :line
+        line_number = sub_node.line
+      end
+    end
+    line_number
+  end
+  
+  # Maps all sub Sexps into a new Sexp, if the node isn't a Sexp
+  # performs the block and maps the result into the new Sexp.
+  def map_sexps
+    self.inject(s()) do |sexps, sexp|
+      unless Sexp === sexp
+        sexps << sexp
+      else
+        sexps << yield(sexp)
+      end
+      sexps
+    end
+  end
+  
+  # Rejects all objects in the Sexp that return true for the block.
+  def deep_reject(&block)
+    output_sexp = self.reject do |node|
+      block[node]
+    end
+    output_sexp.map_sexps do |sexp|
+      sexp.deep_reject(&block)
+    end
+  end
+  
+  # Removes all literals from the Sexp (Symbols aren't excluded as they are used internally
+  # by Sexp for node names which identifies structure important for comparison.)
+  def remove_literals
+    output = self.dup
+    output.deep_reject do |node|
+      !((node.is_a?(Symbol)) || (node.is_a?(Sexp)))
+    end
+  end
+  
+  # Iterates through each child Sexp of the current Sexp.
+  def each_sexp
+    self.each do |sexp|
+      next unless Sexp === sexp
+
+      yield sexp
+    end
+  end
+  
+  # Performs the block on every Sexp in this sexp, looking for one that returns true.
+  def deep_any?(&block)
+    self.any_sexp? do |sexp|
+      block[sexp] || sexp.deep_any?(&block)
+    end
+  end
+  
+  # Iterates through each child Sexp of the current Sexp and looks for any Sexp
+  # that returns true for the block.
+  def any_sexp?
+    self.any? do |sexp|
+      next unless Sexp === sexp
+
+      yield sexp
+    end
+  end
+  
+  # Determines if the passed in block node is contained with in the Sexp node.
+  def contains_block?(block_node)
+    self.deep_any? do |sexp|
+      sexp == block_node
+    end
+  end
+  
+  # First turns the Sexp into an Array then flattens it.
+  def to_flat_ary
+    self.to_a.flatten
+  end
+end