method_source-0.8.2/0000755000004100000410000000000012200466657014421 5ustar www-datawww-datamethod_source-0.8.2/.travis.yml0000644000004100000410000000024612200466657016534 0ustar www-datawww-datarvm: - 1.8.7 - 1.9.2 - 1.9.3 - ree - rbx-18mode - rbx-19mode - jruby notifications: irc: "irc.freenode.org#pry" recipients: - jrmair@gmail.com method_source-0.8.2/test/0000755000004100000410000000000012200466657015400 5ustar www-datawww-datamethod_source-0.8.2/test/test_code_helpers.rb0000644000004100000410000000251712200466657021425 0ustar www-datawww-datadescribe MethodSource::CodeHelpers do before do @tester = Object.new.extend(MethodSource::CodeHelpers) end [ ["p = '", "'"], ["def", "a", "(); end"], ["p = <= 0") if s.respond_to? :required_rubygems_version= s.authors = ["John Mair (banisterfiend)"] s.date = "2012-10-17" s.description = "retrieve the sourcecode for a method" s.email = "jrmair@gmail.com" s.files = [".gemtest", ".travis.yml", ".yardopts", "Gemfile", "LICENSE", "README.markdown", "Rakefile", "lib/method_source.rb", "lib/method_source/code_helpers.rb", "lib/method_source/source_location.rb", "lib/method_source/version.rb", "method_source.gemspec", "test/test.rb", "test/test_code_helpers.rb", "test/test_helper.rb"] s.homepage = "http://banisterfiend.wordpress.com" s.require_paths = ["lib"] s.rubygems_version = "1.8.23" s.summary = "retrieve the sourcecode for a method" s.test_files = ["test/test.rb", "test/test_code_helpers.rb", "test/test_helper.rb"] if s.respond_to? :specification_version then s.specification_version = 3 if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then s.add_development_dependency(%q, ["~> 1.1.0"]) s.add_development_dependency(%q, ["~> 0.9"]) else s.add_dependency(%q, ["~> 1.1.0"]) s.add_dependency(%q, ["~> 0.9"]) end else s.add_dependency(%q, ["~> 1.1.0"]) s.add_dependency(%q, ["~> 0.9"]) end end method_source-0.8.2/LICENSE0000644000004100000410000000212212200466657015423 0ustar www-datawww-dataLicense ------- (The MIT License) Copyright (c) 2011 John Mair (banisterfiend) 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. method_source-0.8.2/Rakefile0000644000004100000410000000407412200466657016073 0ustar www-datawww-datadlext = RbConfig::CONFIG['DLEXT'] direc = File.dirname(__FILE__) require 'rake/clean' require 'rubygems/package_task' require "#{direc}/lib/method_source/version" CLOBBER.include("**/*.#{dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o") CLEAN.include("ext/**/*.#{dlext}", "ext/**/*.log", "ext/**/*.o", "ext/**/*~", "ext/**/*#*", "ext/**/*.obj", "**/*.rbc", "ext/**/*.def", "ext/**/*.pdb", "**/*_flymake*.*", "**/*_flymake") def apply_spec_defaults(s) s.name = "method_source" s.summary = "retrieve the sourcecode for a method" s.version = MethodSource::VERSION s.date = Time.now.strftime '%Y-%m-%d' s.author = "John Mair (banisterfiend)" s.email = 'jrmair@gmail.com' s.description = s.summary s.require_path = 'lib' s.add_development_dependency("bacon","~>1.1.0") s.add_development_dependency("rake", "~>0.9") s.homepage = "http://banisterfiend.wordpress.com" s.has_rdoc = 'yard' s.files = `git ls-files`.split("\n") s.test_files = `git ls-files -- test/*`.split("\n") end task :test do sh "bacon -q #{direc}/test/test.rb #{direc}/test/test_code_helpers.rb" end desc "reinstall gem" task :reinstall => :gems do sh "gem uninstall method_source" rescue nil sh "gem install #{direc}/pkg/method_source-#{MethodSource::VERSION}.gem" end desc "Set up and run tests" task :default => [:test] desc "Build the gemspec file" task :gemspec => "ruby:gemspec" namespace :ruby do spec = Gem::Specification.new do |s| apply_spec_defaults(s) s.platform = Gem::Platform::RUBY end Gem::PackageTask.new(spec) do |pkg| pkg.need_zip = false pkg.need_tar = false end desc "Generate gemspec file" task :gemspec do File.open("#{spec.name}.gemspec", "w") do |f| f << spec.to_ruby end end end desc "build all platform gems at once" task :gems => [:rmgems, "ruby:gem"] desc "remove all platform gems" task :rmgems => ["ruby:clobber_package"] desc "build and push latest gems" task :pushgems => :gems do chdir("#{direc}/pkg") do Dir["*.gem"].each do |gemfile| sh "gem push #{gemfile}" end end end method_source-0.8.2/.gemtest0000644000004100000410000000000012200466657016060 0ustar www-datawww-datamethod_source-0.8.2/README.markdown0000644000004100000410000000565112200466657017131 0ustar www-datawww-datamethod_source ============= (C) John Mair (banisterfiend) 2011 _retrieve the sourcecode for a method_ *NOTE:* This simply utilizes `Method#source_location`; it does not access the live AST. `method_source` is a utility to return a method's sourcecode as a Ruby string. Also returns `Proc` and `Lambda` sourcecode. Method comments can also be extracted using the `comment` method. It is written in pure Ruby (no C). * Some Ruby 1.8 support now available. * Support for MRI, RBX, JRuby, REE `method_source` provides the `source` and `comment` methods to the `Method` and `UnboundMethod` and `Proc` classes. * Install the [gem](https://rubygems.org/gems/method_source): `gem install method_source` * Read the [documentation](http://rdoc.info/github/banister/method_source/master/file/README.markdown) * See the [source code](http://github.com/banister/method_source) Example: display method source ------------------------------ Set.instance_method(:merge).source.display # => def merge(enum) if enum.instance_of?(self.class) @hash.update(enum.instance_variable_get(:@hash)) else do_with_enum(enum) { |o| add(o) } end self end Example: display method comments -------------------------------- Set.instance_method(:merge).comment.display # => # Merges the elements of the given enumerable object to the set and # returns self. Limitations: ------------ * Occasional strange behaviour in Ruby 1.8 * Cannot return source for C methods. * Cannot return source for dynamically defined methods. Special Thanks -------------- [Adam Sanderson](https://github.com/adamsanderson) for `comment` functionality. [Dmitry Elastic](https://github.com/dmitryelastic) for the brilliant Ruby 1.8 `source_location` hack. [Samuel Kadolph](https://github.com/samuelkadolph) for the JRuby 1.8 `source_location`. License ------- (The MIT License) Copyright (c) 2011 John Mair (banisterfiend) 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. method_source-0.8.2/checksums.yaml.gz0000444000004100000410000000041412200466657017706 0ustar www-datawww-dataVQeU0 L“g+=HDEK0vzo:HVB`W*^(=XpO_O.0,IQL^DHʮ2߮.F: YV!J g+q2XP"sݶ# jf [:u2ż꩎*8XrSrQT2`_ gI[f #w`f)9hC:((j hKM1method_source-0.8.2/metadata.yml0000644000004100000410000000375012200466657016731 0ustar www-datawww-data--- !ruby/object:Gem::Specification name: method_source version: !ruby/object:Gem::Version version: 0.8.2 platform: ruby authors: - John Mair (banisterfiend) autorequire: bindir: bin cert_chain: [] date: 2013-07-27 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency name: bacon requirement: !ruby/object:Gem::Requirement requirements: - - ~> - !ruby/object:Gem::Version version: 1.1.0 type: :development prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ~> - !ruby/object:Gem::Version version: 1.1.0 - !ruby/object:Gem::Dependency name: rake requirement: !ruby/object:Gem::Requirement requirements: - - ~> - !ruby/object:Gem::Version version: '0.9' type: :development prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ~> - !ruby/object:Gem::Version version: '0.9' description: retrieve the sourcecode for a method email: jrmair@gmail.com executables: [] extensions: [] extra_rdoc_files: [] files: - .gemtest - .travis.yml - .yardopts - Gemfile - LICENSE - README.markdown - Rakefile - lib/method_source.rb - lib/method_source/code_helpers.rb - lib/method_source/source_location.rb - lib/method_source/version.rb - method_source.gemspec - test/test.rb - test/test_code_helpers.rb - test/test_helper.rb homepage: http://banisterfiend.wordpress.com licenses: [] metadata: {} post_install_message: rdoc_options: [] require_paths: - lib required_ruby_version: !ruby/object:Gem::Requirement requirements: - - '>=' - !ruby/object:Gem::Version version: '0' required_rubygems_version: !ruby/object:Gem::Requirement requirements: - - '>=' - !ruby/object:Gem::Version version: '0' requirements: [] rubyforge_project: rubygems_version: 2.0.2 signing_key: specification_version: 4 summary: retrieve the sourcecode for a method test_files: - test/test.rb - test/test_code_helpers.rb - test/test_helper.rb method_source-0.8.2/.yardopts0000644000004100000410000000001512200466657016263 0ustar www-datawww-data-m markdown method_source-0.8.2/Gemfile0000644000004100000410000000003112200466657015706 0ustar www-datawww-datasource :rubygems gemspec method_source-0.8.2/lib/0000755000004100000410000000000012200466657015167 5ustar www-datawww-datamethod_source-0.8.2/lib/method_source/0000755000004100000410000000000012200466657020027 5ustar www-datawww-datamethod_source-0.8.2/lib/method_source/version.rb0000644000004100000410000000005412200466657022040 0ustar www-datawww-datamodule MethodSource VERSION = "0.8.2" end method_source-0.8.2/lib/method_source/source_location.rb0000644000004100000410000001052512200466657023547 0ustar www-datawww-datamodule MethodSource module ReeSourceLocation # Ruby enterprise edition provides all the information that's # needed, in a slightly different way. def source_location [__file__, __line__] rescue nil end end module SourceLocation module MethodExtensions if Proc.method_defined? :__file__ include ReeSourceLocation elsif defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/ require 'java' # JRuby version source_location hack # @return [Array] A two element array containing the source location of the method def source_location to_java.source_location(Thread.current.to_java.getContext()) end else def trace_func(event, file, line, id, binding, classname) return unless event == 'call' set_trace_func nil @file, @line = file, line raise :found end private :trace_func # Return the source location of a method for Ruby 1.8. # @return [Array] A two element array. First element is the # file, second element is the line in the file where the # method definition is found. def source_location if @file.nil? args =[*(1..(arity<-1 ? -arity-1 : arity ))] set_trace_func method(:trace_func).to_proc call(*args) rescue nil set_trace_func nil @file = File.expand_path(@file) if @file && File.exist?(File.expand_path(@file)) end [@file, @line] if @file end end end module ProcExtensions if Proc.method_defined? :__file__ include ReeSourceLocation elsif defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/ # Return the source location for a Proc (Rubinius only) # @return [Array] A two element array. First element is the # file, second element is the line in the file where the # proc definition is found. def source_location [block.file.to_s, block.line] end else # Return the source location for a Proc (in implementations # without Proc#source_location) # @return [Array] A two element array. First element is the # file, second element is the line in the file where the # proc definition is found. def source_location self.to_s =~ /@(.*):(\d+)/ [$1, $2.to_i] end end end module UnboundMethodExtensions if Proc.method_defined? :__file__ include ReeSourceLocation elsif defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/ require 'java' # JRuby version source_location hack # @return [Array] A two element array containing the source location of the method def source_location to_java.source_location(Thread.current.to_java.getContext()) end else # Return the source location of an instance method for Ruby 1.8. # @return [Array] A two element array. First element is the # file, second element is the line in the file where the # method definition is found. def source_location klass = case owner when Class owner when Module method_owner = owner Class.new { include(method_owner) } end # deal with immediate values case when klass == Symbol return :a.method(name).source_location when klass == Fixnum return 0.method(name).source_location when klass == TrueClass return true.method(name).source_location when klass == FalseClass return false.method(name).source_location when klass == NilClass return nil.method(name).source_location end begin Object.instance_method(:method).bind(klass.allocate).call(name).source_location rescue TypeError # Assume we are dealing with a Singleton Class: # 1. Get the instance object # 2. Forward the source_location lookup to the instance instance ||= ObjectSpace.each_object(owner).first Object.instance_method(:method).bind(instance).call(name).source_location end end end end end end method_source-0.8.2/lib/method_source/code_helpers.rb0000644000004100000410000001232412200466657023012 0ustar www-datawww-datamodule MethodSource module CodeHelpers # Retrieve the first expression starting on the given line of the given file. # # This is useful to get module or method source code. # # @param [Array, File, String] file The file to parse, either as a File or as # @param [Fixnum] line_number The line number at which to look. # NOTE: The first line in a file is # line 1! # @param [Hash] options The optional configuration parameters. # @option options [Boolean] :strict If set to true, then only completely # valid expressions are returned. Otherwise heuristics are used to extract # expressions that may have been valid inside an eval. # @option options [Fixnum] :consume A number of lines to automatically # consume (add to the expression buffer) without checking for validity. # @return [String] The first complete expression # @raise [SyntaxError] If the first complete expression can't be identified def expression_at(file, line_number, options={}) options = { :strict => false, :consume => 0 }.merge!(options) lines = file.is_a?(Array) ? file : file.each_line.to_a relevant_lines = lines[(line_number - 1)..-1] || [] extract_first_expression(relevant_lines, options[:consume]) rescue SyntaxError => e raise if options[:strict] begin extract_first_expression(relevant_lines) do |code| code.gsub(/\#\{.*?\}/, "temp") end rescue SyntaxError raise e end end # Retrieve the comment describing the expression on the given line of the given file. # # This is useful to get module or method documentation. # # @param [Array, File, String] file The file to parse, either as a File or as # a String or an Array of lines. # @param [Fixnum] line_number The line number at which to look. # NOTE: The first line in a file is line 1! # @return [String] The comment def comment_describing(file, line_number) lines = file.is_a?(Array) ? file : file.each_line.to_a extract_last_comment(lines[0..(line_number - 2)]) end # Determine if a string of code is a complete Ruby expression. # @param [String] code The code to validate. # @return [Boolean] Whether or not the code is a complete Ruby expression. # @raise [SyntaxError] Any SyntaxError that does not represent incompleteness. # @example # complete_expression?("class Hello") #=> false # complete_expression?("class Hello; end") #=> true # complete_expression?("class 123") #=> SyntaxError: unexpected tINTEGER def complete_expression?(str) old_verbose = $VERBOSE $VERBOSE = nil catch(:valid) do eval("BEGIN{throw :valid}\n#{str}") end # Assert that a line which ends with a , or \ is incomplete. str !~ /[,\\]\s*\z/ rescue IncompleteExpression false ensure $VERBOSE = old_verbose end private # Get the first expression from the input. # # @param [Array] lines # @param [Fixnum] consume A number of lines to automatically # consume (add to the expression buffer) without checking for validity. # @yield a clean-up function to run before checking for complete_expression # @return [String] a valid ruby expression # @raise [SyntaxError] def extract_first_expression(lines, consume=0, &block) code = consume.zero? ? "" : lines.slice!(0..(consume - 1)).join lines.each do |v| code << v return code if complete_expression?(block ? block.call(code) : code) end raise SyntaxError, "unexpected $end" end # Get the last comment from the input. # # @param [Array] lines # @return [String] def extract_last_comment(lines) buffer = "" lines.each do |line| # Add any line that is a valid ruby comment, # but clear as soon as we hit a non comment line. if (line =~ /^\s*#/) || (line =~ /^\s*$/) buffer << line.lstrip else buffer.replace("") end end buffer end # An exception matcher that matches only subsets of SyntaxErrors that can be # fixed by adding more input to the buffer. module IncompleteExpression GENERIC_REGEXPS = [ /unexpected (\$end|end-of-file|end-of-input|END_OF_FILE)/, # mri, jruby, ruby-2.0, ironruby /embedded document meets end of file/, # =begin /unterminated (quoted string|string|regexp) meets end of file/, # "quoted string" is ironruby /can't find string ".*" anywhere before EOF/, # rbx and jruby /missing 'end' for/, /expecting kWHEN/ # rbx ] RBX_ONLY_REGEXPS = [ /expecting '[})\]]'(?:$|:)/, /expecting keyword_end/ ] def self.===(ex) return false unless SyntaxError === ex case ex.message when *GENERIC_REGEXPS true when *RBX_ONLY_REGEXPS rbx? else false end end def self.rbx? RbConfig::CONFIG['ruby_install_name'] == 'rbx' end end end end method_source-0.8.2/lib/method_source.rb0000644000004100000410000001047512200466657020363 0ustar www-datawww-data# (C) John Mair (banisterfiend) 2011 # MIT License direc = File.dirname(__FILE__) require "#{direc}/method_source/version" require "#{direc}/method_source/source_location" require "#{direc}/method_source/code_helpers" module MethodSource extend MethodSource::CodeHelpers # An Exception to mark errors that were raised trying to find the source from # a given source_location. # class SourceNotFoundError < StandardError; end # Helper method responsible for extracting method body. # Defined here to avoid polluting `Method` class. # @param [Array] source_location The array returned by Method#source_location # @param [String] method_name # @return [String] The method body def self.source_helper(source_location, name=nil) raise SourceNotFoundError, "Could not locate source for #{name}!" unless source_location file, line = *source_location expression_at(lines_for(file), line) rescue SyntaxError => e raise SourceNotFoundError, "Could not parse source for #{name}: #{e.message}" end # Helper method responsible for opening source file and buffering up # the comments for a specified method. Defined here to avoid polluting # `Method` class. # @param [Array] source_location The array returned by Method#source_location # @param [String] method_name # @return [String] The comments up to the point of the method. def self.comment_helper(source_location, name=nil) raise SourceNotFoundError, "Could not locate source for #{name}!" unless source_location file, line = *source_location comment_describing(lines_for(file), line) end # Load a memoized copy of the lines in a file. # # @param [String] file_name # @param [String] method_name # @return [Array] the contents of the file # @raise [SourceNotFoundError] def self.lines_for(file_name, name=nil) @lines_for_file ||= {} @lines_for_file[file_name] ||= File.readlines(file_name) rescue Errno::ENOENT => e raise SourceNotFoundError, "Could not load source for #{name}: #{e.message}" end # @deprecated — use MethodSource::CodeHelpers#complete_expression? def self.valid_expression?(str) complete_expression?(str) rescue SyntaxError false end # @deprecated — use MethodSource::CodeHelpers#expression_at def self.extract_code(source_location) source_helper(source_location) end # This module is to be included by `Method` and `UnboundMethod` and # provides the `#source` functionality module MethodExtensions # We use the included hook to patch Method#source on rubinius. # We need to use the included hook as Rubinius defines a `source` # on Method so including a module will have no effect (as it's # higher up the MRO). # @param [Class] klass The class that includes the module. def self.included(klass) if klass.method_defined?(:source) && Object.const_defined?(:RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/ klass.class_eval do orig_source = instance_method(:source) define_method(:source) do begin super rescue orig_source.bind(self).call end end end end end # Return the sourcecode for the method as a string # @return [String] The method sourcecode as a string # @raise SourceNotFoundException # # @example # Set.instance_method(:clear).source.display # => # def clear # @hash.clear # self # end def source MethodSource.source_helper(source_location, defined?(name) ? name : inspect) end # Return the comments associated with the method as a string. # @return [String] The method's comments as a string # @raise SourceNotFoundException # # @example # Set.instance_method(:clear).comment.display # => # # Removes all elements and returns self. def comment MethodSource.comment_helper(source_location, defined?(name) ? name : inspect) end end end class Method include MethodSource::SourceLocation::MethodExtensions include MethodSource::MethodExtensions end class UnboundMethod include MethodSource::SourceLocation::UnboundMethodExtensions include MethodSource::MethodExtensions end class Proc include MethodSource::SourceLocation::ProcExtensions include MethodSource::MethodExtensions end