angelic-dont_repeat_yourself 0.3.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2005-2007 The RSpec Development Team
+
+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/README.txt

@@ -0,0 +1,13 @@
+dont_repeat_yourself gem
+
+Up to date documentation is online on github:
+http://github.com/garnierjm/dont_repeat_yourself/wikis
+
+Based on Simian (Similarity Analyser) by Simon Harris from RedHill Consulting, see http://www.redhillconsulting.com.au/products/simian/
+Copyright (c) 2003-08 RedHill Consulting Pty. Ltd.  All rights reserved.
+
+Report duplicate lines in your code, integrated with Textmate and Netbeans.
+
+- License dry-report gem: See ./MIT-LICENSE
+- License Simian: See ./SIMIAN-LICENSE file
+

data/Rakefile

@@ -0,0 +1,117 @@
+require 'rubygems'
+require 'rake'
+require 'spec/rake/spectask'
+
+#-------- Deployment tasks
+begin
+  require "hoe"
+rescue LoadError
+  puts "This Rakefile requires the 'hoe' RubyGem."
+  puts "Installation: (sudo) gem install hoe -y"
+  exit
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+require 'dont_repeat_yourself/version'
+
+# FIXME In ordert to remove hoe from gemspec, DOES NOT WORK!
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+AUTHOR = 'Jean-Michel Garnier'  # can also be an array of Authors
+EMAIL = 'jm AT 21croissants dot com'
+DESCRIPTION = 'Generate duplicate lines report'
+GEM_NAME = 'dont_repeat_yourself' # what ppl will type to install your gem
+HOMEPATH = "http://github.com/garnierjm/dont_repeat_yourself"
+VERS = DontRepeatYourself::VERSION::STRING
+
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH  
+  p.clean_globs |= ['.project', '.gitignore', '**/.*.sw?', '*.gem', '.config', '**/.DS_Store', '**/*.class']  #An array of file patterns to delete on clean.
+
+  # == Optional
+
+  # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  p.extra_deps = [ ['syntax', ">= 1.0.0"] ]
+  
+end
+
+desc "Refresh #{GEM_NAME}.gemspec to include ALL files"
+task :refresh_gemspec => 'refresh_manifest' do
+  File.open("#{GEM_NAME}.gemspec", 'w') {|io| io.write(hoe.spec.to_ruby)}
+end
+
+desc 'Recreate Manifest.txt to include ALL files'
+task :refresh_manifest do
+  manifest_files = %w(SIMIAN-LICENSE MIT-LICENSE README.txt Rakefile) + Dir.glob("{bin,lib}/**/*")
+  File.open("Manifest.txt", 'w') {|io| io.write(manifest_files.join("\n"))}
+end
+
+
+desc 'Install the package as a gem, without generating documentation(ri/rdoc)'
+task :install_gem_no_doc => [:clean, :package] do
+  sh "#{'sudo ' unless Hoe::WINDOZE }gem install pkg/*.gem --no-rdoc --no-ri"
+end
+
+namespace :manifest do
+  desc 'Recreate Manifest.txt to include ALL files'
+  task :refresh do
+    `rake check_manifest | patch -p0 > Manifest.txt`
+  end
+end
+
+#-------------- Testing taks
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--options', 'spec/spec.opts']  
+end
+
+desc "Generate documentation for the dont_repeat_yourself plugin and store html output in doc.html"
+Spec::Rake::SpecTask.new('doc') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--format html:./doc.html']
+  #  t.spec_opts = ['--format specdoc:./doc.txt']
+end
+
+desc "Run all examples with RCov and generate specs coverage report"
+Spec::Rake::SpecTask.new('coverage') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec,boot.rb']
+end
+
+require 'cucumber/rake/task'
+desc "Run User Acceptance tests with cucumber"
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "--format pretty"
+end
+
+def egrep(pattern)
+  Dir['**/*.rb'].each do |fn|
+    count = 0
+    open(fn) do |f|
+      while line = f.gets
+        count += 1
+        if line =~ pattern
+          puts "#{fn}:#{count}:#{line}"
+        end
+      end
+    end
+  end
+end
+
+desc "Look for TODO and FIXME tags in the code"
+task :todo do
+  egrep /(FIXME|TODO|TBD)/
+end

data/SIMIAN-LICENSE

@@ -0,0 +1,101 @@
+SIMIAN VERSION 2.2.21 SOFTWARE LICENSE AGREEMENT
+
+1. Licenses and Software
+
+RedHill Consulting, Pty. Ltd., an Australian Proprietary Limited Company ("REDHILL") hereby grants to the purchaser
+(the "LICENSEE") a limited, revocable, worldwide, non-exclusive, nontransferable, non-sublicensable license to use the
+Simian version 2 (two) software (the "SOFTWARE"), including any minor upgrades thereof during the Term (hereinafter
+defined) up to, but not including the next major version of the Software. The Licensee shall not, or knowingly allow
+others to, reverse engineer, decompile, disassemble, modify, adapt, create derivative works from or otherwise attempt
+to derive source code from the Software provided. And, in accordance with the terms and conditions of this Software
+License Agreement (the "AGREEMENT"), the Software shall be used solely by the Licensee in accordance with the following
+specific conditions:
+
+    A. Personal/SOHO License
+
+       A Personal/SOHO License entitles the Licensee to use the Software on one (1) machine only. A Personal/SOHO
+       License does not permit the generation of reports for distribution nor use by other than the licensee.
+
+    B. Project License
+
+       A Project License entitles the Licensee to use the Software on any number of machines solely for the licensed
+       project.
+
+    C. Enterprise License
+
+       An Enterprise License entitles the Licensee to use the Software on any number of machines. Reports generated are
+       strictly for use by the Licensee only.
+
+2. License Fee
+
+In exchange for the License(s), the Licensee shall pay to RedHill a one-time, up front, non-refundable license fee.
+At the sole discretion of RedHill, this fee will be waived for non-commercial/non-government projects and for evaluation
+purposes for a period of fifteen (15) days only. The Licensee is also entitled to minor upgrades up to, but not
+including the next major version of the Software at no charge. Notwithstanding the Licensee's payment of the License
+Fee, RedHill reserves the right to terminate the License if RedHill discovers that the Licensee and/or the Licensee's
+use of the Software is in breach of this Agreement.
+
+3. Proprietary Rights
+
+RedHill will retain all right, title and interest in and to the Software, all copies thereof, and RedHill website(s),
+software, and other intellectual property, including, but not limited to, ownership of all copyrights, look and feel,
+trademark rights, design rights, trade secret rights and any and all other intellectual property and other proprietary
+rights therein. The Licensee will not directly or indirectly obtain or attempt to obtain at any time, any right, title
+or interest by registration or otherwise in or to the trademarks, service marks, copyrights, trade names, symbols,
+logos or designations or other intellectual property rights owned or used by RedHill. All technical manuals or other
+information provided by RedHill to the Licensee shall be the sole property of RedHill.
+
+4. Term and Termination
+
+Subject to the other provisions hereof, this Agreement shall commence upon the Licensee's opting into this Agreement
+and continue until the Licensee discontinues use of the Software or the Agreement terminates automatically upon the
+Licensee's breach of any term or condition of this Agreement (the "Term"). Upon any such termination, the Licensee will
+delete the Software immediately.
+
+5. Copying & Transfer
+
+The Licensee may copy the Software to use the Software and for back-up purposes only. The Licensee may not assign or
+otherwise transfer the Software to any third party unless each of the following conditions is met:
+
+1. Redistributions are made at no charge and in accordance with these License terms.
+
+    A. Redistributions are made by and for non-commercial/non-government Licensee(s) or for evaluation purposes set
+       forth as Article 2.
+
+    B. Redistributions must faithfully reproduce all accompanying materials, including these License terms, and the
+       disclaimer/limitation of liability set forth as Article 6, in the documentation and/or other materials provided
+       with the distribution.
+
+6. Specific Disclaimer of Warranty and Limitation of Liability
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL REDHILL
+CONSULTING OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+7. Warranties and Representations
+
+Indemnification. The Licensee warrants and represents that the Licensee's actions with regard to the Software will be
+in compliance with all applicable laws; and the Licensee will indemnify, defend, and hold RedHill harmless from and
+against any and all liabilities, damages, losses, claims, costs, and expenses (including legal fees) arising out of or
+resulting from the Licensee's failure to observe the use restrictions set forth herein.
+
+8. Governing Law
+
+This Agreement shall be governed by the laws of Victoria, Australia.
+
+9. Independent Contractors
+
+Assignment: The parties are independent contractors with respect to each other, and nothing in this Agreement shall be
+construed as creating an employer-employee relationship, a partnership, agency relationship or a joint venture between
+the parties. This Agreement is not assignable or transferable by the Licensee.
+
+10. Entire Agreement
+
+This Agreement constitutes the entire agreement between the parties concerning the Licensee's use of the Software. This
+Agreement supersedes any prior verbal understanding between the parties and any Licensee purchase order or other
+ordering document, regardless of whether such document is received by RedHill before or after execution of this
+Agreement. This Agreement may be amended only in writing by RedHill.

data/bin/dry-report

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib/') unless $:.include?(File.dirname(__FILE__) + '/../lib/')
+require 'dont_repeat_yourself/cli'
+DontRepeatYourself::CLI.execute

data/lib/assets/dry.css

@@ -0,0 +1,127 @@
+#rspec-header {
+  background: #65C400; color: #fff;
+}
+
+.rspec-report h1 {
+  margin: 0px 10px 0px 10px;
+  padding: 10px;
+  font-family: "Lucida Grande", Helvetica, sans-serif;
+  font-size: 1.8em;
+}
+
+#summary {
+  margin: 0; padding: 5px 10px;
+  font-family: "Lucida Grande", Helvetica, sans-serif;
+  text-align: right;
+  position: absolute;
+  top: 0px;
+  right: 0px;
+}
+
+#summary p {
+  margin: 0 0 0 2px;
+}
+
+#summary #totals {
+  font-size: 1.2em;
+}
+
+.behaviour {
+  margin: 0 10px 5px;
+  background: #fff;
+}
+
+dl {
+  margin: 0; padding: 0 0 5px;
+  font: normal 11px "Lucida Grande", Helvetica, sans-serif;
+}
+
+dt {
+  padding: 3px;
+  background: #65C400;
+  color: #fff;
+  font-weight: bold;
+}
+
+dd {
+  margin: 5px 0 5px 5px;
+  padding: 3px 3px 3px 18px;
+}
+
+dd.spec.passed {
+  border-left: 5px solid #65C400;
+  border-bottom: 1px solid #65C400;
+  background: #DBFFB4; color: #3D7700;
+}
+
+dd.spec.failed {
+  border-left: 5px solid #C20000;
+  border-bottom: 1px solid #C20000;
+  color: #C20000; background: #FFFBD3;
+}
+
+dd.spec.not_implemented {
+  border-left: 5px solid #FAF834;
+  border-bottom: 1px solid #FAF834;
+  background: #FCFB98; color: #131313;
+}
+
+dd.spec.pending_fixed {
+  border-left: 5px solid #0000C2;
+  border-bottom: 1px solid #0000C2;
+  color: #0000C2; background: #D3FBFF;
+}
+
+.backtrace {
+  color: #000;
+  font-size: 12px;
+}
+
+a {
+  color: #BE5C00;
+}
+
+div.rspec-report div.dyn-source {
+  background:#FFFFEE none repeat scroll 0%;
+  border:1px dotted black;
+  color:#000000;
+  display:none;
+  margin:0.5em 2em;
+  padding:0.5em;
+}
+
+/* Ruby code, style similar to vibrant ink */
+.ruby {
+  font-size: 12px;
+  font-family: monospace;
+  color: white;
+  background-color: black;
+  padding: 0.1em 0 0.2em 0;
+}
+
+.ruby .keyword { color: #FF6600; }
+.ruby .constant { color: #339999; }
+.ruby .attribute { color: white; }
+.ruby .global { color: white; }
+.ruby .module { color: white; }
+.ruby .class { color: white; }
+.ruby .string { color: #66FF00; }
+.ruby .ident { color: white; }
+.ruby .method { color: #FFCC00; }
+.ruby .number { color: white; }
+.ruby .char { color: white; }
+.ruby .comment { color: #9933CC; }
+.ruby .symbol { color: white; }
+.ruby .regex { color: #44B4CC; }
+.ruby .punct { color: white; }
+.ruby .escape { color: white; }
+.ruby .interp { color: white; }
+.ruby .expr { color: white; }
+
+.ruby .offending { background-color: gray; }
+.ruby .linenum {
+  width: 75px;
+  padding: 0.1em 1em 0.2em 0;
+  color: #000000;
+  background-color: #FFFBD3;
+}

data/lib/assets/dry.js

@@ -0,0 +1,29 @@
+// Lifted from Ruby RDoc
+function toggleSource( id ) {
+  var elem
+  var link
+
+  if( document.getElementById )
+  {
+    elem = document.getElementById( id )
+    link = document.getElementById( "l_" + id )
+  }
+  else if ( document.all )
+  {
+    elem = eval( "document.all." + id )
+    link = eval( "document.all.l_" + id )
+  }
+  else
+    return false;
+
+  if( elem.style.display == "block" )
+  {
+    elem.style.display = "none"
+    link.innerHTML = "Show duplicate lines source code"
+  }
+  else
+  {
+    elem.style.display = "block"
+    link.innerHTML = "Hide duplicate lines source code"
+  }
+}

data/lib/dont_repeat_yourself.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'dont_repeat_yourself/cli'
+require 'dont_repeat_yourself/unit_testing_helpers'
+
+module DontRepeatYourself  
+end

data/lib/dont_repeat_yourself/cli.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/reporter'
+require 'optparse'
+
+module DontRepeatYourself
+  class CLI
+           
+    class << self
+    
+      def execute
+        parse(ARGV).execute!
+      end
+      
+      def parse(args)
+        cli = new
+        cli.parse_options!(args)
+        cli
+      end
+    end
+    
+    attr_reader :options
+    FORMATS = DontRepeatYourself::REPORT_TYPES.map{|format| format.downcase}
+    REPORTERS = DontRepeatYourself::REPORTER_TYPES.map{|reporter| reporter.downcase}
+
+    def initialize
+      
+    end
+
+    def parse_options!(args)
+      args.extend(OptionParser::Arguable)
+
+      @options = { :basedir => './', :format => 'default', :reporter => 'ruby' }
+      args.options do |opts|
+        opts.banner = "Usage: dry-report [options] "
+        
+        opts.on("-d BASEDIR", "--basedir BASEDIR", "set up the base directory of your ruby project, current directory by default") do |b|
+          @options[:basedir] = b
+        end
+        
+        opts.on("-f FORMAT", "--format FORMAT", "report format (default is plain text)",
+          "Available formats: #{FORMATS.join(", ")}") do |v|
+          unless FORMATS.index(v) 
+            STDERR.puts "Invalid format: #{v}\n"
+            STDERR.puts opts.help
+            exit 1
+          end
+          @options[:format] = v
+        end
+                
+        opts.on("-t THRESHOLD", "--threshold THRESHOLD", "threshold of duplicate lines") do |t|
+          @options[:threshold] = t.to_i
+        end
+       
+        opts.on("-r REPORTER", "--reporter REPORTER", "reporter to use (default is ruby): ruby, rails, or plugin",
+          "Available reporters: #{REPORTERS.join(", ")}") do |v|
+          unless REPORTERS.index(v) 
+            STDERR.puts "Invalid reporter: #{v}\n"
+            STDERR.puts opts.help
+            exit 1
+          end
+          @options[:reporter] = v
+        end
+
+        opts.on_tail("--help", "You're looking at it. Any question? http://21croissants.blogspot.com/2008/10/dry.html") do
+          puts opts.help
+          exit
+        end
+      end.parse!
+            
+    end
+            
+    def execute!
+      ruby_project_reporter = DontRepeatYourself::ProjectReporterBase.build_reporter(@options[:reporter], @options[:basedir])
+      ruby_project_reporter.with_threshold_of_duplicate_lines(@options[:threshold]) if @options.has_key?(:threshold)
+      ruby_project_reporter.send("with_#{@options[:format]}_reporting") if @options.has_key?(:format)      
+      STDOUT.print(ruby_project_reporter.report)
+    end
+  end # class 
+  
+end

data/lib/dont_repeat_yourself/formatter.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/simian_results'
+require File.dirname(__FILE__) + '/snippet_extractor'
+
+module DontRepeatYourself
+  
+  class FormatterFactory    
+        
+    # TODO Use a kind of Dependency Injection here, the plugin should not know about this class
+    @@snippet_extractor = DontRepeatYourself::SnippetExtractor.new    
+    
+    def self.create_report(report_type, simian_results)
+      formatter_class = DontRepeatYourself.const_get("#{report_type}Formatter")        
+      return formatter_class.new(@@snippet_extractor, simian_results).report
+    end
+  end
+  
+  class DefaultFormatter
+    
+    attr_reader :simian_results
+    
+    # Inject dependency thtough 
+    def initialize(snippet_extractor, simian_results)
+      @snippet_extractor = snippet_extractor
+      @simian_results = simian_results
+    end
+    
+    def report
+      report_body.gsub(/TWO_SPACE_CHARS/, "  ")      
+    end  
+    
+    # Protected methods to be used by formatters 
+    #    protected            
+    
+    def report_body
+      body = ""
+      body << @simian_results.sentence_processed_a_total_of_x_significant_lines_in_y_files << "\n"
+      body << @simian_results.sentence_found_x_duplicate_lines_in_y_blocks_in_z_files << "\n\n"      
+      @simian_results.sets.each{|set|
+        body << set.sentence_found_x_duplicate_lines_in_the_following_files << "\n"        
+        set.blocks.each{ |block|
+          body << "TWO_SPACE_CHARS" << format_sentence_between_lines_x_and_y_in_filepath(block) << "\n"          
+        }
+        body << "TWO_SPACE_CHARS" << format_duplicate_lines_snippet(set.blocks.last) << "\n"         
+      }
+      body
+    end
+    
+    # Default, return the sentence
+    def format_sentence_between_lines_x_and_y_in_filepath(block)
+      block.sentence_between_lines_x_and_y_in_filepath 
+    end
+    
+    def format_duplicate_lines_snippet(block)
+      snippet = "Duplicate lines:\n"      
+      snippet << @snippet_extractor.plain_source_code(block.line_number_of_first_duplicate_line, block.line_number_of_last_duplicate_line, block.file_path)
+    end                
+               
+  end
+  
+  class NetbeansFormatter < DefaultFormatter          
+    def format_sentence_between_lines_x_and_y_in_filepath(block)
+      block.sentence_between_lines_x_and_y_in_filepath << ":#{block.line_number_of_first_duplicate_line}:" 
+    end    
+  end
+  
+  class HTMLFormatter < DefaultFormatter
+    
+    def report
+      report = report_header          
+      report << report_body.gsub(/TWO_SPACE_CHARS/, "&nbsp;&nbsp;").gsub(/\n/, "</br>\n")           
+      report << report_footer
+    end
+    
+    def format_duplicate_lines_snippet(block)
+      starts = block.line_number_of_first_duplicate_line
+      ends = block.line_number_of_last_duplicate_line
+      file_path = block.file_path      
+      html_source_code = @snippet_extractor.snippet(starts, ends, file_path)
+        
+      source_id = "#{File.basename(file_path)}_#{starts}_#{ends}"
+      source_code_div  = "        <div>&nbsp;&nbsp;[<a id=\"l_#{source_id}\" href=\"javascript:toggleSource('#{source_id}')\">Show duplicate lines source code</a>]</div>"
+      source_code_div << "        <div id=\"#{source_id}\" class=\"dyn-source\"><pre class=\"ruby\"><code>#{html_source_code}</code></pre></div>"     
+    end  
+    
+    # TODO use erb to generate the report?
+    def get_asset(asset)
+      IO.read(File.dirname(__FILE__) + '/../assets/' + asset)
+    end
+    
+    def report_header
+      global_scripts = get_asset('dry.js')
+      global_styles = get_asset('/dry.css')
+      # TODO use erb.html ;-)  
+      <<-EOF
+<html>
+<head>
+<script type="text/javascript">
+    // <![CDATA[
+#{global_scripts}
+    // ]]>
+  </script>
+  <style type="text/css">
+#{global_styles}
+  </style>
+</head>
+
+<body>
+<div class="rspec-report">
+  
+<div id="rspec-header">
+  <h1>Don't Repeat Yourself report Result</h1>  
+</div>
+
+<div class="results">
+      EOF
+    end
+            
+    def report_footer
+      <<-EOF
+          </div>
+        </div>
+      </body>
+    </html>
+      EOF
+    end  
+  end    
+  
+  class TextMateFormatter < HTMLFormatter           
+    
+    def format_sentence_between_lines_x_and_y_in_filepath(block)
+      starts = block.line_number_of_first_duplicate_line
+      file_path = block.file_path
+      sentence = block.sentence_between_lines_x_and_y_in_filepath 
+      "<a href='txmt://open?url=file://#{file_path}&line=#{starts}'>#{sentence}</a>"            
+    end
+    
+  end    
+  
+end

data/lib/dont_repeat_yourself/reporter.rb

@@ -0,0 +1,144 @@
+require File.dirname(__FILE__) + '/simian_runner'
+require File.dirname(__FILE__) + '/simian_results'
+require File.dirname(__FILE__) + '/formatter'
+require 'pathname'
+
+module DontRepeatYourself
+  
+  # TODO Refactor: Use an enum gem / plugin here?
+  DEFAULT_REPORT, HTML_REPORT, NETBEANS_REPORT, TEXTMATE_REPORT = 
+    "Default", "HTML", "Netbeans", "TextMate" unless defined?(DontRepeatYourself::DEFAULT_REPORT)
+
+  DEFAULT_REPORT_DESC   = "display the default plain report"
+  NETBEANS_REPORT_DESC  = "display the report in the Output window of the Netbeans IDE (Ctrl+4)"
+  HTML_REPORT_DESC      = "generate an DRY_report.html file in the project root folder"
+  TEXTMATE_REPORT_DESC  = "to generate an html report with links which open files in the Textmate editor"
+  
+  REPORT_TYPES = [DEFAULT_REPORT, NETBEANS_REPORT, HTML_REPORT, TEXTMATE_REPORT] unless defined?(DontRepeatYourself::REPORT_TYPES)
+
+  RUBY, RAILS, PLUGIN = "Ruby", "Rails", "Plugin" unless defined?(DontRepeatYourself::RUBY)
+  REPORTER_TYPES = [RUBY, RAILS, PLUGIN] unless defined?(DontRepeatYourself::REPORTER_TYPES)
+
+  class ProjectReporterBase
+    attr_reader :name, :maximum_number_of_duplicate_lines_i_want_in_my_project, :report_type
+      
+    def initialize(name)
+      @name = name
+      @simian_runner = DontRepeatYourself::SimianRunner.new      
+      
+      # Default values
+      @maximum_number_of_duplicate_lines_i_want_in_my_project = 0
+      @report_type = DontRepeatYourself::DEFAULT_REPORT
+    end      
+    
+    def patterns_of_directories_to_search_for_duplicate_lines
+      @simian_runner.patterns_of_directories_to_search_for_duplicate_lines
+    end
+      
+    # Fluent interface methods
+    def with_threshold_of_duplicate_lines(threshold)
+      @simian_runner.threshold = threshold        
+      return self
+    end
+    
+    # with_<REPORT_TYPE>_reporting fluent methods
+    REPORT_TYPES.each do |report_type|
+      define_method("with_#{report_type.downcase}_reporting") do        
+        @report_type = eval("DontRepeatYourself::#{report_type.upcase}_REPORT")
+        self
+      end
+    end           
+    
+    def ignoring_the_file(path)
+      @simian_runner.ignore_file(path)
+      self
+    end
+
+    def ignoring_the_directory(path)
+      @simian_runner.ignore_directory(path)
+      self
+    end
+    
+    def basedir
+      @simian_runner.basedir
+    end
+    
+    def report
+      DontRepeatYourself::FormatterFactory.create_report(@report_type, run_simian)
+    end        
+    
+    # TODO Not very readable: you have to read the code of run_simian to understand
+    def is_dry?
+      run_simian.duplicate_line_count <= @maximum_number_of_duplicate_lines_i_want_in_my_project        
+    end
+    
+    def description
+      "DRY\n" << "  - with a threshold of #{@simian_runner.threshold} duplicate lines"
+    end
+    
+    def failure_message      
+      "expected #{@name} to have less or equal #{@maximum_number_of_duplicate_lines_i_want_in_my_project} duplicate lines :\n
+         DRY Report:\n#{report}\n"
+    end                 
+    
+    def self.build_reporter(reporter, basedir)
+      case reporter
+        when 'ruby' then DontRepeatYourself::RubyProjectReporter.new(basedir)
+        when 'rails' then DontRepeatYourself::RailsProjectReporter.new(basedir)
+        when 'plugin' then DontRepeatYourself::RailsPluginProjectReporter.new(basedir)
+      end
+    end
+    protected       
+    
+    def run_simian
+      return @simian_results if @simian_results # so we don't run simian if we already have results
+      self.configure_simian      
+      results_in_yaml_format = @simian_runner.run      
+      @simian_results = DontRepeatYourself::SimianResults.new(results_in_yaml_format) 
+    end        
+    
+    def basename_of_directory(directory)
+      Pathname.new(directory).basename.to_s
+    end
+    
+    def folder_exists?(folder)
+      File.directory?(@simian_runner.basedir + "/" + folder)
+    end
+  end
+
+  # TODO Rename to RubyGemProjectReporter. we might add a "java" project reporter at some point 1 day ;-)
+  class RubyProjectReporter < ProjectReporterBase    
+    def initialize(project_path)
+      super(basename_of_directory(project_path))
+      @simian_runner.basedir = project_path      
+    end
+    
+    def configure_simian        
+      # Only add the "lib" directoy if exists
+      @simian_runner.add_ruby_directory_to_search_for_duplicate_lines("lib")
+      @simian_runner.add_ruby_directory_to_search_for_duplicate_lines("test") if folder_exists?("test")
+      @simian_runner.add_ruby_directory_to_search_for_duplicate_lines("spec") if folder_exists?("spec")
+    end    
+  end
+
+  class RailsProjectReporter < RubyProjectReporter
+    def configure_simian
+      @simian_runner.add_ruby_directory_to_search_for_duplicate_lines("app")
+      @simian_runner.add_ruby_directory_to_search_for_duplicate_lines("lib")
+      @simian_runner.add_html_directory_to_search_for_duplicate_lines("app/views")
+    end
+  end
+
+  class RailsPluginProjectReporter < ProjectReporterBase
+    def initialize(plugin_name)
+      super(plugin_name )
+    end
+
+    def configure_simian
+      @simian_runner.basedir = "#{RAILS_ROOT}/vendor/plugins/#{@name}"
+      @simian_runner.add_ruby_directory_to_search_for_duplicate_lines("lib")
+      #      @project_name = project_basename + " plugin"
+    end
+  end
+  
+end  

data/lib/dont_repeat_yourself/simian_results.rb

@@ -0,0 +1,92 @@
+module DontRepeatYourself
+  class SimianResults
+    attr_reader :duplicate_file_count,
+      :duplicate_line_count,
+      :duplicate_block_count,
+      :total_significant_line_count,
+      :total_raw_line_count, 
+      :total_file_count,
+      :sets
+    
+    def initialize(simian_log_yaml)
+      @simian_log_yaml = simian_log_yaml
+    
+      # TODO Use some code to generate this boring code!
+      @duplicate_file_count = summary['duplicateFileCount']
+      @duplicate_line_count = summary['duplicateLineCount']
+      @duplicate_block_count = summary['duplicateBlockCount']
+      
+      @total_significant_line_count = summary['totalSignificantLineCount']
+      @total_raw_line_count = summary['totalRawLineCount']
+      @total_file_count = summary['totalFileCount']      
+      
+      sets = @simian_log_yaml["simian"]["checks"][0]["sets"]
+      if sets.nil?
+        @sets = []
+      else
+        @sets = @simian_log_yaml["simian"]["checks"][0]["sets"].collect{ |original_set|
+          DontRepeatYourself::SimianResults::DuplicateLinesSet.new(original_set)
+        }  
+      end      
+    end    
+    
+    #    ignoreCurlyBraces		false	boolean	Curly braces are ignored.
+    #ignoreIdentifiers		false	boolean	Completely ignores all identfiers.
+    #ignoreIdentifierCase		true	boolean	Matches identifiers irrespective of case. Eg. MyVariableName and myvariablename would both match.
+    #ignoreStrings		false	boolean	MyVariable and myvariablewould both match.
+    #ignoreStringCase	J	true	boolean	"Hello, World" and "HELLO, WORLD" would both match.
+    #ignoreNumbers		false	boolean	int x = 1; and int x = 576; would both match.
+    #ignoreCharacters		false	boolean	'A' and 'Z'would both match.
+    #ignoreCharacterCase		true	boolean	'A' and 'a'would both match.
+    #ignoreLiterals		false	boolean	'A', "one" and 27.8would all match.
+    #balanceParentheses		false	boolean	Ensures that expressions inside parenthesis that are split across multiple physical lines are considered as one.
+    #balanceCurlyBraces		false	boolean	Ensures that expressions inside curly braces that are split across multiple physical lines are considered as one.
+    #balanceSquareBrackets		false	boolean	Ensures that expressions inside square brackets that are split across multiple physical lines are considered as one. Defaults to false.
+    
+    def sentence_found_x_duplicate_lines_in_y_blocks_in_z_files
+      "Found #{self.duplicate_line_count} duplicate lines in #{self.duplicate_block_count} blocks in #{self.duplicate_file_count} files"
+    end
+    
+    def sentence_processed_a_total_of_x_significant_lines_in_y_files
+      "Processed a total of #{self.total_significant_line_count} significant (#{self.total_raw_line_count} raw) lines in #{self.total_file_count} files"
+    end 
+    
+    class DuplicateLinesSet
+      attr_reader :number_of_duplicate_lines, :blocks
+      def initialize(original_set)
+        @number_of_duplicate_lines = original_set["lineCount"]
+        @blocks = original_set["blocks"].collect{ |original_block|
+          DontRepeatYourself::SimianResults::DuplicateLinesBlock.new(original_block)
+        }      
+      end      
+      
+      def sentence_found_x_duplicate_lines_in_the_following_files
+        "Found #{@number_of_duplicate_lines} duplicate lines in the following files:"
+      end                  
+    
+    end
+    
+    class DuplicateLinesBlock
+      attr_reader :line_number_of_first_duplicate_line,
+        :line_number_of_last_duplicate_line,
+        :file_path
+      
+      def initialize(original_block)
+        @line_number_of_first_duplicate_line = original_block["startLineNumber"]
+        @line_number_of_last_duplicate_line = original_block["endLineNumber"]
+        @file_path = original_block["sourceFile"]
+      end  
+
+      def sentence_between_lines_x_and_y_in_filepath
+        "Between lines #{self.line_number_of_first_duplicate_line} and #{self.line_number_of_last_duplicate_line} in #{self.file_path}"
+      end      
+    end        
+    
+    private
+    
+    def summary
+      @simian_log_yaml["simian"]["checks"][0]["summary"]
+    end
+        
+  end
+end

data/lib/dont_repeat_yourself/simian_runner.rb

@@ -0,0 +1,135 @@
+require 'yaml'
+
+module DontRepeatYourself
+  
+  # See Simian doc in http://www.redhillconsulting.com.au/products/simian/installation.html#cli
+  class SimianRunner
+    
+    attr_reader :basedir,
+                :patterns_of_directories_to_search_for_duplicate_lines,
+                :formatter_option,
+                :simian_jar_path,
+                :executable,
+                :simian_log_file,
+                :threshold
+    
+    DEFAULT_THRESHOLD = 3
+    SIMIAN_LOGFILE_NAME = "simian_log.yaml"
+      
+    def initialize()
+      @threshold = DEFAULT_THRESHOLD
+      @patterns_of_directories_to_search_for_duplicate_lines, @patterns_of_directories_to_exclude_for_duplicate_lines = [], []
+      @formatter_option = "-formatter=yaml"
+      
+      # extension is .txt because the selenium_on_rails project had a problem with jar files that could be
+      # downloaded from the rubygems repository
+      # In order to prevent this kind of problem, I decided to use another suffix as they did ...
+      @simian_jar_path = File.join(File.dirname(__FILE__), '..', 'jars', 'simian-2.2.24.jar.xyz')
+      
+      @executable = "java -jar #{@simian_jar_path}".freeze
+            
+    end
+    
+    def threshold=(threshold)
+      raise ArgumentError.new("Error: Threshold can't be less that 2") if threshold < 2
+      @threshold = threshold
+    end
+    
+    def basedir=(basedir)
+      # TODO Check if Validatable has some generic code for this. I keep copy-pasting here !!!
+      raise ArgumentError.new(basedir << " does not exist") if !File.directory?(basedir)
+      @basedir = basedir
+      @simian_log_file = @basedir + "/" + DontRepeatYourself::SimianRunner::SIMIAN_LOGFILE_NAME
+    end
+    
+    def add_ruby_directory_to_search_for_duplicate_lines(path)
+      valid_directory_path(path)
+      # TODO if the next line usefull ?
+      @patterns_of_directories_to_search_for_duplicate_lines << (path + "/*.rb")
+      @patterns_of_directories_to_search_for_duplicate_lines << (path + "/**/*.rb")
+    end       
+    
+    def add_html_directory_to_search_for_duplicate_lines(path)
+      valid_directory_path(path)
+      @patterns_of_directories_to_search_for_duplicate_lines << (path + "/**/*.*html")
+    end  
+    
+    def ignore_file(path)
+      valid_file_path(path)
+      @patterns_of_directories_to_exclude_for_duplicate_lines << "/" + path
+    end
+
+    def ignore_directory(path)
+      valid_directory_path(path)
+      @patterns_of_directories_to_exclude_for_duplicate_lines << add_ruby_pattern(path)
+    end
+    
+    def run      
+      run_java
+      results_yaml = YAML.load(simian_output_with_header_removed)
+      delete_simian_log_file
+      results_yaml
+    end        
+    
+    private
+
+    def add_ruby_pattern(path)
+      "#{path}/**/*.rb"
+    end
+
+    def parameter_threshold
+      "-threshold=#{@threshold}"
+    end
+    
+    def parameter_includes
+      generate_commandline_parameter("includes", @patterns_of_directories_to_search_for_duplicate_lines)
+    end   
+    
+    def parameter_excludes
+      generate_commandline_parameter("excludes", @patterns_of_directories_to_exclude_for_duplicate_lines)
+    end
+    
+    def generate_commandline_parameter(paramater_name, parameter_list) 
+      parameter_list.map { |pattern| 
+        "-#{paramater_name}=#{File.join(@basedir, pattern)}" 
+      } * ' '
+    end
+    
+    def command_line
+      "#{@executable} #{parameter_threshold} #{@formatter_option} #{parameter_includes} #{parameter_excludes} > #{@simian_log_file}"      
+    end
+    
+    # TODO Add return code processing
+    def run_java
+      system(command_line)
+    end
+    
+    def simian_output_with_header_removed
+      # Remove the Simian text header
+      log = IO.read(@simian_log_file)
+      log[/simian:.*/m] # m <=> Multiline mode
+    end
+    
+    def delete_simian_log_file
+      File.delete @simian_log_file if File.file?(@simian_log_file)
+    end
+    
+    def valid_directory_path(path)
+      absolute_path = File.join(@basedir, "/" + path)
+      if !File.directory?(absolute_path)
+        raise ArgumentError.new(absolute_path << " does not exist, path should be relative to #{@basedir} and not start neither end with '/' ") 
+      end
+      absolute_path
+    end        
+    
+    def valid_file_path(path)
+      absolute_path = File.join(@basedir, "/" + path)
+      if !File.file?(absolute_path)
+        raise ArgumentError.new(absolute_path << " file does not exist, path should be relative to #{@basedir} and not start neither end with '/' ") 
+      end
+      absolute_path
+    end 
+    
+  end
+  
+end

data/lib/dont_repeat_yourself/snippet_extractor.rb

@@ -0,0 +1,31 @@
+module DontRepeatYourself    
+  
+  class SnippetExtractor #:nodoc:
+    class NullConverter; def convert(code, pre); code; end; end #:nodoc:
+    begin
+      require 'rubygems'
+      require 'syntax/convertors/html'
+      @@converter = Syntax::Convertors::HTML.for_syntax "ruby"
+    rescue LoadError
+      @@converter = NullConverter.new
+    end
+    
+    def plain_source_code(starts, ends, file_path)
+      if File.file?(file_path)
+        lines = File.open(file_path).read.split("\n")      
+        lines[starts-1..ends-1].join("\n")
+      else
+        "# Couldn't get snippet for #{file_path}"
+      end        
+    end
+        
+    def snippet(starts, ends, file_path)      
+      raw_code = plain_source_code(starts, ends, file_path)
+      highlighted = @@converter.convert(raw_code, false)
+      highlighted << "\n<span class=\"comment\"># gem install syntax to get syntax highlighting</span>" if @@converter.is_a?(NullConverter)      
+      highlighted
+    end            
+                     
+  end
+  
+end

data/lib/dont_repeat_yourself/unit_testing_helpers.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/reporter'
+require 'spec'
+
+# TODO separate the file!
+require 'test/unit/assertions'
+
+module DontRepeatYourself
+  
+  module UnitTestingHelpers
+        
+    module RubyProjectHelpers           
+      def ruby_project(project_path)
+        DontRepeatYourself::RubyProjectReporter.new(project_path)
+      end
+      def ruby_code_in_rails_plugin(plugin_name)
+        DontRepeatYourself::RailsPluginProjectReporter.new(plugin_name)
+      end
+
+      def rails_application(rails_root = RAILS_ROOT)
+        DontRepeatYourself::RailsProjectReporter.new(rails_root)
+      end
+    end
+
+    module TestUnitExtension
+      include DontRepeatYourself::UnitTestingHelpers::RubyProjectHelpers
+                  
+      def assert_dry(project)
+        assert(project.is_dry?, project.failure_message)
+      end    
+    end   
+
+    module RSpecMatchers
+      
+      include DontRepeatYourself::UnitTestingHelpers::RubyProjectHelpers
+      
+      class BeDRYMatcher
+                              
+        def matches?(project)
+          @project = project
+          @project.is_dry?
+        end
+              
+        # TODO Do we really need this? It does not make a lot of sense
+        def negative_failure_message
+          "expected #{@project.name} to have more than #{@project.maximum_number_of_duplicate_lines_i_want_in_my_project} duplicate lines :\n but found the following:\n "
+        end
+      
+        def description
+          "follow the 'Don't Repeat Yourself' principle " << @project.description
+        end
+        
+        def failure_message
+          @project.failure_message
+        end
+    
+      end        
+    
+      # Custom expectation matcher
+      def follow_the_dry_principle
+        DontRepeatYourself::UnitTestingHelpers::RSpecMatchers::BeDRYMatcher.new
+      end                          
+    
+    end
+  end
+end
+
+# Automatically includes assert_dry
+module Test
+  module Unit
+    class TestCase #:nodoc:
+      include DontRepeatYourself::UnitTestingHelpers::RubyProjectHelpers
+      include DontRepeatYourself::UnitTestingHelpers::TestUnitExtension
+    end
+  end
+end
+

data/lib/dont_repeat_yourself/version.rb

@@ -0,0 +1,9 @@
+module DontRepeatYourself #:nodoc:
+  class VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 3
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: angelic-dont_repeat_yourself
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Jean-Michel Garnier
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-19 00:00:00 -08:00
+default_executable: dry-report
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: syntax
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: Generate duplicate lines report
+email: 
+- jm AT 21croissants dot com
+executables: 
+- dry-report
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- SIMIAN-LICENSE
+- MIT-LICENSE
+- README.txt
+- Rakefile
+- bin/dry-report
+- lib/assets
+- lib/assets/dry.css
+- lib/assets/dry.js
+- lib/dont_repeat_yourself
+- lib/dont_repeat_yourself/formatter.rb
+- lib/dont_repeat_yourself/reporter.rb
+- lib/dont_repeat_yourself/simian_results.rb
+- lib/dont_repeat_yourself/simian_runner.rb
+- lib/dont_repeat_yourself/snippet_extractor.rb
+- lib/dont_repeat_yourself/unit_testing_helpers.rb
+- lib/dont_repeat_yourself/cli.rb
+- lib/dont_repeat_yourself/version.rb
+- lib/jars
+- lib/jars/simian-2.2.24.jar.xyz
+- lib/dont_repeat_yourself.rb
+has_rdoc: true
+homepage: http://github.com/garnierjm/dont_repeat_yourself
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: dont_repeat_yourself
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Generate duplicate lines report
+test_files: []
+