proc 0.0.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a33f3939a8156059653e7edde57a9ac0b0ee46ab04bcb1f08ce098073e884358
-  data.tar.gz: df8c021333f0f03b6acdaa195b2c39035a4054b026fd1f6c09d08df674aef7f9
+  metadata.gz: c3a73eafa61306bca405c0eaec0f8df0d145b22d27a98ee8dcf28db94cdadfa3
+  data.tar.gz: b1e95096528fe529ec664a370095269ae26672994178ed62e3c78159c46ed173
 SHA512:
-  metadata.gz: 52107c5f8c68d623aead4dab7131fe7ea42c5abc29bf748cb81f2aea80bc0ae2b68447764c02a1d40aca4a21e24521f2bc291e9ae7794bd69d98cb867c7f0959
-  data.tar.gz: 8bcab50d65564adb5ce355b75dd407f82ccf93dee798c1219def178293978251b6bfff6c588a823eecd52732a6784a971226026f796601941f1866d3d0c00035
+  metadata.gz: 9708b1585d8c95deb6016cc5dbed10d5c7bffdfa55421d0392d3c51ec2af5ce334eb5b41283c585795874c7cdf5b035e6eb41ca145ee56d7409147546b61a6bf
+  data.tar.gz: ec138355afed48dde883579c73d304196b3cb2b6b8ac7d5a0986b43c5bffb6591fd33c019b516807c46b2c1ef3c6d75df7fc10d5bae10ecfbc38428ea89977c9

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.call(@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,13 @@ class Proc
   class Unauthorized < Error
   end
 
+  class Forbidden < Error
+  end
+
   class Unavailable < Error
   end
 
-  class RateLimited < Error
+  class Limited < Error
   end
 
   class Timeout < Error
@@ -60,10 +64,6 @@ class Proc
       @resets_at
     end
 
-    def compose(&block)
-      Composition.new(client: self, &block)
-    end
-
     DEFAULT_HEADERS = {
       "accept" => "application/json",
       "content-type" => "application/json"
@@ -71,14 +71,14 @@ class Proc
 
     def call(proc = nil, input = nil, **arguments)
       Async(logger: NullLogger) { |task|
-        body = { "<<" => input }
+        body = {"<>" => true}
+
+        unless Proc.undefined?(input)
+          body["<<"] = serialize_value(input)
+        end
 
         arguments.each_pair do |key, value|
-          body[key.to_s] = if value.respond_to?(:serialize)
-            value.serialize
-          else
-            value
-          end
+          body[key.to_s] = serialize_value(value)
         end
 
         headers = {
@@ -86,14 +86,14 @@ class Proc
         }.merge(DEFAULT_HEADERS)
 
         begin
-          response = super(: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
@@ -102,27 +102,56 @@ class Proc
         when 200
           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.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,23 +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 = nil, **arguments)
-      # TODO: This will probably call `proc.run`.
-      #
-      @client.call("compose", input, proc: build_evaluator(**arguments))
+    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)
@@ -28,31 +42,59 @@ class Proc
     end
 
     def <<(callable)
-      @callables << callable
+      case callable
+      when Composition
+        merge(callable)
+      when Callable
+        @callables << callable
+      end
     end
 
-    def with(**arguments)
-      build_evaluator(**arguments)
+    def serialize
+      wrapped = {"[]" => serialized_calls}
+
+      unless Proc.undefined?(@input)
+        wrapped["<<"] = serialized_input
+      end
+
+      {"{}" => wrapped.merge(serialized_arguments)}
     end
 
-    def serialize
-      build_evaluator.serialize
-    rescue ::ArgumentError => error
-      raise ::ArgumentError, error.message + " (try using `with' to build a composition with arguments)"
+    def serialized_calls
+      @callables.map { |callable|
+        arguments = callable.serialized_arguments
+
+        unless Proc.undefined?(callable.input)
+          arguments["<<"] = callable.serialized_input
+        end
+
+        [callable.proc, arguments]
+      }
     end
 
-    private def build_evaluator(**arguments)
-      evaluator = if @block
-        @block.call(Evaluator.new, **arguments)
-      else
-        Evaluator.new
-      end
+    def serialized_input
+      serialize_value(@input)
+    end
 
-      @callables.each do |callable|
-        evaluator << Deferable.new(callable.proc)
-      end
+    def serialized_arguments
+      @arguments.each_pair.each_with_object({}) { |(key, value), hash|
+        hash[key.to_s] = serialize_value(value)
+      }
+    end
 
-      evaluator
+    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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proc
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-24 00:00:00.000000000 Z
+date: 2020-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http
@@ -47,11 +47,10 @@ files:
 - LICENSE
 - 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
@@ -76,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: Proc client library.

data/lib/proc/composition/deferable.rb

@@ -1,29 +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, 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
-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