mirrors 0.0.1

data/lib/mirrors/object_mirror.rb

@@ -0,0 +1,25 @@
+module Mirrors
+  # A mirror class. It is the most generic mirror and should be able
+  # to reflect on any object you can get at in a given system.
+  class ObjectMirror < Mirror
+    # @return [FieldMirror] the instance variables of the object
+    def variables
+      field_mirrors(@subject.instance_variables)
+    end
+
+    # @return [ClassMirror] the a class mirror on the runtime class object
+    def target_class
+      Mirrors.reflect(@subject.class)
+    end
+
+    private
+
+    def field_mirrors(list, subject = @subject)
+      list.map { |name| field_mirror(subject, name) }
+    end
+
+    def field_mirror(subject, name)
+      Mirrors.reflect(FieldMirror::Field.new(subject, name))
+    end
+  end
+end

data/lib/mirrors/package_inference.rb

@@ -0,0 +1,164 @@
+require 'rbconfig'
+require 'set'
+
+require 'mirrors/hook'
+require 'mirrors/package_inference/class_to_file_resolver'
+
+module Mirrors
+  module PackageInference
+    extend self
+
+    def infer_from(mod, resolver = ClassToFileResolver.new)
+      infer_from_key(Mirrors.module_instance_invoke(mod, :inspect), resolver)
+    end
+
+    def infer_from_toplevel(sym, resolver = ClassToFileResolver.new)
+      infer_from_key(sym.to_s, resolver)
+    end
+
+    def contents_of_package(pkg)
+      @inverse_cache[pkg]
+    end
+
+    def qualified_packages
+      @inverse_cache.keys
+    end
+
+    private
+
+    def infer_from_key(key, resolver)
+      @inference_cache ||= {}
+      @inverse_cache ||= {}
+
+      cached = @inference_cache[key]
+      return cached if cached
+
+      pkg = uncached_infer_from(key, [], resolver)
+      @inference_cache[key] = pkg
+      @inverse_cache[pkg] ||= []
+      @inverse_cache[pkg] << key
+
+      pkg
+    end
+
+    # ruby --disable-gems -e 'puts Object.constants'
+    CORE = Set.new(%w(
+      Object Module Class BasicObject Kernel NilClass NIL Data TrueClass TRUE
+      FalseClass FALSE Encoding Comparable Enumerable String Symbol Exception
+      SystemExit SignalException Interrupt StandardError TypeError
+      ArgumentError IndexError KeyError RangeError ScriptError SyntaxError
+      LoadError NotImplementedError NameError NoMethodError RuntimeError
+      SecurityError NoMemoryError EncodingError SystemCallError Errno
+      UncaughtThrowError ZeroDivisionError FloatDomainError Numeric Integer
+      Fixnum Float Bignum Array Hash ENV Struct RegexpError Regexp MatchData
+      Marshal Range IOError EOFError IO STDIN STDOUT STDERR ARGF FileTest File
+      Dir Time Random Signal Proc LocalJumpError SystemStackError Method
+      UnboundMethod Binding Math GC ObjectSpace Enumerator StopIteration
+      RubyVM Thread TOPLEVEL_BINDING ThreadGroup ThreadError ClosedQueueError
+      Mutex Queue SizedQueue ConditionVariable Process Fiber FiberError
+      Rational Complex RUBY_VERSION RUBY_RELEASE_DATE RUBY_PLATFORM
+      RUBY_PATCHLEVEL RUBY_REVISION RUBY_DESCRIPTION RUBY_COPYRIGHT
+      RUBY_ENGINE RUBY_ENGINE_VERSION TracePoint ARGV DidYouMean
+    )).freeze
+
+    CORE_PACKAGE         = 'core'.freeze
+    CORE_STDLIB_PACKAGE  = 'core:stdlib'.freeze
+    APPLICATION_PACKAGE  = 'application'.freeze
+    GEM_PACKAGE_PREFIX   = 'gems:'.freeze
+    UNKNOWN_PACKAGE      = 'unknown'.freeze
+    UNKNOWN_EVAL_PACKAGE = 'unknown:eval'.freeze
+
+    def uncached_infer_from(key, exclusions, resolver)
+      return CORE_PACKAGE if CORE.include?(nesting_first(key))
+
+      filename = determine_filename(key, resolver)
+
+      if filename.nil?
+        return try_harder(key, exclusions, resolver)
+      end
+
+      return APPLICATION_PACKAGE if filename.start_with?(Mirrors.project_root)
+      return CORE_STDLIB_PACKAGE if filename.start_with?(rubylibdir)
+
+      if pkg = try_rubygems(filename)
+        return pkg
+      end
+
+      if pkg = try_bundler(filename)
+        return pkg
+      end
+
+      return UNKNOWN_EVAL_PACKAGE if filename == '(eval)'
+
+      UNKNOWN_PACKAGE
+    end
+
+    def try_rubygems(filename)
+      if defined?(Gem)
+        gem_path.each do |path|
+          next unless filename.start_with?(path)
+          # extract e.g. 'bundler-1.13.6'
+          gem_with_version = filename[path.size..-1].sub(%r{/.*}, '')
+          if gem_with_version =~ /(.*)-(\d|[a-f0-9]+$)/
+            return GEM_PACKAGE_PREFIX + $1
+          end
+        end
+      end
+      nil
+    end
+
+    def try_bundler(filename)
+      if defined?(Bundler)
+        path = bundle_path
+        if filename.start_with?(path)
+          gem_with_version = filename[path.size..-1].sub(%r{/.*}, '')
+          if gem_with_version =~ /(.*)-(\d|[a-f0-9]+$)/
+            return GEM_PACKAGE_PREFIX + $1
+          end
+        end
+      end
+      nil
+    end
+
+    def determine_filename(key, resolver)
+      if fn = CLASS_DEFINITION_POINTS[key]
+        return fn
+      end
+      resolver.resolve(Object.const_get(key))
+    end
+
+    def try_harder(key, exclusions, resolver)
+      obj = Object.const_get(key)
+      return 'obj-not-module' unless obj.is_a?(Module)
+      exclusions << obj
+
+      obj.constants.each do |const|
+        child = obj.const_get(const)
+        next unless child.is_a?(Module)
+
+        next if exclusions.include?(child)
+
+        pkg = uncached_infer_from(Mirrors.module_instance_invoke(child, :inspect), exclusions, resolver)
+        return pkg unless pkg == 'unknown'
+      end
+
+      return 'unknown'
+    end
+
+    def nesting_first(n)
+      n.sub(/::.*/, '')
+    end
+
+    def rubylibdir
+      @rubylibdir ||= RbConfig::CONFIG['rubylibdir']
+    end
+
+    def gem_path
+      @gem_path ||= Gem.path.map { |p| "#{p}/gems/" }
+    end
+
+    def bundle_path
+      @bundle_path ||= "#{Bundler.bundle_path}/bundler/gems/"
+    end
+  end
+end

data/lib/mirrors/package_inference/class_to_file_resolver.rb

@@ -0,0 +1,66 @@
+module Mirrors
+  module PackageInference
+    class ClassToFileResolver
+      def initialize
+        @files = {}
+      end
+
+      def resolve(klass)
+        return nil if klass.nil?
+        try_fast(klass, klass.name)                   ||
+          try_fast(klass.singleton_class, klass.name) ||
+          try_slow(klass)                             ||
+          try_slow(klass.singleton_class)
+      end
+
+      private
+
+      def try_fast(klass, class_name)
+        klass.instance_methods(false).each do |name|
+          meth = klass.instance_method(name)
+
+          file = begin
+            sl = meth.source_location
+            next unless sl
+            sl[0]
+          rescue MethodSource::SourceNotFoundError
+            next
+          end
+
+          contents = (@files[file] ||= File.open(file, 'r') { |f| f.readpartial(4096) })
+          n = class_name.sub(/.*::/, '') # last component of module name
+          return file if contents =~ /^\s+(class|module) ([\S]+::)?#{Regexp.quote(n)}\s/
+        end
+        nil
+      end
+
+      def try_slow(klass)
+        methods = klass
+          .instance_methods(false)
+          .map { |n| klass.instance_method(n) }
+
+        defined_directly_on_class = methods
+          .select do |meth|
+            # as a mostly-useful heuristic, we just eliminate everything that was
+            # defined using a template eval or define_method.
+            meth.source =~ /\A\s+def (self\.)?#{Regexp.quote(meth.name)}/
+          end
+
+        files = Hash.new(0)
+
+        defined_directly_on_class.each do |meth|
+          begin
+            sl = meth.source_location[0]
+            raise unless sl
+            files[sl[0]] += 1
+          rescue MethodSource::SourceNotFoundError
+            raise
+          end
+        end
+
+        file = files.max_by { |_k, v| v }
+        file ? file[0] : nil
+      end
+    end
+  end
+end

data/lib/mirrors/package_mirror.rb

@@ -0,0 +1,33 @@
+require 'mirrors/mirror'
+require 'mirrors/package_inference'
+
+module Mirrors
+  class PackageMirror < Mirror
+    def name
+      @subject.sub(/.*:/, '')
+    end
+
+    def fullname
+      @subject
+    end
+
+    def children
+      names = PackageInference.contents_of_package(@subject)
+      classes = (names || [])
+        .map { |n| Object.const_get(n) }
+        .select { |c| c.is_a?(Module) }
+        .sort_by(&:name)
+      class_mirrors = mirrors(classes)
+
+      # .map    { |pkg| pkg.sub(/#{Regexp.quote(@subject)}:.*?:.*/) }
+      subpackages = PackageInference.qualified_packages
+        .select { |pkg| pkg.start_with?("#{@subject}:") }
+        .sort
+
+      puts subpackages.inspect
+
+      package_mirrors = subpackages.map { |pkg| PackageMirror.reflect(pkg) }
+      package_mirrors.concat(class_mirrors)
+    end
+  end
+end

data/lib/mirrors/visitors/disasm_visitor.rb

@@ -0,0 +1,11 @@
+require 'mirrors/visitors/iseq_visitor'
+
+module Mirrors
+  # DisasmVisitor prints a disassembled version of the bytecodes
+  # in a format similar to that used by the disasm() method.
+  class DisasmVisitor < Mirrors::ISeqVisitor
+    def visit(bytecode)
+      puts " #{'%03d' % @pc} #{bytecode}  (#{@line})"
+    end
+    end
+end

data/lib/mirrors/visitors/iseq_visitor.rb

@@ -0,0 +1,84 @@
+require 'mirrors/visitors/yasmdata'
+require 'pp'
+
+module Mirrors
+  # ISeqVisitor is an abstract class that knows how to walk methods and
+  # call the visit() method for each instruction.  Internally it tracks the
+  # state of the current @pc, @line, and @label during the walk.
+  #
+  class ISeqVisitor
+    attr_reader :iseq, :field_refs, :method_refs, :class_refs
+
+    # visit all the instructions in the supplied method
+    def call(method)
+      @method = method
+      @iseq = method.native_code
+
+      # extract fields from iseq
+      @magic,
+      @major_version,
+      @minor_version,
+      @format_type,
+      @misc,
+      @label,
+      @path,
+      @absolute_path,
+      @first_lineno,
+      @type,
+      @locals,
+      @params,
+      @catch_table,
+      @bytecode = @iseq.to_a
+
+      # walk state
+      @pc = 0 # program counter
+      @label  # current label
+      walk
+      self
+    end
+
+    # iterator call once for each opcode
+    def visit(_bytecode)
+      raise NotImplementedError, "subclass responsibility"
+    end
+
+    private
+
+    # walk the opcodes
+    def walk
+      return unless @bytecode # C extensions have no bytecode
+
+      @pc = 0
+      @label = nil
+      @bytecode.each_with_index do |bc|
+        if (bc.class == Integer || bc.class == Fixnum)
+          @line = bc # bare line number
+          next # line numbers are not executable
+        elsif bc.class == Symbol
+          @label = bc
+          next # labels are not executable
+        elsif bc.class == Array
+          @opcode = VM::InstructionSequence::Instruction.id2insn_no(bc.first)
+          unrecognized_bytecode(bc) unless @opcode
+          visit(bc)
+          @pc += VM::InstructionSequence::Instruction.insn_no2size(@opcode)
+        else
+          unrecognized_bytecode(bc)
+        end
+      end
+    end
+
+    private
+
+    # emit diagnostics and signal that an unrecognized opcode was encountered
+    def unrecognized_bytecode(bc)
+      puts "-----------------bytecode ---------------------"
+      puts "bytecode=#{bc}  clazz=#{bc.class}"
+      puts "---------------- disassembly ------------------"
+      puts @iseq.disasm
+      puts "---------------- bytecode ------------------"
+      pp @bytecode
+      raise "Urecognized bytecode:#{bc} at index:#{@pc}"
+    end
+  end
+end

data/lib/mirrors/visitors/references_visitor.rb

@@ -0,0 +1,58 @@
+require 'mirrors/visitors/iseq_visitor'
+require 'mirrors/index/marker'
+
+module Mirrors
+  # ReferencesVisitor examines opcodes and records references to
+  # classes, methods, and fields
+
+  class ReferencesVisitor < Mirrors::ISeqVisitor
+    attr_reader :markers
+
+    def initialize
+      super
+      @markers = []
+    end
+
+    protected
+
+    def visit(bytecode)
+      case bytecode.first
+      when :getinstancevariable
+        @markers << field_marker(bytecode[1])
+      when :getconstant
+        @markers << class_marker(bytecode.last)
+      when :opt_send_without_block
+        @markers << method_marker(bytecode[1][:mid])
+      end
+    end
+
+    private
+
+    def class_marker(name)
+      Marker.new(
+        type: Mirrors::Marker::TYPE_CLASS_REFERENCE,
+        message: name,
+        file: @absolute_path,
+        line: @line
+      )
+    end
+
+    def field_marker(name)
+      Marker.new(
+        type: Mirrors::Marker::TYPE_FIELD_REFERENCE,
+        message: name,
+        file: @absolute_path,
+        line: @line
+      )
+    end
+
+    def method_marker(name)
+      Marker.new(
+        type: Mirrors::Marker::TYPE_METHOD_REFERENCE,
+        message: name,
+        file: @absolute_path,
+        line: @line
+      )
+    end
+  end
+end