mirrors 0.0.1

data/test/mirrors/iseq_visitor_test.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+require 'mirrors/visitors/disasm_visitor'
+
+module Mirrors
+  class ISeqVisitorTest < MiniTest::Test
+    class CountingVisitor < Mirrors::ISeqVisitor
+      attr_reader :count
+      def initialize
+        @count = 0
+      end
+
+      def visit(_bytecode)
+        @count += 1
+      end
+    end
+
+    def test_all_methods
+      class_count = 0
+      method_count = 0
+      bytecode_count = 0
+      smallest = 1024
+      smallest_method = nil
+      largest = 0
+      largest_method = nil
+
+      Mirrors.classes.each do |clazz|
+        clazz.methods.each do |meth|
+          visitor = CountingVisitor.new
+          visitor.call(meth)
+          bytecode_count += visitor.count
+
+          if visitor.count > largest
+            largest = visitor.count
+            largest_method = meth
+          end
+
+          if visitor.count < smallest && visitor.count > 0
+            smallest = visitor.count
+            smallest_method = meth
+          end
+          bytecode_count += visitor.count
+          method_count += 1
+        end
+        class_count += 1
+      end
+      assert(class_count >= 788)
+      assert(method_count >= 4782)
+      assert(bytecode_count >= 47308)
+
+      puts "Walked #{class_count} classes with #{method_count} methods and #{bytecode_count} bytecodes."
+      puts "Largest method #{largest_method.defining_class.name}.#{largest_method.name}, #{largest} bytecodes."
+      puts "Smallest method #{smallest_method.defining_class.name}.#{smallest_method.name}, #{smallest} bytecodes."
+      puts "Average method #{bytecode_count / method_count}  bytecodes."
+    end
+  end
+end

data/test/mirrors/marker_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+module Mirrors
+  class MarkerTest < MiniTest::Test
+    def setup
+      @class_marker = Marker.new(type: Marker::TYPE_CLASS_REFERENCE, message: 'Class', file: __FILE__, line: __LINE__)
+      @field_marker = Marker.new(type: Marker::TYPE_FIELD_REFERENCE, message: 'Field', file: __FILE__, line: __LINE__)
+      @method_marker = Marker.new(type: Marker::TYPE_METHOD_REFERENCE, message: 'Method', file: __FILE__, line: __LINE__)
+      super
+    end
+
+    def test_class_marker
+      assert_equal(Marker::TYPE_CLASS_REFERENCE, @class_marker.type)
+      assert_equal('Class', @class_marker.message)
+      assert_equal(__FILE__, @class_marker.file)
+      assert_equal(6, @class_marker.line)
+      assert_equal(Marker::NO_COLUMN, @class_marker.start_column)
+      assert_equal(Marker::NO_COLUMN, @class_marker.end_column)
+    end
+
+    def test_field_marker
+      assert_equal(Marker::TYPE_FIELD_REFERENCE, @field_marker.type)
+      assert_equal('Field', @field_marker.message)
+      assert_equal(__FILE__, @field_marker.file)
+      assert_equal(7, @field_marker.line)
+      assert_equal(Marker::NO_COLUMN, @field_marker.start_column)
+      assert_equal(Marker::NO_COLUMN, @field_marker.end_column)
+    end
+
+    def test_method_marker
+      assert_equal(Marker::TYPE_METHOD_REFERENCE, @method_marker.type)
+      assert_equal('Method', @method_marker.message)
+      assert_equal(__FILE__, @method_marker.file)
+      assert_equal(8, @method_marker.line)
+      assert_equal(Marker::NO_COLUMN, @method_marker.start_column)
+      assert_equal(Marker::NO_COLUMN, @method_marker.end_column)
+    end
+
+    def test_hash_and_equal
+      m1 = @class_marker
+      m2 = @class_marker.dup
+      assert(m1.object_id != m2.object_id)
+      assert(m1 == m2)
+      assert(m1.eql?(m2))
+      assert_equal(m1.hash, m2.hash)
+    end
+  end
+end

data/test/mirrors/method_mirror_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+module Mirrors
+  class MethodMirrorTest < MiniTest::Test
+    def setup
+      @cm = Mirrors.reflect(MethodSpecFixture)
+      super
+    end
+
+    def test_source_location
+      @f = MethodSpecFixture
+      m = MethodSpecFixture.instance_method(:source_location)
+      @m = Mirrors.reflect(m)
+
+      assert_equal(@f.new.source_location[0],      @m.file)
+      assert_equal(@f.new.source_location[1] - 2,  @m.line)
+      assert_equal(@f.new.source_location[2],      @m.selector)
+      assert_equal(@f.new.source_location[3].name, @m.defining_class.name)
+      assert_includes(@m.source, '[__FILE__, __LINE__, __method__.to_s, self.class]')
+    end
+
+    def test_arguments
+      m = Mirrors.reflect(method(:method_b))
+      assert_equal(%w(a b bb args block), m.arguments)
+      assert_equal("block",  m.block_argument)
+      assert_equal(%w(a),    m.required_arguments)
+      assert_equal(%w(b bb), m.optional_arguments)
+      assert_equal('args',   m.splat_argument)
+    end
+
+    def test_public_method
+      m = @cm.method(:method_p_public)
+      assert(m.public?)
+      refute(m.protected?)
+      refute(m.private?)
+      assert_equal(:public, m.visibility)
+    end
+
+    def test_protected_method
+      m = @cm.method(:method_p_protected)
+      refute(m.public?)
+      assert(m.protected?)
+      refute(m.private?)
+      assert_equal(:protected, m.visibility)
+    end
+
+    def test_private_method
+      m = @cm.method(:method_p_private)
+      refute(m.public?)
+      refute(m.protected?)
+      assert(m.private?)
+      assert_equal(:private, m.visibility)
+    end
+
+    private
+
+    def method_b(a, b = 1, bb = 2, *args, &block)
+      to_s
+      super
+    end
+  end
+end

data/test/mirrors/object_mirror_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+module Mirrors
+  class ObjectMirrorTest < MiniTest::Test
+    def setup
+      @o = ObjectFixture.new
+      @m = Mirrors.reflect(@o)
+      super
+    end
+
+    def test_variables
+      vars = @m.variables
+      assert_equal(["@ivar"], vars.map(&:name))
+    end
+  end
+end

data/test/mirrors/package_inference_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Mirrors
+  class PackageInferenceTest <  MiniTest::Test
+
+    def test_core
+      assert_equal('core', PackageInference.infer_from(Object))
+      assert_equal('core', PackageInference.infer_from(Errno::EAGAIN))
+    end
+
+    def test_stdlib
+      require 'digest'
+      assert_equal('core:stdlib', PackageInference.infer_from(Digest))
+      assert_equal('core:stdlib', PackageInference.infer_from(Digest::SHA256))
+    end
+
+    def test_gems
+      assert_equal('gems:minitest', PackageInference.infer_from(MiniTest))
+      assert_equal('gems:minitest', PackageInference.infer_from(MiniTest::Test))
+    end
+
+    def test_application
+      assert_equal('application', PackageInference.infer_from(Mirrors))
+    end
+
+    def test_unknown_eval
+      eval('class Unknown; end')
+      assert_equal('unknown:eval', PackageInference.infer_from(Unknown))
+    end
+  end
+end

data/test/mirrors/references_visitor_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+require 'mirrors/index/marker'
+
+module Mirrors
+  class ReferencesVisitorTest < MiniTest::Test
+    class Victim
+      def lol
+        @ivar += 1 # touch one of the ivars
+        to_s # send to_s
+        Kernel.exit # reference another class
+      end
+    end
+
+    def test_victim_class
+      method = Victim.reflect.methods.first
+      refs = method.references
+      assert_equal(4, refs.size)
+      c1 = Marker.new(type: Marker::TYPE_CLASS_REFERENCE, message: :Kernel, file: __FILE__, line: 10)
+      m1 = Marker.new(type: Marker::TYPE_METHOD_REFERENCE, message: :to_s, file: __FILE__, line: 9)
+      m2 = Marker.new(type: Marker::TYPE_METHOD_REFERENCE, message: :exit, file: __FILE__, line: 10)
+      f1 = Marker.new(type: Marker::TYPE_FIELD_REFERENCE, message: :@ivar, file: __FILE__, line: 8)
+
+      assert_equal('lol', method.selector) # ensure that we have the right method
+      assert(refs.include?(c1))
+      assert(refs.include?(m1))
+      assert(refs.include?(m2))
+      assert(refs.include?(f1))
+    end
+  end
+end

data/test/mirrors_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class MirrorsTest < MiniTest::Test
+  def test_modules
+    modules = Mirrors.modules.collect(&:name)
+    assert_includes(modules, "ReflectModule")
+    refute_includes(modules, "ReflectClass")
+  end
+
+  def test_classes
+    classes = Mirrors.classes.collect(&:name)
+    refute_includes(classes, "ReflectModule")
+    assert_includes(classes, "ReflectClass")
+  end
+
+  def test_instances_of
+    klass1 = Class.new
+    klass2 = Class.new(klass1)
+    inst1 = klass1.new
+    inst2 = klass2.new
+    instances = Mirrors.instances_of(klass1).map(&:name)
+    assert_includes(instances, inst1.inspect)
+    refute_includes(instances, inst2.inspect)
+  end
+
+  def test_object_by_id
+    o = Object.new
+    assert_equal(o.inspect, Mirrors.object_by_id(o.object_id).name)
+  end
+
+  def test_implementations_of
+    l = Mirrors.implementations_of("unique_reflect_fixture_method")
+    assert_equal(Array, l.class)
+    assert_equal(1, l.size)
+    assert_equal("unique_reflect_fixture_method", l.first.selector)
+    assert_equal("ReflectClass", l.first.defining_class.name)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.expand_path('..', __FILE__))
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'mirrors'
+
+require 'fixtures/reflect'
+require 'fixtures/class'
+require 'fixtures/object'
+require 'fixtures/method'
+require 'fixtures/field'
+
+require 'minitest/autorun'

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: mirrors
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Burke Libbey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.0.6
+- !ruby/object:Gem::Dependency
+  name: method_source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Provides a number of specs and classes that document a mirror API for
+  Ruby.
+email:
+- burke.libbey@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- asdfasdf.rb
+- bin/bundler
+- bin/byebug
+- bin/testunit
+- circle.yml
+- dev.yml
+- lib/mirrors.rb
+- lib/mirrors/class_mirror.rb
+- lib/mirrors/class_mixin.rb
+- lib/mirrors/field_mirror.rb
+- lib/mirrors/field_mirror/class_variable_mirror.rb
+- lib/mirrors/field_mirror/constant_mirror.rb
+- lib/mirrors/field_mirror/instance_variable_mirror.rb
+- lib/mirrors/hook.rb
+- lib/mirrors/index/indexer.rb
+- lib/mirrors/index/marker.rb
+- lib/mirrors/invoke.rb
+- lib/mirrors/method_mirror.rb
+- lib/mirrors/mirror.rb
+- lib/mirrors/object_mirror.rb
+- lib/mirrors/package_inference.rb
+- lib/mirrors/package_inference/class_to_file_resolver.rb
+- lib/mirrors/package_mirror.rb
+- lib/mirrors/visitors/disasm_visitor.rb
+- lib/mirrors/visitors/iseq_visitor.rb
+- lib/mirrors/visitors/references_visitor.rb
+- lib/mirrors/visitors/yasmdata.rb
+- lol.rb
+- mirrors.gemspec
+- test/fixtures/class.rb
+- test/fixtures/field.rb
+- test/fixtures/method.rb
+- test/fixtures/object.rb
+- test/fixtures/reflect.rb
+- test/mirrors/class_mirror_test.rb
+- test/mirrors/field_mirror_test.rb
+- test/mirrors/iseq_visitor_test.rb
+- test/mirrors/marker_test.rb
+- test/mirrors/method_mirror_test.rb
+- test/mirrors/object_mirror_test.rb
+- test/mirrors/package_inference_test.rb
+- test/mirrors/references_visitor_test.rb
+- test/mirrors_test.rb
+- test/test_helper.rb
+homepage: https://github.com/Shopify/mirrors
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Mirror API for Ruby
+test_files: []