system_navigation 0.1.0

data/lib/system_navigation/ancestor_method_finder.rb

@@ -0,0 +1,44 @@
+class SystemNavigation
+  class AncestorMethodFinder
+    using ArrayRefinement
+
+    def self.find_all_ancestors(of:)
+      finder = self.new(of)
+      singleton_finder = self.new(of.singleton_class)
+
+      ancestor_list = []
+
+      ancestor_list.concat(finder.find_all_methods)
+      ancestor_list.concat(singleton_finder.find_all_methods)
+
+      ancestor_list
+    end
+
+    def initialize(behavior)
+      @behavior = behavior
+      @ancestor_list = behavior.ancestors - [behavior]
+    end
+
+    def find_all_methods
+      self.find_closest_ancestors(@ancestor_list).flat_map do |ancestor|
+        selectors = MethodHash.create(based_on: ancestor, include_super: false)
+        # No inheritance for singletons in Ruby
+        [:public, :private, :protected].each { |t| selectors[t][:singleton] = [] }
+
+        MethodQuery.execute(collection: selectors,
+                            query: :convert_to_methods,
+                            behavior: @behavior)
+      end
+    end
+
+    protected
+
+    def find_closest_ancestors(ancestors)
+      if @behavior.is_a?(Class)
+        ancestors.split(@behavior.superclass).first || []
+      else
+        ancestors
+      end
+    end
+  end
+end

data/lib/system_navigation/array_refinement.rb

@@ -0,0 +1,21 @@
+class SystemNavigation
+  module ArrayRefinement
+    refine Array do
+      def split(value)
+        results, arr = [[]], self.dup
+
+        until arr.empty?
+          if (idx = arr.index(value))
+            results.last.concat(arr.shift(idx))
+            arr.shift
+            results << []
+          else
+            results.last.concat(arr.shift(arr.size))
+          end
+        end
+
+        results
+      end
+    end
+  end
+end

data/lib/system_navigation/compiled_method.rb

@@ -0,0 +1,94 @@
+class SystemNavigation
+  class CompiledMethod
+    def self.compile(method)
+      self.new(method).compile
+    end
+
+    def initialize(method)
+      @method = method
+      @scanner = SystemNavigation::InstructionStream.on(method)
+      @decoder = InstructionStream::Decoder.new(@scanner)
+
+      begin
+        @source = FastMethodSource.source_for(@method)
+      rescue FastMethodSource::SourceNotFoundError, IOError
+        @source = ''
+      end
+
+      begin
+        @comment = FastMethodSource.comment_for(@method)
+      rescue FastMethodSource::SourceNotFoundError, IOError
+        @comment = ''
+      end
+    end
+
+    def compile
+      @scanner.decode
+
+      self
+    end
+
+    def method_missing(method_name, *args, &block)
+      @method.send(method_name, *args, &block)
+    end
+
+    def unwrap
+      @method
+    end
+
+    # Literals that are referenced by the receiver as described in
+    # `doc/syntax/literals.rdoc` in your Ruby, installation minus procs and
+    # backticks.
+    def has_literal?(literal)
+      return true if self.scan_for { @decoder.literal_scan(literal) }
+      return false if self.c_method?
+
+      exptree = ExpressionTree.of(method: @method, source: @source)
+      exptree.includes?(literal)
+    end
+
+    def reads_field?(ivar)
+      self.scan_for { @decoder.ivar_read_scan(ivar) }
+    end
+
+    def writes_field?(ivar)
+      self.scan_for { @decoder.ivar_write_scan(ivar) }
+    end
+
+    def sends_message?(message)
+      self.scan_for { @decoder.msg_send_scan(message) }
+    end
+
+    def source_contains?(string, match_case)
+      string = string.dup
+      code_and_comment = @source + @comment
+      code_and_comment.downcase! && string.downcase! unless match_case
+      !!code_and_comment.match(string)
+    end
+
+    def c_method?
+      @method.source_location.nil?
+    end
+
+    def rb_method?
+      !self.c_method?
+    end
+
+    def sent_messages
+      @decoder.scan_for_sent_messages
+    end
+
+    protected
+
+    def scan_for
+      @scanner.scan_for(yield)
+    end
+
+    def scan_for_literal(literal)
+      return false if self.c_method?
+
+      exptree = ExpressionTree.of(method: @method, source: @source)
+      exptree.includes?(literal)
+    end
+  end
+end

data/lib/system_navigation/expression_tree.rb

@@ -0,0 +1,95 @@
+class SystemNavigation
+  class ExpressionTree
+    def self.of(method:, source:)
+      tree = self.new(method: method, source: source)
+      tree.parse
+      tree
+    end
+
+    def initialize(method: nil, source: nil)
+      @method = method
+      @source = source
+      @keywords = []
+      @hashes = []
+      @arrays = []
+      @ranges = []
+      @tree = nil
+    end
+
+    def parse
+      return false if [@method, @source].compact.empty?
+
+      @tree = Ripper.sexp(@source)
+      return false unless @tree
+
+      parsed = @tree[1][0]
+      return false unless parsed.first == :def
+
+      method_body_tree = parsed[3][1]
+
+      self.walk(method_body_tree)
+
+      true
+    end
+
+    def includes?(obj)
+      built = Ripper.sexp(obj.inspect)
+      built_obj = built[1][0][1]
+
+      collection = case obj
+                   when Array then @arrays
+                   when Hash then @hashes
+                   when Range then @ranges
+                   else
+                     []
+                   end
+      !!find_includes(collection, built_obj) || @keywords.include?(obj.inspect)
+    end
+
+    protected
+
+    def find_includes(collection, obj)
+      collection.find do |item|
+        item = item[1]
+
+        unify(item)
+        unify(obj)
+
+        item == obj
+      end
+    end
+
+    def unify(node)
+      node.each do |n|
+        if n.instance_of?(Array)
+          if n.size == 2 && n.all? { |num| num.instance_of?(Fixnum) }
+            n[0] = 0
+            n[1] = 0
+          end
+
+          unify(n)
+        end
+      end
+    end
+
+    def walk(tree)
+      tree.each do |node|
+        walk_node(node)
+      end
+    end
+
+    def walk_node(node)
+      node.each_with_index do |n, i|
+        case n
+        when Array
+          walk_node(n)
+        when Symbol
+          @keywords << node[i + 1] if n == :@kw
+          @hashes << node if n == :hash
+          @arrays << node if n == :array
+          @ranges << node if n == :dot2 || n == :dot3
+        end
+      end
+    end
+  end
+end

data/lib/system_navigation/instruction_stream.rb

@@ -0,0 +1,33 @@
+class SystemNavigation
+  class InstructionStream
+    def self.on(method)
+      self.new(method: method)
+    end
+
+    attr_reader :method
+
+    def initialize(method: nil, iseq: nil)
+      @method = method
+      @iseq = iseq
+    end
+
+    def decode
+      @iseq ||= RubyVM::InstructionSequence.disasm(@method) || ''
+    end
+
+    def scan_for(selected_instructs)
+      selected_instructs.any?
+    end
+
+    def iseqs(sym)
+      iseqs = @iseq.split("\n")
+
+      if iseqs.any?
+        instructions = iseqs.map { |instruction| Instruction.parse(instruction) }
+        instructions.compact.select(&:vm_operative?)
+      else
+        Instruction::AttrInstruction.parse(@method, sym) || []
+      end
+    end
+  end
+end

data/lib/system_navigation/instruction_stream/decoder.rb

@@ -0,0 +1,91 @@
+class SystemNavigation
+  class InstructionStream
+    class Decoder
+      def initialize(scanner)
+        @scanner = scanner
+      end
+
+      def select_instructions(literal:, method_name: nil, &block)
+        instructions = @scanner.iseqs(method_name || literal)
+
+        instructions.select.with_index do |instruction, i|
+          prev = instructions[i - 1]
+          prev_prev = instructions[i - 2]
+
+          returned = block.call(prev_prev, prev, instruction)
+          next instruction if returned
+
+          next if !(instruction.evals? && prev.putstrings?(literal))
+
+          self.class.new(iseq_from_eval(prev, @scanner.method)).
+            __send__(block.binding.eval('__method__'), literal).any?
+        end
+      end
+
+      def ivar_read_scan(ivar)
+        self.select_instructions(literal: ivar) do |_prev_prev, prev, instruction|
+          next instruction if instruction.reads_ivar?(ivar)
+
+          if instruction.dynamically_reads_ivar? && prev.putobjects?(ivar)
+            next instruction
+          end
+        end
+      end
+
+      def ivar_write_scan(ivar)
+        self.select_instructions(literal: ivar) do |prev_prev, prev, instruction|
+          next instruction if instruction.writes_ivar?(ivar)
+
+          if instruction.dynamically_writes_ivar? && prev_prev.putobjects?(ivar)
+            next instruction
+          end
+        end
+      end
+
+      def literal_scan(literal)
+        name = @scanner.method.original_name
+
+        self.select_instructions(method_name: name, literal: literal) do |_prev_prev, prev, instruction|
+          if instruction.putobjects?(literal) ||
+             instruction.putnils?(literal) ||
+             instruction.duparrays?(literal) ||
+             instruction.putstrings?(literal)
+            next instruction
+          end
+        end
+      end
+
+      def msg_send_scan(message)
+        self.select_instructions(literal: message) do |_prev_prev, prev, instruction|
+          next instruction if instruction.sends_msg?(message)
+        end
+      end
+
+      def scan_for_sent_messages
+        @scanner.iseqs(nil).map do |instruction|
+          instruction.find_message
+        end.compact
+      end
+
+      private
+
+      def iseq_from_eval(instruction, method = nil)
+        # Avoid segfault if evaling_str is nil.
+        # See: https://bugs.ruby-lang.org/issues/11159
+        uncompiled = unwind_eval(instruction.evaling_str || nil.to_s)
+        uncompiled.gsub!(/\\n/, ?\n)
+
+        iseq = RubyVM::InstructionSequence.compile(uncompiled).disasm
+        InstructionStream.new(method: method, iseq: iseq)
+      end
+
+      def unwind_eval(eval_string)
+        eval_string.sub(/\A(eval\(\\?["'])*/, '').sub(/(\\?["']\))*\z/, '')
+      end
+
+      def sanitize_newlines(eval_string)
+        eval_string.gsub(/\\n/, ?\n)
+      end
+    end
+  end
+end

data/lib/system_navigation/instruction_stream/instruction.rb

@@ -0,0 +1,180 @@
+class SystemNavigation
+  class InstructionStream
+    class Instruction
+      def self.parse(str)
+        self.new(str).parse
+      end
+
+      def initialize(str)
+        @raw = StringScanner.new(str)
+        @pos = nil
+        @opcode = ''
+        @operand = nil
+        @evaling_str = nil
+        @lineno = nil
+        @op_id = nil
+        @ivar = nil
+        @service_instruction = false
+      end
+
+      def parse
+        return if parse_service_instruction
+
+        parse_position
+        parse_opcode
+        parse_operand
+        parse_lineno
+        parse_op_id
+        parse_ivar
+
+        self
+      end
+
+      def parse_service_instruction
+        if @raw.peek(2) == '==' || @raw.peek(6) !~ /[0-9]{4,6} /
+          @service_instruction = true
+        end
+      end
+
+      def parse_position
+        n = @raw.scan(/[0-9]{4,6}/)
+        @pos = n.to_i if n
+        @raw.skip(/\s*/)
+      end
+
+      def parse_opcode
+        @opcode = @raw.scan(/[a-zA-Z0-9_]+/)
+        @raw.skip(/\s*/)
+      end
+
+      def parse_operand
+        if @raw.check(/</)
+          @operand = @raw.scan(/<.+>/)
+        elsif @raw.check(/\[/)
+          @operand = @raw.scan(/\[.*\]/)
+        elsif @raw.check(/"/)
+          @operand = @raw.scan(/".*"/)
+        elsif @raw.check(%r{/})
+          @operand = @raw.scan(%r{/.*/})
+        else
+          @operand = @raw.scan(/-?[0-9a-zA-Z:@_=.]+/)
+
+          if @raw.peek(1) == ','
+            @operand << @raw.scan(/[^\(]*/).rstrip
+          end
+        end
+
+        @raw.skip(/\s*\(?/)
+        @raw.skip(/\s*/)
+      end
+
+      def parse_lineno
+        n = @raw.scan(/[0-9]+/)
+        @lineno = n.to_i if n
+        @raw.skip(/\)/)
+      end
+
+      def parse_op_id
+        return unless sending?
+
+        callinfo = StringScanner.new(@operand)
+        callinfo.skip(/<callinfo!mid:/)
+        @op_id = callinfo.scan(/\S+(?=,)/)
+        callinfo.terminate
+      end
+
+      def parse_ivar
+        return unless accessing_ivar?
+
+        ivar = StringScanner.new(@operand)
+        @ivar = ivar.scan(/:[^,]+/)[1..-1].to_sym
+        ivar.terminate
+      end
+
+      def accessing_ivar?
+        @opcode == 'getinstancevariable' || @opcode == 'setinstancevariable'
+      end
+
+      def vm_operative?
+        @service_instruction == false
+      end
+
+      def reads_ivar?(ivar)
+        @opcode == 'getinstancevariable' && @ivar == ivar
+      end
+
+      def writes_ivar?(ivar)
+        @opcode == 'setinstancevariable' && @ivar == ivar
+      end
+
+      def dynamically_reads_ivar?
+        @op_id == 'instance_variable_get'
+      end
+
+      def dynamically_writes_ivar?
+        @op_id == 'instance_variable_set'
+      end
+
+      def evals?
+        @op_id == 'eval'
+      end
+
+      def putstrings?(str)
+        return false unless @opcode == 'putstring'
+
+        s = str.inspect
+
+        return true if @operand == s || @operand == %|"#{s}"|
+        if @operand.match(/(eval\()?.*:?#{str}[^[\w;]].*\)?/)
+          return true
+        else
+
+        end
+
+        false
+      end
+
+      def putobjects?(str)
+        return false unless @opcode == 'putobject'
+
+        return true if @operand.match(/(?::#{str}\z|\[.*:#{str},.*\])/)
+        return true if @operand == str.inspect
+
+        false
+      end
+
+      def putnils?(str)
+        return false unless @opcode == 'putnil'
+        @operand == str.inspect
+      end
+
+      def duparrays?(str)
+        !!(@opcode == 'duparray' && @operand.match(/:#{str}[,\]]/))
+      end
+
+      def sends_msg?(message)
+        !!(sending? && @op_id == message.to_s)
+      end
+
+      def operand
+        @operand
+      end
+
+      def evaling_str
+        @evaling_str ||= @operand.sub!(/\A"(.+)"/, '\1')
+      end
+
+      def find_message
+        return unless sending?
+
+        @op_id
+      end
+
+      private
+
+      def sending?
+        @opcode == 'opt_send_without_block' || @opcode == 'send'
+      end
+    end
+  end
+end