doppelganger 0.8.0

data/test/sample_files/sexp_test_file.rb

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

data/test/sexp_ext_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class DoppelgangerSexpTest < Test::Unit::TestCase
+  
+  context 'extended Sexp object' do
+    setup do
+      @pt = RubyParser.new
+      sample_file_path = File.expand_path(File.join(File.dirname(__FILE__), 'sample_files/sexp_test_file.rb'))
+      @sexp = @pt.process(File.read(sample_file_path), sample_file_path)
+    end
+    
+    should 'remove all literal objects' do
+      clean_sexp_array = [:defn,
+                         :muir,
+                         [:args],
+                         [:scope,
+                          [:block,
+                           [:call, :puts, [:arglist, [:str]]],
+                           [:iasgn, :@variable, [:str]],
+                           [:iter,
+                            [:call,
+                             [:array, [:str], [:str], [:str], [:str]],
+                             :each,
+                             [:arglist]],
+                            [:lasgn, :word],
+                            [:call, [:lvar, :word], :size, [:arglist]]]]]]
+      assert_equal clean_sexp_array, @sexp.remove_literals.to_a
+    end
+    
+    should 'return flattened array' do
+      flat_array = [:defn, :muir, :args, :scope, :block, :call, nil, :puts, :arglist, :str, 
+                    "John Muir", :iasgn, :@variable, :str, "muir", :iter, :call, :array, :str, 
+                    "this", :str, "is", :str, "some", :str, "words", :each, :arglist, :lasgn, 
+                    :word, :call, :lvar, :word, :size, :arglist]
+      assert_equal flat_array, @sexp.to_flat_ary
+    end
+    
+    should 'retrive last line number for a given node' do
+      assert_respond_to @sexp, :last_line_number
+      assert_equal 6, @sexp.last_line_number
+    end
+    
+    should 'determin if a block Sexp node is a child of another node' do
+      block_node = @sexp[3][1]
+      assert @sexp.contains_block?(block_node)
+    end
+    
+    teardown do
+      @pt, @sexp = nil
+    end
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,79 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+require File.expand_path( File.join(File.dirname(__FILE__), %w[.. lib doppelganger]) )
+
+
+class DoppelgangerTestCase < Test::Unit::TestCase
+  def setup
+    @the_nodes = [
+      # second_file.rb
+      [:defn, :foo, [:args], [:scope, [:block, [:return, [:str, "also not unique"]]]]],
+      [:defn, :baz, [:args], [:scope, [:block, [:or, [:true], [:str, "is unique"]]]]],
+
+      # first_file.rb
+      [:defn, :foo, [:args], [:scope, [:block, [:call, nil, :puts, [:arglist, [:lit, :something_unique]]]]]],
+      [:defn, :bar, [:args], [:scope, [:block, [:return, [:str, "something not unique"]]]]]
+    ]
+
+    @bigger_diff_blocks = [
+[:defn, :foo, [:args], 
+  [:scope, 
+    [:block, 
+      [:call, nil, :puts, 
+        [:arglist, [:str, "muppetfuckers"]]], 
+        [:iasgn, :@variable, [:str, "foo"]], 
+        [:iter, [:call, 
+          [:array, [:str, "this"], [:str, "is"], [:str, "some"], [:str, "words"]], :each, [:arglist]], 
+          [:lasgn, :word], 
+          [:call, [:lvar, :word], :size, [:arglist]]]]]],
+[:defn, :bar, [:args], 
+  [:scope, [:block, 
+    [:call, nil, :puts, 
+      [:arglist, [:str, "muppetfuckers"]]], 
+      [:iter, [:call, 
+        [:array, [:str, "this"], [:str, "is"], [:str, "bad"], [:str, "words"]], :each, [:arglist]], 
+        [:lasgn, :word], 
+        [:call, nil, :puts, [:arglist, [:lvar, :word]]]], 
+      [:iasgn, :@variable, [:str, "bar"]]]]]
+    ]
+    
+    @repeated_pairs = [
+      [s(:block, s(:iter, s(:call, s(:self), :each_sexp, s(:arglist)), s(:lasgn, :sexp), s(:block, s(:call, s(:lvar, :block), :[], s(:arglist, s(:lvar, :sexp))), s(:call, s(:lvar, :sexp), :deep_each, s(:arglist, s(:block_pass, s(:lvar, :block))))))),
+       s(:defn, :deep_each, s(:args, :"&block"), s(:scope, s(:block, s(:iter, s(:call, s(:self), :each_sexp, s(:arglist)), s(:lasgn, :sexp), s(:block, s(:call, s(:lvar, :block), :[], s(:arglist, s(:lvar, :sexp))), s(:call, s(:lvar, :sexp), :deep_each, s(:arglist, s(:block_pass, s(:lvar, :block)))))))))],
+      
+      [s(:block, s(:lasgn, :line_number, s(:nil)), s(:iter, s(:call, s(:self), :deep_each, s(:arglist)), s(:lasgn, :sub_node), s(:if, s(:call, s(:lvar, :sub_node), :respond_to?, s(:arglist, s(:lit, :line))), s(:lasgn, :line_number, s(:call, s(:lvar, :sub_node), :line, s(:arglist))), nil)), s(:lvar, :line_number)),
+       s(:defn, :last_line_number, s(:args), s(:scope, s(:block, s(:lasgn, :line_number, s(:nil)), s(:iter, s(:call, s(:self), :deep_each, s(:arglist)), s(:lasgn, :sub_node), s(:if, s(:call, s(:lvar, :sub_node), :respond_to?, s(:arglist, s(:lit, :line))), s(:lasgn, :line_number, s(:call, s(:lvar, :sub_node), :line, s(:arglist))), nil)), s(:lvar, :line_number))))],
+      
+      [s(:block, s(:iter, s(:call, s(:self), :inject, s(:arglist, s(:call, nil, :s, s(:arglist)))), s(:masgn, s(:array, s(:lasgn, :sexps), s(:lasgn, :sexp))), s(:block, s(:if, s(:call, s(:const, :Sexp), :===, s(:arglist, s(:lvar, :sexp))), s(:call, s(:lvar, :sexps), :<<, s(:arglist, s(:yield, s(:lvar, :sexp)))), s(:call, s(:lvar, :sexps), :<<, s(:arglist, s(:lvar, :sexp)))), s(:lvar, :sexps)))),
+       s(:defn, :map_sexps, s(:args), s(:scope, s(:block, s(:iter, s(:call, s(:self), :inject, s(:arglist, s(:call, nil, :s, s(:arglist)))), s(:masgn, s(:array, s(:lasgn, :sexps), s(:lasgn, :sexp))), s(:block, s(:if, s(:call, s(:const, :Sexp), :===, s(:arglist, s(:lvar, :sexp))), s(:call, s(:lvar, :sexps), :<<, s(:arglist, s(:yield, s(:lvar, :sexp)))), s(:call, s(:lvar, :sexps), :<<, s(:arglist, s(:lvar, :sexp)))), s(:lvar, :sexps))))))],
+      
+      [s(:block, s(:lasgn, :output_sexp, s(:iter, s(:call, s(:self), :reject, s(:arglist)), s(:lasgn, :node), s(:call, s(:lvar, :block), :[], s(:arglist, s(:lvar, :node))))), s(:iter, s(:call, s(:lvar, :output_sexp), :map_sexps, s(:arglist)), s(:lasgn, :sexp), s(:call, s(:lvar, :sexp), :deep_reject, s(:arglist, s(:block_pass, s(:lvar, :block)))))),
+       s(:defn, :deep_reject, s(:args, :"&block"), s(:scope, s(:block, s(:lasgn, :output_sexp, s(:iter, s(:call, s(:self), :reject, s(:arglist)), s(:lasgn, :node), s(:call, s(:lvar, :block), :[], s(:arglist, s(:lvar, :node))))), s(:iter, s(:call, s(:lvar, :output_sexp), :map_sexps, s(:arglist)), s(:lasgn, :sexp), s(:call, s(:lvar, :sexp), :deep_reject, s(:arglist, s(:block_pass, s(:lvar, :block))))))))],
+      
+      [s(:block, s(:lasgn, :output, s(:call, s(:self), :dup, s(:arglist))), s(:iter, s(:call, s(:lvar, :output), :deep_reject, s(:arglist)), s(:lasgn, :node), s(:not, s(:or, s(:call, s(:lvar, :node), :is_a?, s(:arglist, s(:const, :Symbol))), s(:call, s(:lvar, :node), :is_a?, s(:arglist, s(:const, :Sexp))))))),
+       s(:defn, :remove_literals, s(:args), s(:scope, s(:block, s(:lasgn, :output, s(:call, s(:self), :dup, s(:arglist))), s(:iter, s(:call, s(:lvar, :output), :deep_reject, s(:arglist)), s(:lasgn, :node), s(:not, s(:or, s(:call, s(:lvar, :node), :is_a?, s(:arglist, s(:const, :Symbol))), s(:call, s(:lvar, :node), :is_a?, s(:arglist, s(:const, :Sexp)))))))))],
+      
+      [s(:block, s(:iter, s(:call, s(:self), :each, s(:arglist)), s(:lasgn, :sexp), s(:block, s(:if, s(:call, s(:const, :Sexp), :===, s(:arglist, s(:lvar, :sexp))), nil, s(:next)), s(:yield, s(:lvar, :sexp))))),
+       s(:defn, :each_sexp, s(:args), s(:scope, s(:block, s(:iter, s(:call, s(:self), :each, s(:arglist)), s(:lasgn, :sexp), s(:block, s(:if, s(:call, s(:const, :Sexp), :===, s(:arglist, s(:lvar, :sexp))), nil, s(:next)), s(:yield, s(:lvar, :sexp)))))))],
+      
+      [s(:block, s(:iter, s(:call, s(:self), :each, s(:arglist)), s(:lasgn, :sexp), s(:block, s(:if, s(:call, s(:const, :Sexp), :===, s(:arglist, s(:lvar, :sexp))), nil, s(:next)), s(:yield, s(:lvar, :sexp))))),
+       s(:block, s(:iter, s(:call, s(:self), :any?, s(:arglist)), s(:lasgn, :sexp), s(:block, s(:if, s(:call, s(:const, :Sexp), :===, s(:arglist, s(:lvar, :sexp))), nil, s(:next)), s(:yield, s(:lvar, :sexp)))))],
+      
+      [s(:block, s(:iter, s(:call, s(:self), :each, s(:arglist)), s(:lasgn, :sexp), s(:block, s(:if, s(:call, s(:const, :Sexp), :===, s(:arglist, s(:lvar, :sexp))), nil, s(:next)), s(:yield, s(:lvar, :sexp))))),
+       s(:defn, :any_sexp?, s(:args), s(:scope, s(:block, s(:iter, s(:call, s(:self), :any?, s(:arglist)), s(:lasgn, :sexp), s(:block, s(:if, s(:call, s(:const, :Sexp), :===, s(:arglist, s(:lvar, :sexp))), nil, s(:next)), s(:yield, s(:lvar, :sexp)))))))],
+      
+      [s(:defn, :each_sexp, s(:args), s(:scope, s(:block, s(:iter, s(:call, s(:self), :each, s(:arglist)), s(:lasgn, :sexp), s(:block, s(:if, s(:call, s(:const, :Sexp), :===, s(:arglist, s(:lvar, :sexp))), nil, s(:next)), s(:yield, s(:lvar, :sexp))))))),
+       s(:block, s(:iter, s(:call, s(:self), :any?, s(:arglist)), s(:lasgn, :sexp), s(:block, s(:if, s(:call, s(:const, :Sexp), :===, s(:arglist, s(:lvar, :sexp))), nil, s(:next)), s(:yield, s(:lvar, :sexp)))))]
+    ]
+    
+    @analyzer = Doppelganger::Extractor.new
+  end
+  
+  def default_test; end
+  
+  def teardown
+    @the_nodes,  @unique_block, @bigger_diff_blocks, @anlyzer, @repeated_pairs = nil
+  end
+end
+

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification 
+name: doppelganger
+version: !ruby/object:Gem::Version 
+  version: 0.8.0
+platform: ruby
+authors: 
+- Brian Landau
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-18 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sexp_processor
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby_parser
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ruby2ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: diff-lcs
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.1"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: highline
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.4"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.4"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
+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.
+email: brian.landau@viget.com
+executables: 
+- doppelganger
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- LICENSE
+- README.rdoc
+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
+has_rdoc: true
+homepage: http://doppelganger.rubyforge.org/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+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: doppelganger
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Doppelganger helps you to find areas of your code that are good places to refactor
+test_files: 
+- test/array_test.rb
+- test/doppelganger_test.rb
+- test/sexp_ext_test.rb