proc 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ec097a6117d6d476f35dbd2368b5e70e74b42ef134bf2df9a6f21f81f16a1a9
-  data.tar.gz: 5930aff0b125dc144bca46a6505b68dc049b0be416726b9f4af8fcafaa5b0a04
+  metadata.gz: a33f3939a8156059653e7edde57a9ac0b0ee46ab04bcb1f08ce098073e884358
+  data.tar.gz: df8c021333f0f03b6acdaa195b2c39035a4054b026fd1f6c09d08df674aef7f9
 SHA512:
-  metadata.gz: 05d23e88b3c71c8fe7e06d450da67bd95054d2eecd5b25c35a5e92c2f0e0892739f5fb7d7a6c7343ef6081529ff5d1fb46f7e0f9368fc421c03187c6e16f3842
-  data.tar.gz: b50b6af0c4cc0a383aaa6043d2e9c99689951b87934bb5746fd59084c504d597555d61619e3cade3ed2d1be51d9d064536a0e1e50d4bcb499816db4e4e072d69
+  metadata.gz: 52107c5f8c68d623aead4dab7131fe7ea42c5abc29bf748cb81f2aea80bc0ae2b68447764c02a1d40aca4a21e24521f2bc291e9ae7794bd69d98cb867c7f0959
+  data.tar.gz: 8bcab50d65564adb5ce355b75dd407f82ccf93dee798c1219def178293978251b6bfff6c588a823eecd52732a6784a971226026f796601941f1866d3d0c00035

data/lib/proc/callable.rb

@@ -10,7 +10,7 @@ class Proc
     end
 
     def call(input = nil, **arguments)
-      @client.perform(@proc, input, **arguments)
+      @client.call(@proc, input, **arguments)
     end
 
     def >>(other)

data/lib/proc/client.rb

@@ -28,6 +28,9 @@ class Proc
   class RateLimited < Error
   end
 
+  class Timeout < Error
+  end
+
   class Client < Http::Client
     def initialize(authorization, scheme: "https", host: "proc.dev")
       @authorization = authorization
@@ -62,21 +65,28 @@ class Proc
     end
 
     DEFAULT_HEADERS = {
+      "accept" => "application/json",
       "content-type" => "application/json"
     }.freeze
 
-    def perform(proc, input, **arguments)
+    def call(proc = nil, input = nil, **arguments)
       Async(logger: NullLogger) { |task|
-        body = {
-          input: input, arguments: arguments
-        }
+        body = { "<<" => input }
+
+        arguments.each_pair do |key, value|
+          body[key.to_s] = if value.respond_to?(:serialize)
+            value.serialize
+          else
+            value
+          end
+        end
 
         headers = {
-          "authorization" => "Bearer #{@authorization}"
+          "authorization" => "bearer #{@authorization}"
         }.merge(DEFAULT_HEADERS)
 
         begin
-          response = call(:post, build_uri(proc), headers: headers, body: Oj.dump(body, mode: :json), task: task)
+          response = super(:post, build_uri(proc), headers: headers, body: Oj.dump(body, mode: :json), task: task)
 
           @remaining = response.headers["x-rate-limit-remaining"].to_s.to_i
           @resets_at = Time.at(response.headers["x-rate-limit-reset"].to_s.to_i)
@@ -90,23 +100,27 @@ class Proc
 
         case response.status
         when 200
-          payload["value"]
+          payload[">>"]
         when 400
           raise Proc::ArgumentError, payload.dig("error", "message")
         when 403
           raise Proc::Unauthorized, payload.dig("error", "message")
         when 404
           raise Proc::Undefined, payload.dig("error", "message")
+        when 408
+          raise Proc::Timeout, payload.dig("error", "message")
         when 429
           raise Proc::RateLimited, payload.dig("error", "message")
         when 500
           raise Proc::Error, payload.dig("error", "message")
+        else
+          raise Proc::Error, "unhandled"
         end
       }.wait
     end
 
     private def build_uri(proc)
-      host_and_path = File.join(@host, proc.split(".").join("/"))
+      host_and_path = File.join(@host, proc.to_s.split(".").join("/"))
 
       "#{@scheme}://#{host_and_path}"
     end

data/lib/proc/composition.rb

@@ -15,13 +15,10 @@ class Proc
       @callables = @callables.dup
     end
 
-    def call(input, **arguments)
-      if @block
-        evaluator = @block.call(Evaluator.new, **arguments)
-        @client.perform("compose", input, procs: evaluator.serialize.concat(serialize))
-      else
-        @client.perform("compose", input, procs: serialize)
-      end
+    def call(input = nil, **arguments)
+      # TODO: This will probably call `proc.run`.
+      #
+      @client.call("compose", input, proc: build_evaluator(**arguments))
     end
 
     def >>(other)
@@ -34,8 +31,28 @@ class Proc
       @callables << callable
     end
 
-    protected def serialize
-      @callables.map(&:proc)
+    def with(**arguments)
+      build_evaluator(**arguments)
+    end
+
+    def serialize
+      build_evaluator.serialize
+    rescue ::ArgumentError => error
+      raise ::ArgumentError, error.message + " (try using `with' to build a composition with arguments)"
+    end
+
+    private def build_evaluator(**arguments)
+      evaluator = if @block
+        @block.call(Evaluator.new, **arguments)
+      else
+        Evaluator.new
+      end
+
+      @callables.each do |callable|
+        evaluator << Deferable.new(callable.proc)
+      end
+
+      evaluator
     end
   end
 end

data/lib/proc/composition/deferable.rb

@@ -12,7 +12,17 @@ class Proc
       end
 
       def serialize
-        [@proc, @arguments]
+        [@proc, serialized_arguments]
+      end
+
+      private def serialized_arguments
+        @arguments.each.each_with_object({}) do |(key, value), hash|
+          hash[key] = if value.respond_to?(:serialize)
+            value.serialize
+          else
+            value
+          end
+        end
       end
     end
   end

data/lib/proc/composition/evaluator.rb

@@ -45,7 +45,7 @@ class Proc
       end
 
       def serialize
-        @callables.map(&:serialize)
+        { "[]" => @callables.map(&:serialize) }
       end
     end
   end

data/lib/proc/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Proc
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 
   def self.version
     VERSION

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proc
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-21 00:00:00.000000000 Z
+date: 2020-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http
@@ -45,7 +45,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
-- lib/examples/scratch.rb
+- README.md
 - lib/proc.rb
 - lib/proc/callable.rb
 - lib/proc/client.rb

data/lib/examples/scratch.rb

@@ -1,61 +0,0 @@
-# Pass `token: "..."` or default to `PROC_ACCESS_TOKEN`:
-#
-client = Proc.connect
-
-# Not chainable, returns the value:
-#
-client.stdlib.echo("bar")
-# => bar
-
-# Create chains using `chain` (perhaps alias as `with`):
-#
-client.chain("foo") { |chain| chain.stdlib.reverse.capitalize.truncate(2) }
-# => Oo
-
-# Or return a chain to pass around:
-#
-chain = client.chain("foo")
-# => <Proc::Chain ...>
-chain.stdlib.echo("bar")
-
-# Call `value` or `perform` to evaluate the chain:
-#
-chain.value
-
-# Calling a non-existent proc raises a Proc::NameError,
-#
-chain.nonexistent
-
-# Pass values through different contexts:
-#
-client.chain("foo") { |chain| chain.stdlib.reverse >> chain.whatever.other }
-
-# Use from the cli (included with the ruby gem OR as a go library):
-#
-# proc echo "bar" -t access-token
-# proc chain "bar" "stdlib.reverse >> whatever.other" -t access-token
-
-#########################################################
-# alternatives so that we don't have to fetch metadata: #
-#########################################################
-
-proc = Proc.connect
-
-# I like this because it's obvious how to get a reference as well as just make the call.
-#
-proc["stdlib.echo"].call("foo")
-
-# This works for simple composition, where the value is simply passed through.
-#
-my_proc = proc["stdlib.reverse"] >> proc["stdlib.capitalize"]
-
-my_proc.call("foo")
-
-# Perhaps something like this, where we compose a proc with arguments. Each is implicitly called, or
-# call explicitly to pass an argument to the proc. I sort of like the simplicity of this.
-#
-my_proc = proc.compose { |context, length:|
-  context["stdlib.reverse"] >> context["stdlib.capitalize"] >> context["stdlib.truncate"].call(length)
-}
-
-my_proc.call("foo", length: 2)