object_oculus 1.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 13c75e4eff1e0a849c8a2162097995baa400503a112fb2c41c167a1ab91d194a
+  data.tar.gz: da3566f45634c1718bf235c95c58ce9762e4f1c0770206a460e09c11efa79fc2
+SHA512:
+  metadata.gz: 2489cd1b412bd62a5880de14a4452d816bef3a2e4693b482a8e1ffaae6db969854d52a027396c7d641028b9bd2174f7ea73136877a7f34d3a2b29dd0c6d6cdde
+  data.tar.gz: 3ed6a105543d05053b0ca088824e4b83ceffbd1785694260992dd17cb45b9e84cbedc1d4409cbc7daf2873beb2895d3e2bd15a9e42954b2a64fe6f555630e2cb

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+.DS_Store
+doc/*
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in object_oculus.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    object_oculus (1.2.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.5.1)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  object_oculus!
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.5.6

data/README.rdoc

@@ -0,0 +1,102 @@
+= object\_oculus
+
+This is a fork of Dr. Nic's excellent little what_methods utility, updated a bit to expand
+functionality and bring syntax a bit more in line with the Ruby status quo. It's actually been
+batted around the internet for a while, with rough etchings dating to 2002. So this is my shot at
+it.
+
+<b>Dr. Nic says</b> (or is heard from echoes traversing the sands of time)<b>:</b>
+
+This is from Dr. Nic.  See http://drnicwilliams.com/2006/10/12/my-irbrc-for-consoleirb/
+
+Ever asked: "if I have an object, what method can I call on it to get that result?"
+
+See if this suits your console cravings:
+
+    > 3.45.what_equals 3
+    3.45.to_i     == 3
+    3.45.to_int   == 3
+    3.45.floor    == 3
+    3.45.round    == 3
+    3.45.truncate == 3
+    => {:to_i=>3, :to_int=>3, :floor=>3, :round=>3, :truncate=>3}
+
+    > 3.45.what_equals 4
+    3.45.ceil == 4
+    => {:ceil=>4}
+
+    > 3.55.what_equals 4
+    3.55.ceil  == 4
+    3.55.round == 4
+    => {:ceil=>4, :round=>4}
+
+    > 3.45.what_equals /\n/
+    3.45.psych_to_yaml  == "--- 3.45\n...\n"
+    3.45.to_yaml        == "--- 3.45\n...\n"
+    3.45.pretty_inspect == "3.45\n"
+    => {:psych_to_yaml=>"--- 3.45\n...\n", :to_yaml=>"--- 3.45\n...\n", :pretty_inspect=>"3.45\n"}
+    
+    > 3.what_equals 4, 1
+    3 + 1 == 4
+    => {:+=>4}
+
+    > 3.given(1).what_equals 4
+    3 + 1 == 4
+
+Just what you need in the console.
+
+Notice the last example: you can pass parameters after the desired result. whats_up will tell you
+what method will return the desired result if you pass those parameters to it.
+
+<b>Bryan says:</b>
+
+This modest little update retains the original +what?+ method, but that was from the halcyon days of
+2006, before the Ruby community had a rough consensus that +?+ methods should be returning a true or
+false value (or at least something useable as such). I've aliased that method as +what_equals+.
+
+You can add arguments by either supplying additional arguments after the expected result or by using
+the +given+ method. So the following two queries are equivalent:
+
+    5.given(1).what_equals 6
+    5.what_equals 6, 1
+
+Note also the addition of helpers like +whats_exactly+, which will only find exact matches, and
++what_matches+, which will match a regular expression:
+
+    > 5.whats_exactly 5.0
+    5.to_f == 5.0
+    => {:to_f=>5.0}
+
+    > "hello".what_matches /^\d$/
+    "hello".length   == 5
+    "hello".size     == 5
+    "hello".bytesize == 5
+    "hello".to_i     == 0
+    "hello".hex      == 0
+    "hello".oct      == 0
+    => {:length=>5, :size=>5, :bytesize=>5, :to_i=>0, :hex=>0, :oct=>0}
+
+And if you just want to know everything, I've added +what_works_with+ that lists the results of all
+current methods and +whats_not_blank_with+ that ignores any false, falsy or empty values:
+
+    > "hello".what_works_with 2
+    "hello" <=> 2   == nil
+    "hello" == 2    == false
+    "hello" === 2   == false
+    "hello".eql?(2) == false
+    "hello" * 2     == "hellohello"
+    "hello" % 2     == "hello"
+    "hello"[2]      == "l"
+    "hello" =~ 2    == nil
+    "hello".upto(2) == #<Enumerator: "hello":upto(2)>
+    # ...
+
+    > "hello".given(2).whats_not_blank
+    "hello" * 2     == "hellohello"
+    "hello" % 2     == "hello"
+    "hello"[2]      == "l"
+    "hello".upto(2) == #<Enumerator: "hello":upto(2)>
+    # ...
+
+In line with the original +what_methods+ gem, you can <tt>require "object_oculus/classic"</tt> to enable
+aliases like +what?+, +matches?+, +exactly?+, +works?+ and +not_blank?+.

data/lib/object_oculus/classic.rb

@@ -0,0 +1,29 @@
+require "object_oculus"
+
+module ObjectOculus
+  # This module contains the original +what?+ method, as well as some aliases for newer methods. In
+  # line with the current expectation that a Ruby method ending in +?+ returns a true or false value
+  # (or at least something truthy or falsy), I've decided not to make +what?+ and it's brethren the
+  # default. You can include them by:
+  #
+  #   require "object_oculus/classic"
+  #
+  # or, if object_oculus is already loaded:
+  # 
+  #   ObjectOculus::Classic  # which triggers object_oculus/classic to autoload
+  module Classic
+    alias :what?      :what_equals
+    alias :exactly?   :whats_exactly
+    alias :matches?   :what_matches
+    alias :works?     :what_works_with
+    alias :not_blank? :whats_not_blank_with
+  end
+
+  class MethodFinder
+    @@blacklist += Classic.instance_methods
+  end
+end
+
+class Object  # :nodoc:
+  include ObjectOculus::Classic
+end

data/lib/object_oculus/dummy_out.rb

@@ -0,0 +1,10 @@
+module ObjectOculus
+  # A class to suppress anything that would normally output to $stdout
+  class DummyOut
+    # Does nothing (instead of writing to an IO stream)
+    def write(*args)
+    end
+    alias :print :write
+    alias :puts  :write
+  end
+end

data/lib/object_oculus/frozen_section.rb

@@ -0,0 +1,29 @@
+module ObjectOculus
+  # A classic designed to allow variables to be stored along with a frozen object.
+  #
+  # Frozen objects can't have new instance variables added directly, so this prevents object_oculus
+  # methods from being locked out of inspecting anything frozen. This proxy class should be
+  # initialized automatically if object_oculus detects that the object it's to inspect is frozen.
+  class FrozenSection
+    # The frozen object
+    attr_reader :object
+
+    # Creates a new FrozenSection object from the provided +object+ and a list of instance variables
+    # to store
+    def initialize(object, vars = {})
+      @object = object
+      vars.each do |key, value|
+        instance_variable_set "@#{key}", value
+      end
+    end
+
+    private
+
+    # An override of Methods#show_methods that passes the object stored in <tt>@object</tt> instead of
+    # +self+
+    def show_methods(expected_result, opts = {}, *args, &block)  # :doc:
+      @args = args unless args.empty?
+      MethodFinder.show(@object, expected_result, opts, *@args)
+    end
+  end
+end

data/lib/object_oculus/method_finder.rb

@@ -0,0 +1,146 @@
+module ObjectOculus
+  # A singleton class used to iterate over the methods of an object trying to match any returned
+  # values with an expected result. ny matches will then be pretty printed to the console.
+  class MethodFinder
+    # A list of symbols indicated which methods to always ignore
+    @@blacklist  = %w(daemonize debug debugger display ed emacs exec exit! fork mate nano sleep
+                      stub stub! stub_chain syscall system unstub unstub! vi vim).map(&:to_sym)
+    @@blacklist += Methods.instance_methods
+
+    # A list of symbols for infix operators for which Ruby has special syntax
+    @@infixes    = %w(+ - * / % ** == != =~ !~ !=~ > < >= <= <=> === & | ^ << >>).map(&:to_sym)
+    
+    # A list of symbols for prefix operators for which Ruby has special syntax
+    @@prefixes   = %w(+@ -@ ~ !).map(&:to_sym)
+    
+    class << self
+      # Builds a lambda for checking against the provided +expected_result+ given a hash of options.
+      # Given the value of a method, the result of this lambda will determine whether that method
+      # and value are included in the output of a object_oculus method.
+      #
+      # ==== Options
+      #
+      # * <tt>:exclude_blank</tt> - Exclude blank values
+      # * <tt>:force_exact</tt> - Force values to be exactly equal
+      # * <tt>:force_regex</tt> - Coerce the +expected_result+ into a regular expression for pattern
+      #   matching
+      # * <tt>:show_all</tt> - Show the results of all methods
+      def build_check_lambda(expected_result, opts = {})
+        if opts[:force_regex]
+          expected_result = Regexp.new(expected_result.to_s) unless expected_result.is_a?(Regexp)
+          ->(value) { expected_result === value.to_s }
+        elsif expected_result.is_a?(Regexp) && !opts[:force_exact]
+          ->(value) { expected_result === value.to_s }
+        elsif opts[:force_exact]
+          ->(value) { expected_result.eql?(value) }
+        elsif opts[:show_all]
+          if opts[:exclude_blank]
+            ->(value) { !value.nil? && !(value.respond_to?(:empty?) && value.empty?) }
+          else
+            ->(value) { true }
+          end
+        else
+          ->(value) { expected_result == value }
+        end
+      end
+
+      # Find all methods on +an_object+ which, when called with +args+ return +expected_result+
+      def find(an_object, expected_result, opts = {}, *args, &block)
+        check_result    = build_check_lambda(expected_result, opts)
+
+        # Prevent any writing to the terminal
+        stdout, stderr = $stdout, $stderr
+        unless $stdout.is_a?(DummyOut)
+          $stdout = $stderr = DummyOut.new
+          restore_std = true
+        end
+
+        # Use only methods with valid arity that aren't blacklisted
+        methods = an_object.methods
+        methods.select! { |n| an_object.method(n).arity <= args.size && !@@blacklist.include?(n) }
+
+        # Collect all methods equaling the expected result
+        results = methods.inject({}) do |res, name|
+          stdout.print ""
+          begin
+            value = an_object.clone.method(name).call(*args, &block)
+            res[name] = value if check_result.call(value)
+          rescue
+          end
+          res
+        end
+
+        # Restore printing to the terminal
+        $stdout, $stderr = stdout, stderr if restore_std
+        results
+      end
+      
+      # Pretty prints the results of #find
+      def show(an_object, expected_result, opts = {}, *args, &block)
+        opts = {
+          exclude_blank: false,
+          force_exact:   false,
+          force_regex:   false,
+          show_all:      false
+        }.merge(opts)
+
+        found      = find(an_object, expected_result, opts, *args, &block)
+        prettified = prettify_found(an_object, found, *args)
+        max_length = prettified.map { |k, v| k.length }.max
+
+        prettified.each { |k, v| puts "#{k.ljust max_length} == #{v}" }
+
+        found
+      end
+
+      private
+
+      # Pretty prints a method depending on whether it's an operator, has arguments, is array/hash
+      # syntax, etc.
+      def prettify_found(an_object, found, *args)
+        args = args.map { |a| a.inspect }.join(", ")
+        pretty_object = truncate_inspect(an_object, to: 40)
+
+        found.map do |key, value|
+          pretty_key = if @@infixes.include?(key)
+                         "#{pretty_object} #{key} #{args}"
+                       elsif @@prefixes.include?(key)
+                         "#{key.to_s.sub /\@$/, ""}#{pretty_object}"
+                       elsif key == :[]
+                         "#{pretty_object}[#{args}]"
+                       elsif args != ""
+                         "#{pretty_object}.#{key}(#{args})"
+                       else
+                         "#{pretty_object}.#{key}"
+                       end
+
+          pretty_value =
+            begin
+              truncate_inspect(value, to: 120)
+            rescue => ex
+              ex.class
+            end
+
+          [pretty_key, pretty_value]
+        end
+      end
+
+      # Inspects an object and returns a string representation, truncating it to length in the
+      # provided <tt>to:</tt> argument if necessary
+      def truncate_inspect(object, opts = {})
+        max_length = opts[:to] || 80
+        full       = object.inspect
+
+        if full.length > max_length
+          available_length = max_length - 5  # to account for the " ... "
+          left_cutoff      = available_length * 2 / 3
+          right_cutoff     = available_length - left_cutoff - 1
+
+          "#{full[0..left_cutoff]} ... #{full[-right_cutoff..-1]}"
+        else
+          full
+        end
+      end
+    end
+  end
+end

data/lib/object_oculus/methods.rb

@@ -0,0 +1,80 @@
+module ObjectOculus
+  # The methods added to all objects by object_oculus
+  module Methods
+    # Provides a list of arguments that will be used when trying to find matching methods.
+    #
+    #   5.given(1).what_equals 6
+    #   # => 5 + 1 == 6
+    def given(*args)
+      if frozen?
+        FrozenSection.new self, args: args
+      else
+        @args = args
+        self
+      end
+    end
+
+    # Outputs a list of methods and their values that equal an +expected_result+, allowing for some
+    # coercion (e.g. <tt>5 == 5.0</tt>)
+    def what_equals(expected_result, *args, &block)
+      show_methods expected_result, {}, *args, &block
+    end
+
+    # Outputs a list of methods and their values that exactly equal an +expected_result+
+    def whats_exactly(expected_result, *args, &block)
+      show_methods expected_result, { force_exact: true }, *args, &block
+    end
+
+    # Outputs a list of methods and their values that match an +expected_result+, which is coerced
+    # into a regular expression if it's not already one
+    def what_matches(expected_result, *args, &block)
+      show_methods expected_result, { force_regex: true }, *args, &block
+    end
+
+    # Outputs a list of all methods and their values
+    def what_works_with(*args, &block)
+      show_methods nil, { show_all: true }, *args, &block
+    end
+    alias :what_works :what_works_with
+
+    # Outputs a list of all methods and their values, provided they are not blank (nil, false,
+    # undefined, empty)
+    def whats_not_blank_with(*args, &block)
+      show_methods nil, { show_all: true, exclude_blank: true }, *args, &block
+    end
+    alias :whats_not_blank :whats_not_blank_with
+
+    # The list of all methods unique to an object
+    def unique_methods
+      methods - self.class.methods
+    end
+
+    # Lists all methods available to the object by ancestor
+    def methods_by_ancestor
+      ([self] + self.class.ancestors).inject({}) do |result, object|
+        result[object] = object.unique_methods
+        result
+      end
+    end
+
+    # Make sure cloning doesn't cause anything to fail via type errors
+    alias_method :__clone__, :clone
+
+    # Adds in a type error check to the default Object#clone method to prevent any interruptions while
+    # checking methods. If a TypeError is encountered, +self+ is returned
+    def clone
+      __clone__
+    rescue TypeError
+      self
+    end
+
+    private
+
+    # Called by all of the +what_+ methods, this tells MethodFinder to output the result for any methods
+    # matching an +expected_result+ for the #given arguments
+    def show_methods(expected_result, opts = {}, *args, &block)  # :doc:
+      @args = args unless args.empty?
+      MethodFinder.show(self, expected_result, opts, *@args, &block)
+    end
+  end
+end

data/lib/object_oculus/version.rb

@@ -0,0 +1,4 @@
+module ObjectOculus
+  # The current version
+  VERSION = "1.2.3"
+end

data/lib/object_oculus.rb

@@ -0,0 +1,37 @@
+# object_oculus enables you to determine what methods can be called on an object that return a given
+# value
+#
+# === Some credits from Dr. Nic
+#
+# Code this version is based on: {Andrew
+# Birkett's}[http://www.nobugs.org/developer/ruby/method_finder.html]
+#
+# Improvements from Why's blog entry:
+# * +what?+ - Why
+# * <tt>@@blacklist</tt> - llasram
+# * +clone+ alias - Daniel Schierbeck
+# * <tt>$stdout</tt> redirect - Why
+#
+# {Improvements from Nikolas Coukouma}[http://atrustheotaku.livejournal.com/339449.html]
+# * Varargs and block support
+# * Improved catching
+# * Redirecting <tt>$stdout</tt> and <tt>$stderr</tt> (independently of Why)
+#
+# {A version posted in 2002 by Steven
+# Grady}[http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/32844]
+#
+# David Tran's versions:
+# * Simple[http://www.doublegifts.com/pub/ruby/methodfinder.rb.html]
+# * {Checks permutations of arguments}[http://www.doublegifts.com/pub/ruby/methodfinder2.rb.html]
+module ObjectOculus
+  autoload :Classic,       "object_oculus/classic"
+  autoload :DummyOut,      "object_oculus/dummy_out"
+  autoload :FrozenSection, "object_oculus/frozen_section"
+  autoload :MethodFinder,  "object_oculus/method_finder"
+  autoload :Methods,       "object_oculus/methods"
+  autoload :VERSION,       "object_oculus/version"
+end
+
+class Object  # :nodoc:
+  include ObjectOculus::Methods
+end

data/object_oculus.gemspec

@@ -0,0 +1,22 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "object_oculus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "object_oculus"
+  s.authors     = ["Jason Cheong-Kee-You", "Bryan McKelvey", "Dr Nic Williams"]
+  s.email       = "j.chunky@gmail.com"
+  s.homepage    = "https://github.com/jchunky/object_oculus"
+  s.licenses    = ['MIT']
+  s.platform    = Gem::Platform::RUBY
+  s.version     = ObjectOculus::VERSION
+  s.summary     = "Rapidly explore an object's API in 'irb'"
+  s.description = <<~DESCRIPTION
+    ObjectOculus is a ruby tool for viewing all of an object's methods and seeing what those
+    methods return. ObjectOculus can be used in 'irb' to rapidly explore an object's API.
+  DESCRIPTION
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", "~> 3.0"
+end

data/spec/classic_spec.rb

@@ -0,0 +1,10 @@
+RSpec.describe "ObjectOculus::Classic" do
+  it "should not have any classic methods without Classic loaded" do
+    expect("hello").not_to respond_to(:what?)
+  end
+
+  it "should have classic methods with Classic loaded" do
+    require "object_oculus/classic"
+    expect("hello").to respond_to(:what?)
+  end
+end

data/spec/frozen_section_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe FrozenSection do
+  describe "initialization" do
+    before(:each) do
+      @number = 2
+      @string = "hello"
+    end
+
+    it "should not occur given an unfrozen object" do
+      expect(@string.given(1)).to be_a(String)
+    end
+
+    it "should occur given an integer" do
+      expect(@number.given(1)).to be_a(FrozenSection)
+    end
+
+    it "should occur given a frozen object" do
+      @number.freeze
+      @string.freeze
+      expect(@number.given(1)).to be_a(FrozenSection)
+      expect(@string.given(1)).to be_a(FrozenSection)
+    end
+  end
+end

data/spec/method_finder_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe MethodFinder do
+  describe "blacklist" do
+    it "should contain classic methods" do
+      expect(MethodFinder.class_variable_get(:@@blacklist)).to include(:what?)
+      expect(MethodFinder.class_variable_get(:@@blacklist)).to include(:works?)
+    end
+
+    it "should contain newer methods" do
+      expect(MethodFinder.class_variable_get(:@@blacklist)).to include(:what_equals)
+      expect(MethodFinder.class_variable_get(:@@blacklist)).to include(:what_works)
+    end
+  end
+end

data/spec/methods_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe Methods do
+  before(:all) do
+    @stderr, @stdout = $stderr, $stdout
+    $stderr = $stdout = DummyOut.new
+  end
+
+  after(:all) do
+    $stderr, $stdout = @stderr, @stdout
+  end
+
+  describe "what_equals" do
+    it "should find the correct method without arguments" do
+      expect("hello ".what_equals("hello")).to have_key(:rstrip)
+    end
+
+    it "should find the correct method with arguments" do
+      expect("hello".what_equals("e", 1)).to have_key(:[])
+    end
+
+    it "should find the correct method with arguments using given" do
+      expect("hello".given(1).what_equals("e")).to have_key(:[])
+    end
+  end
+
+  describe "what_matches" do
+    it "should find the correct method given a regular expression" do
+      expect(5.what_matches(/5/)).to have_key(:to_s)
+    end
+
+    it "should find the correct method by converting an arbitrary object to a regular expression" do
+      expect(5.what_matches(5)).to have_key(:to_s)
+    end
+  end
+
+  describe "whats_exactly" do
+    it "should fail to match inexact matches that would succeed with == type coercion" do
+      expect(5.whats_exactly(5.0)).not_to have_key(:to_i)
+    end
+
+    it "should succeed for exact matches" do
+      expect(5.whats_exactly(5.0)).to have_key(:to_f)
+    end
+  end
+
+  describe "whats_not_blank" do
+    it "should include only non-blank values" do
+      expect(5.whats_not_blank.select { |n| !n || n.empty? }).to be_empty
+    end
+  end
+
+  describe "what_works" do
+    it "should produce all results found with whats_not_blank" do
+      works = 5.what_works
+
+      5.whats_not_blank.keys.each do |key|
+        expect(works).to have_key(key)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require "object_oculus"
+include ObjectOculus
+
+RSpec.configure do |config|
+  config.deprecation_stream = '/dev/null'
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: object_oculus
+version: !ruby/object:Gem::Version
+  version: 1.2.3
+platform: ruby
+authors:
+- Jason Cheong-Kee-You
+- Bryan McKelvey
+- Dr Nic Williams
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |
+  ObjectOculus is a ruby tool for viewing all of an object's methods and seeing what those
+  methods return. ObjectOculus can be used in 'irb' to rapidly explore an object's API.
+email: j.chunky@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- lib/object_oculus.rb
+- lib/object_oculus/classic.rb
+- lib/object_oculus/dummy_out.rb
+- lib/object_oculus/frozen_section.rb
+- lib/object_oculus/method_finder.rb
+- lib/object_oculus/methods.rb
+- lib/object_oculus/version.rb
+- object_oculus.gemspec
+- spec/classic_spec.rb
+- spec/frozen_section_spec.rb
+- spec/method_finder_spec.rb
+- spec/methods_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jchunky/object_oculus
+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: []
+rubygems_version: 3.5.6
+signing_key:
+specification_version: 4
+summary: Rapidly explore an object's API in 'irb'
+test_files: []