mighty_tap 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b96cefd2c1d58b2daee5d42f29d70b52d6a80d70
-  data.tar.gz: c95d71e6110c5659887b74cd9366e89948152598
+  metadata.gz: bc6bf0254dafee2cfd74c1ddd10bc2e9f60195ea
+  data.tar.gz: 5105254ec2a78d5ce987b5afc9a3cda4b7495314
 SHA512:
-  metadata.gz: 535626fe844b78f42052d39fab6b58790b7bfa2374d49ffd3ce67b05209ab67142ac70cce285b09569dd55e9a5a0d9568703a720bcb4937fdb19cfec6f0d0fb6
-  data.tar.gz: 2d93eeb666f6407ae4e7d886d75c045d2a17822925b8a73cc8c51deb6382082ec1f1c9b2bec55182286a6f5a20b681bde9b8e83a554c1b6e1ef70ea957fb0f9e
+  metadata.gz: 19c0b1e0aa425751cf215722cfff5edd82151c30f9193cabc47d0d2def58b348d45abd498843ffa567bf1786ccdca1c9304eb8be042f2992f926ec07b8f233f8
+  data.tar.gz: ed222ab149152578c2b14f97b904a6f8ca9ea5a5b26a87a9bf98389e5ebd491b36fd618b6347b8c5af82ced65a4c771014c0bc4997a125c2179b81aa8982b121

data/README.md

@@ -1,4 +1,73 @@
-# MightyTap
+# mighty_tap
+
+Rubys `tap` is a awesome. mighty_tap tries to make it even more awesome by adding some missing features, while maintining full compatibility to the orginal `tap`. In order to make its usage more pleasant, `mighty_tap` is defined as in instance method on `Object` and aliased to `mtap`.
+
+## What is it even more awesome than `tap` ?
+* you can give it a method name
+* you can give it arguments and blocks for methods to call
+* dispite calling methods on the object itself, you can provide a callable
+  * in fact you can provide anything that responds to :call
+* dispite the added features it acts like the original `tap` (can act as drop-in replacement)
+
+## Usage
+
+```ruby
+require "mighty_tap"
+
+#
+# it can be used just like tap
+#
+[[[1,2,3]]].mtap(&:flatten!) # => [1,2,3]
+
+#
+# dispite the implicite &: block syntax, it can take a method name
+#
+[[[1,2,3]]].mtap(:flatten!) # => [1,2,3]
+
+#
+# it also takes method arguments
+#
+[[[1,2,3]]].mtap(:flatten!, 1) # => [[1,2,3]]
+
+#
+# if the last argument is a proc, the method is called with the procs block variant
+#
+[1,2,3].mtap(:map!, -> (number) { number * 2 }) => [2,4,6]
+
+#
+# you can also give it a callable (something that responds to #call)
+#
+class ArrayDoubler
+  def call(array)
+    array.map! { |element| element * 2 }
+  end
+end
+
+[1,2,3].mtap(ArrayDoubler.new) # => [2,4,6]
+
+#
+# callables can have arguments and blocks, too
+#
+class ArrayMultiplier
+  def call(array, factor, &reducer)
+    multiplied_array = array.map! { |element| element * factor }
+    
+    if block_given?
+      yield multiplied_array
+    end
+  end
+end
+
+[1,2,3].mtap(ArrayMultiplier.new, 3) # => [3,6,9]
+[1,2,3].mtap(ArrayMultiplier.new, 3, -> (array) { array.delete_if { |int| int < 9 } }) # => [9]
+
+#
+# this can all be combinded with taps original block syntax
+#
+[1,2,3].mtap(ArrayDoubler.new) do |doubled_array|
+  doubled_array.map! { |element| element * element }
+end # => [4, 16, 36]
+```
 
 ## Installation
 
@@ -16,10 +85,6 @@ Or install it yourself as:
 
     $ gem install mighty_tap
 
-## Usage
-
-TODO: Write usage instructions here
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mighty_tap"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+begin
+  require "pry"
+  Pry.start
+rescue LoadError
+  require "irb"
+  IRB.start
+end

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mighty_tap/version.rb

@@ -1,3 +1,3 @@
 module MightyTap
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/mighty_tap.rb

@@ -2,18 +2,14 @@ require "mighty_tap/version"
 
 class Object
   def mighty_tap(*args, &block)
-    if args.length == 1
-      self.send(args[0])
-    elsif args.length == 2
-      if args[1].is_a?(Proc)
-        # this assumption might be wrong for some edge cases but
-        # in almost all other cases it should be the right decision
-        self.send(args[0], &args[1])
-      else
-        self.send(args[0], args[1])
-      end
-    elsif args.length > 2
-      self.send(args[0], *args[1..-1])
+    if args.length > 1 && args.last.is_a?(Proc)
+      method_block_proc = args.pop
+    end
+
+    if args[0].is_a?(String) || args[0].is_a?(Symbol)
+      self.send(args[0], *args[1..-1], &method_block_proc)
+    elsif args[0].respond_to?(:call)
+      args[0].call(self, *args[1..-1], &method_block_proc)
     end
 
     if block_given?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mighty_tap
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Michael Sievers
@@ -85,6 +85,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console
+- bin/setup
 - lib/mighty_tap.rb
 - lib/mighty_tap/version.rb
 - mighty_tap.gemspec