ssoroka-grepmate 1.0.1 → 2.0.0

data/config/dot-grepmate

@@ -0,0 +1,52 @@
+# this file will be installed as ~/.grepmate
+--- 
+# valid outputs are: text, html, textmate, file_and_line
+default_output: html
+search_rails_source: false
+search_gems: false
+# if you only want to search a specific rails version, uncomment and set this:
+# :use_only_rails_version: 2.3.2
+exclude_file_extensions: 
+  - sql
+  - log
+  - tmp
+  - gz
+  - bz2
+  - tar
+  - zip
+  - db
+  - sqlite
+  - sqlite3
+  - csv
+  - DS_Store
+  - svn
+  - git
+  - tmproj
+  - sql
+  - dat
+  - gitignore
+  - gitmodules
+  - gemspec
+  - rdoc
+  - ico
+  - pdf
+  - xml
+  - html
+  - swf
+  - jpg
+  - png
+  - gif
+include_dirs: 
+  - .
+exclude_dirs:
+  - .git
+  - .svn
+  - sphinx
+  - sql
+  - tmp
+  - log
+  - doc
+  - coverage
+  - flash
+  - images
+  - videos

data/grepmate.gemspec

@@ -2,35 +2,62 @@
 
 Gem::Specification.new do |s|
   s.name = %q{grepmate}
-  s.version = "1.0.1"
+  s.version = "2.0.0"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Steven Soroka"]
-  s.date = %q{2008-12-06}
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Steven Soroka", "Zach Holt"]
+  s.date = %q{2009-07-23}
   s.default_executable = %q{grepmate}
   s.description = %q{Extremely fast search of rails projects or rails source for code, open in textmate or browser with html output}
   s.email = %q{ssoroka78@gmail.com}
   s.executables = ["grepmate"]
-  s.extra_rdoc_files = ["bin/grepmate", "README"]
-  s.files = ["bin/grepmate", "grepmate.gemspec", "Manifest", "Rakefile", "README"]
-  s.has_rdoc = true
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/grepmate",
+     "config/dot-grepmate",
+     "grepmate.gemspec",
+     "lib/.empty",
+     "lib/.git-empty",
+     "lib/grepmate.rb",
+     "lib/output/file_and_line.rb",
+     "lib/output/html.rb",
+     "lib/output/text.rb",
+     "lib/output/textmate.rb",
+     "spec/grepmate_spec.rb",
+     "spec/spec_helper.rb",
+     "tmp/grepmate.html"
+  ]
   s.homepage = %q{http://github.com/ssoroka/grepmate}
-  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Grepmate", "--main", "README"]
+  s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubyforge_project = %q{grepmate}
-  s.rubygems_version = %q{1.3.1}
+  s.rubygems_version = %q{1.3.3}
   s.summary = %q{Extremely fast search of rails projects or rails source for code, open in textmate or browser with html output}
+  s.test_files = [
+    "spec/grepmate_spec.rb",
+     "spec/spec_helper.rb"
+  ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<main>, [">= 0"])
+      s.add_runtime_dependency(%q<main>, [">= 2.8.3"])
+      s.add_runtime_dependency(%q<syntax>, [">= 1.0.0"])
     else
-      s.add_dependency(%q<main>, [">= 0"])
+      s.add_dependency(%q<main>, [">= 2.8.3"])
+      s.add_dependency(%q<syntax>, [">= 1.0.0"])
     end
   else
-    s.add_dependency(%q<main>, [">= 0"])
+    s.add_dependency(%q<main>, [">= 2.8.3"])
+    s.add_dependency(%q<syntax>, [">= 1.0.0"])
   end
 end

data/lib/.git-empty

@@ -0,0 +1 @@
+

data/lib/grepmate.rb

@@ -0,0 +1,187 @@
+require 'rubygems'
+begin
+  gem 'syntax'
+rescue LoadError
+end
+require 'yaml'
+require 'enumerator'
+require File.join(File.dirname(__FILE__), 'output', 'html')
+require File.join(File.dirname(__FILE__), 'output', 'textmate')
+require File.join(File.dirname(__FILE__), 'output', 'text')
+require File.join(File.dirname(__FILE__), 'output', 'file_and_line')
+
+class Grepmate
+  attr_reader :params, :dirs, :query, :results
+  CONFIG_FILE = File.expand_path("~/.grepmate")
+  
+  def initialize(params)
+    @params = params
+
+    load_config
+  end
+  
+  def gem_path
+    `gem environment gemdir`.chomp
+  end
+
+  def gems_path
+    File.join(gem_path, 'gems')
+  end
+
+  def rails_version
+    `rails -v`.chomp.split(' ').last
+  end
+
+  def rails_path
+    vendor_rails = "vendor/rails"
+
+    if File.exist?(vendor_rails)
+      vendor_rails
+    else
+      Dir["#{gems_path}/acti*-#{rails_version}"]
+    end
+  end
+  
+  def load_config
+    if !File.exist?(CONFIG_FILE)
+      # create
+      safe_puts "Creating config file #{CONFIG_FILE}..."
+      FileUtils.cp(File.expand_path(File.join(File.dirname(__FILE__), %w(.. config dot-grepmate))), CONFIG_FILE)
+    else
+      verbose("Using config file #{CONFIG_FILE}...")
+    end
+    
+    # load
+    @config = YAML::load(File.read(CONFIG_FILE))
+    # set output type
+    @output = @config['default_output']
+    %w(html text textmate file_and_line).each{|out_type|
+      @output = out_type if params[out_type].value
+    }
+    verbose("Output mode set to #{@output}")
+    
+    # set default search directories
+    unless params['dir'].values.any?
+      params['dir'].values = @config['include_dirs']
+    end
+    
+    # exclude extensions
+    @exclude_exts = (@config['exclude_file_extensions'] || [])
+    verbose "Excluding file extensions: #{@exclude_exts.join(' ')}"
+    # dir exclusions
+    @exclude_dirs = (@config['exclude_dirs'] || [])
+    verbose "Excluding dirs: #{@exclude_dirs.join(' ')}"
+    
+    @search_rails = params['rails'].given? ? params['rails'].value : @config['search_rails_source']
+    verbose "Searching rails source" if @search_rails
+    @search_gems = params['gems'].given? ? params['gems'].value : @config['search_gems']
+    verbose "Searching gems source" if @search_gems
+  end
+
+  # use default dirs, param dirs, or files/dirs from STDIN
+  def determine_directories_to_search
+    if STDIN.tty?
+      @dirs = if params['only_rails'].value || params['only_gems'].value
+        [] 
+      else
+        params['dir'].values || []
+      end
+      @dirs += Array(rails_path) if params['only_rails'].value || params['rails'].value
+      @dirs << gems_path if params['only_gems'].value || params['gems'].value
+    else
+      @dirs = []
+      input = STDIN.read
+    
+      input.split("\n").each do |ln|
+        if ln =~ /^([^:]*)/ # Assume everything to the first colon is a file name
+          # filename = File.expand_path($1)
+          # if File.exist?(filename) # But actually check that it is
+            @dirs << $1# filename
+          # end
+        end
+      end
+    end
+    @dirs.uniq! # remove duplicates
+    verbose "including dirs: #{@dirs.join(' ')}"
+    @dirs.reject!{ |dir|
+      !File.exist?(dir) || @exclude_dirs.any?{ |exclude| dir =~ /(^|\/)#{exclude}(\/|$)/i }
+    }
+    verbose "rejected dirs, left with: #{@dirs.join(' ')}"
+  end
+
+  def determine_what_to_search_for
+    # funny bunny => 'funny' 'bunny'
+    # 'funny bunny' => 'funny bunny'
+    if params['regex'].value
+      exp = params['what_to_search_for'].value.dup
+      exp.gsub!(/^\//, '')
+      exp.gsub!(/\/$/, '')
+      @query = %("#{exp}")
+      verbose "Searching for: /#{exp}/"
+    else
+      verbose "Searching for: #{params['what_to_search_for'].values.inspect}"
+      @query = params['what_to_search_for'].values.map {|v| "\"#{v.gsub(/"/, '\\"')}\"" }.join(" ")
+    end
+  end
+
+  def find
+    determine_directories_to_search
+    determine_what_to_search_for
+
+    @results = []
+    if @dirs.any?
+      paths = `find #{@dirs.join(' ')}`.split("\n").map{|sp| sp.gsub(' ', '\\ ')} # escape spaces in found files
+      paths = paths.map!{|p| p.gsub(/^\.\//, '') }.uniq
+      paths.reject! { |path| 
+        @exclude_exts.any?{ |exclude| path =~ /\.#{Regexp.escape(exclude)}$/i } ||
+        @exclude_dirs.any?{ |exclude| path =~ /(^|\/)#{Regexp.escape(exclude)}(\/|$)/i } 
+      }
+
+      cmd = 'grep '
+      cmd << '-i ' unless params['case'].value
+      # 3 lines of context for html and text
+      cmd << '-C 3 ' if (@output == 'html') && !params['count'].value
+      cmd << '-E ' if params['regex']
+
+      # paths get too large for grep to handle, so limit the number it has to deal with at once.
+      paths.each_slice(100) {|sub_paths|
+        @results += `#{cmd} -n #{query} #{sub_paths.join(' ')}`.split("\n")
+      }
+    end
+  end
+
+  def display
+    if @results.empty?
+      safe_puts "Nothing found!"
+      exit
+    elsif params['count'].value
+      puts "Matches: #{@results.size}"
+      exit
+    end
+
+    output_class = case @output.to_s
+    when 'html'
+      Output::HTML
+    when 'text'
+      Output::Text
+    when 'textmate'
+      Output::Textmate
+    when 'file_and_line'
+      Output::FileAndLine
+    end
+    
+    output_class.new(self).process
+  end
+  
+  def safe_puts(msg)
+    if STDOUT.tty?
+      puts msg
+    end
+  end
+  
+  def verbose(msg)
+    if @params['verbose'].value
+      puts msg
+    end
+  end
+end

data/lib/output/file_and_line.rb

@@ -0,0 +1,17 @@
+module Output
+  class FileAndLine
+    def initialize(grepmate)
+      @grepmate = grepmate
+    end
+    
+    def process
+      @grepmate.results.each{|line|
+        if line
+          puts line.split(':')[0..1].join(':')
+        else
+          puts line
+        end
+      }
+    end
+  end
+end

data/lib/output/html.rb

@@ -0,0 +1,136 @@
+module Output
+  class HTML
+    TEMP_FILE = File.expand_path(File.join(File.dirname(__FILE__), %w(.. .. tmp grepmate.html)))
+    
+    def initialize(grepmate)
+      @grepmate = grepmate
+    end
+    
+    def determine_javascript_highlight_text
+      @grepmate.params['what_to_search_for'].values.map {|v| "highlightSearchTerms('#{v.gsub(/'/, "\\'").gsub(/:/, "\\:")}', false)" }.join(";")
+    end
+
+    def process
+      syntax_installed = true
+      begin
+        require 'syntax/convertors/html'
+      rescue LoadError
+        syntax_installed = false
+      end
+
+      html = '<html><head>'
+      html << <<-CSS
+  <style type="text/css">body { background-color: #EEEEEE; } pre {
+  display: inline; } .ruby { font-family: Monaco; font-size: 10pt;
+  background-color: white } .ruby .normal {} .ruby .comment { color:
+  #005; font-style: italic; } .ruby .keyword { color: #A00; font-weight:
+  bold; } .ruby .method { color: #077; } .ruby .class { color: #074; }
+  .ruby .module { color: #050; } .ruby .punct { color: #447; font-weight:
+  bold; } .ruby .symbol { color: #099; } .ruby .string { color: #944;
+  background: #FFE; } .ruby .char { color: #F07; } .ruby .ident { color:
+  #004; } .ruby .constant { color: #07F; } .ruby .regex { color: #B66;
+  background: #FEF; } .ruby .number { color: #F99; } .ruby .attribute {
+  color: #7BB; } .ruby .global { color: #7FB; } .ruby .expr { color:
+  #227; } .ruby .escape { color: #277; } .ruby .highlight {
+  background-color: yellow; font-weight: 900; } td.lineno { text-align:
+  right; font-family: Monaco; font-size: 9pt; padding-right: 10px; }
+  td.filename { padding-top: 35px; font-family: Monaco; font-size: 14pt;
+  }</style>
+
+  <script type="text/javascript">
+  // http://www.nsftools.com/misc/SearchAndHighlight.htm
+
+  function doHighlight(bodyText,searchTerm,highlightStartTag,highlightEndTag)
+  {if((!highlightStartTag)||(!highlightEndTag)){highlightStartTag="<font style='color:blue; background-color:yellow;'>";highlightEndTag="</font>";}
+  var newText="";var i=-1;var lcSearchTerm=searchTerm.toLowerCase();var lcBodyText=bodyText.toLowerCase();while(bodyText.length>0){i=lcBodyText.indexOf(lcSearchTerm,i+1);if(i<0){newText+=bodyText;bodyText="";}else{if(bodyText.lastIndexOf(">",i)>=bodyText.lastIndexOf("<",i)){if(lcBodyText.lastIndexOf("/script>",i)>=lcBodyText.lastIndexOf("<script",i)){newText+=bodyText.substring(0,i)+highlightStartTag+bodyText.substr(i,searchTerm.length)+highlightEndTag;bodyText=bodyText.substr(i+searchTerm.length);lcBodyText=bodyText.toLowerCase();i=-1;}}}}
+  return newText;}
+  function highlightSearchTerms(searchText,treatAsPhrase,warnOnFailure,highlightStartTag,highlightEndTag)
+  {if(treatAsPhrase){searchArray=[searchText];}else{searchArray=searchText.split(" ");}
+  if(!document.body||typeof(document.body.innerHTML)=="undefined"){if(warnOnFailure){alert("Sorry, for some reason the text of this page is unavailable. Searching will not work.");}
+  return false;}
+  var bodyText=document.body.innerHTML;for(var i=0;i<searchArray.length;i++){bodyText=doHighlight(bodyText,searchArray[i],highlightStartTag,highlightEndTag);}
+  document.body.innerHTML=bodyText;return true;}</script></script>
+    CSS
+
+      # some searches can return stupid-huge result sets.  Javascript will likely freeze or crash the browser in those cases.
+      if @grepmate.results.size < 1000
+        html << "</head><body onLoad=\"#{determine_javascript_highlight_text}\">"
+      else
+        html << "</head><body>"
+      end
+
+      syntax_converter = (syntax_installed ? Syntax::Convertors::HTML.for_syntax("ruby") : nil)
+      html << '<pre>sudo gem install syntax</pre> to get syntax highlighting<br><br>' unless syntax_installed
+
+      html << '<table cellspacing="0" cellpadding="2">'
+
+      last_file = ''
+      separator = false
+
+      html << @grepmate.results.map{ |line|
+        if line == '--'
+          separator = true
+          ''
+        elsif line =~ /^(.+?)-(\d+)-(.*)$/ || line =~ /^(.+?):(\d+):(.*)$/
+          file = $1
+          line = $2
+          context = $3
+
+          file_group = ''
+
+          if file == last_file
+            file_group << "<tr><td class=\"lineno\">...</td><td></td></tr>" if separator
+          else
+            parts = file.split(/\//)
+            path = ''
+            file_group << "<tr><td colspan=\"2\" class=\"filename\">"
+            parts.each do |part|
+              path << "/#{part}"
+              file_group << "/" unless part.equal?(parts.first)
+              if part.equal?(parts.last)
+                file_group << "<a href=\"txmt://open?url=file://#{file}\">#{part}</a>"
+              else
+                file_group << "<a href=\"file:/#{path}\">#{part}</a>"
+              end
+            end
+            file_group << "</td></tr>\n"
+          end
+
+          separator = false
+          last_file = file
+
+          file_group << "<tr><td class=\"lineno\"><a href=\"txmt://open?url=file://#{file}&line=#{line}\">#{line}</a></td>"
+
+          converted = begin
+            syntax_converter ? syntax_converter.convert(context =~ /^(.+?)\s*$/ ? $1 : context) : context
+          rescue Exception => e
+            "TOKENIZING ERROR: #{context} <!-- \n#{e.message}\n#{e.backtrace.join("\n")}\n -->"
+          end
+          file_group << "<td class=\"ruby\">#{converted}</td></tr>\n"
+
+          file_group
+        end
+      }.join
+
+      html << '</table></body></html>'
+
+      begin
+        FileUtils.touch(TEMP_FILE)
+      rescue Errno::EACCES => e
+        puts %(
+
+        Looks like there's a permission error for the file #{TEMP_FILE}.  The grepmate gem expects to have write access to this file.
+
+        To fix, please do:
+          sudo chmod 0666 #{TEMP_FILE}
+          
+        )
+        raise e
+      end
+      File.open(TEMP_FILE, 'w') { |f| f.write(html) }
+
+      system("open #{TEMP_FILE}")
+  
+    end
+  end
+end