proc 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b1cac83c7cff9f09dc94086b6b58e43cf686c4faa28e95aecda09c73e9eebbc
-  data.tar.gz: e349377c73af33cdff5dfb488dbfd199ec37b9c1db84132e82dde7d65889b71b
+  metadata.gz: 63fefe7d8d6f97ef667ca24f07ef5f38b402c6982d783582d6ea869dbfc67c76
+  data.tar.gz: ceaeee3d8d634ba9d9ba6771266554e8dc7b8662b819751520658b0e657dbfa8
 SHA512:
-  metadata.gz: e9b7322deb5945ddac4cff0c12c444d8c90d88b917619176bc2983370e215f54ebafdf83e82a4778424fc94a9ed67149596ebb7fd7378d0bea8d0fcdac611a67
-  data.tar.gz: 91286717d2ee7d67a8021f3aedf2debec4c2da88e2f9abbe34dadd751f02c64f227a40dbdb8e3f6b95ed0ca5ead33557b096683594b3b5e32f10aab5eaf23367
+  metadata.gz: 1c44c09c6526286bbcc8e67fefd1c2d13cb5dec65b4471452eb07c9845f36e8c2aa92dcd7c5080ff7070a2a1228b6f3667c7d9616f35e37ba7d14ec9f882ac22
+  data.tar.gz: a38fe68ec69ed2b086741d46728245d3351fe58ed26c956fcb9ec67257e9089b9e2e383a8551530bed293188f6e14ca9799ebaf57859163bf1b9fbd0bfb26f82

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# TODO: Introduce inspectable everywhere (just bundle from pakyow).
-
 require_relative "proc/client"
 
 class Proc

data/lib/proc/callable.rb

@@ -2,22 +2,79 @@
 
 class Proc
   class Callable
-    attr_reader :proc
+    attr_reader :proc, :input, :arguments
 
-    def initialize(proc, client:)
+    def initialize(proc, client:, input: nil, arguments: {})
       @proc = proc
       @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 >>(callable)
-      composed = Composition.new(client: @client)
+    def call(input = input_omitted = true, **arguments)
+      @client.call(@proc, input_omitted ? @input : input, **@arguments.merge(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, input: @input)
       composed << self
-      composed << callable
+      composed << other
       composed
     end
+
+    def serialize
+      {
+        "{}" => {
+          "<<" => serialize_value(@input),
+          "[]" => [[@proc, serialized_arguments]]
+        }
+      }
+    end
+
+    def serialized_arguments
+      @arguments.each_pair.each_with_object({}) { |(key, value), hash|
+        hash[key.to_s] = serialize_value(value)
+      }
+    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

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require "async"
 require "oj"
 
 require_relative "callable"
 require_relative "composition"
+require_relative "null_logger"
 
 require_relative "http/client"
 
@@ -23,6 +25,12 @@ class Proc
   class Unavailable < Error
   end
 
+  class RateLimited < Error
+  end
+
+  class Timeout < Error
+  end
+
   class Client < Http::Client
     def initialize(authorization, scheme: "https", host: "proc.dev")
       @authorization = authorization
@@ -36,51 +44,94 @@ class Proc
       Callable.new(proc, client: self)
     end
 
-    def compose(&block)
-      Composition.new(client: self, &block)
+    def remaining
+      unless defined?(@remaining)
+        self["ping"].call
+      end
+
+      @remaining
     end
 
+    def resets_at
+      unless defined?(@resets_at)
+        self["ping"].call
+      end
+
+      @resets_at
+    end
+
+
     DEFAULT_HEADERS = {
+      "accept" => "application/json",
       "content-type" => "application/json"
     }.freeze
 
-    def perform(proc, input, **arguments)
-      body = {
-        input: input, arguments: arguments
-      }
-
-      headers = {
-        "authorization" => "Bearer #{@authorization}"
-      }.merge(DEFAULT_HEADERS)
-
-      begin
-        response = call(:post, build_uri(proc), headers: headers, body: Oj.dump(body, mode: :json))
-      rescue => error
-        raise Proc::Unavailable, error.message
-      end
+    def call(proc = nil, input = nil, **arguments)
+      Async(logger: NullLogger) { |task|
+        body = { "<<" => serialize_value(input) }
+
+        arguments.each_pair do |key, value|
+          body[key.to_s] = serialize_value(value)
+        end
+
+        headers = {
+          "authorization" => "bearer #{@authorization}"
+        }.merge(DEFAULT_HEADERS)
+
+        begin
+          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: :compat)
+        rescue => error
+          raise Proc::Unavailable, error.message
+        ensure
+          response&.close
+        end
+
+        case response.status
+        when 200
+          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
 
-      payload = if response.body
-        Oj.load(response.body.read, mode: :strict)
-      end
+    def method_missing(name, input = nil, **arguments)
+      Callable.new(name, client: self, input: input, arguments: arguments)
+    end
 
-      case response.status
-      when 200
-        payload["value"]
-      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 500
-        raise Proc::Error, payload.dig("error", "message")
-      end
+    def respond_to_missing?(name, *)
+      true
     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
+
+    private def serialize_value(value)
+      if value.respond_to?(:serialize)
+        value.serialize
+      else
+        value
+      end
+    end
   end
 end

data/lib/proc/composition.rb

@@ -2,31 +2,27 @@
 
 class Proc
   class Composition
-    require_relative "composition/deferable"
-    require_relative "composition/evaluator"
-
-    def initialize(client:, &block)
+    def initialize(client:, input:, callables: [])
       @client = client
-      @block = block
-      @callables = []
+      @input = input
+      @callables = callables
     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)
+      @client.call("exec", input_omitted ? @input : input, proc: serialized_calls)
+    end
+
+    def with(input = input_omitted = true)
+      self.class.new(client: @client, input: input_omitted ? @input : input, callables: @callables.dup)
     end
 
-    def >>(callable)
+    def >>(other)
       composed = dup
-      composed << callable
+      composed << other
       composed
     end
 
@@ -34,8 +30,19 @@ class Proc
       @callables << callable
     end
 
-    protected def serialize
-      @callables.map(&:proc)
+    def serialize
+      {
+        "{}" => {
+          "<<" => @input,
+          "[]" => serialized_calls
+        }
+      }
+    end
+
+    def serialized_calls
+      @callables.map { |callable|
+        [callable.proc, callable.serialized_arguments]
+      }
     end
   end
 end

data/lib/proc/http/client.rb

@@ -8,35 +8,31 @@ require "protocol/http/body/streamable"
 require_relative "request"
 require_relative "response"
 
+require_relative "../null_logger"
+
 class Proc
   module Http
     class Client
-      class NullLogger
-        class << self
-          def method_missing(*, **)
-          end
-
-          def respond_to_missing?(*)
-            true
-          end
-        end
-      end
-
       def initialize
         @internet = Async::HTTP::Internet.new
         @responses = {}
       end
 
-      def call(method, uri, params: {}, headers: {}, body: nil)
+      def call(method, uri, params: {}, headers: {}, body: nil, task: nil)
         request = Request.new(method: method, uri: uri, params: params, headers: headers, body: body)
 
-        Async(logger: NullLogger) {
-          async_request = @internet.call(*request.callable)
-          wrap_async_response_for_request(async_request, request)
-        }.wait
+        if task
+          make_request(request)
+        else
+          Async(logger: NullLogger) {
+            make_request(request)
+          }.wait
+        end
       end
 
       def close
+        # TODO: Make sure this works. We should also close / clear after accumulating some amount.
+        #
         @responses.each_value(&:close)
         @responses.clear
         @internet.close
@@ -46,20 +42,13 @@ class Proc
         @responses.count
       end
 
-      private def wrap_async_response_for_request(async_response, request)
-        Protocol::HTTP::Body::Streamable.wrap(async_response) do
-          @responses.delete(async_response)
-        end
-
-        response = Response.new(
-          request: request,
-          status: async_response.status,
-          version: async_response.version,
-          headers: async_response.headers,
-          body: async_response.body
-        )
+      private def make_request(request)
+        async_response = @internet.call(*request.callable)
+        wrap_async_response_for_request(async_response, request)
+      end
 
-        @responses[async_response] = response
+      private def wrap_async_response_for_request(async_response, request)
+        @responses[async_response] = Response.new(request, async_response)
       end
     end
   end

data/lib/proc/http/request.rb

@@ -14,7 +14,7 @@ class Proc
       end
 
       def callable
-        return @method.to_s.upcase, finalize_uri(@uri, @params), @headers, @body
+        [@method.to_s.upcase, finalize_uri(@uri, @params), @headers, @body]
       end
 
       private def finalize_uri(uri, params)

data/lib/proc/http/response.rb

@@ -1,37 +1,18 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 class Proc
   module Http
     class Response
-      attr_reader :request, :status, :version, :headers, :body
-
-      def initialize(request:, status:, version:, headers:, body:)
-        @request = request
-        @status = status
-        @version = version
-        @headers = headers
-        @body = body
-
-        @stream = nil
-        @stream_blocks = []
-      end
-
-      def stream(&block)
-        @stream_blocks << block
+      extend Forwardable
+      def_delegators :@response, :status, :version, :headers, :read, :close
 
-        @stream ||= Async {
-          @body.each do |chunk|
-            @stream_blocks.each do |stream_callback|
-              stream_callback.call(chunk)
-            end
-          end
-        }
-      end
+      attr_reader :request
 
-      def close
-        @stream&.stop
-        @stream_blocks.clear
-        @body.close
+      def initialize(request, response)
+        @request = request
+        @response = response
       end
     end
   end

data/lib/proc/null_logger.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Proc
+  class NullLogger
+    class << self
+      def method_missing(*, **)
+      end
+
+      def respond_to_missing?(*)
+        true
+      end
+    end
+  end
+end

data/lib/proc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proc
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-20 00:00:00.000000000 Z
+date: 2020-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http
@@ -45,16 +45,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
-- lib/examples/scratch.rb
+- README.md
 - lib/proc.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
+- lib/proc/null_logger.rb
 - lib/proc/version.rb
 homepage: https://proc.dev/
 licenses:

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 >>(callable)
-        evaluator = dup
-
-        case callable
-        when Evaluator
-          callable.callables.each do |each_callable|
-            evaluator << each_callable
-          end
-        when Callable
-          evaluator << Deferable.new(callable.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