sourcify 0.4.1 → 0.4.2

data/HISTORY.txt

@@ -1,3 +1,8 @@
+=== 0.4.2 (Feb 06, 2011)
+
+* fixes Sourcify::NoMatchingProcError when inline proc contains hashes (issue#7) [#ngty]
+* uses RubyParser#parse to eval correctness of code instead of Kernel#eval [#ngty]
+
 === 0.4.1 (Jan 29, 2011)
 
 * fixes Sourcify::NoMatchingProcError when if/unless/until/while modifier follows

data/VERSION

@@ -1 +1 @@
-0.4.1
+0.4.2

data/lib/sourcify/proc/parser.rb

@@ -1,12 +1,12 @@
 Sourcify.require_rb('proc', 'scanner')
+%w{normalizer code_scanner source_code converter}.each do |file|
+  Sourcify.require_rb('proc', 'parser', file)
+end
 
 module Sourcify
   module Proc
     class Parser #:nodoc:all
 
-      RUBY_PARSER = RubyParser.new
-      RUBY_2_RUBY = Ruby2Ruby.new
-
       IS_19x = RUBY_VERSION.include?('1.9.')
 
       def initialize(_proc)
@@ -17,13 +17,12 @@ module Sourcify
       end
 
       def source(opts)
-        (@sources ||= {})[opts.hash] ||=
-          RUBY_2_RUBY.process(Sexp.from_array(sexp(opts).to_a))
+        (@sources ||= {})[opts.hash] ||= Converter.to_code(sexp(opts))
       end
 
       def sexp(opts)
         (@sexps ||= {})[opts.hash] ||= (
-          raw_sexp = RUBY_PARSER.parse(raw_source(opts), @source_code.file)
+          raw_sexp = Converter.to_sexp(raw_source(opts), @source_code.file)
           sexp = Normalizer.process(raw_sexp, @binding)
           opts[:strip_enclosure] ? Sexp.from_array(sexp.to_a.last) : sexp
         )
@@ -41,110 +40,6 @@ module Sourcify
           end
         end
 
-        class Normalizer
-          class << self
-
-            def process(sexp, binding)
-              @binding = binding
-              Sexp.from_array(fix_no_arg_method_calls(sexp.to_a))
-            end
-
-            def fix_no_arg_method_calls(array)
-              return array if [:class, :sclass, :defn, :module].include?(array[0])
-              array.map do |e|
-                if e.is_a?(Array)
-                  no_arg_method_call?(e) or fix_no_arg_method_calls(e)
-                else
-                  e
-                end
-              end
-            end
-
-            def no_arg_method_call?(e)
-              if like_no_arg_method_call?(e)
-                bounded_var?(var = e[2]) ? [:lvar, var] : e
-              end
-            end
-
-            def like_no_arg_method_call?(e)
-              e.size == 4 && e[0..1] == [:call, nil] &&
-                e[3] == [:arglist] && (var = e[2]).is_a?(Symbol)
-            end
-
-            def bounded_var?(var)
-              qvar = (@q ||= (IS_19x ? ":%s" : "'%s'")) % var
-              @binding.eval("local_variables.include?(#{qvar})")
-            end
-
-          end
-        end
-
-        class CodeScanner
-          class << self
-
-            def process(source_code, opts, &matcher)
-              results = rscan(source_code.to_s, {
-                :start_pattern => scan_pattern_hint(opts[:attached_to]),
-                :body_matcher => opts[:body_matcher],
-                :ignore_nested => opts[:ignore_nested],
-                :stop_on_newline => false,
-              }).flatten.select(&matcher)
-              case results.size
-              when 0 then raise NoMatchingProcError
-              when 1 then ("\n" * source_code.line) + results[0]
-              else raise MultipleMatchingProcsPerLineError
-              end
-            end
-
-            def scan_pattern_hint(val)
-              case val
-              when Regexp then val
-              when String, Symbol then /^(?:.*?\W|)#{val}(?:\W)/
-              when nil then /.*/
-              else raise TypeError
-              end
-            end
-
-            def rscan(str, opts)
-              results = Scanner.process(str, opts) || []
-              return results if opts[:ignore_nested]
-              results.map do |outer|
-                inner = rscan(outer.sub(/^proc\s*(do|\{)/,''), opts.merge(:stop_on_newline => true))
-                [outer, inner]
-              end
-            end
-
-          end
-        end
-
-        class SourceCode < Struct.new(:file, :line)
-
-          def line
-            super.pred
-          end
-
-          def to_s
-            case file
-            when /\(irb\)/ then from_irb_to_s
-            else from_file_to_s
-            end
-          end
-
-          def from_file_to_s
-            File.open(file, 'r') do |fh|
-              fh.extend(File::Tail).forward(line)
-              fh.readlines.join
-            end
-          end
-
-          def from_irb_to_s
-            # Really owe it to Florian Groß's solution @ http://rubyquiz.com/quiz38.html ...
-            # anyway, note that we use *line.succ* instead of *line* here.
-            IRB.CurrentContext.io.line(line.succ .. -1).join
-          end
-
-        end
-
     end
   end
 end

data/lib/sourcify/proc/parser/code_scanner.rb

@@ -0,0 +1,43 @@
+module Sourcify
+  module Proc
+    class Parser #:nodoc:all
+      class CodeScanner
+        class << self
+
+          def process(source_code, opts, &matcher)
+            results = rscan(source_code.to_s, {
+              :start_pattern => scan_pattern_hint(opts[:attached_to]),
+              :body_matcher => opts[:body_matcher],
+              :ignore_nested => opts[:ignore_nested],
+              :stop_on_newline => false,
+            }).flatten.select(&matcher)
+            case results.size
+            when 0 then raise NoMatchingProcError
+            when 1 then ("\n" * source_code.line) + results[0]
+            else raise MultipleMatchingProcsPerLineError
+            end
+          end
+
+          def scan_pattern_hint(val)
+            case val
+            when Regexp then val
+            when String, Symbol then /^(?:.*?\W|)#{val}(?:\W)/
+            when nil then /.*/
+            else raise TypeError
+            end
+          end
+
+          def rscan(str, opts)
+            results = Scanner.process(str, opts) || []
+            return results if opts[:ignore_nested]
+            results.map do |outer|
+              inner = rscan(outer.sub(/^proc\s*(do|\{)/,''), opts.merge(:stop_on_newline => true))
+                [outer, inner]
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end

data/lib/sourcify/proc/parser/converter.rb

@@ -0,0 +1,29 @@
+module Sourcify
+  module Proc
+    class Parser #:nodoc:all
+      class Converter
+        class << self
+
+          RUBY_PARSER = RubyParser.new
+          RUBY_2_RUBY = Ruby2Ruby.new
+
+          def to_sexp(code, file = nil)
+            retried = false
+            begin
+              RUBY_PARSER.reset
+              (retried ? RubyParser.new : RUBY_PARSER).parse(*[code, file].compact)
+            rescue Racc::ParseError, SyntaxError
+              return nil if retried
+              retried = true; retry
+            end
+          end
+
+          def to_code(sexp)
+            RUBY_2_RUBY.process(Sexp.from_array(sexp.to_a))
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/sourcify/proc/parser/normalizer.rb

@@ -0,0 +1,43 @@
+module Sourcify
+  module Proc
+    class Parser #:nodoc:all
+      class Normalizer
+        class << self
+
+          def process(sexp, binding)
+            @binding = binding
+            Sexp.from_array(fix_no_arg_method_calls(sexp.to_a))
+          end
+
+          def fix_no_arg_method_calls(array)
+            return array if [:class, :sclass, :defn, :module].include?(array[0])
+            array.map do |e|
+              if e.is_a?(Array)
+                no_arg_method_call?(e) or fix_no_arg_method_calls(e)
+              else
+                e
+              end
+            end
+          end
+
+          def no_arg_method_call?(e)
+            if like_no_arg_method_call?(e)
+              bounded_var?(var = e[2]) ? [:lvar, var] : e
+            end
+          end
+
+          def like_no_arg_method_call?(e)
+            e.size == 4 && e[0..1] == [:call, nil] &&
+              e[3] == [:arglist] && (var = e[2]).is_a?(Symbol)
+          end
+
+          def bounded_var?(var)
+            qvar = (@q ||= (IS_19x ? ":%s" : "'%s'")) % var
+            @binding.eval("local_variables.include?(#{qvar})")
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/sourcify/proc/parser/source_code.rb

@@ -0,0 +1,33 @@
+module Sourcify
+  module Proc
+    class Parser #:nodoc:all
+      class SourceCode < Struct.new(:file, :line)
+
+        def line
+          super.pred
+        end
+
+        def to_s
+          case file
+          when /\(irb\)/ then from_irb_to_s
+          else from_file_to_s
+          end
+        end
+
+        def from_file_to_s
+          File.open(file, 'r') do |fh|
+            fh.extend(File::Tail).forward(line)
+            fh.readlines.join
+          end
+        end
+
+        def from_irb_to_s
+          # Really owe it to Florian Groß's solution @ http://rubyquiz.com/quiz38.html ...
+          # anyway, note that we use *line.succ* instead of *line* here.
+          IRB.CurrentContext.io.line(line.succ .. -1).join
+        end
+
+      end
+    end
+  end
+end

data/lib/sourcify/proc/scanner/dstring.rb

@@ -16,16 +16,7 @@ module Sourcify
         end
 
         def closed?
-          # NOTE: The only real error is SyntaxError, other errors are due
-          # to undefined variable or watever, which are perfectly ok when
-          # testing for validity of the string.
-          begin
-            instance_eval(safe_contents) if evaluable?
-          rescue SyntaxError
-            false
-          rescue Exception
-            true
-          end
+          evaluable? && parsable?
         end
 
         private
@@ -36,10 +27,20 @@ module Sourcify
             @contents[-1][-1].chr == end_tag
           end
 
+          def parsable?
+            begin
+              Parser::Converter.to_sexp <<-SOURCIFIED_HEREDOKIE.strip
+                #{safe_contents}
+              SOURCIFIED_HEREDOKIE
+            rescue Exception
+              true
+            end
+          end
+
           def safe_contents
             # NOTE: %x & ` strings are dangerous to eval cos they execute shell commands,
             # thus we convert them to normal strings 1st
-            @contents.join.gsub(/(%x)(\W|\_)/, '%Q\2').gsub(/.{0,2}(`)/) do |s|
+            to_s.gsub(/(%x)(\W|\_)/, '%Q\2').gsub(/.{0,2}(`)/) do |s|
               s =~ /^(%Q|%W|%r|%x|.?%|.?\\)/ ? s : s.sub(/`$/,'%Q`')
             end
           end

data/lib/sourcify/proc/scanner/extensions.rb

@@ -8,6 +8,7 @@ module Sourcify
       module Extensions
 
         class Escape < Exception; end
+        RUBY_PARSER = RubyParser.new
 
         def process(data, opts={})
           begin
@@ -32,9 +33,7 @@ module Sourcify
 
         def push_dstring(ts, te)
           data = data_frag(ts .. te.pred)
-          unless @dstring
-            @dstring = DString.new(data[%r{^("|`|/|%(?:Q|W|r|x|)(?:\W|_))},1])
-          end
+          @dstring ||= DString.new(data[%r{^("|`|/|%(?:Q|W|r|x|)(?:\W|_))},1])
           @dstring << data
           return true unless @dstring.closed?
           @tokens << [:dstring, @dstring.to_s]
@@ -104,6 +103,7 @@ module Sourcify
 
         def fix_counter_false_start(key)
           return unless this_counter(key).just_started?
+          return unless really_false_started?
           reset_attributes
           @tokens, @false_start_backup = @false_start_backup.dup, nil if @false_start_backup
         end
@@ -117,10 +117,12 @@ module Sourcify
         end
 
         def construct_result_code
+          code = <<-SOURCIFIED_HEREDOKIE.strip
+            proc #{codified_tokens}
+          SOURCIFIED_HEREDOKIE
+
           begin
-            code = 'proc ' + codified_tokens
-            eval(code) # TODO: any better way to check for completeness of proc code ??
-            if @body_matcher.call(code)
+            if safe_eval(code) && @body_matcher.call(code)
               @results << code
               raise Escape if @stop_on_newline or @lineno != 1
               reset_attributes
@@ -143,6 +145,13 @@ module Sourcify
           @rejecting_block = false
         end
 
+        def really_false_started?
+          safe_eval(<<-SOURCIFIED_HEREDOKIE.strip
+              #{codified_tokens} 1}
+            SOURCIFIED_HEREDOKIE
+          ) && true
+        end
+
         def offset_attributes
           @lineno = 1 # Fixing JRuby's lineno bug (see http://jira.codehaus.org/browse/JRUBY-5014)
           unless @tokens.empty?
@@ -152,6 +161,10 @@ module Sourcify
           end
         end
 
+        def safe_eval(string)
+          Parser::Converter.to_sexp(string)
+        end
+
       end
     end
   end

data/sourcify.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["NgTzeYang"]
-  s.date = %q{2011-01-29}
+  s.date = %q{2011-02-06}
   s.description = %q{}
   s.email = %q{ngty77@gmail.com}
   s.extra_rdoc_files = [
@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.files = [
     ".document",
     ".infinity_test",
+    ".rvmrc",
     "HISTORY.txt",
     "LICENSE",
     "README.rdoc",
@@ -31,6 +32,10 @@ Gem::Specification.new do |s|
     "lib/sourcify/proc/methods/to_sexp.rb",
     "lib/sourcify/proc/methods/to_source.rb",
     "lib/sourcify/proc/parser.rb",
+    "lib/sourcify/proc/parser/code_scanner.rb",
+    "lib/sourcify/proc/parser/converter.rb",
+    "lib/sourcify/proc/parser/normalizer.rb",
+    "lib/sourcify/proc/parser/source_code.rb",
     "lib/sourcify/proc/scanner.rb",
     "lib/sourcify/proc/scanner.rl",
     "lib/sourcify/proc/scanner/comment.rb",
@@ -162,15 +167,18 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<ruby2ruby>, [">= 1.2.5"])
       s.add_runtime_dependency(%q<sexp_processor>, [">= 3.0.5"])
+      s.add_runtime_dependency(%q<file-tail>, [">= 1.0.5"])
       s.add_development_dependency(%q<bacon>, [">= 0"])
     else
       s.add_dependency(%q<ruby2ruby>, [">= 1.2.5"])
       s.add_dependency(%q<sexp_processor>, [">= 3.0.5"])
+      s.add_dependency(%q<file-tail>, [">= 1.0.5"])
       s.add_dependency(%q<bacon>, [">= 0"])
     end
   else
     s.add_dependency(%q<ruby2ruby>, [">= 1.2.5"])
     s.add_dependency(%q<sexp_processor>, [">= 3.0.5"])
+    s.add_dependency(%q<file-tail>, [">= 1.0.5"])
     s.add_dependency(%q<bacon>, [">= 0"])
   end
 end

data/spec/proc/to_source_from_braced_block_w_nested_hash_spec.rb

@@ -26,6 +26,30 @@ describe "Proc#to_source from { ... } block (w nested hash)" do
     \)
   end
 
+  should 'handle method w only hash args' do
+    (
+      lambda {
+        test :a => 2
+      }
+    ).should.be having_source(%Q\
+      proc do
+        test(:a => 2)
+      end
+    \)
+  end
+
+  should 'handle method w mixed args' do
+    (
+      lambda {
+        test 1, :a => 2
+      }
+    ).should.be having_source(%Q\
+      proc do
+        test(1, :a => 2)
+      end
+    \)
+  end
+
   if RUBY_VERSION.include?('1.9.')
     require File.join(File.expand_path(File.dirname(__FILE__)), '19x_extras')
     behaves_like 'Proc#to_source from { ... } block (1.9.*)'

data/spec/proc/to_source_from_multi_blocks_w_specified_attached_to_spec.rb

@@ -66,14 +66,15 @@ describe 'Proc#to_source w specified {:attached_to => ...}' do
     describe '>> w false start as a result of preceding hash' do
 
       option = {:attached_to => :watever}
+      aa = :aa
 
       should 'handle for do ... end block' do
-        x = watever({:aa => 1, :bb => 3}) do :blah end
+        x = watever({aa => 1, :bb => 3}) do :blah end
         x.should.be having_source('proc { :blah }', option)
       end
 
       should 'handle for { ... } block' do
-        x = watever({:aa => 1, :bb => 3}) { :blah }
+        x = watever({aa => 1, :bb => 3}) { :blah }
         x.should.be having_source('proc { :blah }', option)
       end
 

data/spec/spec_helper.rb

@@ -5,22 +5,6 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'sourcify'
 
-# ///////////////////////////////////////////////////////////
-# Regenerate ragel-based scanner
-# ///////////////////////////////////////////////////////////
-
-ragel_dir = File.join(File.dirname(__FILE__), '..', 'lib', 'sourcify', 'proc')
-ragel_file = File.join(ragel_dir, 'scanner.rl')
-ruby_file = File.join(ragel_dir, 'scanner.rb')
-File.delete(ruby_file) rescue nil
-system("ragel -R #{ragel_file}")
-
-begin
-  require File.join(ragel_dir, 'scanner.rb')
-rescue LoadError
-  raise $!
-end
-
 # ///////////////////////////////////////////////////////////
 # Bacon
 # ///////////////////////////////////////////////////////////
@@ -75,11 +59,9 @@ end
 
 def having_source(expected, opts={}, &matcher)
   lambda do |_proc|
-    if block_given?
-      normalize_code(_proc.to_source(&matcher)) == normalize_code(expected)
-    else
-      normalize_code(_proc.to_source(opts)) == normalize_code(expected)
-    end
+    normalize_code(expected) # added for bug fixing
+    normalize_code(block_given? ? _proc.to_source(&matcher) : _proc.to_source(opts)) \
+      == normalize_code(expected)
   end
 end
 
@@ -117,3 +99,20 @@ def irb_exec(stdin_str)
   (values[-1].nil? && RUBY_VERSION.include?('1.9.2')) ? values[0 .. -2] : values
 end
 
+# ///////////////////////////////////////////////////////////
+# Regenerate ragel-based scanner
+# ///////////////////////////////////////////////////////////
+
+unless has_parsetree?
+  ragel_dir = File.join(File.dirname(__FILE__), '..', 'lib', 'sourcify', 'proc')
+  ragel_file = File.join(ragel_dir, 'scanner.rl')
+  ruby_file = File.join(ragel_dir, 'scanner.rb')
+  File.delete(ruby_file) rescue nil
+  system("ragel -R #{ragel_file}")
+
+  begin
+    require File.join(ragel_dir, 'scanner.rb')
+  rescue LoadError
+    raise $!
+  end
+end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: sourcify
 version: !ruby/object:Gem::Version 
-  hash: 13
   prerelease: false
   segments: 
   - 0
   - 4
-  - 1
-  version: 0.4.1
+  - 2
+  version: 0.4.2
 platform: ruby
 authors: 
 - NgTzeYang
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-30 00:00:00 +08:00
+date: 2011-02-06 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,7 +25,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 21
         segments: 
         - 1
         - 2
@@ -42,7 +40,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 13
         segments: 
         - 3
         - 0
@@ -58,7 +55,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 29
         segments: 
         - 1
         - 0
@@ -74,7 +70,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
@@ -105,6 +100,10 @@ files:
 - lib/sourcify/proc/methods/to_sexp.rb
 - lib/sourcify/proc/methods/to_source.rb
 - lib/sourcify/proc/parser.rb
+- lib/sourcify/proc/parser/code_scanner.rb
+- lib/sourcify/proc/parser/converter.rb
+- lib/sourcify/proc/parser/normalizer.rb
+- lib/sourcify/proc/parser/source_code.rb
 - lib/sourcify/proc/scanner.rb
 - lib/sourcify/proc/scanner.rl
 - lib/sourcify/proc/scanner/comment.rb
@@ -181,7 +180,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 59
       segments: 
       - 1
       - 8
@@ -192,7 +190,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"