object_shadow 1.0.0

data/lib/object_shadow/instance_variables.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class ObjectShadow
+  module InstanceVariables
+    # Returns the instance variable given
+    # Please note: Does not expect @ prefix
+    def [](ivar_name)
+      object.instance_variable_get(:"@#{ivar_name}")
+    end
+
+    # Sets the instance variable given
+    # Please note: Does not expect @ prefix
+    def []=(ivar_name, value)
+      object.instance_variable_set(:"@#{ivar_name}", value)
+    end
+
+    def remove(ivar_name)
+      object.remove_instance_variable(:"@#{ivar_name}")
+    end
+
+    def variable?(ivar_name)
+      object.instance_variable_defined?(:"@#{ivar_name}")
+    end
+
+    def variables
+      object.instance_variables.map{ |ivar| ivar[1..-1].to_sym }
+    end
+
+    def to_h
+      variables.map{ |ivar| [ivar, self[ivar]] }.to_h
+    end
+
+    def to_a
+      variables.map{ |ivar| self[ivar] }
+    end
+  end
+end

data/lib/object_shadow/method_introspection.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+class ObjectShadow
+  module MethodIntrospection
+    # #shadow#methods returns a sorted list of methods related to the object
+    # in question. It lets you specify the kind of methods you want to retrieve
+    # by the following keyword parameters:
+    #
+    # target: (default :self)
+    #
+    # - :self - This returns the list of methods available to call
+    #           on the current object, including singleton methods
+    #           If the object is a class/module, this means that it
+    #           will return class methods
+    #
+    # - :class - This will refer to the object's class (via the `class`) method
+    #            and return its methods, usually to be called from an instance
+    #            If called for a class or module, it will return `Class`' methods
+    #
+    # - :instances - This will list all methods which instances of the class (or the class
+    #                that includes the module, in case of a module) in question will have
+    #                Raises an ArgumentError when called on with a non-`Module`
+    #
+    #
+    # scope: (default :public)
+    #
+    # - :public - Restrict to to methods of public visibility
+    #
+    # - :protected - Restrict to to methods of protected visibility
+    #
+    # - :private - Restrict to to methods of private visibility
+    #
+    # - :all - Restrict to to methods of public visibility
+    #
+    #
+    # inherit: (default :exclude_object)
+    #
+    # - :singleton - Show only methods directly defined in the object's singleton class
+    #
+    # - :self  - Show singleton methods and methods directly defined in the object's class,
+    #            but do not traverse the inheritance chain
+    #
+    # - :exclude_class - Stop inheritance chain just before Class or Module. For
+    #                    non-modules it fallbacks to :exclude_object
+    #
+    # - :exclude_object - Stop inheritance chain just before Object
+    #
+    # - :all - Show methods from the whole inheritance chain
+    #
+    def methods(target: :self, scope: :public, inherit: :exclude_class)
+      MethodIntrospection.lookup_chain_for(object, target, inherit, true).flat_map { |lookup_class|
+        full_inheritance_lookup = inherit == :all || inherit == true
+
+        case scope
+        when :public
+          lookup_class.public_instance_methods(full_inheritance_lookup)
+        when :protected
+          lookup_class.protected_instance_methods(full_inheritance_lookup)
+        when :private
+          lookup_class.private_instance_methods(full_inheritance_lookup)
+        when :all
+          lookup_class.instance_methods(full_inheritance_lookup) +
+          lookup_class.private_instance_methods(full_inheritance_lookup)
+        else
+          Kernel.raise ArgumentError, \
+            "(ObjectShadow) Method scope: must be one of [:public, :protected, :private, :all]"
+        end
+      }.uniq.sort
+    end
+
+    # Returns true if a method of this name is defined
+    # First parameter is the name of the method in question
+    #
+    # - target: must be one of [:self, :class, :instances]
+    #
+    def method?(method_name, target: :self)
+      MethodIntrospection.simple_lookup_chain_for(object, target).any?{ |lookup_class|
+        if RUBY_VERSION >= "2.6.0"
+          lookup_class.method_defined?(method_name, true) ||
+          lookup_class.private_method_defined?(method_name, true)
+        else
+          lookup_class.method_defined?(method_name) ||
+          lookup_class.private_method_defined?(method_name)
+        end
+      }
+    end
+
+    # Returns the scope of method name given
+    #
+    # - target: must be one of [:self, :class, :instances]
+    #
+    # Possible return values: [:public, :protected, :private, nil]
+    #
+    def method_scope(method_name, target: :self)
+      MethodIntrospection.simple_lookup_chain_for(object, target).map{ |lookup_class|
+        if RUBY_VERSION >= "2.6.0"
+          case
+          when lookup_class.public_method_defined?(method_name, true)
+            :public
+          when lookup_class.protected_method_defined?(method_name, true)
+            :protected
+          when lookup_class.private_method_defined?(method_name, true)
+            :private
+          else
+            nil
+          end
+        else
+          case
+          when lookup_class.public_method_defined?(method_name)
+            :public
+          when lookup_class.protected_method_defined?(method_name)
+            :protected
+          when lookup_class.private_method_defined?(method_name)
+            :private
+          else
+            nil
+          end
+        end
+      }.compact.first
+    end
+
+    # Returns the objectified reference to a method
+    #
+    # - target: must be one of [:self, :class, :instances]
+    #
+    # Pass unbind: true if you always want UnboundMethod objects
+    #
+    # Pass all: true to not only get the method that would be called,
+    # but an Array with every occurrence of this method along the inheritance chain
+    def method(method_name, target: :self, unbind: false, all: false)
+      if all
+        MethodIntrospection.lookup_chain_for(object, target, :all).map{ |lookup_class|
+          if  lookup_class.instance_methods(false).include?(method_name) ||
+              lookup_class.private_instance_methods(false).include?(method_name)
+            lookup_class.instance_method(method_name)
+          end
+        }.compact
+      else
+        MethodIntrospection.get_method(object, target, method_name, unbind)
+      end
+    end
+
+    # Returns the lookup/ancestor chain for an object
+    #
+    # - target: must be one of [:self, :class, :instances]
+    #
+    # Takes the same inherit options like #methods
+    def method_lookup_chain(target: :self, inherit: :exclude_class)
+      MethodIntrospection.lookup_chain_for(object, target, inherit)
+    end
+
+    class << self
+      def lookup_chain_for(object, target, inherit, optimize = false)
+        validate_arguments! object, target, inherit
+        singleton, klass, chain = get_singleton_klass_and_chain(object, target)
+
+        case inherit
+        when :singleton
+          singleton
+        when :self, false
+          singleton + klass
+        when :exclude_class
+          singleton + chain[0...(chain.index(Class) || chain.index(Module) || chain.index(Object))]
+        when :exclude_object
+          singleton + chain[0...chain.index(Object)]
+        when Module
+          singleton + chain[0..chain.index(inherit)]
+        when :all, true
+          if optimize # full chain build by Ruby using (all=true) param in list
+            singleton + klass
+          else
+            singleton + chain
+          end
+        end
+      end
+
+      def simple_lookup_chain_for(object, target)
+        validate_arguments! object, target
+        singleton, klass, = get_singleton_klass_and_chain(object, target)
+
+        singleton + klass
+      end
+
+      def get_method(object, target, method_name, unbind)
+        case target
+        when :self
+          if unbind
+            object.method(method_name).unbind()
+          else
+            object.method(method_name)
+          end
+        when :class
+          if unbind
+            object.class.method(method_name).unbind()
+          else
+            object.class.method(method_name)
+          end
+        when :instances
+          object.instance_method(method_name)
+        else
+          Kernel.raise ArgumentError, "(ObjectShadow) target: must be one of [:self, :class, :instances]"
+        end
+      rescue NameError
+        nil
+      end
+
+      private
+
+      # Explanation:
+      # - singleton: [singleton_class] or [] if not retrievable
+      # - klass: [first entry of inheritance chain] or [] for modules
+      # - chain: inheritance chain without singleton
+      def get_singleton_klass_and_chain(object, target)
+        target_object = target == :class ? object.class : object
+
+        begin
+          if target == :instances
+            singleton = []
+            klass = target_object.ancestors[0, 1]
+            chain = target_object.ancestors
+          else
+            singleton = [target_object.singleton_class]
+
+            if target_object.is_a? Module
+              klass = []
+              chain = target_object.singleton_class.ancestors[1..-1]
+            else
+              klass = target_object.singleton_class.ancestors[1, 1]
+              chain = target_object.singleton_class.ancestors[1..-1]
+            end
+          end
+        rescue TypeError # e.g. Integer
+          singleton = []
+          klass = target_object.class.ancestors[0, 1]
+          chain = target_object.class.ancestors
+        end
+
+        [singleton, klass, chain]
+      end
+
+      def validate_arguments!(object, target, inherit = nil)
+        unless [:self, :class, :instances].include?(target)
+          Kernel.raise ArgumentError, "(ObjectShadow) target: must be one of [:self, :class, :instances]"
+        end
+
+        if target == :instances
+          if !object.is_a?(Module)
+            Kernel.raise ArgumentError, "(ObjectShadow) target: can only be set to :instances for classes and modules"
+          end
+
+          if inherit == :singleton
+            Kernel.raise ArgumentError, "(ObjectShadow) cannot request :singleton inheritance when target is :instances"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/object_shadow/object_method.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ObjectShadow
+  module ObjectMethod
+    def shadow
+      ObjectShadow.new(self)
+    end
+  end
+end
+
+Object.include(ObjectShadow::ObjectMethod)

data/lib/object_shadow/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "basic_object"
+
+class ObjectShadow
+  VERSION = "1.0.0"
+end

data/lib/object_shadow/wrap.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class ObjectShadow
+  module Wrap
+    attr_reader :object
+
+    def initialize(object)
+      @object = object
+    end
+
+    # Since shadows are not supposed to be passed around, to_s is left neutral
+    def to_s
+      "#<ObjectShadow of #{object.inspect}>"
+    end
+
+    # The base inspect is boring, too, but it will be improved by InfoInspect
+    alias inspect to_s
+  end
+end

data/object_shadow.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require File.dirname(__FILE__) + "/lib/object_shadow/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "object_shadow"
+  gem.version       = ObjectShadow::VERSION
+  gem.summary       = "Metaprogramming Level 2"
+  gem.description   = "provides a simple convenient API for accessing an object's state."
+  gem.authors       = ["Jan Lelis"]
+  gem.email         = ["mail@janlelis.de"]
+  gem.homepage      = "https://github.com/janlelis/object_shadow"
+  gem.license       = "MIT"
+
+  gem.files         = Dir["{**/}{.*,*}"].select{ |path| File.file?(path) && path !~ /^pkg/ && path !~ /png\z/ }
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = "~> 2.0"
+end

data/spec/object_shadow_instance_variables_spec.rb

@@ -0,0 +1,71 @@
+require_relative "../lib/object_shadow"
+require "minitest/autorun"
+
+describe "Object#shadow" do
+  let :c do
+    Class.new do
+      def initialize
+        @ivar = 42
+        @another_variable = 43
+      end
+    end
+  end
+
+  let :o do
+    c.new
+  end
+
+  describe "#variables" do
+    it "shows list of instance variable names" do
+      assert_equal \
+        [:ivar, :another_variable],
+        o.shadow.variables
+    end
+  end
+
+  describe "#variable?" do
+    it "returns true if variable is defined" do
+      assert \
+        o.shadow.variable?(:ivar)
+    end
+
+    it "returns false if variable is not defined" do
+      refute \
+        o.shadow.variable?(:ovar)
+    end
+  end
+
+  describe "#[]" do
+    it "returns value of given instance variable name" do
+      assert_equal \
+        42,
+        o.shadow[:ivar]
+    end
+  end
+
+  describe "#[]=" do
+    it "sets value of given instance variable name" do
+      o.shadow[:ivar] = 1
+      assert_equal \
+        1,
+        o.instance_variable_get(:@ivar)
+    end
+  end
+
+  describe "to_h" do
+    it "returns hash of all instance variables" do
+      assert_equal(
+        { ivar: 42, another_variable: 43 },
+        o.shadow.to_h
+      )
+    end
+  end
+
+  describe "to_a" do
+    it "returns array of all instance variable values" do
+      assert_equal \
+        [42, 43],
+        o.shadow.to_a
+    end
+  end
+end

data/spec/object_shadow_method_introspection_spec.rb

@@ -0,0 +1,914 @@
+require_relative "../lib/object_shadow"
+require "minitest/autorun"
+
+describe "Object#shadow" do
+  let :astronomical_body do
+    Class.new do
+      def fly
+      end
+
+      protected
+
+      def crash
+      end
+
+      private
+
+      def explode
+      end
+
+
+      class << self
+        def make
+        end
+
+        protected
+
+        def stir
+        end
+
+        private
+
+        def idea
+        end
+      end
+    end
+  end
+
+  let :planet do
+    Class.new(astronomical_body) do
+      def rotate
+      end
+
+      protected
+
+      def bump
+      end
+
+      private
+
+      def implode
+      end
+
+      class << self
+        def construct
+        end
+
+        protected
+
+        def prepare
+        end
+
+        private
+
+        def think
+        end
+      end
+    end
+  end
+
+  let :earth do
+    earth = planet.new
+
+    class << earth
+      def develop
+      end
+
+      protected
+
+      def magnetize
+      end
+
+      private
+
+      def repair
+      end
+    end
+
+    earth
+  end
+
+
+  describe "#methods" do
+    describe "[target: :self]" do
+      describe "[scope: :public]" do
+        describe "[inherit: :singleton]" do
+          it "✓" do
+            assert_equal \
+              [:develop],
+              earth.shadow.methods(target: :self, scope: :public, inherit: :singleton)
+          end
+        end
+
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:develop, :rotate],
+              earth.shadow.methods(target: :self, scope: :public, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              [:develop, :fly, :rotate],
+              earth.shadow.methods(target: :self, scope: :public, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              [:develop, :fly, :rotate],
+              earth.shadow.methods(target: :self, scope: :public, inherit: astronomical_body)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:develop, :fly, :rotate] +
+                Object.public_instance_methods
+              ).sort,
+              earth.shadow.methods(target: :self, scope: :public, inherit: :all)
+          end
+        end
+      end
+
+      describe "[scope: :protected]" do
+        describe "[inherit: :singleton]" do
+          it "✓" do
+            assert_equal \
+              [:magnetize],
+              earth.shadow.methods(target: :self, scope: :protected, inherit: :singleton)
+          end
+        end
+
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :magnetize],
+              earth.shadow.methods(target: :self, scope: :protected, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_class]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash, :magnetize],
+              earth.shadow.methods(target: :self, scope: :protected, inherit: :exclude_class)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash, :magnetize],
+              earth.shadow.methods(target: :self, scope: :protected, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash, :magnetize],
+              earth.shadow.methods(target: :self, scope: :protected, inherit: astronomical_body)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:bump, :crash, :magnetize] +
+                Object.protected_instance_methods
+              ).sort,
+              earth.shadow.methods(target: :self, scope: :protected, inherit: :all)
+          end
+        end
+      end
+
+      describe "[scope: :private]" do
+        describe "[inherit: :singleton]" do
+          it "✓" do
+            assert_equal \
+              [:repair],
+              earth.shadow.methods(target: :self, scope: :private, inherit: :singleton)
+          end
+        end
+
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:implode, :repair],
+              earth.shadow.methods(target: :self, scope: :private, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_class]" do
+          it "✓" do
+            assert_equal \
+              [:explode, :implode, :repair],
+              earth.shadow.methods(target: :self, scope: :private, inherit: :exclude_class)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              [:explode, :implode, :repair],
+              earth.shadow.methods(target: :self, scope: :private, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              [:explode, :implode, :repair],
+              earth.shadow.methods(target: :self, scope: :private, inherit: astronomical_body)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:explode, :implode, :repair] +
+                Object.private_instance_methods
+              ).sort,
+              earth.shadow.methods(target: :self, scope: :private, inherit: :all)
+          end
+        end
+      end
+
+      describe "[scope: :all]" do
+        describe "[inherit: :singleton]" do
+          it "✓" do
+            assert_equal \
+              [:develop, :magnetize, :repair],
+              earth.shadow.methods(target: :self, scope: :all, inherit: :singleton)
+          end
+        end
+
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :develop, :implode, :magnetize, :repair, :rotate],
+              earth.shadow.methods(target: :self, scope: :all, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_class]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash, :develop, :explode, :fly, :implode, :magnetize, :repair, :rotate],
+              earth.shadow.methods(target: :self, scope: :all, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash, :develop, :explode, :fly, :implode, :magnetize, :repair, :rotate],
+              earth.shadow.methods(target: :self, scope: :all, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash, :develop, :explode, :fly, :implode, :magnetize, :repair, :rotate],
+              earth.shadow.methods(target: :self, scope: :all, inherit: astronomical_body)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:bump, :crash, :develop, :explode, :fly, :implode, :magnetize, :repair, :rotate] +
+                Object.instance_methods +
+                Object.private_instance_methods
+              ).sort,
+              earth.shadow.methods(target: :self, scope: :all, inherit: :all)
+          end
+        end
+      end
+    end
+
+
+    describe "[target: :class]" do
+      describe "[scope: :public]" do
+        describe "[inherit: :singleton]" do
+          it "✓" do
+            assert_equal \
+              [:construct],
+              earth.shadow.methods(target: :class, scope: :public, inherit: :singleton)
+          end
+        end
+
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:construct],
+              earth.shadow.methods(target: :class, scope: :public, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_class]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:construct, :make] +
+                Object.singleton_class.public_instance_methods(false) +
+                BasicObject.singleton_class.public_instance_methods(false)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :public, inherit: :exclude_class)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:construct, :make] +
+                Object.singleton_class.public_instance_methods(false) +
+                BasicObject.singleton_class.public_instance_methods(false) +
+                Class.public_instance_methods(false) +
+                Module.public_instance_methods(false)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :public, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:construct, :make] +
+                Object.singleton_class.public_instance_methods(false)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :public, inherit: Object.singleton_class)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:construct, :make] +
+                Object.singleton_class.public_instance_methods(true)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :public, inherit: :all)
+          end
+        end
+      end
+
+      describe "[scope: :protected]" do
+        describe "[inherit: :singleton]" do
+          it "✓" do
+            assert_equal \
+              [:prepare],
+              earth.shadow.methods(target: :class, scope: :protected, inherit: :singleton)
+          end
+        end
+
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:prepare],
+              earth.shadow.methods(target: :class, scope: :protected, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_class]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:prepare, :stir] +
+                Object.singleton_class.protected_instance_methods(false) +
+                BasicObject.singleton_class.protected_instance_methods(false)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :protected, inherit: :exclude_class)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:prepare, :stir] +
+                Object.singleton_class.protected_instance_methods(false) +
+                BasicObject.singleton_class.protected_instance_methods(false) +
+                Class.protected_instance_methods(false) +
+                Module.protected_instance_methods(false)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :protected, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:prepare, :stir] +
+                Object.singleton_class.protected_instance_methods(false)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :protected, inherit: Object.singleton_class)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:prepare, :stir] +
+                Object.singleton_class.protected_instance_methods(true)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :protected, inherit: :all)
+          end
+        end
+      end
+
+      describe "[scope: :private]" do
+        describe "[inherit: :singleton]" do
+          it "✓" do
+            assert_equal \
+              [:think],
+              earth.shadow.methods(target: :class, scope: :private, inherit: :singleton)
+          end
+        end
+
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:think],
+              earth.shadow.methods(target: :class, scope: :private, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_class]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:think, :idea] +
+                Object.singleton_class.private_instance_methods(false) +
+                BasicObject.singleton_class.private_instance_methods(false)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :private, inherit: :exclude_class)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:think, :idea] +
+                Object.singleton_class.private_instance_methods(false) +
+                BasicObject.singleton_class.private_instance_methods(false) +
+                Class.private_instance_methods(false) +
+                Module.private_instance_methods(false)
+              ).uniq.sort,
+              earth.shadow.methods(target: :class, scope: :private, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:think, :idea] +
+                Object.singleton_class.private_instance_methods(false)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :private, inherit: Object.singleton_class)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:think, :idea] +
+                Object.singleton_class.private_instance_methods(true)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :private, inherit: :all)
+          end
+        end
+      end
+
+      describe "[scope: :all]" do
+        describe "[inherit: :singleton]" do
+          it "✓" do
+            assert_equal \
+              [:construct, :prepare, :think],
+              earth.shadow.methods(target: :class, scope: :all, inherit: :singleton)
+          end
+        end
+
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:construct, :prepare, :think],
+              earth.shadow.methods(target: :class, scope: :all, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_class]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:construct, :idea, :make, :prepare, :stir, :think] +
+                Object.singleton_class.instance_methods(false) +
+                Object.singleton_class.private_instance_methods(false) +
+                BasicObject.singleton_class.instance_methods(false) +
+                BasicObject.singleton_class.private_instance_methods(false)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :all, inherit: :exclude_class)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:construct, :idea, :make, :prepare, :stir, :think] +
+                Object.singleton_class.instance_methods(false) +
+                Object.singleton_class.private_instance_methods(false) +
+                BasicObject.singleton_class.instance_methods(false) +
+                BasicObject.singleton_class.private_instance_methods(false) +
+                Class.instance_methods(false) +
+                Class.private_instance_methods(false) +
+                Module.instance_methods(false) +
+                Module.private_instance_methods(false)
+              ).uniq.sort,
+              earth.shadow.methods(target: :class, scope: :all, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:construct, :idea, :make, :prepare, :stir, :think] +
+                Object.singleton_class.instance_methods(false) +
+                Object.singleton_class.private_instance_methods(false)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :all, inherit: Object.singleton_class)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:construct, :idea, :make, :prepare, :stir, :think] +
+                Object.singleton_class.instance_methods(true) +
+                Object.singleton_class.private_instance_methods(true)
+              ).sort,
+              earth.shadow.methods(target: :class, scope: :all, inherit: :all)
+          end
+        end
+      end
+    end
+
+
+    describe "[target: :instances]" do
+      describe "context: called for a non-module" do
+        it "✗ will raise an ArgumentError" do
+          assert_raises(ArgumentError) {
+            earth.shadow.methods(target: :instances)
+          }
+        end
+      end
+
+      describe "[inherit: :singleton]" do
+        it "✗ will raise an ArgumentError" do
+          assert_raises(ArgumentError) {
+            planet.shadow.methods(target: :instances, inherit: :singleton)
+          }
+        end
+      end
+
+      describe "[scope: :public]" do
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:rotate],
+              planet.shadow.methods(target: :instances, scope: :public, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              [:fly, :rotate],
+              planet.shadow.methods(target: :instances, scope: :public, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              [:fly, :rotate],
+              planet.shadow.methods(target: :instances, scope: :public, inherit: astronomical_body)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:fly, :rotate] +
+                Object.public_instance_methods
+              ).sort,
+              planet.shadow.methods(target: :instances, scope: :public, inherit: :all)
+          end
+        end
+      end
+
+      describe "[scope: :protected]" do
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:bump],
+              planet.shadow.methods(target: :instances, scope: :protected, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_class]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash],
+              planet.shadow.methods(target: :instances, scope: :protected, inherit: :exclude_class)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash],
+              planet.shadow.methods(target: :instances, scope: :protected, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash],
+              planet.shadow.methods(target: :instances, scope: :protected, inherit: astronomical_body)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:bump, :crash] +
+                Object.protected_instance_methods
+              ).sort,
+              planet.shadow.methods(target: :instances, scope: :protected, inherit: :all)
+          end
+        end
+      end
+
+      describe "[scope: :private]" do
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:implode],
+              planet.shadow.methods(target: :instances, scope: :private, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_class]" do
+          it "✓" do
+            assert_equal \
+              [:explode, :implode],
+              planet.shadow.methods(target: :instances, scope: :private, inherit: :exclude_class)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              [:explode, :implode],
+              planet.shadow.methods(target: :instances, scope: :private, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              [:explode, :implode],
+              planet.shadow.methods(target: :instances, scope: :private, inherit: astronomical_body)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:explode, :implode] +
+                Object.private_instance_methods
+              ).sort,
+              planet.shadow.methods(target: :instances, scope: :private, inherit: :all)
+          end
+        end
+      end
+
+      describe "[scope: :all]" do
+        describe "[inherit: :self, inherit: false]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :implode, :rotate],
+              planet.shadow.methods(target: :instances, scope: :all, inherit: :self)
+          end
+        end
+
+        describe "[inherit: :exclude_class]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash, :explode, :fly, :implode, :rotate],
+              planet.shadow.methods(target: :instances, scope: :all, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: :exclude_object]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash, :explode, :fly, :implode, :rotate],
+              planet.shadow.methods(target: :instances, scope: :all, inherit: :exclude_object)
+          end
+        end
+
+        describe "[inherit: Module]" do
+          it "✓" do
+            assert_equal \
+              [:bump, :crash, :explode, :fly, :implode, :rotate],
+              planet.shadow.methods(target: :instances, scope: :all, inherit: astronomical_body)
+          end
+        end
+
+        describe "[inherit: :all, inherit: true]" do
+          it "✓" do
+            assert_equal \
+              (
+                [:bump, :crash, :explode, :fly, :implode, :rotate] +
+                Object.instance_methods +
+                Object.private_instance_methods
+              ).sort,
+              planet.shadow.methods(target: :instances, scope: :all, inherit: :all)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#method?" do
+    it "will return true if method exists" do
+      assert earth.shadow.method?(:bump)
+      assert earth.shadow.method?(:magnetize)
+      assert earth.shadow.method?(:stir, target: :class)
+
+      assert planet.shadow.method?(:idea)
+      assert planet.shadow.method?(:implode, target: :instances)
+    end
+
+    it "will return false if method does not exist" do
+      refute earth.shadow.method?(:idea)
+      refute earth.shadow.method?(:idiosyncratic)
+      refute earth.shadow.method?(:magnetize, target: :class)
+
+      refute planet.shadow.method?(:rotate)
+      refute planet.shadow.method?(:stir, target: :instances)
+    end
+  end
+
+  describe "#method_scope" do
+    it "will return :public for public methods" do
+      assert_equal :public, earth.shadow.method_scope(:rotate)
+      assert_equal :public, earth.shadow.method_scope(:develop)
+      assert_equal :public, earth.shadow.method_scope(:make, target: :class)
+
+      assert_equal :public, planet.shadow.method_scope(:construct)
+      assert_equal :public, planet.shadow.method_scope(:rotate, target: :instances)
+    end
+
+    it "will return :protected for protected methods" do
+      assert_equal :protected, earth.shadow.method_scope(:bump)
+      assert_equal :protected, earth.shadow.method_scope(:magnetize)
+      assert_equal :protected, earth.shadow.method_scope(:stir, target: :class)
+
+      assert_equal :protected, planet.shadow.method_scope(:prepare)
+      assert_equal :protected, planet.shadow.method_scope(:bump, target: :instances)
+    end
+
+    it "will return :private for private methods" do
+      assert_equal :private, earth.shadow.method_scope(:implode)
+      assert_equal :private, earth.shadow.method_scope(:repair)
+      assert_equal :private, earth.shadow.method_scope(:think, target: :class)
+
+      assert_equal :private, planet.shadow.method_scope(:idea)
+      assert_equal :private, planet.shadow.method_scope(:implode, target: :instances)
+    end
+
+    it "will return nil if method does not exist" do
+      refute earth.shadow.method?(:idea)
+      refute earth.shadow.method?(:magnetize, target: :class)
+
+      refute planet.shadow.method?(:rotate)
+      refute planet.shadow.method?(:stir, target: :instances)
+    end
+  end
+
+  describe "#method" do
+    it "will return Method object" do
+      assert_instance_of Method, earth.shadow.method(:bump)
+      assert_instance_of Method, earth.shadow.method(:magnetize)
+      assert_instance_of Method, earth.shadow.method(:stir, target: :class)
+
+      assert_instance_of Method, planet.shadow.method(:idea)
+    end
+
+    it "will return UnboundMethod object for target: instances "do
+      assert_instance_of UnboundMethod, planet.shadow.method(:implode, target: :instances)
+    end
+
+    it "will return UnboundMethod object when unbind: true is passed" do
+      assert_instance_of UnboundMethod, earth.shadow.method(:bump, unbind: true)
+    end
+
+    it "will return nil if method does not exist" do
+      assert_nil earth.shadow.method(:fun)
+    end
+
+
+    it "returns an array of all (unbound) methods in the lookup chain if all: true is passed" do
+      def earth.bump() end
+
+      res = earth.shadow.method(:bump, all: true)
+      assert_instance_of Array, res
+      assert_instance_of UnboundMethod, res[0]
+      assert_instance_of UnboundMethod, res[1]
+    end
+  end
+
+  describe "#method_lookup_chain" do
+    describe "[inherit: :exclude_class]" do
+      it "shows the lookup chain (including singleton class) for non-classes, stops lookup chain before Class" do
+        assert_equal \
+          [earth.singleton_class, planet, astronomical_body],
+          earth.shadow.method_lookup_chain
+      end
+
+      it "shows the lookup chain for classes, stops lookup chain before Class" do
+        assert_equal \
+          [
+            planet,
+            astronomical_body,
+            Object,
+            BasicObject,
+          ].map(&:singleton_class),
+          planet.shadow.method_lookup_chain
+      end
+    end
+
+    describe "[inherit: :all]" do
+      it "shows the lookup chain (including singleton class) for non-classes" do
+        assert_equal \
+          [
+            earth.singleton_class,
+            planet,
+            astronomical_body,
+            Object,
+            Minitest::Expectations,
+            ObjectShadow::ObjectMethod,
+            Kernel,
+            BasicObject,
+          ],
+          earth.shadow.method_lookup_chain(inherit: :all)
+      end
+
+      it "shows the lookup chain for classes" do
+        assert_equal \
+          [
+            planet,
+            astronomical_body,
+            Object,
+            BasicObject,
+          ].map(&:singleton_class) + [
+            Class,
+            Module,
+            Object,
+            Minitest::Expectations,
+            ObjectShadow::ObjectMethod,
+            Kernel,
+            BasicObject,
+          ],
+          planet.shadow.method_lookup_chain(inherit: :all)
+      end
+    end
+  end
+end
+