whats_up 1.1.1

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/README.md

@@ -0,0 +1,94 @@
+whats\_up
+=========
+
+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.
+
+**Dr. Nic says** (or is heard from echoes traversing the sands of time)**:**
+
+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}
+
+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.
+
+**Bryan says:**
+
+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`.
+
+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".whats_not_blank_with 2
+    "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 `require "whats_up/classic"` to enable aliases
+like `what?`, `matches?`, `exactly?`, `works?` and `not_blank?`.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/whats_up/classic.rb

@@ -0,0 +1,15 @@
+require "whats_up"
+
+class Object
+  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
+
+module WhatsUp
+  class MethodFinder
+    @@blacklist += %w(what? exactly? matches? works? not_blank?)
+  end
+end

data/lib/whats_up/version.rb

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

data/lib/whats_up.rb

@@ -0,0 +1,195 @@
+# Some credits:
+# Code this version is based on: Andrew Birkett
+#   http://www.nobugs.org/developer/ruby/method_finder.html
+# Improvements from Why's blog entry
+# * what? == - Why
+# * @@blacklist - llasram
+# * clone alias - Daniel Schierbeck
+# * $stdout redirect - Why
+#   http://redhanded.hobix.com/inspect/stickItInYourIrbrcMethodfinder.html
+# Improvements from Nikolas Coukouma
+# * Varargs and block support
+# * Improved catching
+# * Redirecting $stdout and $stderr (independently of Why)
+#   http://atrustheotaku.livejournal.com/339449.html
+#
+# 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
+#
+# Last updated: 2006/05/20
+
+class Object
+  def what_equals(*a)
+    WhatsUp::MethodFinder.show(self, {}, *a)
+  end
+
+  def whats_exactly(*a)
+    WhatsUp::MethodFinder.show(self, { force_exact: true }, *a)
+  end
+  
+  def what_matches(*a)
+    WhatsUp::MethodFinder.show(self, { force_regex: true }, *a)
+  end
+
+  def what_works_with(*a)
+    WhatsUp::MethodFinder.show(self, { show_all: true }, *a)
+  end
+
+  def whats_not_blank_with(*a)
+    WhatsUp::MethodFinder.show(self, { show_all: true, exclude_blank: true }, *a)
+  end
+
+  # Make sure cloning doesn't cause anything to fail via type errors
+  alias_method :__clone__, :clone
+  def clone
+    __clone__
+  rescue TypeError
+    self
+  end
+end
+
+# A class to suppress anything that would normally output to $stdout
+class DummyOut
+  # Does nothing (instead of writing to $stdout)
+  def write(*args); end
+end
+
+module WhatsUp
+  class MethodFinder
+    @@blacklist = %w(daemonize display exec exit! fork sleep system syscall what_equals
+                     whats_exactly what_matches whats_up ed emacs mate nano vi vim)
+    @@infixes   = %w(+ - * / % ** == != =~ !~ !=~ > < >= <= <=> === & | ^ << >>).map(&:to_sym)
+    @@prefixes  = %w(+@ -@ ~ !).map(&:to_sym)
+    
+    def initialize(obj, *args)
+      @obj = obj
+      @args = args
+    end
+    def ==(val)
+      MethodFinder.show(@obj, val, *@args)
+    end
+    
+    class << self
+      def build_check_lambda(expected_result, opts = {})
+        if opts[:force_regex]
+          -> a, b { a === b.to_s }
+        elsif expected_result.is_a?(Regexp) && !opts[:force_exact]
+          -> a, b { a === b.to_s }
+        elsif opts[:force_exact]
+          -> a, b { a.eql?(b) }
+        elsif opts[:show_all]
+          if opts[:exclude_blank]
+            -> a, b { !b.nil? && !b.empty? }
+          else
+            -> a, b { true }
+          end
+        else
+          -> a, b { a == b }
+        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)
+
+        if opts[:force_regex] && expected_result.is_a?(String)
+          expected_result = Regexp.new(expected_result)
+        end
+
+        # Prevent any writing to the terminal
+        stdout, stderr = $stdout, $stderr
+        $stdout = $stderr = DummyOut.new
+
+        methods = an_object.methods
+
+        # Use only methods with valid arity that aren't blacklisted
+        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|
+          begin
+            stdout.print ""
+            value = an_object.clone.method(name).call(*args, &block)
+            res[name] = value if check_result.call(expected_result, value)
+          rescue
+          end
+          res
+        end
+
+        # Restore printing to the terminal
+        $stdout, $stderr = stdout, stderr
+        results
+      end
+      
+      # Pretty-prints the results of the previous method
+      def show(an_object, opts = {}, *args, &block)
+        opts = {
+          force_regex:   false,
+          force_exact:   false,
+          show_all:      false,
+          exclude_blank: false
+        }.merge(opts)
+
+        expected_result = opts[:show_all] ? nil : args.shift
+        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 do |key, value|
+          puts "#{key.ljust max_length} == #{value}"
+        end
+
+        found
+      end
+
+      private
+
+      # Pretty prints a method depending on whether it's an operator, has arguments, is array/hash
+      # syntax, etc. For example:
+      #
+      #   
+      def prettify_found(an_object, found, *args)
+        args = args.map { |o| o.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 = truncate_inspect(value, to: 120)
+
+          [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
+          left_cutoff  = (max_length - 5) * 2 / 3.0
+          right_cutoff = max_length - 6 - left_cutoff
+          "#{full[0..left_cutoff]} ... #{full[-right_cutoff..-1]}"
+        else
+          full
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require "whats_up"
+include WhatsUp

data/whats_up.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "whats_up/version"
+
+Gem::Specification.new do |s|
+  s.name        = "whats_up"
+  s.version     = WhatsUp::VERSION
+  s.authors     = ["Bryan McKelvey", "Dr Nic Williams"]
+  s.email       = ["bryan.mckelvey@gmail.com", "drnicwilliams@gmail.com"]
+  s.homepage    = "http://brymck.herokuapp.com/"
+  s.summary     = %q{Determine what methods can be called on an object that return a given value}
+  s.description = %q{Determine what methods can be called on an object that return a given value}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "autotest"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: whats_up
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Bryan McKelvey
+- Dr Nic Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: autotest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Determine what methods can be called on an object that return a given
+  value
+email:
+- bryan.mckelvey@gmail.com
+- drnicwilliams@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .autotest
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- lib/whats_up.rb
+- lib/whats_up/classic.rb
+- lib/whats_up/version.rb
+- spec/spec_helper.rb
+- whats_up.gemspec
+homepage: http://brymck.herokuapp.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.19
+signing_key: 
+specification_version: 3
+summary: Determine what methods can be called on an object that return a given value
+test_files:
+- spec/spec_helper.rb