pipe_operator 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc08d5b15937d1418ca864e631eb9f0a6a3fafd04e2c1f7496fbdd925531eec7
-  data.tar.gz: 340f185be7fe2f803a0d61603f1b1c89c641f6dfbf21ba691e1c3e48c3c5bdce
+  metadata.gz: ddf66c989601033a8afbc02f4ae7689052eecaa61d361d477f2cf92bec30ce97
+  data.tar.gz: fa3b1c43271d8ee56032fe7b485a81aec78152602e39ece819929c2accf246f6
 SHA512:
-  metadata.gz: 4b2e3096c092d839dde50eadbc196cef82745371c99cb313f845587b0c4908ab6225a261309984d2cdef927605f44308026adf57a7c02970721d84c0e240d958
-  data.tar.gz: a873ca59f03c6e50630c9d8b91f5494a5b7bfb06b558b21c574c716065f63fb381d155b66c106c4d12de237fbb8b1506bb40fd2e459f130a278ceea26ee0daa5
+  metadata.gz: 32a09b3839ee5f41e35623300a0501c8fdc3365c38996d6433ad89d659e055d514afa170946c10c58fb5646236c077fe5463c047c2e96c2ddd48e13d141ba196
+  data.tar.gz: b3e31722a99368a65a8daf790693d0712008862c558daea345321d8bdbaaccf5eaf09037c516e1210fdf0fbc967130459cbbb545e91ad28e4381c40ff6608227

data/README.md

@@ -3,22 +3,47 @@
 > Elixir/Unix style pipe operations in Ruby - **PROOF OF CONCEPT**
 
 ```ruby
--9.pipe { abs | Math.sqrt | to_i } #=> 3
-```
-
-```ruby
-[9, 64].map(&Math.|.sqrt.to_i) #=> [3, 8]
-```
-
-```ruby
-"https://api.github.com/repos/ruby/ruby".| do
+"https://api.github.com/repos/ruby/ruby".pipe do
   URI.parse
   Net::HTTP.get
   JSON.parse.fetch("stargazers_count")
   yield_self { |n| "Ruby has #{n} stars" }
   Kernel.puts
 end
-#=> Ruby has 15115 stars
+#=> Ruby has 15120 stars
+```
+
+```ruby
+-9.pipe { abs; Math.sqrt; to_i } #=> 3
+
+# Method chaining is supported:
+-9.pipe { abs; Math.sqrt.to_i } #=> 3
+
+# Pipe | for syntactic sugar:
+-9.pipe { abs | Math.sqrt.to_i } #=> 3
+
+# Pipe blocks are instance_exec within the context
+# of a PipeOperator::Pipe object which defines its
+# own implementation for how `|` should behave.
+#
+# If we actually need to pipe the method `|` on
+# some other object then we can just use `send`:
+-2.pipe { abs | send(:|, 4) } #=> 6
+```
+
+```ruby
+sqrt = Math.pipe.sqrt #=> #<PipeOperator::Closure:0x00007fc1172ed558@pipe_operator/closure.rb:18>
+sqrt.call(9)          #=> 3.0
+sqrt.call(64)         #=> 8.0
+
+[9, 64].map(&Math.pipe.sqrt)           #=> [3.0, 8.0]
+[9, 64].map(&Math.pipe.sqrt.to_i.to_s) #=> ["3", "8"]
+
+# Still not concise enough for you?
+Module.alias_method(:|, :__pipe__)
+
+[9, 64].map(&Math.|.sqrt)           #=> [3.0, 8.0]
+[9, 64].map(&Math.|.sqrt.to_i.to_s) #=> [3.0, 8.0]
 ```
 
 ## Why?
@@ -31,6 +56,16 @@ There's been some recent activity related to `Method` and `Proc` composition in
 
 This gem was created to **propose an alternative syntax** for this kind of behavior.
 
+## Matz on Ruby
+
+Source: [ruby-lang.org/en/about](https://www.ruby-lang.org/en/about)
+
+Ruby is a language of careful **balance of both functional and imperative programming**.
+
+Matz has often said that he is **trying to make Ruby natural, not simple**, in a way that mirrors life.
+ 
+Building on this, he adds: Ruby is **simple in appearance, but is very complex inside**, just like our human body.
+
 ## Concept
 
 The general idea is to **pass the result of one expression as an argument to another expression** - similar to [Unix pipelines](https://en.wikipedia.org/wiki/Pipeline_(Unix)):
@@ -46,7 +81,7 @@ The [Elixir pipe operator documentation](https://elixirschool.com/en/lessons/bas
 JSON.parse(Net::HTTP.get(URI.parse(url)))
 ```
 
-To be **inversed** and rewritten as **left to right** or **top to bottom** which is more **natural to read** in English:
+To be **inverted** and rewritten as **left to right** or **top to bottom** which is more **natural to read** in English:
 
 ```ruby
 # left to right
@@ -83,7 +118,7 @@ end
 While the ability to perform a job correctly and efficiently is certainly important - the **true beauty of a program lies in its clarity and conciseness**:
 
 ```ruby
-"https://api.github.com/repos/ruby/ruby".| do
+"https://api.github.com/repos/ruby/ruby".pipe do
   URI.parse
   Net::HTTP.get
   JSON.parse.fetch("stargazers_count")
@@ -96,22 +131,12 @@ end
 There's nothing really special here - it's just a **block of expressions like any other Ruby DSL** and the pipe `|` operator has been [around for decades](https://en.wikipedia.org/wiki/Pipeline_(Unix))!
 
 ```ruby
-# we can already do this
-objects.map(&Marshal.method(:dump))
-
-# but this is more concise
-objects.map(&Marshal.|.dump)
-```
-
-The **simplicity and elegance of Ruby** is one of the many reasons that people fall in love with the language!
-
-```ruby
-Ruby.is.so(:simple, &elegant).that(you can) do
+Ruby.is.so(elegant, &:expressive).that(you can) do
   pretty_much ANYTHING if it.compiles!
 end
 ```
 
-This concept of **pipes could be a great fit** like it has been for many other languages:
+This concept of **pipe operations could be a great fit** like it has been for many other languages:
 
 * [Caml composition operators](http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#1_Compositionoperators)
 * [Closure threading macros](https://clojure.org/guides/threading_macros)
@@ -128,22 +153,11 @@ This concept of **pipes could be a great fit** like it has been for many other l
 
 **WARNING - EXPERIMENTAL PROOF OF CONCEPT**
 
-This has only been **tested in isolation with RSpec**!
+This has only been **tested in isolation with RSpec and Ruby 2.5.3**!
 
 ```ruby
 # First `gem install pipe_operator`
 require "pipe_operator"
-
-# Then use PipeOperator as a refinement
-using ::PipeOperator
-
-# Or include PipeOperator in classes/modules
-class AnyClass
-  include ::PipeOperator
-end
-
-# Or monkey patch PipeOperator into ALL objects
-require "pipe_operator/autoload"
 ```
 
 ## Implementation
@@ -151,37 +165,40 @@ require "pipe_operator/autoload"
 The [PipeOperator](https://github.com/lendinghome/pipe_operator/blob/master/lib/pipe_operator.rb) module has a method named `__pipe__` which is aliased as `pipe` for convenience and `|` for syntactic sugar:
 
 ```ruby
-def __pipe__(*args, &block)
-  Pipe.new(self, *args, &block)
+module PipeOperator
+  def __pipe__(*args, &block)
+    Pipe.new(self, *args, &block)
+  end
 end
 
-alias | __pipe__
-alias pipe __pipe__
+BasicObject.send(:include, PipeOperator)
+Kernel.alias_method(:pipe, :__pipe__)
+Module.alias_method(:|, :__pipe__)
 ```
 
 When no arguments are passed to `__pipe__` then a [PipeOperator::Pipe](https://github.com/lendinghome/pipe_operator/blob/master/lib/pipe_operator/pipe.rb) object is returned:
 
 ```ruby
-Math.| #=> #<PipeOperator::Pipe:Math>
+Math.pipe #=> #<PipeOperator::Pipe:Math>
 ```
 
 Any methods invoked on this object returns a [PipeOperator::Closure](https://github.com/lendinghome/pipe_operator/blob/master/lib/pipe_operator/closure.rb) which **calls the method on the object later**:
 
 ```ruby
-sqrt = Math.|.sqrt       #=> #<PipeOperator::Closure:0x00007fc1172ed558@pipe_operator/closure.rb:18>
-sqrt.call(16)            #=> 4.0
+sqrt = Math.pipe.sqrt       #=> #<PipeOperator::Closure:0x00007fc1172ed558@pipe_operator/closure.rb:18>
+sqrt.call(16)               #=> 4.0
 
-missing = Math.|.missing #=> #<PipeOperator::Closure:0x00007fc11726f0e0@pipe_operator/closure.rb:18>
-missing.call             #=> NoMethodError: undefined method 'missing' for Math:Module
+missing = Math.pipe.missing #=> #<PipeOperator::Closure:0x00007fc11726f0e0@pipe_operator/closure.rb:18>
+missing.call                #=> NoMethodError: undefined method 'missing' for Math:Module
 
-Math.method(:missing)    #=> NameError: undefined method 'missing' for class '#<Class:Math>'
+Math.method(:missing)       #=> NameError: undefined method 'missing' for class '#<Class:Math>'
 ```
 
 When `__pipe__` is called **with arguments but without a block** then it behaves similar to `__send__`:
 
 ```ruby
-sqrt = Math | :sqrt #=> #<PipeOperator::Closure:0x00007fe52e0cdf80@pipe_operator/closure.rb:18>
-sqrt.call(16)       #=> 4.0
+sqrt = Math.pipe(:sqrt) #=> #<PipeOperator::Closure:0x00007fe52e0cdf80@pipe_operator/closure.rb:18>
+sqrt.call(16)           #=> 4.0
 
 sqrt = Math.pipe(:sqrt, 16) #=> #<PipeOperator::Closure:0x00007fe52fa18fd0@pipe_operator/closure.rb:18>
 sqrt.call                   #=> 4.0
@@ -191,13 +208,13 @@ sqrt.call(16)               #=> ArgumentError: wrong number of arguments (given
 These [PipeOperator::Closure](https://github.com/lendinghome/pipe_operator/blob/master/lib/pipe_operator/closure.rb) objects can be [bound as block arguments](https://github.com/lendinghome/pipe_operator/blob/master/lib/pipe_operator/proxy.rb#L10-L13) just like any other [Proc](https://ruby-doc.org/core-2.5.3/Proc.html):
 
 ```ruby
-[16, 256].map(&Math.|.sqrt) #=> [4.0, 16.0]
+[16, 256].map(&Math.pipe.sqrt) #=> [4.0, 16.0]
 ```
 
 Simple **closure composition is supported** via [method chaining](https://github.com/lendinghome/pipe_operator/blob/master/lib/pipe_operator/closure.rb#L56):
 
 ```ruby
-[16, 256].map(&Math.|.sqrt.to_i.to_s) #=> ["4", "16"]
+[16, 256].map(&Math.pipe.sqrt.to_i.to_s) #=> ["4", "16"]
 ```
 
 The **block** form of `__pipe__` behaves **similar to instance_exec** but can also [call methods on other objects](https://github.com/lendinghome/pipe_operator/blob/master/lib/pipe_operator/pipe.rb#L81):
@@ -292,7 +309,35 @@ define_method(method) do |*args, &block|
 end
 ```
 
-These proxy modules are prepended everywhere! It's certainly something that **could be way more efficient as a core part of Ruby**.
+These **proxy modules are prepended everywhere**!
+
+It's certainly something that **could be way more efficient as a core part of Ruby**.
+
+Maybe somewhere **lower level where methods are dispatched**? Possibly somewhere in this [vm_eval.c switch](https://github.com/ruby/ruby/blob/trunk/vm_eval.c#L111)?
+
+```c
+again:
+  switch (cc->me->def->type) {
+    case VM_METHOD_TYPE_ISEQ
+    case VM_METHOD_TYPE_NOTIMPLEMENTED
+    case VM_METHOD_TYPE_CFUNC
+    case VM_METHOD_TYPE_ATTRSET
+    case VM_METHOD_TYPE_IVAR
+    case VM_METHOD_TYPE_BMETHOD
+    case VM_METHOD_TYPE_ZSUPER
+    case VM_METHOD_TYPE_REFINED
+    case VM_METHOD_TYPE_ALIAS
+    case VM_METHOD_TYPE_MISSING
+    case VM_METHOD_TYPE_OPTIMIZED
+    case OPTIMIZED_METHOD_TYPE_SEND
+    case OPTIMIZED_METHOD_TYPE_CALL
+    case VM_METHOD_TYPE_UNDEF
+  }
+```
+
+Then we'd **only need Ruby C API ports** for [PipeOperator::Pipe](https://github.com/LendingHome/pipe_operator/blob/master/lib/pipe_operator/pipe.rb) and [PipeOperator::Closure](https://github.com/LendingHome/pipe_operator/blob/master/lib/pipe_operator/closure.rb)!
+
+All other objects in this proof of concept are related to **method interception** and would no longer be necessary.
 
 ## Bugs
 
@@ -366,6 +411,7 @@ bundle exec rspec
 * https://github.com/tiagopog/piped_ruby
 * https://github.com/jicksta/methodphitamine
 * https://github.com/jicksta/superators
+* https://github.com/baweaver/xf
 
 ## Contributing
 

data/lib/pipe_operator.rb

@@ -13,10 +13,6 @@ module PipeOperator
   def __pipe__(*args, &block)
     Pipe.new(self, *args, &block)
   end
-  alias | __pipe__
-  alias pipe __pipe__
-
-  refine(::BasicObject) { include PipeOperator }
 
   class << self
     def gem
@@ -47,3 +43,7 @@ module PipeOperator
     end
   end
 end
+
+BasicObject.send(:include, PipeOperator)
+Kernel.alias_method(:pipe, :__pipe__)
+Module.alias_method(:|, :__pipe__)

data/lib/pipe_operator/closure.rb

@@ -39,6 +39,10 @@ module PipeOperator
       super
     end
 
+    def |(*args, &block)
+      Pipe.new(self, *args, &block)
+    end
+
     def __chain__(*args)
       return @__chain__ if args.empty?
 

data/pipe_operator.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 2.0.0"
   s.summary               = "Elixir/Unix style pipe operations in Ruby"
   s.test_files            = `git ls-files -- spec/* 2>/dev/null`.split("\n")
-  s.version               = "0.0.1"
+  s.version               = "0.0.2"
 
   s.rdoc_options = %w[
     --all

data/spec/pipe_operator_spec.rb

@@ -1,6 +1,4 @@
 RSpec.describe PipeOperator do
-  using PipeOperator
-
   describe ".gem" do
     it "returns a Gem::Specification" do
       gem = PipeOperator.gem
@@ -61,7 +59,7 @@ RSpec.describe PipeOperator do
     end
 
     it "curries arguments and blocks" do
-      actual = "testing".|.sub("test").("TEST")
+      actual = "testing".pipe.sub("test").("TEST")
       expect(actual).to eq("TESTing")
 
       actual = ["testing"].pipe.map(&:upcase).call
@@ -106,22 +104,22 @@ RSpec.describe PipeOperator do
     end
 
     it "supports pipe and stream expressions" do
-      actual = "-9".|{to_i}
+      actual = "-9".pipe{to_i}
       expect(actual).to eq(-9)
 
-      actual = "-9".|{to_i; abs}
+      actual = "-9".pipe{to_i; abs}
       expect(actual).to eq(9)
 
-      actual = "-9".|{to_i; abs; Math.sqrt}
+      actual = "-9".pipe{to_i; abs; Math.sqrt}
       expect(actual).to eq(3)
 
       actual = "-9".pipe { to_i | abs | Math.sqrt }
       expect(actual).to eq(3)
 
-      actual = "-9".|{to_i; abs; Math.sqrt; to_i; send(:*, 2)}
+      actual = "-9".pipe{to_i; abs; Math.sqrt; to_i; send(:*, 2)}
       expect(actual).to eq(6)
 
-      actual = "-16".|{
+      actual = "-16".pipe{
         to_i
         abs
         Math.sqrt
@@ -174,7 +172,7 @@ RSpec.describe PipeOperator do
         end
       end
 
-      actual = Markdown.new.|.format.call("test")
+      actual = Markdown.new.pipe.format.call("test")
       expect(actual).to eq("TEST")
 
       actual = "test".pipe(Markdown.new, &:format)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pipe_operator
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - LendingHome
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-09 00:00:00.000000000 Z
+date: 2018-12-13 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: engineering@lendinghome.com
@@ -26,7 +26,6 @@ files:
 - README.md
 - Rakefile
 - lib/pipe_operator.rb
-- lib/pipe_operator/autoload.rb
 - lib/pipe_operator/closure.rb
 - lib/pipe_operator/observer.rb
 - lib/pipe_operator/pipe.rb

data/lib/pipe_operator/autoload.rb

@@ -1,3 +0,0 @@
-require_relative "../pipe_operator"
-
-BasicObject.send(:include, PipeOperator)