sourcify 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/HISTORY.txt

@@ -0,0 +1,4 @@
+=== 0.1.0 (Aug 28, 2010)
+
+* 1st gem release !! [#ngty]
+

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 NgTzeYang
+
+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.rdoc

@@ -0,0 +1,154 @@
+= Sourcify
+
+*ParseTree* is great, it accesses the runtime AST (abstract syntax tree) and makes it
+possible to convert any object to ruby code & S-expression, BUT ParseTree doesn't work
+for 1.9.* & JRuby.
+
+*RubyParser* is great, and it works for any rubies (of course, not 100% compatible for
+1.9.* syntax yet), BUT it works only with static code.
+
+I truely enjoy using the above tools, but with my other projects, the absence of ParseTree
+on the different rubies is forcing me to hand-baked my own solution each time to extract
+the proc code i need at runtime. This is frustrating, the solution for each of them is
+never perfect, and i'm reinventing the wheel each time just to address a particular
+pattern of usage (using regexp kungfu).
+
+Enough is enough, and now we have Sourcify, a unified solution to extract proc code.
+When ParseTree is available, it simply works as a wrapper round it, otherwise, it uses:
+
+* Ripper (part of the stdlib for 1.9.*), OR
+* RubyLex (under irb, which is part of the stdlib for any ruby)
+
+to extract the code, and does further processing with RubyParser & Ruby2Ruby to ensure
+100% compatbility with ParseTree (yup, there is no denying that i really like ParseTree).
+
+== Installing It
+
+The religiously standard way:
+
+  $ gem install ParseTree sourcify
+
+Or on 1.9.* or JRuby:
+
+  $ gem install ruby_parser file-tail sourcify
+
+== Using It
+
+Sourcify adds 3 methods to Proc:
+
+=== 1. Proc#to_source
+
+Returns the code representation of the proc:
+
+  require 'sourcify'
+
+  proc1 = lambda { x + y }
+  puts proc1.to_source # proc { (x + y) }
+
+  proc2 = proc { x + y }
+  puts proc2.to_source # proc { (x + y) }
+
+Like it or not, a lambda is represented as a proc when converted to source (exactly the
+same way as ParseTree).
+
+=== 2. Proc#to_sexp
+
+Returns the S-expression of the proc:
+
+  require 'sourcify'
+  require 'pp'
+
+  x = 1
+  pp lambda { x + y }.to_sexp
+  # >> s(:iter,
+  # >>  s(:call, nil, :proc, s(:arglist)),
+  # >>   nil,
+  # >>    s(:call, s(:lvar, :x), :+, s(:arglist, s(:call, nil, :y, s(:arglist)))))
+
+=== 3. Proc#source_location
+
+By default, this is only available on 1.9.*, it is added (as a bonus) to provide
+consistency under 1.8.*:
+
+  # /tmp/test.rb
+  require 'sourcify'
+  require 'pp'
+
+  pp lambda { x + y }.source_location
+  # >> ["/tmp/test.rb", 5]
+
+== Performance
+
+Performance is reasonable (but can always be improved on):
+
+  ruby                 user      system    total     real
+  1.8.7 (w ParseTree)  0.010000  0.000000  1.270000  1.273631
+  1.8.7 (w RubyLex)    0.000000  0.000000  1.640000  1.641778
+  1.9.1 (w Ripper)     0.000000  0.000000  1.070000  1.067248
+  JRuby (w RubyLex)    5.054000  0.000000  5.054000  5.055000
+
+It would be great if Ripper can be ported over to 1.8.* & JRuby (hint hint).
+
+== Gotchas
+
+Nothing beats ParseTree's ability to access the runtime AST, it is a very powerful feature.
+The lexer-based (static) implementations suffer the following gotchas:
+
+=== 1. The source code is everything
+
+Since static code analysis is involved, the subject code needs to physically exist within a
+file, meaning Proc#source_location must return the expected [file, lineno], the following
+will not work:
+
+  def test
+    eval('lambda { x + y }')
+  end
+
+  pp test.source_location
+  # >> ["(eval)", 1]
+
+  puts test.to_source
+  # >> `initialize': No such file or directory - (eval) (Errno::ENOENT)
+
+=== 2. Multiple matching procs per line error
+
+Sometimes, we may have multiple procs on a line, Sourcify can handle this as long as the
+subject proc has arity that is unique from others:
+
+  # Yup, this works as expected :)
+  b1 = lambda {|a| a+1 }; b2 = lambda { 1+2 }
+  puts b2.to_source
+  # >> proc { (1 + 2) }
+
+  # Nope, this won't work :(
+  b1 = lambda { 1+2 }; b2 = lambda { 2+3 }
+  b2.to_source
+  # >> raises Sourcify::MultipleMatchingProcsPerLineError
+
+Using Proc#arity is a pretty good way to uniquely identify the subject proc, since having
+too many procs per line is not a good practice as it reduces readability. However, the
+following bug under 1.8.* may trip u over:
+
+  lambda { }.arity         # 1.8.* (-1) / 1.9.* (0)  (?!)
+  lambda {|x| }.arity      # 1.8.* (1)  / 1.9.* (1)
+  lambda {|x,y| }.arity    # 1.8.* (2)  / 1.9.* (2)
+  lambda {|*x| }.arity     # 1.8.* (-1) / 1.9.* (-1)
+  lambda {|x, *y| }.arity  # 1.8.* (-2) / 1.9.* (-2)
+  lambda {|(x,y)| }.arity  # 1.8.* (1)  / 1.9.* (1)
+
+This is another reason to install ParseTree when u are on 1.8.*. On JRuby, where u don't
+have the choice, just avoid multiple procs here line.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 NgTzeYang. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,114 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+    gem.name = "sourcify"
+    gem.summary = %Q{Workarounds before ruby-core officially supports Proc#to_source (& friends)}
+    gem.description = %Q{}
+    gem.email = "ngty77@gmail.com"
+    gem.homepage = "http://github.com/ngty/sourcify"
+    gem.authors = ["NgTzeYang"]
+    gem.add_dependency 'ruby2ruby', '>= 1.2.4'
+    gem.add_development_dependency "bacon", ">= 0"
+    # Plus one of the following groups:
+    #
+    # 1). ParseTree (better performance + dynamic goodness, but not supported on java & 1.9.*)
+    # >> gem.add_dependency "ParseTree", ">= 3.0.5"
+    #
+    # 2). RubyParser (supported for all)
+    # >> gem.add_dependency "ruby_parser", ">= 2.0.4"
+    # >> gem.add_dependency "file-tail", ">= 1.0.5"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |spec|
+    spec.libs << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'reek/adapters/rake_task'
+  Reek::RakeTask.new do |t|
+    t.fail_on_error = true
+    t.verbose = false
+    t.source_files = 'lib/**/*.rb'
+  end
+rescue LoadError
+  task :reek do
+    abort "Reek is not available. In order to run reek, you must: sudo gem install reek"
+  end
+end
+
+begin
+  require 'roodi'
+  require 'roodi_task'
+  RoodiTask.new do |t|
+    t.verbose = false
+  end
+rescue LoadError
+  task :roodi do
+    abort "Roodi is not available. In order to run roodi, you must: sudo gem install roodi"
+  end
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sourcify #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# Benchmarking
+task :benchmark, :task, :times do |t, args|
+  times, task = (args.times || 5).to_i.method(:times), args.task
+  title = " ~ Benchmark Results for Task :#{task} ~ "
+  results = [%w{nth}, %w{user}, %w{system}, %w{total}, %w{real}]
+
+  # Running benchmarking & collecting results
+  require 'benchmark'
+  times.call do |i|
+    result = Benchmark.measure{ Rake::Task[task].execute }.to_s
+    user, system, total, real =
+      result.match(/^\s*(\d+\.\d+)\s+(\d+\.\d+)\s+(\d+\.\d+)\s+\(\s*(\d+\.\d+)\)$/)[1..-1]
+    ["##{i.succ}", user, system, total, real].each_with_index{|val, j| results[j] << val }
+  end
+
+  # Formatting benchmarking results
+  formatted_results = results.map do |rs|
+    width = rs.map(&:to_s).map(&:size).max
+    rs.map{|r| '  ' + r.ljust(width, ' ') }
+  end.transpose.map{|row| row.join }
+
+  # Showdown .. printout
+  line = '=' * ([title.size, formatted_results.map(&:size).max].max + 2)
+  puts [line, title, formatted_results.join("\n"), line].join("\n\n")
+
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/sourcify.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'ruby2ruby'
+
+begin
+  require 'parse_tree'
+  require 'parse_tree_extensions'
+rescue LoadError
+  require 'ruby_parser'
+  require 'file/tail'
+end
+
+require 'sourcify/proc'

data/lib/sourcify/proc.rb

@@ -0,0 +1,53 @@
+module Sourcify
+
+  class MultipleMatchingProcsPerLineError < Exception ; end
+
+  module Proc
+
+    def self.included(base)
+      base.class_eval do
+
+        meths = instance_methods.map(&:to_s)
+
+        # Added as a bonus, by default, only 1.9.* implements this.
+        unless meths.include?('source_location')
+          def source_location
+            @source_location ||= (
+              file, line = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+).*?>$/.match(inspect)[1..2]
+              [file, line.to_i]
+            )
+          end
+        end
+
+        # When ParseTree is available, we just make use of all the convenience it offers :)
+        if Object.const_defined?(:ParseTree)
+
+          alias_method :to_source, :to_ruby
+
+        # Otherwise, we are going to do abit of static text parsing :(
+        else
+
+          unless meths.include?('to_source')
+            def to_source
+              require 'sourcify/proc/parser'
+              (@parser ||= Parser.new(self)).source
+            end
+          end
+
+          unless meths.include?('to_sexp')
+            def to_sexp
+              require 'sourcify/proc/parser'
+              (@parser ||= Parser.new(self)).sexp
+            end
+          end
+
+        end
+      end
+    end
+
+  end
+end
+
+::Proc.class_eval do
+  include Sourcify::Proc
+end

data/lib/sourcify/proc/counter.rb

@@ -0,0 +1,41 @@
+module Sourcify
+  module Proc
+    class Counter
+
+      attr_accessor :marker
+
+      def initialize
+        @marker, @counter = nil, {:start => 0, :end => 0}
+      end
+
+      def [](key)
+        @counter[key]
+      end
+
+      def started?
+        @counter.values != [0,0]
+      end
+
+      def telly?
+        @counter[:start] == @counter[:end]
+      end
+
+      def decrement_start
+        @counter[:start] -= 1
+        self
+      end
+
+      def increment_start
+        @counter[:start] += 1
+        self
+      end
+
+      def increment_end
+        @counter[:end] += 1
+        self
+      end
+
+    end
+  end
+end
+

data/lib/sourcify/proc/lexer.rb

@@ -0,0 +1,40 @@
+module Sourcify
+  module Proc
+    module Lexer
+
+      class << self
+        def new(*args)
+          begin
+            require 'sourcify/proc/lexer19'
+            Lexer19.new(*args)
+          rescue LoadError
+            require 'sourcify/proc/lexer18'
+            Lexer18.new(*args)
+          end
+        end
+      end
+
+      module Commons
+
+        class EndOfBlock < Exception ; end
+        class EndOfLine < Exception ; end
+
+        def work
+          begin
+            @results ||= []
+            @do_end_counter = Sourcify::Proc::Counter.new
+            @braced_counter = Sourcify::Proc::Counter.new
+            lex
+          rescue EndOfBlock
+            @results << @result.dup
+            @is_multiline_block ? @results : retry
+          rescue EndOfLine
+            @results
+          end
+        end
+
+      end
+
+    end
+  end
+end