rubymirrors 0.0.1

data/lib/abstract_reflection/mirror.rb

@@ -0,0 +1,108 @@
+module AbstractReflection
+  # The basic mirror. This is the lib code. It is also the factory to
+  # use for creating new mirrors on any kind of object. Its #reflect
+  # class method will return an appropriate mirror for a given object,
+  # provided one has been registered. The [ObjectMirror] class should
+  # have been registered as the fallback case for any kind of object,
+  # but that may depend on the specific API implementation.
+  module Mirror
+    module ClassMethods
+      @@mirrors = []
+
+      # Reflect on the passed object. This is the default factory for
+      # creating new mirrors, and it will try and find the appropriate
+      # mirror from the list of registered mirrors.
+      #
+      # @param [Object] the object to reflect upon. This need not be the
+      #   actual object represented - it can itself be just a
+      #   representation.  It is really up to the mirror to decide what to
+      #   do with it
+      # @param [Reflection] the instance of a Reflection this mirror was
+      #   spawned in.
+      def reflect(obj, reflection)
+        target_mirror = nil
+        @@mirrors.detect {|klass| target_mirror = klass.mirror_class(obj) }
+        raise CapabilitiesExceeded if target_mirror.nil?
+        target_mirror.new(obj, reflection)
+      end
+
+      # The constructor, sets the @reflection instance variable before
+      # calling initialize.
+      def new(obj, reflection)
+        basic_new_object = allocate
+        basic_new_object.reflection = reflection
+        basic_new_object.send(:initialize, obj)
+        basic_new_object
+      end
+
+      # Decides whether the given class can reflect on [obj]
+      # @param [Object] the object to reflect upon
+      # @return [true, false]
+      def reflects?(obj)
+        @reflected_modules.any? { |mod| mod === obj }
+      end
+
+      # A shortcut to define reflects? behavior.
+      # @param [Module] the module whose instances this mirror reflects
+      def reflect!(*modules)
+        @reflected_modules = modules
+        register_mirror self
+      end
+
+      # Some objects may be more useful with a specialized kind of
+      # mirror. This method can be used to register new mirror
+      # classes. If used within a module, each class that includes
+      # that specific module is registered upon inclusion.
+      #
+      # @param [Module] The class or module to register
+      #
+      # @return [Mirror] returns self
+      def register_mirror(klass)
+        @@mirrors.unshift klass
+        @@mirrors.uniq!
+        self
+      end
+
+      # @param [Object] the object to reflect upon
+      #
+      # @return [Mirror, NilClass] the class to instantiate as mirror,
+      #   using #new, or nil, if non is known
+      def mirror_class(obj)
+        self if reflects?(obj)
+      end
+
+      # Only define this once, and always get the ClassMethods from
+      # the current module. When [Mirror] is included in another
+      # module, this will enable that module to also define ClassMethods
+      # to mix in when included. Additionally, if [Mirror] had registered
+      # itself for matching specific objects, this registration is forwarded
+      # to the class.
+      def included(base)
+        base.extend(const_get("ClassMethods")) if const_defined?("ClassMethods")
+        base.const_set(:CapabilitiesExceeded, CapabilitiesExceeded)
+      end
+    end
+
+    extend ClassMethods
+    attr_accessor :reflection
+
+    def initialize(obj)
+      @subject = obj
+    end
+
+    # A generic representation of the object under observation.
+    def name
+      @subject.inspect
+    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
+  end
+end

data/lib/abstract_reflection/object_mirror.rb

@@ -0,0 +1,48 @@
+module AbstractReflection
+  # 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.
+  module ObjectMirror
+    include Mirror
+
+    # @return [FieldMirror] the instance variables of the object
+    def variables
+      raise CapabilitiesExceeded
+    end
+
+    # @return [FieldMirror] the class variables of the object or its class
+    def class_variables
+      raise CapabilitiesExceeded
+    end
+
+    # @return [ClassMirror] the a class mirror on the runtime class object
+    def target_class
+      raise CapabilitiesExceeded
+    end
+
+    # Searches the system for other objects that have references to
+    # this one.
+    #
+    # @return [Array<ObjectMirror>]
+    def objects_with_references
+    end
+
+    # Returns the transitive closure (the full object tree under this
+    # object, without duplicates).
+    #
+    # @return [Hash<ObjectMirror => Hash<...,...>>] nested hashes
+    def transitive_closure
+    end
+
+    # Searches for a reference path from this object to another given
+    # object.
+    #
+    # @return [Array<ObjectMirror>, NilClass] the object path or nil, if none
+    def path_to(obj)
+    end
+
+    # The instance_eval known from Ruby. Should return the result or a
+    # representation thereof.
+    def instance_eval
+    end
+  end
+end

data/lib/abstract_reflection/stack_frame_mirror.rb

@@ -0,0 +1,61 @@
+module AbstractReflection
+  module StackFrameMirror
+    include Mirror
+
+    def restart
+      raise CapabilitiesExceeded
+    end
+
+    def pop
+      raise CapabilitiesExceeded
+    end
+
+    def step(length = :over)
+      raise CapabilitiesExceeded
+    end
+
+    def receiver
+      raise CapabilitiesExceeded
+    end
+
+    def self
+      raise CapabilitiesExceeded
+    end
+
+    def selector
+      raise CapabilitiesExceeded
+    end
+
+    def ip_offset
+      raise CapabilitiesExceeded
+    end
+
+    def step_offset
+      raise CapabilitiesExceeded
+    end
+
+    def source_offset
+      raise CapabilitiesExceeded
+    end
+
+    def arguments
+      raise CapabilitiesExceeded
+    end
+
+    def locals
+      raise CapabilitiesExceeded
+    end
+
+    def variable_context
+      raise CapabilitiesExceeded
+    end
+
+    def binding
+      raise CapabilitiesExceeded
+    end
+
+    def method
+      raise CapabilitiesExceeded
+    end
+  end
+end

data/lib/abstract_reflection/thread_mirror.rb

@@ -0,0 +1,64 @@
+module AbstractReflection
+  module ThreadMirror
+    include Mirror
+
+    def stop
+      raise CapabilitiesExceeded
+    end
+
+    def run
+      raise CapabilitiesExceeded
+    end
+
+    def kill
+      raise CapabilitiesExceeded
+    end
+
+    def return_value
+      raise CapabilitiesExceeded
+    end
+
+    def status
+      raise CapabilitiesExceeded
+    end
+
+    def stack
+      raise CapabilitiesExceeded
+    end
+
+    def step(length = :over)
+      raise CapabilitiesExceeded
+    end
+
+    def breakpoints
+      raise CapabilitiesExceeded
+    end
+
+    def thread_data
+      raise CapabilitiesExceeded
+    end
+
+    def compiler
+      raise CapabilitiesExceeded
+    end
+
+    # Installs an exception block in the thread. This is no rescue,
+    # the block will be executed for the given exception type, but it
+    # will not prevent the exception from propagating through the
+    # thread.
+    #
+    # @param [Exception, Array<Exception>] the exception(s) to rescue
+    # @param [Block] the exception handler
+    def handle_exception(e = Exception, &block)
+      raise CapabilitiesExceeded
+    end
+
+    def reset
+      raise CapabilitiesExceeded
+    end
+
+    def shift
+      raise CapabilitiesExceeded
+    end
+  end
+end

data/lib/maglev/reflection.rb

@@ -0,0 +1,49 @@
+require 'ruby/reflection'
+require 'maglev/reflection/core_ext/class_organizer'
+
+module Maglev
+  class Reflection < Ruby::Reflection
+    def modules
+      mirror_modules_satisfying {|m| Module === m && !(Class === m) }
+    end
+
+    def classes
+      mirror_modules_satisfying {|m| Class === m }
+    end
+
+    def implementations_of(str)
+      if sym = Symbol.__existing_symbol(str.to_s)
+        class_list = ClassOrganizer.cached_organizer.implementors_of sym
+        class_list.collect {|cls| self.reflect(cls).method sym }
+      else
+        []
+      end
+    end
+
+    def senders_of(str)
+      if sym = Symbol.__existing_symbol(str.to_s)
+        meth_list = ClassOrganizer.cached_organizer.senders_of sym
+        meth_list.collect do |m|
+          self.reflect(m.__in_class).method m.__name
+        end
+      else
+        []
+      end
+    end
+
+    private
+    def mirror_modules_satisfying
+      modules = self.reflect(Object).each_module
+      modules = modules.select {|m| yield m }
+      modules.collect {|m| self.reflect m }
+    end
+  end
+end
+
+require 'maglev/reflection/mirror'
+require 'maglev/reflection/object_mirror'
+require 'maglev/reflection/field_mirror'
+require 'maglev/reflection/thread_mirror'
+require 'maglev/reflection/stack_frame_mirror'
+require 'maglev/reflection/class_mirror'
+require 'maglev/reflection/method_mirror'

data/lib/maglev/reflection/class_mirror.rb

@@ -0,0 +1,157 @@
+require 'maglev/reflection/core_ext/module'
+
+module Maglev
+  class Reflection
+    class ClassMirror < ObjectMirror
+      include AbstractReflection::ClassMirror
+      reflect! Module
+
+      def singleton_instance
+        raise TypeError, "not a singleton class" unless self.singleton_class?
+        if self.inspect =~ /^#<Class:.*>$/
+
+        else
+          raise NotImplementedError, "not implemented yet"
+        end
+      end
+
+      def singleton_class
+        reflection.reflect @subject.singleton_class
+      end
+
+      def singleton_class?
+        self.name =~ /^\#<Class:.*>$/
+      end
+
+      def compile_method(source, selector = nil)
+        meth_dict = instance_methods(false) + methods(false)
+        if selector || (md = /^\s*def\s+(?:self\.)?([^;\( \n]+)/.match(source))
+          selector = selector || md[1]
+          begin
+            method(selector).source!(source, true)
+          rescue NameError, TypeError
+            class_eval(source)
+          end
+        else
+          class_eval(source)
+        end
+        new_meth_dict = instance_methods(false) + methods(false)
+        new_method_selector = if new_meth_dict > meth_dict
+          (new_meth_dict - meth_dict).first
+        else
+          selector
+        end
+        method(new_method_selector) if new_method_selector
+      end
+
+      def instance_variables
+        if (fixed_ivs = @subject.__inst_var_names).empty?
+          raise AbstractReflection::CapabilitiesExceeded
+        else
+          field_mirrors fixed_ivs
+        end
+      end
+
+      def class_variables
+        field_mirrors @subject.class_variables
+      end
+
+      def class_instance_variables
+        field_mirrors @subject.instance_variables
+      end
+
+      def nested_classes
+        constants.collect(&:value).select {|c| ClassMirror === c }
+      end
+
+      def source_files
+        method_objects = @subject.instance_methods(false).collect do |name|
+          @subject.instance_method(name)
+        end
+        method_objects += @subject.methods(false).collect do |name|
+          @subject.method(name)
+        end
+        method_objects.collect(&:source_location).collect(&:first).uniq
+      end
+
+      def mixins
+        mirrors @subject.ancestors.reject {|m| m.is_a? Class }
+      end
+
+      def superclass
+        self.class.new @subject.superclass
+      end
+
+      def subclasses
+        ary = []
+        each_module do |m|
+          ary << m if m.superclass && m.superclass.mirrors?(@subject)
+        end
+        ary
+      end
+
+      def ancestors
+        mirrors @subject.ancestors
+      end
+
+      def constant(str)
+        path = str.to_s.split("::")
+        c = path[0..-2].inject(@subject) {|klass,str| klass.const_get(str) }
+        field_mirror c, path.last
+      rescue NameError
+        nil
+      end
+
+      def constants
+        field_mirrors (@subject.constants - @subject.instance_variables)
+      end
+
+      def method(name)
+        reflection.reflect @subject.instance_method(name.to_s)
+      end
+
+      def methods
+        @subject.instance_methods(false)
+      end
+
+      def nesting
+        ary = [@subject]
+        while (ns = ary.last.__transient_namespace(1)) &&
+              (par = ns.parent) &&
+              (nxt = par.my_class)
+          break if nxt.nil? || nxt == Object
+          ary << nxt
+        end
+        ary
+      end
+
+      # Maglev specific, not public reflection API.
+      #
+      # Traverse the Ruby namespace hierarchy and execute block for
+      # all classes and modules.  Returns an IdentitySet of all
+      # classes and modules found.  Skips autoloads (i.e., does not
+      # trigger them and does not yield them to the block).
+      #
+      # @param [Module] klass The Class or Module object to start traversal.
+      #         Default is Object.
+      #
+      # @param [IdentitySet] rg The recursion guard used to prevent infinite
+      #         loops; also used as return value.
+      #
+      # @return [IdentitySet] An IdentitySet of all the Classes and Modules
+      #         registered in the Ruby namespace
+      #
+      def each_module(from=Object, rg=IdentitySet.new, &block)
+        unless rg.include?(from)
+          rg.add from
+          yield reflection.reflect(from) if block
+          if ns = from.__transient_namespace(1)
+            ns.values.each {|c| each_module(c, rg, &block) if Module === c }
+          end
+        end
+        rg
+      end
+
+    end
+  end
+end