rubymirrors 0.0.1

data/lib/rubinius/reflection.rb

@@ -0,0 +1,6 @@
+require 'ruby/reflection'
+
+module Rubinius
+  class Reflection < Ruby::Reflection
+  end
+end

data/lib/ruby/reflection.rb

@@ -0,0 +1,74 @@
+require 'abstract_reflection'
+require 'ruby/reflection/mirror'
+require 'ruby/reflection/object_mirror'
+require 'ruby/reflection/class_mirror'
+require 'ruby/reflection/field_mirror'
+require 'ruby/reflection/thread_mirror'
+require 'ruby/reflection/stack_frame_mirror'
+require 'ruby/reflection/method_mirror'
+
+module Ruby
+  class Reflection
+    include AbstractReflection
+
+    def self.codebase
+      nil.class
+    end
+
+    def initialize(ignored = nil)
+    end
+
+    def modules
+      instances_of(Module)
+    end
+
+    def classes
+      instances_of(Class)
+    end
+
+    def instances_of(klass)
+      mirrors ObjectSpace.each_object(klass).select {|obj| obj.class == klass }
+    end
+
+    def object_by_id(id)
+      if obj = ObjectSpace._id2ref(id)
+        reflect obj
+      else
+        nil
+      end
+    end
+
+    def threads
+      instances_of(Thread)
+    end
+
+    def platform
+      Object::RUBY_PLATFORM
+    end
+
+    def engine
+      Object::RUBY_ENGINE
+    end
+
+    def version
+      Object.const_get("#{engine.upcase}_VERSION")
+    end
+
+    def implementations_of(str)
+      mirrors methods.select {|m| m.name.to_s == str.to_s }
+    end
+
+    private
+    def methods
+      ObjectSpace.each_object(Module).collect do |m|
+        ims = m.instance_methods(false).collect {|s| m.instance_method(s) }
+        cms = m.methods(false).collect {|s| m.method(s) }
+        ims + cms
+      end.flatten
+    end
+
+    def mirrors(list)
+      list.collect {|each| reflect each }
+    end
+  end
+end

data/lib/ruby/reflection/class_mirror.rb

@@ -0,0 +1,89 @@
+module Ruby
+  class Reflection
+    class ClassMirror < ObjectMirror
+      include AbstractReflection::ClassMirror
+      reflect! Module
+
+      def class_variables
+        field_mirrors @subject.class_variables
+      end
+
+      def class_instance_variables
+        field_mirrors @subject.instance_variables
+      end
+
+      def source_files
+        locations = @subject.instance_methods(false).collect do |name|
+          method = @subject.instance_method(name)
+          file   = method.source_location if method.respond_to? :source_location
+          file.first if file
+        end
+        locations.compact.uniq
+      end
+
+      def singleton_class
+        reflection.reflect @subject.singleton_class
+      end
+
+      def singleton_class?
+        self.name =~ /^\#<Class:.*>$/
+      end
+
+      def mixins
+        mirrors @subject.ancestors.reject {|m| m.is_a? Class }
+      end
+
+      def superclass
+        reflection.reflect @subject.superclass
+      end
+
+      def subclasses
+        l = ObjectSpace.each_object(Class).select {|a| a.superclass == @subject }
+        mirrors l
+      end
+
+      def ancestors
+        mirrors @subject.ancestors
+      end
+
+      def constants
+        field_mirrors @subject.constants
+      end
+
+      def constant(str)
+        path = str.to_s.split("::")
+        c = path[0..-2].inject(@subject) {|klass,str| klass.const_get(str) }
+        field_mirror (c || @subject), path.last
+      rescue NameError => e
+        p e
+        nil
+      end
+
+      def nesting
+        ary = []
+        @subject.name.split("::").inject(Object) do |klass,str|
+          ary << klass.const_get(str)
+          ary.last
+        end
+        ary.reverse
+      rescue NameError => e
+        [@subject]
+      end
+
+      def nested_classes
+        nc = @subject.constants.collect do |c|
+          @subject.const_get(c) if @subject.const_defined? c
+        end.compact.select {|c| Module === c }
+        mirrors nc
+      end
+
+      def methods
+        @subject.instance_methods(false).collect(&:to_s)
+      end
+
+      def method(name)
+        reflection.reflect @subject.instance_method(name)
+      end
+    end
+  end
+end

data/lib/ruby/reflection/field_mirror.rb

@@ -0,0 +1,32 @@
+module Ruby
+  class Reflection
+    class FieldMirror < Mirror
+      include AbstractReflection::FieldMirror
+      Field = Struct.new(:object, :name)
+      reflect! Field
+
+      def self.mirror_class(field)
+        return unless reflects? field
+        case field.name.to_s
+        when /^@@/ then ClassVariableMirror
+        when /^@/  then InstanceVariableMirror
+        else            ConstantMirror
+        end
+      end
+
+      def initialize(obj)
+        super
+        @object = obj.object
+        @name = obj.name.to_s
+      end
+
+      def name
+        @name
+      end
+    end
+  end
+end
+
+require 'ruby/reflection/field_mirror/class_variable_mirror'
+require 'ruby/reflection/field_mirror/instance_variable_mirror'
+require 'ruby/reflection/field_mirror/constant_mirror'

data/lib/ruby/reflection/field_mirror/class_variable_mirror.rb

@@ -0,0 +1,25 @@
+module Ruby
+  class Reflection
+    class ClassVariableMirror < FieldMirror
+      def value
+        reflection.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
+end

data/lib/ruby/reflection/field_mirror/constant_mirror.rb

@@ -0,0 +1,36 @@
+module Ruby
+  class Reflection
+    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
+        reflection.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
+end

data/lib/ruby/reflection/field_mirror/instance_variable_mirror.rb

@@ -0,0 +1,25 @@
+module Ruby
+  class Reflection
+    class InstanceVariableMirror < FieldMirror
+      def value
+        reflection.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
+end

data/lib/ruby/reflection/method_mirror.rb

@@ -0,0 +1,122 @@
+begin
+  require 'method_source'
+rescue LoadError
+end
+begin
+  require 'ruby_parser' unless defined? RubyParser
+rescue LoadError
+end
+
+module Ruby
+  class Reflection
+    class MethodMirror < Mirror
+      include AbstractReflection::MethodMirror
+      reflect! Method, UnboundMethod
+
+      def file
+        source_location.first
+      end
+
+      def file=(name)
+        defining_class.reflectee.class_eval(source, name, line)
+        @subject = defining_class.method(selector)
+      end
+
+      def line
+        source_location.last
+      end
+
+      def line=(num)
+        defining_class.reflectee.class_eval(source, file, num)
+        @subject = defining_class.method(selector)
+      end
+
+      def selector
+        @subject.name.to_s
+      end
+
+      def defining_class
+        reflection.reflect try_send(:owner)
+      end
+
+      def delete
+        try_send(:owner).send(:remove_method, @subject.name)
+      end
+
+      def block_argument
+        args(:block).first
+      end
+
+      def splat_argument
+        args(:rest).first
+      end
+
+      def optional_arguments
+        args(:opt)
+      end
+
+      def required_arguments
+        args(:req)
+      end
+
+      def arguments
+        try_send(:parameters).map { |t,a| a.to_s }
+      end
+
+      def protected?
+        visibility? :protected
+      end
+
+      def public?
+        visibility? :public
+      end
+
+      def private?
+        visibility? :private
+      end
+
+      def source
+        try_send(:source) or raise(CapabilitiesExceeded)
+      end
+
+      def step_offsets
+        [1, *send_offsets.values]
+      end
+
+      def send_offsets
+        sexp = RubyParser.new.process(source).flatten
+        sends = sexp.each_with_index.map {|e,i| sexp[i-1] if e == :arglist }
+        sends = sends.compact.collect(&:to_s)
+
+        offsets = [0]
+        sends.each do |name|
+          offsets << (source[offsets.last..-1] =~ /#{Regexp.escape(name)}/)
+        end
+        offsets.shift
+        Hash[*sends.zip(offsets).flatten]
+      end
+
+      private
+
+      def visibility?(type)
+        list = try_send(:owner).send("#{type}_instance_methods")
+        list.any? { |m| m.to_s == selector }
+      end
+
+      def try_send(method)
+        raise CapabilitiesExceeded unless @subject.respond_to? method
+        @subject.send(method)
+      end
+
+      def args(type)
+        args = []
+        try_send(:parameters).select { |t,n| args << n.to_s if t == type }
+        args
+      end
+
+      def source_location
+        try_send(:source_location) or raise(CapabilitiesExceeded)
+      end
+    end
+  end
+end

data/lib/ruby/reflection/mirror.rb

@@ -0,0 +1,12 @@
+module Ruby
+  class Reflection
+    class Mirror
+      include AbstractReflection::Mirror
+
+      private
+      def mirrors(list)
+        list.collect {|each| reflection.reflect each }
+      end
+    end
+  end
+end

data/lib/ruby/reflection/object_mirror.rb

@@ -0,0 +1,25 @@
+module Ruby
+  class Reflection
+    class ObjectMirror < Mirror
+      include AbstractReflection::ObjectMirror
+      reflect! (defined?(BasicObject) ? BasicObject : Object)
+
+      def variables
+        field_mirrors @subject.instance_variables
+      end
+
+      def target_class
+        reflection.reflect @subject.class
+      end
+
+      private
+      def field_mirrors(list, subject = @subject)
+        list.collect {|name| field_mirror subject, name }
+      end
+
+      def field_mirror(subject, name)
+        reflection.reflect FieldMirror::Field.new(subject, name)
+      end
+    end
+  end
+end