proc 0.0.2 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59becc885513c542ccee8100b436c2854d5c42939b72424a691a281741861728
-  data.tar.gz: 82cfac2a503a9e934efeae9b41d037b6dd72d1e78e493a6ec921d04a39fec97e
+  metadata.gz: 2950f8e2178a95a40c29372c902203d883bda75ac84785a3579134b9394d7a52
+  data.tar.gz: 6c8433c3f49bbc0a6a62187c9b992fd7c39e6eac2894f7d71a2056205bdc7900
 SHA512:
-  metadata.gz: 71cbb386c7e906584a706538f3cccba04a7090496486b80160b2856b2d4dbe480d35b02f83814643fb208173518053f283b9d4e2c365f8164781e569b23f98ea
-  data.tar.gz: '095adc172bb26b52871a0fb9d8265fb782cab0ae43981c03f1bedfe47200cdf1551e78cf1564e29ade46a535f0c717350e306513583b4ced7e09eac815a10c73'
+  metadata.gz: 36828988724d7e3cad08a3a741f576bfa50f8d53a459062892bb270e01da1d8a1ddf4977255976a314a15b4e79e8266da4089c9cdbb8f723c30d681099654c7f
+  data.tar.gz: e224df7dcabcf284d5cf72f410be3ccf713dfbb0ff386ae5a50597e5c9a6b07634c87759f30d5e4b4a95fc0091d0c2f0aa490146a02b8806a3784033025fd123

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/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,104 @@
 
 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)
+      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, input: @input)
       composed << self
-      composed << callable
+      composed << other
       composed
     end
+
+    def serialize
+      {
+        "{}" => {
+          "<<" => serialized_input,
+          "[]" => [[@proc, serialized_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 [](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,9 +23,18 @@ class Proc
   class Unauthorized < Error
   end
 
+  class Forbidden < Error
+  end
+
   class Unavailable < Error
   end
 
+  class Limited < Error
+  end
+
+  class Timeout < Error
+  end
+
   class Client < Http::Client
     def initialize(authorization, scheme: "https", host: "proc.dev")
       @authorization = authorization
@@ -38,29 +48,49 @@ 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)
+    def call(proc = nil, input = nil, **arguments)
       Async(logger: NullLogger) { |task|
-        body = {
-          input: input, arguments: arguments
-        }
+        body = { "<<" => serialize_value(input) }
+
+        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)
 
-          payload = Oj.load(response.read, mode: :strict)
+          @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
+          # TODO: This should wrap `error`.
+          #
           raise Proc::Unavailable, error.message
         ensure
           response&.close
@@ -68,23 +98,54 @@ class Proc
 
         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::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 = nil, **arguments)
+      Callable.new(name, client: self, input: input, arguments: arguments)
+    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,31 +2,49 @@
 
 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 >>(callable)
+    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)
       composed = dup
-      composed << callable
+
+      case other
+      when Composition
+        composed.merge(other)
+      when Callable
+        composed << other
+      end
+
       composed
     end
 
@@ -34,8 +52,44 @@ class Proc
       @callables << callable
     end
 
-    protected def serialize
-      @callables.map(&:proc)
+    def serialize
+      {
+        "{}" => {
+          "<<" => serialized_input,
+          "[]" => serialized_calls
+        }.merge(serialized_arguments)
+      }
+    end
+
+    def serialized_calls
+      @callables.map { |callable|
+        [callable.proc, callable.serialized_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
+
+    private def serialize_value(value)
+      if value.respond_to?(:serialize)
+        value.serialize
+      else
+        value
+      end
     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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proc
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.2
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-21 00:00:00.000000000 Z
+date: 2020-10-31 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 >>(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