hyper-max-tool 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e2f7d03f112146f6a7ff0096c0b9844017a36a63de34050f9b6451d355d16a12
+  data.tar.gz: 3caeecd27bfd870481165e89b8d44942097969f32c436310a6169bd95c39737f
+SHA512:
+  metadata.gz: 4c81857f24db5b14528f883671853359dcceaacf5546c928d4760e208cc7c7183dc2ab79573c3ba6eb5523ed50c3d828596a968ba117200fcc7a7dd0ae9dabb4
+  data.tar.gz: 1b81c786899bd05e7e628a9fbc1ab78a64c2e941c2dd32119882f3f9b3facb7d5f0748397af145eb09978196932962c5d5e63a50d25d5811b73d88cfa2f82add

data/hyper-max-tool.gemspec

@@ -0,0 +1,11 @@
+Gem::Specification.new do |s|
+  s.name        = "hyper-max-tool"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on method_source"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+end

data/method_source-1.1.0/CHANGELOG.md

@@ -0,0 +1,15 @@
+# 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

data/method_source-1.1.0/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "rake"
+gem "rspec"

data/method_source-1.1.0/LICENSE

@@ -0,0 +1,22 @@
+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.

data/method_source-1.1.0/README.markdown

@@ -0,0 +1,101 @@
+method_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.

data/method_source-1.1.0/Rakefile

@@ -0,0 +1,81 @@
+dlext = 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

data/method_source-1.1.0/lib/method_source/code_helpers.rb

@@ -0,0 +1,154 @@
+module 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<String>, 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<String>, 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<String>]  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<String>]  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

data/method_source-1.1.0/lib/method_source/source_location.rb

@@ -0,0 +1,138 @@
+module 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

data/method_source-1.1.0/lib/method_source/version.rb

@@ -0,0 +1,3 @@
+module MethodSource
+  VERSION = '1.1.0'.freeze
+end

data/method_source-1.1.0/lib/method_source.rb

@@ -0,0 +1,177 @@
+# (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<String>]  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
+

data/method_source-1.1.0/method_source.gemspec

@@ -0,0 +1,19 @@
+# -*- 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

data/method_source-1.1.0/spec/method_source/code_helpers_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe MethodSource::CodeHelpers do
+  before do
+    @tester = Object.new.extend(MethodSource::CodeHelpers)
+  end
+
+  [
+    ["p = '", "'"],
+    ["def", "a", "(); end"],
+    ["p = <<FOO", "lots", "and", "lots of", "foo", "FOO"],
+    ["[", ":lets,", "'list',", "[/nested/", "], things ]"],
+    ["abc =~ /hello", "/"],
+    ["issue = %W/", "343/"],
+    ["pouts(<<HI, 'foo", "bar", "HI", "baz')"],
+    ["=begin", "no-one uses this syntax anymore...", "=end"],
+    ["puts 1, 2,", "3"],
+    ["puts 'hello'\\", "'world'"]
+  ].each do |lines|
+    it "should not raise an error on broken lines: #{lines.join("\\n")}" do
+      1.upto(lines.size - 1) do |i|
+        expect(@tester.complete_expression?(lines[0...i].join("\n") + "\n")).to be_falsy
+      end
+      expect(@tester.complete_expression?(lines.join("\n"))).to be_truthy
+    end
+  end
+
+  [
+    ["end"],
+    ["puts )("],
+    ["1 1"],
+    ["puts :"]
+  ] + (RbConfig::CONFIG['ruby_install_name'] == 'rbx' ? [] : [
+    ["def", "method(1"], # in this case the syntax error is "expecting ')'".
+    ["o = Object.new.tap{ def o.render;","'MEH'", "}"] # in this case the syntax error is "expecting keyword_end".
+  ]).compact.each do |foo|
+    it "should raise an error on invalid syntax like #{foo.inspect}" do
+      expect {
+        @tester.complete_expression?(foo.join("\n"))
+      }.to raise_error(SyntaxError)
+    end
+  end
+end

data/method_source-1.1.0/spec/method_source_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe MethodSource do
+
+  describe "source_location (testing 1.8 implementation)" do
+    it 'should return correct source_location for a method' do
+      expect(method(:hello).source_location.first).to match(/spec_helper/)
+    end
+
+    it 'should not raise for immediate instance methods' do
+      [Symbol, Integer, TrueClass, FalseClass, NilClass].each do |immediate_class|
+        expect do
+          immediate_class.instance_method(:to_s).source_location
+        end.not_to raise_error
+      end
+    end
+
+    it 'should not raise for immediate methods' do
+      [:a, 1, true, false, nil].each do |immediate|
+        expect do
+          immediate.method(:to_s).source_location
+        end.not_to raise_error
+      end
+    end
+  end
+
+  before do
+    @hello_module_source = "  def hello; :hello_module; end\n"
+    @hello_singleton_source = "def $o.hello; :hello_singleton; end\n"
+    @hello_source = "def hello; :hello; end\n"
+    @hello_comment = "# A comment for hello\n# It spans two lines and is indented by 2 spaces\n"
+    @lambda_comment = "# This is a comment for MyLambda\n"
+    @module_comment = "# This is a comment for module\n"
+    @class_comment = "# This is a comment for class\n"
+    @lambda_source = "MyLambda = lambda { :lambda }\n"
+    @proc_source = "MyProc = Proc.new { :proc }\n"
+    @hello_instance_evaled_source = "  def hello_\#{name}(*args)\n    send_mesg(:\#{name}, *args)\n  end\n"
+    @hello_instance_evaled_source_2 = "  def \#{name}_two()\n    if 40 + 4\n      45\n    end\n  end\n"
+    @hello_class_evaled_source = "  def hello_\#{name}(*args)\n    send_mesg(:\#{name}, *args)\n  end\n"
+    @hi_module_evaled_source = "  def hi_\#{name}\n    @var = \#{name}\n  end\n"
+  end
+
+  it 'should define methods on Method and UnboundMethod and Proc' do
+    expect(Method.method_defined?(:source)).to be_truthy
+    expect(UnboundMethod.method_defined?(:source)).to be_truthy
+    expect(Proc.method_defined?(:source)).to be_truthy
+  end
+
+  describe "Methods" do
+    it 'should return source for method' do
+      expect(method(:hello).source).to eq(@hello_source)
+    end
+
+    it 'should return source for a method defined in a module' do
+      expect(M.instance_method(:hello).source).to eq(@hello_module_source)
+    end
+
+    it 'should return source for a singleton method as an instance method' do
+      expect(class << $o
+        self
+      end.instance_method(:hello).source).to eq(@hello_singleton_source)
+    end
+
+    it 'should return source for a singleton method' do
+      expect($o.method(:hello).source).to eq(@hello_singleton_source)
+    end
+
+    it 'should return a comment for method' do
+      expect(method(:hello).comment).to eq(@hello_comment)
+    end
+
+    # These tests fail because of http://jira.codehaus.org/browse/JRUBY-4576
+    unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+      it 'should return source for an *_evaled method' do
+        expect(M.method(:hello_name).source).to eq(@hello_instance_evaled_source)
+        expect(M.method(:name_two).source).to eq(@hello_instance_evaled_source_2)
+        expect(M.instance_method(:hello_name).source).to eq(@hello_class_evaled_source)
+        expect(M.instance_method(:hi_name).source).to eq(@hi_module_evaled_source)
+      end
+    end
+
+    it "should raise error for evaled methods that do not pass __FILE__ and __LINE__ + 1 as its arguments" do
+      expect do
+        M.instance_method(:name_three).source
+      end.to raise_error(MethodSource::SourceNotFoundError)
+    end
+
+    if !is_rbx?
+      it 'should raise for C methods' do
+        expect do
+          method(:puts).source
+        end.to raise_error(MethodSource::SourceNotFoundError)
+      end
+    end
+  end
+
+  # if RUBY_VERSION =~ /1.9/ || is_rbx?
+  describe "Lambdas and Procs" do
+    it 'should return source for proc' do
+      expect(MyProc.source).to eq(@proc_source)
+    end
+
+    it 'should return an empty string if there is no comment' do
+      expect(MyProc.comment).to eq('')
+    end
+
+    it 'should return source for lambda' do
+      expect(MyLambda.source).to eq(@lambda_source)
+    end
+
+    it 'should return comment for lambda' do
+      expect(MyLambda.comment).to eq(@lambda_comment)
+    end
+
+    it 'should return comment for module' do
+      expect(M.instance_method(:hello).module_comment).to eq(@module_comment)
+    end
+
+    it 'should return comment for class' do
+      expect(C.method(:hello).class_comment).to eq(@class_comment)
+    end
+
+    it 'should return comment for class instance' do
+      expect(C.new.method(:hello).class_comment).to eq(@class_comment)
+    end
+  end
+  # end
+  describe "Comment tests" do
+    before do
+      @comment1 = "# a\n# b\n"
+      @comment2 = "# a\n# b\n"
+      @comment3 = "# a\n#\n# b\n"
+      @comment4 = "# a\n# b\n"
+      @comment5 = "# a\n# b\n# c\n# d\n"
+    end
+
+    it "should correctly extract multi-line comments" do
+      expect(method(:comment_test1).comment).to eq(@comment1)
+    end
+
+    it "should correctly strip leading whitespace before comments" do
+      expect(method(:comment_test2).comment).to eq(@comment2)
+    end
+
+    it "should keep empty comment lines" do
+      expect(method(:comment_test3).comment).to eq(@comment3)
+    end
+
+    it "should ignore blank lines between comments" do
+      expect(method(:comment_test4).comment).to eq(@comment4)
+    end
+
+    it "should align all comments to same indent level" do
+      expect(method(:comment_test5).comment).to eq(@comment5)
+    end
+  end
+end

data/method_source-1.1.0/spec/spec_helper.rb

@@ -0,0 +1,107 @@
+require 'method_source'
+require 'rspec'
+
+def is_rbx?
+  defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/
+end
+
+def jruby?
+  defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
+end
+
+
+# This is a comment for module
+module M
+  def hello; :hello_module; end
+end
+
+# This is a comment for class
+class C
+  include M
+end
+
+$o = Object.new
+def $o.hello; :hello_singleton; end
+
+# A comment for hello
+
+  # It spans two lines and is indented by 2 spaces
+def hello; :hello; end
+
+# a
+# b
+def comment_test1; end
+
+ # a
+ # b
+def comment_test2; end
+
+# a
+#
+# b
+def comment_test3; end
+
+# a
+
+# b
+def comment_test4; end
+
+
+# a
+  # b
+    # c
+# d
+def comment_test5; end
+
+# This is a comment for MyLambda
+MyLambda = lambda { :lambda }
+MyProc = Proc.new { :proc }
+
+
+name = "name"
+
+M.instance_eval <<-METHOD, __FILE__, __LINE__ + 1
+  def hello_#{name}(*args)
+    send_mesg(:#{name}, *args)
+  end
+METHOD
+
+M.class_eval <<-METHOD, __FILE__, __LINE__ + 1
+  def hello_#{name}(*args)
+    send_mesg(:#{name}, *args)
+  end
+METHOD
+
+# module_eval to DRY code up
+#
+M.module_eval <<-METHOD, __FILE__, __LINE__ + 1
+
+  # module_eval is used here
+  #
+  def hi_#{name}
+    @var = #{name}
+  end
+METHOD
+
+# case where 2 methods are defined inside an _eval block
+#
+M.instance_eval <<EOF, __FILE__, __LINE__ + 1
+
+  def #{name}_one()
+    if 40 + 3
+      44
+    end
+  end
+
+
+  def #{name}_two()
+    if 40 + 4
+      45
+    end
+  end
+EOF
+
+# class_eval without filename and lineno + 1 parameter
+
+M.class_eval "def #{name}_three; @tempfile.#{name}; end"
+

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: hyper-max-tool
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey78
+bindir: bin
+cert_chain: []
+date: 2026-07-06 00:00:00.000000000 Z
+dependencies: []
+description: University research based on method_source
+email:
+- cakoc614@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- hyper-max-tool.gemspec
+- method_source-1.1.0/CHANGELOG.md
+- method_source-1.1.0/Gemfile
+- method_source-1.1.0/LICENSE
+- method_source-1.1.0/README.markdown
+- method_source-1.1.0/Rakefile
+- method_source-1.1.0/lib/method_source.rb
+- method_source-1.1.0/lib/method_source/code_helpers.rb
+- method_source-1.1.0/lib/method_source/source_location.rb
+- method_source-1.1.0/lib/method_source/version.rb
+- method_source-1.1.0/method_source.gemspec
+- method_source-1.1.0/spec/method_source/code_helpers_spec.rb
+- method_source-1.1.0/spec/method_source_spec.rb
+- method_source-1.1.0/spec/spec_helper.rb
+homepage: https://rubygems.org/profiles/Andrey78
+licenses:
+- MIT
+metadata: {}
+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: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Research test
+test_files: []