whats_up 1.1.2 → 1.1.3

data/README.md

@@ -38,9 +38,12 @@ See if this suits your console cravings:
     => {: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
+    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
@@ -52,6 +55,12 @@ This modest little update retains the original `what?` method, but that was from
 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:
 
@@ -83,7 +92,7 @@ current methods and `whats_not_blank_with` that ignores any false, falsy or empt
     "hello".upto(2) == #<Enumerator: "hello":upto(2)>
     # ...
 
-    > "hello".whats_not_blank_with 2
+    > "hello".given(2).whats_not_blank
     "hello" * 2     == "hellohello"
     "hello" % 2     == "hello"
     "hello"[2]      == "l"

data/lib/whats_up/dummy_out.rb

@@ -0,0 +1,7 @@
+module WhatsUp
+  # 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
+end

data/lib/whats_up/frozen_section.rb

@@ -0,0 +1,17 @@
+module WhatsUp
+  class FrozenSection
+    def initialize(object, vars = {})
+      @object = object
+      vars.each do |key, value|
+        instance_variable_set "@#{key}", value
+      end
+    end
+
+    private
+
+    def show_methods
+      @args = args unless args.empty?
+      WhatsUp::MethodFinder.show(@object, expected_result, opts, *@args)
+    end
+  end
+end

data/lib/whats_up/method_finder.rb

@@ -0,0 +1,132 @@
+module WhatsUp
+  class MethodFinder
+    @@blacklist = %w(daemonize display exec exit! fork sleep system syscall what_equals
+                     whats_exactly what_matches what_works_with what_works whats_not_blank_with
+                     whats_not_blank given 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]
+          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.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
+        $stdout = $stderr = DummyOut.new
+
+        # 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|
+          begin
+            stdout.print ""
+            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
+        results
+      end
+      
+      # Pretty-prints the results of the previous method
+      def show(an_object, expected_result, opts = {}, *args, &block)
+        opts = {
+          force_regex:   false,
+          force_exact:   false,
+          show_all:      false,
+          exclude_blank: 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 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
+          available_length = max_length - 5  # to account for the " ... "
+          left_cutoff      = available_length * 2 / 3.0
+          right_cutoff     = available_length - left_cutoff - 1
+
+          "#{full[0..left_cutoff]} ... #{full[-right_cutoff..-1]}"
+        else
+          full
+        end
+      end
+    end
+  end
+end

data/lib/whats_up/version.rb

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

data/lib/whats_up.rb

@@ -24,25 +24,36 @@
 # Last updated: 2006/05/20
 
 class Object
-  def what_equals(*a)
-    WhatsUp::MethodFinder.show(self, {}, *a)
+  def given(*args)
+    if frozen?
+      WhatsUp::FrozenSection.new self, args: args
+    else
+      @args = args
+      self
+    end
+  end
+
+  def what_equals(expected_result, *args)
+    show_methods expected_result, {}, *args
   end
 
-  def whats_exactly(*a)
-    WhatsUp::MethodFinder.show(self, { force_exact: true }, *a)
+  def whats_exactly(expected_result, *args)
+    show_methods expected_result, { force_exact: true }, *args
   end
   
-  def what_matches(*a)
-    WhatsUp::MethodFinder.show(self, { force_regex: true }, *a)
+  def what_matches(expected_result, *args)
+    show_methods expected_result, { force_regex: true }, *args
   end
 
-  def what_works_with(*a)
-    WhatsUp::MethodFinder.show(self, { show_all: true }, *a)
+  def what_works_with(*args)
+    show_methods nil, { show_all: true }, *args
   end
+  alias :what_works :what_works_with
 
-  def whats_not_blank_with(*a)
-    WhatsUp::MethodFinder.show(self, { show_all: true, exclude_blank: true }, *a)
+  def whats_not_blank_with(*args)
+    show_methods nil, { show_all: true, exclude_blank: true }, *args
   end
+  alias :whats_not_blank :whats_not_blank_with
 
   # Make sure cloning doesn't cause anything to fail via type errors
   alias_method :__clone__, :clone
@@ -51,143 +62,17 @@ class Object
   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
+  private
+
+  def show_methods(expected_result, opts = {}, *args)
+    @args = args unless args.empty?
+    WhatsUp::MethodFinder.show(self, expected_result, opts, *@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]
-          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.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
-        $stdout = $stderr = DummyOut.new
-
-        # 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|
-          begin
-            stdout.print ""
-            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
-        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
-          available_length = max_length - 5  # to account for the " ... "
-          left_cutoff      = available_length * 2 / 3.0
-          right_cutoff     = available_length - left_cutoff - 1
-
-          "#{full[0..left_cutoff]} ... #{full[-right_cutoff..-1]}"
-        else
-          full
-        end
-      end
-    end
-  end
+  autoload :DummyOut,      "whats_up/dummy_out"
+  autoload :FrozenSection, "whats_up/frozen_section"
+  autoload :MethodFinder,  "whats_up/method_finder"
 end

data/spec/frozen_section_spec.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe FrozenSection do
+  describe "initialization" do
+    before :each do
+      @number = 2
+      @string = "hello"
+    end
+
+    it "should not occur given an unfrozen object" do
+      @number.given(1).should be_a(Fixnum)
+      @string.given(1).should be_a(String)
+    end
+
+    it "should occur given a frozen object" do
+      @number.freeze
+      @string.freeze
+      @number.given(1).should be_a(FrozenSection)
+      @string.given(1).should be_a(FrozenSection)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whats_up
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -77,7 +77,11 @@ files:
 - Rakefile
 - lib/whats_up.rb
 - lib/whats_up/classic.rb
+- lib/whats_up/dummy_out.rb
+- lib/whats_up/frozen_section.rb
+- lib/whats_up/method_finder.rb
 - lib/whats_up/version.rb
+- spec/frozen_section_spec.rb
 - spec/spec_helper.rb
 - whats_up.gemspec
 homepage: http://brymck.herokuapp.com/
@@ -100,9 +104,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.19
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: Determine what methods can be called on an object that return a given value
 test_files:
+- spec/frozen_section_spec.rb
 - spec/spec_helper.rb