mirrors 0.0.1

data/lib/mirrors/class_mixin.rb

@@ -0,0 +1,11 @@
+# mixin, convenience operator for method reflection
+# inspired by Smalltalk
+class Class
+  def >>(symbol)
+    Mirrors.reflect(method(symbol))
+  end
+
+  def reflect
+    Mirrors.reflect(self)
+  end
+end

data/lib/mirrors/field_mirror.rb

@@ -0,0 +1,24 @@
+module Mirrors
+  # A class to reflect on instance, class, and class instance variables,
+  # as well as constants.
+  class FieldMirror < Mirror
+    Field = Struct.new(:object, :name)
+
+    attr_reader :name
+
+    def initialize(obj)
+      super
+      @object = obj.object
+      @name = obj.name.to_s
+    end
+
+    # @return [ClassMirror] The class this method was originally defined in
+    def defining_class
+      Mirrors.reflect(@object)
+    end
+  end
+end
+
+require 'mirrors/field_mirror/class_variable_mirror'
+require 'mirrors/field_mirror/instance_variable_mirror'
+require 'mirrors/field_mirror/constant_mirror'

data/lib/mirrors/field_mirror/class_variable_mirror.rb

@@ -0,0 +1,23 @@
+module Mirrors
+  class ClassVariableMirror < FieldMirror
+    def value
+      Mirrors.reflect(@object.class_variable_get(@name))
+    end
+
+    def value=(o)
+      @object.class_variable_set(@name, o)
+    end
+
+    def public?
+      false
+    end
+
+    def protected?
+      false
+    end
+
+    def private?
+      true
+    end
+  end
+end

data/lib/mirrors/field_mirror/constant_mirror.rb

@@ -0,0 +1,34 @@
+module Mirrors
+  class ConstantMirror < FieldMirror
+    def value
+      if path = @object.autoload?(@name)
+        unless $LOADED_FEATURES.include?(path) ||
+            $LOADED_FEATURES.include?(File.expand_path(path))
+          # Do not trigger autoload
+          return nil
+        end
+      end
+      Mirrors.reflect @object.const_get(@name)
+    end
+
+    def value=(o)
+      @object.const_set(@name, o)
+    end
+
+    def public?
+      true
+    end
+
+    def protected?
+      false
+    end
+
+    def private?
+      false
+    end
+
+    def delete
+      @object.send(:remove_const, @name)
+    end
+  end
+end

data/lib/mirrors/field_mirror/instance_variable_mirror.rb

@@ -0,0 +1,23 @@
+module Mirrors
+  class InstanceVariableMirror < FieldMirror
+    def value
+      Mirrors.reflect(@object.instance_variable_get(@name))
+    end
+
+    def value=(o)
+      @object.instance_variable_set(@name, o)
+    end
+
+    def public?
+      false
+    end
+
+    def protected?
+      false
+    end
+
+    def private?
+      true
+    end
+  end
+end

data/lib/mirrors/hook.rb

@@ -0,0 +1,33 @@
+require 'mirrors/invoke'
+
+module Mirrors
+  CLASS_DEFINITION_POINTS = {}
+
+  NoGemfile = Class.new(StandardError)
+
+  class << self
+    attr_accessor :project_root
+  end
+end
+
+begin
+  unless Mirrors.project_root
+    appline = caller.detect { |line| line !~ /:in `require'/ }
+    f = File.expand_path(appline.sub(/:\d.*/, ''))
+    Mirrors.project_root = loop do
+      f = File.dirname(f)
+      raise Mirrors::NoGemfile if f == '/'
+      break f if File.exist?("#{f}/Gemfile")
+    end
+  end
+end
+
+class Class
+  alias_method :__lg_orig_inherited, :inherited
+  def inherited(subclass)
+    file = caller[0].sub(/:\d+:in.*/, '')
+    key = Mirrors.module_instance_invoke(subclass, :inspect)
+    Mirrors::CLASS_DEFINITION_POINTS[key] = file
+    __lg_orig_inherited(subclass)
+  end
+end

data/lib/mirrors/index/indexer.rb

@@ -0,0 +1,6 @@
+module Mirrors
+  module Index
+    class Indexer
+    end
+  end
+end

data/lib/mirrors/index/marker.rb

@@ -0,0 +1,40 @@
+module Mirrors
+  class Marker
+    TYPE_TASK = 'mirrors.marker.task'.freeze
+    TYPE_PROBLEM = 'mirrors.marker.problem'.freeze
+    TYPE_TEXT = 'mirrors.marker.text'.freeze
+    TYPE_CLASS_REFERENCE = 'mirrors.marker.text.class_reference'.freeze
+    TYPE_METHOD_REFERENCE = 'mirrors.marker.text.method_reference'.freeze
+    TYPE_FIELD_REFERENCE = 'mirrors.marker.text.field_reference'.freeze
+
+    NO_LINE = -1
+    NO_COLUMN = -1
+
+    attr_reader :message, :type, :file, :line, :start_column, :end_column
+
+    def initialize(type: TYPE_TASK, message: '', file: nil, line: NO_LINE, start_column: NO_COLUMN, end_column: NO_COLUMN)
+      @type = type
+      @message = message
+      @file = file
+      @line = line
+      @start_column = start_column
+      @end_column = end_column
+    end
+
+    def ==(other)
+      type == other.type && message == other.message && line == other.line && start_column == other.start_column && end_column == other.end_column
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      [@type, @message, @line, @start_column, @end_column].hash
+    end
+
+    def hashy
+      [@type, @message, @line, @start_column, @end_column]
+    end
+  end
+end

data/lib/mirrors/invoke.rb

@@ -0,0 +1,29 @@
+module Mirrors
+  # Methods here follow the pattern of:
+  # <target>_<instance or singleton>_<invoke or method>
+  #
+  # * target is the owner of the method
+  # * instance or singleton indicates whether we want an instance method or a
+  #   singleton method from the target
+  # * invoke calls the method on a receiver, which must be compatible with the
+  #   method. method returns the method to bind to whatever receiver you want.
+
+  @unbound_module_instance_methods = {}
+  @unbound_class_singleton_methods = {}
+
+  def self.module_instance_invoke(receiver, msg)
+    module_instance_method(msg).bind(receiver).call
+  end
+
+  def self.module_instance_method(msg)
+    @unbound_module_instance_methods[msg] ||= Module.instance_method(msg)
+  end
+
+  def self.class_singleton_invoke(receiver, msg)
+    class_singleton_method(msg).bind(receiver).call
+  end
+
+  def self.class_singleton_method(msg)
+    @unbound_class_singleton_methods[msg] ||= Class.method(msg).unbind
+  end
+end

data/lib/mirrors/method_mirror.rb

@@ -0,0 +1,206 @@
+require 'method_source'
+require 'base64'
+require 'ripper'
+require 'pp'
+require 'mirrors/visitors/iseq_visitor'
+require 'mirrors/visitors/references_visitor'
+
+module Mirrors
+  # A MethodMirror should reflect on methods, but in a more general
+  # sense than the Method and UnboundMethod classes in Ruby are able
+  # to offer.
+  #
+  # In actual execution, a method is pretty much every chunk of code,
+  # even loading a file triggers a process not unlike compiling a
+  # method (if only for the side-effects). Method mirrors should allow
+  # access to the runtime objects, but also to their static
+  # representations (bytecode, source, ...), their debugging
+  # information and statistical information
+  class MethodMirror < Mirror
+    # @return [String, nil] The filename, if available
+    def file
+      sl = source_location
+      sl ? sl.first : nil
+    end
+
+    # @return [Fixnum, nil] The source line, if available
+    def line
+      sl = source_location
+      sl && sl.last ? sl.last - 1 : nil
+    end
+
+    # @return [String] The method name
+    def selector
+      @subject.name.to_s
+    end
+
+    # @return [ClassMirror] The class this method was originally defined in
+    def defining_class
+      Mirrors.reflect @subject.send(:owner)
+    end
+
+    # Return the value the block argument, or nil
+    #
+    # @return [String, nil]
+    def block_argument
+      args(:block).first
+    end
+
+    # Returns a field mirror with name and possibly value of the splat
+    # argument, or nil, if there is none to this method.
+    #
+    # @return [String, nil]
+    def splat_argument
+      args(:rest).first
+    end
+
+    # Returns names and values of the optional arguments.
+    #
+    # @return [Array<String>, nil]
+    def optional_arguments
+      args(:opt)
+    end
+
+    # Returns the name and possibly values of the required arguments
+    #
+    # @return [Array<String>]
+    def required_arguments
+      args(:req)
+    end
+
+    # Queries the method for it's arguments and returns a list of
+    # mirrors that hold name and value information.
+    #
+    # @return [Array<String>]
+    def arguments
+      @subject.send(:parameters).map { |_, a| a.to_s }
+    end
+
+    # Is the method :public, :private, or :protected?
+    #
+    # @return [String]
+    def visibility
+      return :public  if visibility?(:public)
+      return :private if visibility?(:private)
+      :protected
+    end
+
+    def protected?
+      visibility?(:protected)
+    end
+
+    def public?
+      visibility?(:public)
+    end
+
+    def private?
+      visibility?(:private)
+    end
+
+    def super_method
+      owner = @subject.send(:owner)
+
+      if owner.is_a?(Class)
+        meth = Mirrors
+          .class_singleton_method(:allocate)
+          .bind(instance)
+          .super_method
+          .unbind
+      else
+        meth = @subject.bind(owner).super_method.unbind
+      end
+
+      meth ? Mirrors.reflect(meth) : nil
+    end
+
+    # @return [String,nil] The source code of this method
+    def source
+      @source ||= unindent(@subject.send(:source))
+    rescue MethodSource::SourceNotFoundError
+      nil
+    end
+
+    # @return [String,nil] The pre-definition comment of this method
+    def comment
+      @subject.send(:comment)
+    rescue MethodSource::SourceNotFoundError
+      nil
+    end
+
+    # Returns the instruction sequence for the method (cached)
+    def iseq
+      @iseq ||= RubyVM::InstructionSequence.of(@subject)
+    end
+
+    # Returns the disassembled code if available.
+    #
+    # @return [String, nil] human-readable bytedcode dump
+    def bytecode
+      @bytecode ||= iseq.disasm if iseq
+      @bytecode
+    end
+
+    # Returns the parse tree if available
+    #
+    # @return [String, nil] prettified AST
+    def sexp
+      src = source
+      src ? Ripper.sexp(src).pretty_inspect : nil
+    end
+
+    # Returns the compiled code if available.
+    #
+    # @return [RubyVM::InstructionSequence, nil] native code
+    def native_code
+      RubyVM::InstructionSequence.of(@subject)
+    end
+
+    def name
+      @subject.name
+    end
+
+    def references
+      visitor = Mirrors::ReferencesVisitor.new
+      visitor.call(self)
+      visitor.markers
+    end
+
+    private
+
+    def visibility?(type)
+      list = @subject.send(:owner).send("#{type}_instance_methods")
+      list.any? { |m| m.to_s == selector }
+    end
+
+    def args(type)
+      args = []
+      @subject.send(:parameters).select { |t, n| args << n.to_s if t == type }
+      args
+    end
+
+    def source_location
+      @subject.send(:source_location)
+    end
+
+    def unindent(str)
+      lines = str.split("\n")
+      return str if lines.empty?
+
+      indents = lines.map do |line|
+        if line =~ /\S/
+          line.start_with?(" ") ? line.match(/^ +/).offset(0)[1] : 0
+        end
+      end
+      indents.compact!
+
+      if indents.empty?
+        # No lines had any non-whitespace characters.
+        return ([""] * lines.size).join "\n"
+      end
+
+      min_indent = indents.min
+      return str if min_indent.zero?
+      lines.map { |line| line =~ /\S/ ? line.gsub(/^ {#{min_indent}}/, "") : line }.join("\n")
+    end
+  end
+end

data/lib/mirrors/mirror.rb

@@ -0,0 +1,37 @@
+module Mirrors
+  # The basic mirror
+  class Mirror
+    def initialize(obj)
+      @subject = obj
+    end
+
+    def subject_id
+      @subject.__id__.to_s
+    end
+
+    # A generic representation of the object under observation.
+    def name
+      if @subject.is_a?(String) || @subject.is_a?(Symbol)
+        @subject
+      else
+        @subject.inspect
+      end
+    end
+
+    # The equivalent to #==/#eql? for comparison of mirrors against objects
+    def mirrors?(other)
+      @subject == other
+    end
+
+    # Accessor to the reflected object
+    def reflectee
+      @subject
+    end
+
+    private
+
+    def mirrors(list)
+      list.collect { |e| Mirrors.reflect(e) }
+    end
+  end
+end