piped_ruby 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 005c1764bc7845f7f02b2828042107818c715627
-  data.tar.gz: 07a97f6a1b1dfdeb7079a9ae1aeac0e76d75aba9
+  metadata.gz: a304ea3db4e8015621d0464fb87513565ec11037
+  data.tar.gz: 808ec638afd890440f88bb37081ba72c4cbdc89a
 SHA512:
-  metadata.gz: 8ae57b57993db4e0f843c252698a348230d962a8429e092d1639da3e541acd746088f49e81c82094b40cb876eb3adadf1d3051f90afad9d67476572d2f45158c
-  data.tar.gz: d01316c53748dc6461dd503efa5ef36ad8f9d8f4d7c336f929df0399f63e5e6c4c0001e2827f87b674c6785967a4005dfe0a823a9ef436a0237cfa7885da445c
+  metadata.gz: abb245a6fd266c16899e7341e8b206bcb0996457b2a4863746d25ea8cee88deb8704ca57a18c5bad6b41e74cd3e41c1b9b63744a59e98be3b8ee0f46fb61e7b3
+  data.tar.gz: 55661b1c7bd5da2696bf79ff2cc98954d46af5918041efaa7585206e3c31dcaf46f722082a818a80a0667b4605ec30e131924eb4d2b22125c5149edebd67c0f6

data/README.md

@@ -3,12 +3,12 @@
 ```ruby
 -> { "Pipe" }.| { |e| "#{e} things"  }
              .| { |e| "#{e} in Ruby!" }
-             .| { |e| puts e } # Pipe things in Ruby!
+             .unwrap #=> "Pipe things in Ruby!"
 ```
 
-Piped Ruby is a tiny piece of code that brings an awesome feature to Ruby: pipe operators.
+Piped Ruby is a tiny piece of code that aims to bring the beauty of pipe operators and data transformation to your Ruby application.
 
-Credit to [Elixir's pipe operator](http://elixir-lang.org/getting-started/enumerables-and-streams.html#the-pipe-operator) that is the source of inspiration for this gem :-)
+Credit to [Elixir's Pipe Operator](http://elixir-lang.org/getting-started/enumerables-and-streams.html#the-pipe-operator) and [Chainable Methods](https://github.com/akitaonrails/chainable_methods) gem which were the source of inspiration for this gem :-)
 
 ## Installation
 
@@ -34,15 +34,44 @@ require 'piped_ruby'
 
 ## Usage
 
-Print max element of a given array:
+With Piped Ruby doing this:
+
+```ruby
+-> { some_text.upcase }.>> { |e| MyModule.method_a(e)  }
+                       .>> { |e| MyModule.method_b(e, "something") }
+                       .>> { |e| MyModule.method_c(e) { |c| do_something3(c) } }
+                       .unwrap
+```
+
+...is equivalent to this:
+
+```ruby
+a = some_text.upcase
+b = MyModule.method_a(a)
+c = MyModule.method_b(b, "something")
+d = MyModule.method_c(c) { |c| do_something3(c) }
+```
+
+### More examples
+
+Exporting clients from CSV file:
+
 ```ruby
-array = [1, 3, 2, 5]
--> { array }.| { |e| e.length == 4 ? e.push(4) : e }
-            .| { |e| e.max }
-            .| { |e| puts e } # 5
+#...
+def call
+  File.foreach(file) do |line|
+    -> { values_from(line) }
+      .>> { |e| match_fields_for(e) }
+      .>> { |e| sanitize(e) }
+      .>> { |e| Save.new(attributes: sanitize(e)) }
+      .>> { |save| save.call }
+      .unwrap
+  end
+end
 ```
 
-Making some fun with strings:
+Fun with strings:
+
 ```ruby
 module Foo
   class << self
@@ -51,13 +80,37 @@ module Foo
   end
 end
 
--> { Foo.number }.| { |e| e + 1 }
-                 .| { |e| e * 21 }
-                 .| { |e| Foo.answer(e) }
-                 .| { |e| e + ' :-)' }
-                 .| { |e| puts(e) } # So the answer of the life, the universe and everything is... 42! :-)"
+-> { Foo.number }.>> { |e| e + 1 }
+                 .>> { |e| e * 21 }
+                 .>> { |e| Foo.answer(e) }
+                 .>> { |e| e + ' :-)' }
+                 .unwrap #=> "So the answer of the life, the universe and everything is... 42! :-)"
+```
+
+
+## Backstage
+
+Pipe operations happen between Proc objects (blocks). After requiring the gem every Proc in your Ruby program will be capable to start a pipe operation.
+
+```ruby
+operation = -> { 'Foo' }.>> { |e| "#{e}bar" }
+operation.class #=> Proc
+operation.unwrap #=> "Foobar"
+```
+
+The `PipedRuby#unwrap` method is the way to get the returning value from the last evaluated block:
+
+```ruby
+operation = -> { 'Foo' }.>> { |e| "#{e}bar" }
+operation.>> { |e| puts e } #=> Prints "Foobar" and returns a Proc object
+operation.>> { |e| puts e }.unwrap #=> Prints "Foobar" and returns nil
 ```
 
+## TODO
+
+- [ ] Write more cool examples in README;
+- [ ] Introduce something similar to Elixir's Streams;
+- [ ] Store Procs and be able to unwrap a returning value in different points of execution.
 
 ## Contributing
 

data/lib/piped_ruby/version.rb

@@ -1,3 +1,3 @@
 module PipedRuby
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/piped_ruby.rb

@@ -3,7 +3,7 @@ require 'piped_ruby/version'
 module PipedRuby
   attr_accessor :piped
 
-  def |(&chained)
+  def >>(&chained)
     self.piped = call if piped.nil?
     chained.piped = chained.call(piped)
     chained

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: piped_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tiago Guedes
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-01 00:00:00.000000000 Z
+date: 2016-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler