pax_global_header00006660000000000000000000000064146072335200014514gustar00rootroot0000000000000052 comment=eef98af83806572d503c8bc624de0efdc0dffc28 method_source-1.1.0/000077500000000000000000000000001460723352000143535ustar00rootroot00000000000000method_source-1.1.0/.gemtest000066400000000000000000000000001460723352000160120ustar00rootroot00000000000000method_source-1.1.0/.github/000077500000000000000000000000001460723352000157135ustar00rootroot00000000000000method_source-1.1.0/.github/workflows/000077500000000000000000000000001460723352000177505ustar00rootroot00000000000000method_source-1.1.0/.github/workflows/main.yml000066400000000000000000000011401460723352000214130ustar00rootroot00000000000000name: Ruby on: ['push'] jobs: build: runs-on: ubuntu-latest name: Ruby ${{ matrix.ruby }} strategy: matrix: ruby: ['2.7', '3.0', '3.1', '3.2', '3.3', 'head'] rubyopt: [''] include: - ruby: '3.3' rubyopt: "--enable-frozen-string-literal --debug-frozen-string-literal" steps: - uses: actions/checkout@v4 - name: Set up Ruby uses: ruby/setup-ruby@v1 with: ruby-version: ${{ matrix.ruby }} bundler-cache: true - name: Run the default task run: bundle exec rake RUBYOPT="${{ matrix.rubyopt }}" method_source-1.1.0/.gitignore000066400000000000000000000000161460723352000163400ustar00rootroot00000000000000Gemfile.lock method_source-1.1.0/.yardopts000066400000000000000000000000151460723352000162150ustar00rootroot00000000000000-m markdown method_source-1.1.0/CHANGELOG.md000066400000000000000000000006021460723352000161620ustar00rootroot00000000000000# method_source changelog ### master ### [v1.1.0][v1.1.0] (April 15, 2024) - Added `MethodSource.clear_cache` - Added support for `RUBYOPT="--enable-frozen-string-literal"` ### [v1.0.0][v1.0.0] (March 19, 2020) - Added Ruby 2.7 support [v1.0.0]: https://github.com/banister/method_source/releases/tag/v1.0.0 [v1.1.0]: https://github.com/banister/method_source/releases/tag/v1.1.0 method_source-1.1.0/Gemfile000066400000000000000000000000771460723352000156520ustar00rootroot00000000000000source 'https://rubygems.org' gemspec gem "rake" gem "rspec" method_source-1.1.0/LICENSE000066400000000000000000000020721460723352000153610ustar00rootroot00000000000000MIT 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-1.1.0/README.markdown000066400000000000000000000064671460723352000170710ustar00rootroot00000000000000method_source ============= [![Circle Build Status](https://circleci.com/gh/banister/method_source.svg?style=shield)](https://circleci.com/gh/banister/method_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](https://www.rubydoc.info/github/banister/method_source/master) * 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. Example: display module/class comments -------------------------------------- MethodSource::MethodExtensions.method(:included).module_comment # => # This module is to be included by `Method` and `UnboundMethod` and # provides the `#source` functionality 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-1.1.0/Rakefile000066400000000000000000000041251460723352000160220ustar00rootroot00000000000000dlext = 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.license = 'MIT' s.add_development_dependency("rspec","~>3.6") 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 -- spec/*`.split("\n") end require "rspec/core/rake_task" RSpec::Core::RakeTask.new(:spec) do |t| t.ruby_opts = %w[-w] 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 => [:spec] 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-1.1.0/lib/000077500000000000000000000000001460723352000151215ustar00rootroot00000000000000method_source-1.1.0/lib/method_source.rb000066400000000000000000000126331460723352000203130ustar00rootroot00000000000000# (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 # Clear cache. def self.clear_cache @lines_for_file = {} 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 # Return the comments associated with the method class/module. # @return [String] The method's comments as a string # @raise SourceNotFoundException # # @example # MethodSource::MethodExtensions.method(:included).module_comment # => # # This module is to be included by `Method` and `UnboundMethod` and # # provides the `#source` functionality def class_comment if self.respond_to?(:receiver) class_inst_or_module = self.receiver elsif self.respond_to?(:owner) class_inst_or_module = self.owner else return comment end if class_inst_or_module.respond_to?(:name) const_name = class_inst_or_module.name else const_name = class_inst_or_module.class.name class_inst_or_module = class_inst_or_module.class end location = class_inst_or_module.const_source_location(const_name) MethodSource.comment_helper(location, defined?(name) ? name : inspect) end alias module_comment class_comment 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 method_source-1.1.0/lib/method_source/000077500000000000000000000000001460723352000177615ustar00rootroot00000000000000method_source-1.1.0/lib/method_source/code_helpers.rb000066400000000000000000000123311460723352000227420ustar00rootroot00000000000000module 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 [Integer] 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 [Integer] :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 [Integer] 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 [Integer] 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.clear 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|list) 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-1.1.0/lib/method_source/source_location.rb000066400000000000000000000105261460723352000235020ustar00rootroot00000000000000module 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 == Integer 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-1.1.0/lib/method_source/version.rb000066400000000000000000000000631460723352000217720ustar00rootroot00000000000000module MethodSource VERSION = '1.1.0'.freeze end method_source-1.1.0/method_source.gemspec000066400000000000000000000024251460723352000205630ustar00rootroot00000000000000# -*- encoding: utf-8 -*- Gem::Specification.new do |s| s.name = "method_source".freeze s.version = "1.1.0" s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version= s.require_paths = ["lib".freeze] s.authors = ["John Mair (banisterfiend)".freeze] s.date = "2024-04-15" s.description = "retrieve the sourcecode for a method".freeze s.email = "jrmair@gmail.com".freeze s.files = ["CHANGELOG.md".freeze, ".gemtest".freeze, ".yardopts".freeze, "Gemfile".freeze, "LICENSE".freeze, "README.markdown".freeze, "Rakefile".freeze, "lib/method_source.rb".freeze, "lib/method_source/code_helpers.rb".freeze, "lib/method_source/source_location.rb".freeze, "lib/method_source/version.rb".freeze, "method_source.gemspec".freeze, "spec/method_source/code_helpers_spec.rb".freeze, "spec/method_source_spec.rb".freeze, "spec/spec_helper.rb".freeze] s.homepage = "http://banisterfiend.wordpress.com".freeze s.metadata["changelog_uri"] = "https://github.com/banister/method_source/blob/master/CHANGELOG.md".freeze s.licenses = ["MIT".freeze] s.summary = "retrieve the sourcecode for a method".freeze s.test_files = ["spec/method_source/code_helpers_spec.rb".freeze, "spec/method_source_spec.rb".freeze, "spec/spec_helper.rb".freeze] end method_source-1.1.0/spec/000077500000000000000000000000001460723352000153055ustar00rootroot00000000000000method_source-1.1.0/spec/method_source/000077500000000000000000000000001460723352000201455ustar00rootroot00000000000000method_source-1.1.0/spec/method_source/code_helpers_spec.rb000066400000000000000000000025631460723352000241460ustar00rootroot00000000000000require 'spec_helper' describe MethodSource::CodeHelpers do before do @tester = Object.new.extend(MethodSource::CodeHelpers) end [ ["p = '", "'"], ["def", "a", "(); end"], ["p = <