proc 0.0.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ec097a6117d6d476f35dbd2368b5e70e74b42ef134bf2df9a6f21f81f16a1a9
-  data.tar.gz: 5930aff0b125dc144bca46a6505b68dc049b0be416726b9f4af8fcafaa5b0a04
+  metadata.gz: 75ef8a4c8d8b8f07682996ca70c0263f5e0b6d123493137a07f92717c9c16eab
+  data.tar.gz: 48d2b0b5a4e453366ec4fc99536f98d875f804cb705ff5fde9a8b4b2d46e74c0
 SHA512:
-  metadata.gz: 05d23e88b3c71c8fe7e06d450da67bd95054d2eecd5b25c35a5e92c2f0e0892739f5fb7d7a6c7343ef6081529ff5d1fb46f7e0f9368fc421c03187c6e16f3842
-  data.tar.gz: b50b6af0c4cc0a383aaa6043d2e9c99689951b87934bb5746fd59084c504d597555d61619e3cade3ed2d1be51d9d064536a0e1e50d4bcb499816db4e4e072d69
+  metadata.gz: 1fca54bd564be4fa0ac560ee4c81c9f6d81421b6fe26a6a7038ac97c4b2a17da34359949ba9d1d02191370022d916727793bda08e3d5a3c6d50d577acfaea17b
+  data.tar.gz: 7a7bba01f304f8866ff2cd69b779c4a4995b966d0ec835d78da29f577704c89d848d79b83b516c5b53df59c0352fb7a038f4f28e2a2d02fab5337048cbfb6fff

data/README.md

@@ -0,0 +1,80 @@
+The `proc` gem lets you call codeless web functions through the proc.dev service.
+
+## Getting Started
+
+Install `proc` using the `gem` command from the command line:
+
+```
+gem install proc
+```
+
+You will also need a proc.dev account. Create a free account in seconds at [proc.dev](https://proc.dev/).
+
+## Connecting
+
+Sign in to your proc.dev account and locate your secret key. Use the secret to create a client connection:
+
+```ruby
+client = Proc.connect("secret-key")
+```
+
+## Calling Procs
+
+You can call available procs through a connected client:
+
+```ruby
+client.core.string.reverse.call("hello")
+=> "olleh"
+```
+
+Requests are sent to proc.dev anytime the `call` method is invoked.
+
+## Callable Contexts
+
+Proc lookups create contexts that can be called later:
+
+```ruby
+string = client.core.string
+
+string.reverse.call("hello")
+=> "olleh"
+
+string.truncate.call("hello", length: 3)
+=> "hel"
+```
+
+Contexts can be configured with default input and arguments using the `with` method:
+
+```ruby
+truncate = client.core.string.truncate.with("default", length: 1)
+
+truncate.call
+=> "d"
+```
+
+Default input and/or arguments can be overidden for a specific call:
+
+```ruby
+truncate.call(length: 3)
+=> "def"
+```
+
+Procs can also be looked up using the hash key syntax:
+
+```ruby
+client["core.string.truncate"].call("hello", length: 3)
+=> "hel"
+```
+
+## Compositions
+
+Procs can be composed together to build more complex behavior:
+
+```ruby
+composition = client.core.string.reverse >> client.core.string.truncate(length: 3) >> client.core.string.capitalize
+
+composition.call("hello")
+=> "Oll"
+```
+
+Compositions are sent to proc.dev in a single request.

data/lib/proc.rb

@@ -6,4 +6,12 @@ class Proc
   def self.connect(authorization, **options)
     Client.new(authorization, **options)
   end
+
+  def self.undefined
+    @_undefined ||= Object.new
+  end
+
+  def self.undefined?(value)
+    value == undefined
+  end
 end

data/lib/proc/argument.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Proc
+  class Argument
+    def initialize(name, **options)
+      @name = name
+      @options = options
+    end
+
+    def serialize
+      {"::" => {"name" => @name.to_s}.merge(serialized_options)}
+    end
+
+    def serialized_options
+      @options.each_pair.each_with_object({}) { |(key, value), hash|
+        hash[key.to_s] = serialize_value(value)
+      }
+    end
+
+    private def serialize_value(value)
+      if value.respond_to?(:serialize)
+        value.serialize
+      else
+        value
+      end
+    end
+  end
+end

data/lib/proc/callable.rb

@@ -2,22 +2,105 @@
 
 class Proc
   class Callable
-    attr_reader :proc
+    attr_reader :proc, :input, :arguments
 
-    def initialize(proc, client:)
-      @proc = proc
+    def initialize(proc, client:, input: Proc.undefined, arguments: {})
+      @proc = proc.to_s
       @client = client
+      @input = input
+      @arguments = arguments
     end
 
-    def call(input = nil, **arguments)
-      @client.perform(@proc, input, **arguments)
+    def initialize_copy(_)
+      @input = input.dup
+      @arguments = arguments.dup
+    end
+
+    def call(input = input_omitted = true, **arguments)
+      callable = self.class.new(
+        @proc,
+        client: @client,
+        input: input_omitted ? @input : input,
+        arguments: @arguments.merge(arguments)
+      )
+
+      @client.call(@proc, callable.serialized_input, **callable.serialized_arguments)
+    end
+
+    def with(input = input_omitted = true, **arguments)
+      self.class.new(
+        @proc,
+        client: @client,
+        input: input_omitted ? @input : input,
+        arguments: @arguments.merge(arguments)
+      )
     end
 
     def >>(other)
-      composed = Composition.new(client: @client)
+      composed = Composition.new(client: @client, input: @input)
       composed << self
       composed << other
       composed
     end
+
+    def serialize
+      wrapped =  {"[]" => [[@proc, serialized_arguments]]}
+
+      unless Proc.undefined?(@input)
+        wrapped["<<"] = serialized_input
+      end
+
+      {"{}" => wrapped}
+    end
+
+    def serialized_input
+      serialize_value(@input)
+    end
+
+    def serialized_arguments
+      @arguments.each_pair.each_with_object({}) { |(key, value), hash|
+        hash[key.to_s] = serialize_value(value)
+      }
+    end
+
+    def [](proc)
+      Callable.new(
+        [@proc, proc].join("."),
+        client: @client,
+        input: @input,
+        arguments: @arguments
+      )
+    end
+
+    IGNORE_MISSING = %i[to_hash].freeze
+
+    def method_missing(name, input = input_omitted = true, **arguments)
+      if IGNORE_MISSING.include?(name)
+        super
+      else
+        Callable.new(
+          [@proc, name].join("."),
+          client: @client,
+          input: input_omitted ? @input : input,
+          arguments: @arguments.merge(arguments)
+        )
+      end
+    end
+
+    def respond_to_missing?(name, *)
+      if IGNORE_MISSING.include?(name)
+        super
+      else
+        true
+      end
+    end
+
+    private def serialize_value(value)
+      if value.respond_to?(:serialize)
+        value.serialize
+      else
+        value
+      end
+    end
   end
 end

data/lib/proc/client.rb

@@ -3,6 +3,7 @@
 require "async"
 require "oj"
 
+require_relative "argument"
 require_relative "callable"
 require_relative "composition"
 require_relative "null_logger"
@@ -13,7 +14,7 @@ class Proc
   class Error < StandardError
   end
 
-  class ArgumentError < ::ArgumentError
+  class Invalid < ::ArgumentError
   end
 
   class Undefined < ::NameError
@@ -22,10 +23,16 @@ class Proc
   class Unauthorized < Error
   end
 
+  class Forbidden < Error
+  end
+
   class Unavailable < Error
   end
 
-  class RateLimited < Error
+  class Limited < Error
+  end
+
+  class Timeout < Error
   end
 
   class Client < Http::Client
@@ -57,58 +64,94 @@ class Proc
       @resets_at
     end
 
-    def compose(&block)
-      Composition.new(client: self, &block)
-    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 = {}
+
+        unless Proc.undefined?(input)
+          body["<<"] = serialize_value(input)
+        end
+
+        arguments.each_pair do |key, value|
+          body[key.to_s] = serialize_value(value)
+        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: :custom), 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)
 
-          payload = Oj.load(response.read, mode: :strict)
-        rescue => error
-          raise Proc::Unavailable, error.message
+          payload = Oj.load(response.read, mode: :compat)
+        rescue
+          raise Proc::Unavailable
         ensure
           response&.close
         end
 
         case response.status
         when 200
-          payload["value"]
+          payload[">>"]
         when 400
-          raise Proc::ArgumentError, payload.dig("error", "message")
-        when 403
+          raise Proc::Invalid, payload.dig("error", "message")
+        when 401
           raise Proc::Unauthorized, payload.dig("error", "message")
+        when 403
+          raise Proc::Forbidden, 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")
+          raise Proc::Limited, payload.dig("error", "message")
         when 500
           raise Proc::Error, payload.dig("error", "message")
+        when 508
+          raise Proc::Error, payload.dig("error", "message")
+        else
+          raise Proc::Error, "unhandled"
         end
       }.wait
     end
 
+    def method_missing(name, input = input_omitted = true, **arguments)
+      if input_omitted
+        Callable.new(name, client: self, arguments: arguments)
+      else
+        Callable.new(name, client: self, input: input, arguments: arguments)
+      end
+    end
+
+    def respond_to_missing?(name, *)
+      true
+    end
+
+    def argument(name, **options)
+      Argument.new(name, **options)
+    end
+    alias_method :arg, :argument
+
     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
+
+    private def serialize_value(value)
+      if value.respond_to?(:serialize)
+        value.serialize
+      else
+        value
+      end
+    end
   end
 end

data/lib/proc/composition.rb

@@ -2,26 +2,37 @@
 
 class Proc
   class Composition
-    require_relative "composition/deferable"
-    require_relative "composition/evaluator"
+    attr_reader :input, :callables, :arguments
 
-    def initialize(client:, &block)
+    def initialize(client:, input:, callables: [], arguments: {})
       @client = client
-      @block = block
-      @callables = []
+      @input = input
+      @callables = callables
+      @arguments = arguments
     end
 
     def initialize_copy(_)
       @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 = input_omitted = true, **arguments)
+      callable = self.class.new(
+        client: @client,
+        input: input_omitted ? @input : input,
+        callables: @callables.dup,
+        arguments: @arguments.merge(arguments)
+      )
+
+      @client.call("proc.exec", nil, proc: callable.serialize)
+    end
+
+    def with(input = input_omitted = true, **arguments)
+      self.class.new(
+        client: @client,
+        input: input_omitted ? @input : input,
+        callables: @callables.dup,
+        arguments: @arguments.merge(arguments)
+      )
     end
 
     def >>(other)
@@ -31,11 +42,59 @@ class Proc
     end
 
     def <<(callable)
-      @callables << callable
+      case callable
+      when Composition
+        merge(callable)
+      when Callable
+        @callables << callable
+      end
+    end
+
+    def serialize
+      wrapped = {"[]" => serialized_calls}
+
+      unless Proc.undefined?(@input)
+        wrapped["<<"] = serialized_input
+      end
+
+      {"{}" => wrapped.merge(serialized_arguments)}
+    end
+
+    def serialized_calls
+      @callables.map { |callable|
+        arguments = callable.serialized_arguments
+
+        unless Proc.undefined?(callable.input)
+          arguments["<<"] = callable.serialized_input
+        end
+
+        [callable.proc, arguments]
+      }
+    end
+
+    def serialized_input
+      serialize_value(@input)
+    end
+
+    def serialized_arguments
+      @arguments.each_pair.each_with_object({}) { |(key, value), hash|
+        hash[key.to_s] = serialize_value(value)
+      }
+    end
+
+    def merge(composition)
+      raise ArgumentError, "expected a composition" unless composition.is_a?(self.class)
+
+      @callables.concat(composition.callables)
+      @arguments.merge!(composition.arguments)
     end
 
-    protected def serialize
-      @callables.map(&:proc)
+    private def serialize_value(value)
+      if value.respond_to?(:serialize)
+        value.serialize
+      else
+        value
+      end
     end
   end
 end

data/lib/proc/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Proc
-  VERSION = "0.0.3"
+  VERSION = "0.2.0"
 
   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.2.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-21 00:00:00.000000000 Z
+date: 2020-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http
@@ -45,13 +45,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
-- lib/examples/scratch.rb
+- README.md
 - lib/proc.rb
+- lib/proc/argument.rb
 - lib/proc/callable.rb
 - lib/proc/client.rb
 - lib/proc/composition.rb
-- lib/proc/composition/deferable.rb
-- lib/proc/composition/evaluator.rb
 - lib/proc/http/client.rb
 - lib/proc/http/request.rb
 - lib/proc/http/response.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)

data/lib/proc/composition/deferable.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-class Proc
-  class Composition
-    class Deferable
-      attr_reader :proc
-      attr_writer :arguments
-
-      def initialize(proc)
-        @proc = proc
-        @arguments = {}
-      end
-
-      def serialize
-        [@proc, @arguments]
-      end
-    end
-  end
-end

data/lib/proc/composition/evaluator.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-class Proc
-  class Composition
-    class Evaluator
-      attr_reader :callables
-
-      def initialize
-        @callables = []
-      end
-
-      def initialize_copy(_)
-        @callables = @callables.map(&:dup)
-      end
-
-      def [](proc)
-        evaluator = dup
-        evaluator << Deferable.new(proc)
-        evaluator
-      end
-
-      def <<(proc)
-        @callables << proc
-      end
-
-      def >>(other)
-        evaluator = dup
-
-        case other
-        when Evaluator
-          other.callables.each do |each_callable|
-            evaluator << each_callable
-          end
-        when Callable
-          evaluator << Deferable.new(other.proc)
-        end
-
-        evaluator
-      end
-
-      def call(**arguments)
-        evaluator = dup
-        evaluator.callables.last.arguments = arguments
-        evaluator
-      end
-
-      def serialize
-        @callables.map(&:serialize)
-      end
-    end
-  end
-end