mirrors 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0d3d02baa921913fcc9ac830bba816d1a9f47339
+  data.tar.gz: 71253ea57e8ae471532753da621496811112da9b
+SHA512:
+  metadata.gz: 6922717b62cd336253f51223ff28b3c7be93471c15f7117d92e6b61796a562c613c027ac0185275aa6947c7631e24e7b586113850652ef80f13ff6420db86fa2
+  data.tar.gz: 4f3ffb84b4cada62a5f67b47be3484dbb832b62831c886a73554d12c0f6f9641e69466e51cb5abc0393b62ab16dd2e3a4ace12d14a855ebb63b836c87dcbe764

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+.rubocop-http*
+.byebug_history
+.vscode/

data/.rubocop.yml

@@ -0,0 +1,2 @@
+inherit_from:
+  - http://shopify.github.io/ruby-style-guide/rubocop.yml

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    mirrors (0.0.1)
+      method_source (~> 0.8)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (9.0.6)
+    method_source (0.8.2)
+    minitest (5.9.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug (~> 9.0.6)
+  minitest (~> 5.0)
+  mirrors!
+
+BUNDLED WITH
+   1.13.6

data/LICENSE.txt

@@ -0,0 +1,59 @@
+Copyright (c) 2016 Burke Libbey, Shopify
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. The names of the contributors may not be used
+       to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+--- most code derived from github.com/timfel/rubymirrors ---
+
+
+Copyright (c) Tim Felgentreff and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. The names of the contributors may not be used
+       to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1 @@
+Use `bin/frontend` and `bin/backend`.

data/asdfasdf.rb

@@ -0,0 +1,53 @@
+class Resolver
+  def resolve(klass)
+    @files ||= {}
+
+    klass.instance_methods(false).each do |name|
+      meth = klass.instance_method(name)
+
+      file = begin
+        meth.source_location[0]
+      rescue # ???
+        next
+      end
+
+      contents = (@files[file] ||= File.open(file, 'r') { |f| f.readpartial(4096) })
+      n = klass.name.sub(/.*::/, '') # last component of module name
+      return file if contents =~ /^\s+(class|module) ([\S]+::)?#{Regexp.quote(n)}\s/
+    end
+    nil
+  end
+end
+
+def infer_class_file_from_methods(klass)
+  if m = Resolver.new.resolve(klass)
+    return m
+  end
+
+  methods = klass
+    .instance_methods(false)
+    .map { |n| klass.instance_method(n) }
+
+  defined_directly_on_class = methods
+    .select do |meth|
+      # aliased methods can show up with instance_methods(false)
+      # but their source_location and owner point to the module they came from.
+      meth.owner == klass &&
+        meth.source =~ /\A\s+def #{Regexp.quote(meth.name)}/
+      # as a mostly-useful heuristic, we just eliminate everything that was
+      # defined using a template eval or define_method.
+    end
+
+  files = Hash.new(0)
+
+  defined_directly_on_class.each do |meth|
+    begin
+      files[meth.source_location[0]] += 1
+    rescue # which class?
+      raise
+    end
+  end
+
+  file = files.max_by { |k, v| v }
+  file ? file[0] : nil
+end

data/bin/bundler

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'bundler' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("bundler", "bundler")

data/bin/byebug

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'byebug' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("byebug", "byebug")

data/bin/testunit

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+if [ $# -eq 0 ]; then
+  ruby -I"test" -e 'Dir.glob("./test/**/*_test.rb").each { |f| require f }' -- "$@"
+else
+  path=$1
+  ruby -I"test" -e "require '${path#test/}'" -- "$@"
+fi

data/circle.yml

@@ -0,0 +1,6 @@
+machine:
+  ruby:
+    version: ruby-2.3.1
+test:
+  override:
+    - bundle exec bin/testunit

data/dev.yml

@@ -0,0 +1,6 @@
+up:
+  - ruby: 2.3.1
+  - bundler
+commands:
+  test:    bundle exec bin/testunit
+  console: bundle exec irb -r mirrors

data/lib/mirrors.rb

@@ -0,0 +1,150 @@
+require 'logger'
+require 'mirrors/mirror'
+require 'mirrors/object_mirror'
+require 'mirrors/class_mirror'
+require 'mirrors/field_mirror'
+require 'mirrors/method_mirror'
+require 'mirrors/package_mirror'
+require 'mirrors/package_inference'
+require 'mirrors/class_mixin'
+require 'mirrors/index/indexer'
+
+module Mirrors
+  extend self
+
+  @class_mirrors = {}
+  @constant_mirrors = {}
+  @watches = {}
+  @logger = Logger.new(STDOUT)
+
+  def packages
+    packages = {}
+    # Object is the top-level.
+    Object.constants.each do |const|
+      pkg = PackageInference.infer_from_toplevel(const)
+      packages[pkg] = true
+    end
+    toplevel_packages = packages.keys.map { |pkg| pkg.sub(/:.*/, '') }.sort
+    package_mirrors(toplevel_packages)
+  end
+
+  # This method can be used to query the system for known modules. It
+  # is not guaranteed that all possible modules are returned.
+  #
+  # @return [Array<ClassMirror>] a list of class mirrors
+  def modules
+    instances_of(Module).sort! { |a, b| a.name <=> b.name }
+  end
+
+  # This method can be used to query the system for known classes. It
+  # is not guaranteed that all possible classes are returned.
+  #
+  # @return [Array<ClassMirror>] a list of class mirrors
+  def classes
+    instances_of(Class).sort! { |a, b| a.name <=> b.name }
+  end
+
+  # Query the system for objects that are direct instances of the
+  # given class.
+  # @param [Class]
+  # @return [Array<ObjectMirror>] a list of appropriate mirrors for the requested objects
+  def instances_of(klass)
+    mirrors(ObjectSpace.each_object(klass).select { |obj| obj.class == klass })
+  end
+
+  # Ask the system to find the object with the given object id
+  # @param [Numeric] object id
+  # @return [ObjectMirror, NilClass] the object mirror or nil
+  def object_by_id(id)
+    obj = ObjectSpace._id2ref(id)
+    obj ? reflect(obj) : nil
+  end
+
+  # Query the system for implementors of a particular message
+  # @param [String] the message name
+  # @return [Array<MethodMirror>] the implementing methods
+  def implementations_of(str)
+    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
+
+    mirrors(methods.select { |m| m.name.to_s == str.to_s })
+  end
+
+  def references_to(str)
+    filtered = {}
+    Mirrors.classes.each do |klass|
+      klass.methods.each do |m|
+        refs = m.references.select { |marker| marker.message.match(str) }
+        filtered[m] = refs unless refs.empty?
+      end
+    end
+    filtered
+  end
+
+  # Create a mirror for a given object in the system under
+  # observation.  This is *the* factory method for all mirror
+  # instances, interning and cache invalidation will be added here.
+  #
+  # @param [Object]
+  # @return [Mirror]
+  def reflect(obj)
+    klass = basic_class(obj)
+    mirror =
+      if klass == FieldMirror::Field || klass == Symbol
+        case obj.name.to_s
+        when /^@@/
+          intern_field_mirror(ClassVariableMirror.new(obj))
+        when /^@/
+          # instance variables not interned as they are not guaranteed to be
+          # present in all instances
+          InstanceVariableMirror.new(obj)
+        else
+          intern_field_mirror(ConstantMirror.new(obj))
+        end
+      elsif klass == Method || klass == UnboundMethod
+        intern_method_mirror(MethodMirror.new(obj))
+      elsif klass == Class || klass == Module
+        intern_class_mirror(ClassMirror.new(obj))
+      else
+        # TODO: revisit if ObjectMirror delivers value
+        ObjectMirror.new(obj)
+      end
+    raise "badness" unless mirror.is_a?(Mirror)
+    mirror
+  end
+
+  private
+
+  # find the class of obj
+  def basic_class(obj)
+    Kernel.instance_method(:class).bind(obj).call
+  end
+
+  # find the class name of obj
+  def basic_class_name(klass)
+    Class.instance_method(:name).bind(klass).call
+  end
+
+  def intern_class_mirror(mirror)
+    interned = @class_mirrors[mirror.name] ||= mirror
+  end
+
+  def intern_method_mirror(mirror)
+    mirror.defining_class.intern_method_mirror(mirror)
+  end
+
+  def intern_field_mirror(mirror)
+    mirror.defining_class.intern_field_mirror(mirror)
+  end
+
+  def mirrors(list)
+    list.map { |e| reflect(e) }
+  end
+
+  def package_mirrors(list)
+    list.map { |e| PackageMirror.reflect(e) }
+  end
+end

data/lib/mirrors/class_mirror.rb

@@ -0,0 +1,197 @@
+module Mirrors
+  # A specific mirror for a class, that includes all the capabilites
+  # and information we can gather about classes.
+  class ClassMirror < ObjectMirror
+    def initialize(obj)
+      super(obj)
+      @field_mirrors = {}
+      @method_mirrors = {}
+    end
+
+    def is_class
+      @subject.is_a?(Class)
+    end
+
+    def package
+      # TODO(burke)
+    end
+
+    def fields
+      [constants, class_variables, class_instance_variables, instance_variables].flatten
+    end
+
+    # The known class variables.
+    # @see #instance_variables
+    # @return [Array<FieldMirror>]
+    def class_variables
+      field_mirrors(@subject.class_variables)
+    end
+
+    # The known class variables.
+    # @see #instance_variables
+    # @return [Array<FieldMirror>]
+    def class_instance_variables
+      field_mirrors(@subject.instance_variables)
+    end
+
+    # The source files this class is defined and/or extended in.
+    #
+    # @return [Array<String,File>]
+    def source_files
+      locations = @subject.instance_methods(false).collect do |name|
+        method = @subject.instance_method(name)
+        sl = method.source_location
+        sl.first if sl
+      end
+      locations.compact.uniq
+    end
+
+    # The singleton class of this class
+    #
+    # @return [ClassMirror]
+    def singleton_class
+      Mirrors.reflect(@subject.singleton_class)
+    end
+
+    # Predicate to determine whether the subject is a singleton class
+    #
+    # @return [true,false]
+    def singleton_class?
+      name.match(/^\#<Class:.*>$/)
+    end
+
+    # The mixins included in the ancestors of this class.
+    #
+    # @return [Array<ClassMirror>]
+    def mixins
+      mirrors(@subject.ancestors.reject { |m| m.is_a?(Class) })
+    end
+
+    # The direct superclass
+    #
+    # @return [ClassMirror]
+    def superclass
+      Mirrors.reflect(@subject.superclass)
+    end
+
+    # The known subclasses
+    #
+    # @return [Array<ClassMirror>]
+    def subclasses
+      mirrors(ObjectSpace.each_object(Class).select { |a| a.superclass == @subject })
+    end
+
+    # The list of ancestors
+    #
+    # @return [Array<ClassMirror>]
+    def ancestors
+      mirrors(@subject.ancestors)
+    end
+
+    # The constants defined within this class. This includes nested
+    # classes and modules, but also all other kinds of constants.
+    #
+    # @return [Array<FieldMirror>]
+    def constants
+      field_mirrors(@subject.constants)
+    end
+
+    # Searches for the named constant in the mirrored namespace. May
+    # include a colon (::) separated constant path. This _may_ trigger
+    # an autoload!
+    #
+    # @return [ClassMirror, nil] the requested constant, or nil
+    def constant(str)
+      path = str.to_s.split("::")
+      c = path[0..-2].inject(@subject) { |klass, s| klass.const_get(s) }
+      field_mirror (c || @subject), path.last
+    rescue NameError => e
+      p e
+      nil
+    end
+
+    # The full nesting.
+    #
+    # @return [Array<ClassMirror>]
+    def nesting
+      ary = []
+      @subject.name.split('::').inject(Object) do |klass, str|
+        ary << klass.const_get(str)
+        ary.last
+      end
+      ary.reverse
+    rescue NameError
+      [@subject]
+    end
+
+    # The classes nested within the subject. Should _not_ trigger
+    # autloads!
+    #
+    # @return [Array<ClassMirror>]
+    def nested_classes
+      nc = @subject.constants.collect do |c|
+        # do not trigger autoloads
+        if @subject.const_defined?(c) && !@subject.autoload?(c)
+          @subject.const_get(c)
+        end
+      end
+      mirrors(nc.compact.select { |c| c.is_a?(Module) }.sort_by(&:name))
+    end
+
+    def nested_class_count
+      nested_classes.count
+    end
+
+    # The instance methods of this class. To get to the class methods,
+    # ask the #singleton_class for its methods.
+    #
+    # @return [Array<MethodMirror>]
+    def methods
+      pub_names  = @subject.public_instance_methods(false)
+      prot_names = @subject.protected_instance_methods(false)
+      priv_names = @subject.private_instance_methods(false)
+
+      mirrors = []
+      pub_names.sort.each do |n|
+        mirrors << Mirrors.reflect(@subject.instance_method(n))
+      end
+      prot_names.sort.each do |n|
+        mirrors << Mirrors.reflect(@subject.instance_method(n))
+      end
+      priv_names.sort.each do |n|
+        mirrors << Mirrors.reflect(@subject.instance_method(n))
+      end
+      mirrors
+    end
+
+    # The instance method of this class or any of its superclasses
+    # that has the specified selector
+    #
+    # @return [MethodMirror, nil] the method or nil, if none was found
+    def method(name)
+      Mirrors.reflect @subject.instance_method(name)
+    end
+
+    # to work around overridden `name` methods
+    MODULE_INSPECT = Module.instance_method(:inspect)
+    def name
+      MODULE_INSPECT.bind(@subject).call
+    rescue
+      puts @subject.inspect
+      puts @subject.class
+      raise
+    end
+
+    def demodulized_name
+      name.split('::').last
+    end
+
+    def intern_method_mirror(mirror)
+      @method_mirrors[mirror.name] ||= mirror
+    end
+
+    def intern_field_mirror(mirror)
+      @field_mirrors[mirror.name] ||= mirror
+    end
+  end
+end