proc 0.1.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63fefe7d8d6f97ef667ca24f07ef5f38b402c6982d783582d6ea869dbfc67c76
-  data.tar.gz: ceaeee3d8d634ba9d9ba6771266554e8dc7b8662b819751520658b0e657dbfa8
+  metadata.gz: a3b65698431242010b57cb9897c5ddf826cbd9c81dea9a3947505062e8060aeb
+  data.tar.gz: bf1d1caaa7fffda8b8eac8d65c50b29a4c95003d980b8c83962f65bed8e1749e
 SHA512:
-  metadata.gz: 1c44c09c6526286bbcc8e67fefd1c2d13cb5dec65b4471452eb07c9845f36e8c2aa92dcd7c5080ff7070a2a1228b6f3667c7d9616f35e37ba7d14ec9f882ac22
-  data.tar.gz: a38fe68ec69ed2b086741d46728245d3351fe58ed26c956fcb9ec67257e9089b9e2e383a8551530bed293188f6e14ca9799ebaf57859163bf1b9fbd0bfb26f82
+  metadata.gz: ba18a8388e58dfe25119b412274b13eaf7cf684fc33e2ca186c8527c85a6f8973ecf01d39c9f56b861456646262b0a0fbaf9272feaec44ce178f328e1c6349ca
+  data.tar.gz: 77ecd00cf5f48da5e17e80da46b2f0145ec1c8ae87d710d0b423d3e1908f7fdbc13fe251b9efee67289b5f20e1711b81a2c186fc0a48a9042aaff02413a8cdc8

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.to_s, 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

@@ -4,8 +4,8 @@ class Proc
   class Callable
     attr_reader :proc, :input, :arguments
 
-    def initialize(proc, client:, input: nil, arguments: {})
-      @proc = proc
+    def initialize(proc, client:, input: Proc.undefined, arguments: {})
+      @proc = proc.to_s
       @client = client
       @input = input
       @arguments = arguments
@@ -17,11 +17,23 @@ class Proc
     end
 
     def call(input = input_omitted = true, **arguments)
-      @client.call(@proc, input_omitted ? @input : input, **@arguments.merge(arguments))
+      callable = self.class.new(
+        @proc,
+        client: @client,
+        input: input_omitted ? @input : input,
+        arguments: @arguments.merge(arguments)
+      )
+
+      @client.call(@proc, callable.input, **callable.arguments)
     end
 
     def with(input = input_omitted = true, **arguments)
-      self.class.new(@proc, client: @client, input: input_omitted ? @input : input, arguments: @arguments.merge(arguments))
+      self.class.new(
+        @proc,
+        client: @client,
+        input: input_omitted ? @input : input,
+        arguments: @arguments.merge(arguments)
+      )
     end
 
     def >>(other)
@@ -32,20 +44,36 @@ class Proc
     end
 
     def serialize
-      {
-        "{}" => {
-          "<<" => serialize_value(@input),
-          "[]" => [[@proc, serialized_arguments]]
-        }
-      }
+      serialized = ["()", @proc]
+
+      unless Proc.undefined?(@input)
+        serialized << [">>", serialized_input]
+      end
+
+      serialized.concat(serialized_arguments)
+
+      ["{}", serialized]
+    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)
+      @arguments.map { |key, value|
+        ["$$", 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)
@@ -73,7 +101,7 @@ class Proc
       if value.respond_to?(:serialize)
         value.serialize
       else
-        value
+        ["%%", value]
       end
     end
   end

data/lib/proc/client.rb

@@ -3,17 +3,19 @@
 require "async"
 require "oj"
 
+require_relative "argument"
 require_relative "callable"
 require_relative "composition"
-require_relative "null_logger"
 
 require_relative "http/client"
 
+Console.logger.off!
+
 class Proc
   class Error < StandardError
   end
 
-  class ArgumentError < ::ArgumentError
+  class Invalid < ::ArgumentError
   end
 
   class Undefined < ::NameError
@@ -22,22 +24,24 @@ 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
+  class Client
     def initialize(authorization, scheme: "https", host: "proc.dev")
       @authorization = authorization
       @scheme = scheme
       @host = host
-
-      super()
+      @internal = Http::Client.new
     end
 
     def [](proc)
@@ -60,66 +64,75 @@ class Proc
       @resets_at
     end
 
-
     DEFAULT_HEADERS = {
-      "accept" => "application/json",
-      "content-type" => "application/json"
+      "accept" => "application/vnd.proc+json",
+      "content-type" => "application/vnd.proc+json"
     }.freeze
 
-    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)
+    def call(proc = nil, input = Proc.undefined, **arguments)
+      body = []
 
-          @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)
+      unless Proc.undefined?(input)
+        body << [">>", serialize_value(input)]
+      end
 
-          payload = Oj.load(response.read, mode: :compat)
-        rescue => error
-          raise Proc::Unavailable, error.message
-        ensure
-          response&.close
-        end
+      arguments.each_pair do |key, value|
+        body << ["$$", key.to_s, serialize_value(value)]
+      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
+      headers = {
+        "authorization" => "bearer #{@authorization}"
+      }.merge(DEFAULT_HEADERS)
+
+      status, payload = get_payload(proc: proc, headers: headers, body: body)
+
+      case status
+      when 200
+        extract_output(payload)
+      when 400
+        raise Proc::Invalid, extract_error_message(payload)
+      when 401
+        raise Proc::Unauthorized, extract_error_message(payload)
+      when 403
+        raise Proc::Forbidden, extract_error_message(payload)
+      when 404
+        raise Proc::Undefined, extract_error_message(payload)
+      when 408
+        raise Proc::Timeout, extract_error_message(payload)
+      when 413
+        raise Proc::Invalid, extract_error_message(payload)
+      when 429
+        raise Proc::Limited, extract_error_message(payload)
+      when 500
+        raise Proc::Error, extract_error_message(payload)
+      when 508
+        raise Proc::Error, extract_error_message(payload)
+      else
+        raise Proc::Error, "unhandled"
+      end
     end
 
-    def method_missing(name, input = nil, **arguments)
-      Callable.new(name, client: self, input: input, arguments: arguments)
+    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
+
+    def close
+      @internal.close
+    end
+
     private def build_uri(proc)
       host_and_path = File.join(@host, proc.to_s.split(".").join("/"))
 
@@ -130,8 +143,44 @@ class Proc
       if value.respond_to?(:serialize)
         value.serialize
       else
-        value
+        ["%%", value]
+      end
+    end
+
+    private def get_payload(proc:, headers:, body:)
+      @internal.call(:post, build_uri(proc), headers: headers, body: Oj.dump(body, mode: :custom)) do |response|
+        @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)
+        [response.status, Oj.load(response.read, mode: :compat, compat_bigdecimal: true)]
+      end
+    rescue
+      raise Proc::Unavailable
+    end
+
+    private def extract_output(payload)
+      payload.each do |tuple|
+        case tuple[0]
+        when "<<"
+          return tuple[1]
+        end
       end
+
+      nil
+    end
+
+    private def extract_error(payload)
+      payload.each do |tuple|
+        case tuple[0]
+        when "!!"
+          return tuple[1]
+        end
+      end
+
+      nil
+    end
+
+    private def extract_error_message(payload)
+      extract_error(payload)&.dig("message")
     end
   end
 end

data/lib/proc/composition.rb

@@ -2,10 +2,13 @@
 
 class Proc
   class Composition
-    def initialize(client:, input:, callables: [])
+    attr_reader :input, :callables, :arguments
+
+    def initialize(client:, input:, callables: [], arguments: {})
       @client = client
       @input = input
       @callables = callables
+      @arguments = arguments
     end
 
     def initialize_copy(_)
@@ -13,11 +16,23 @@ class Proc
     end
 
     def call(input = input_omitted = true, **arguments)
-      @client.call("exec", input_omitted ? @input : input, proc: serialized_calls)
+      callable = self.class.new(
+        client: @client,
+        input: input_omitted ? @input : input,
+        callables: @callables.dup,
+        arguments: @arguments.merge(arguments)
+      )
+
+      @client.call("proc.exec", Proc.undefined, proc: callable)
     end
 
-    def with(input = input_omitted = true)
-      self.class.new(client: @client, input: input_omitted ? @input : input, callables: @callables.dup)
+    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)
@@ -27,22 +42,67 @@ class Proc
     end
 
     def <<(callable)
-      @callables << callable
+      case callable
+      when Composition
+        merge(callable)
+      when Callable
+        @callables << callable
+      end
     end
 
     def serialize
-      {
-        "{}" => {
-          "<<" => @input,
-          "[]" => serialized_calls
-        }
-      }
+      # wrapped = {"[]" => serialized_calls}
+
+      # unless Proc.undefined?(@input)
+      #   wrapped["<<"] = serialized_input
+      # end
+
+      # {"{}" => wrapped.merge(serialized_arguments)}
+
+      serialized = ["{}"]
+
+      unless Proc.undefined?(@input)
+        serialized << [">>", serialized_input]
+      end
+
+      serialized + serialized_arguments + serialized_calls
     end
 
     def serialized_calls
       @callables.map { |callable|
-        [callable.proc, callable.serialized_arguments]
+        serialized = ["()", callable.proc]
+
+        unless Proc.undefined?(callable.input)
+          serialized << [">>", callable.serialized_input]
+        end
+
+        serialized.concat(callable.serialized_arguments)
       }
     end
+
+    def serialized_input
+      serialize_value(@input)
+    end
+
+    def serialized_arguments
+      @arguments.map { |key, value|
+        ["$$", 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/client.rb

@@ -5,50 +5,45 @@ require "async/http/internet"
 
 require "protocol/http/body/streamable"
 
+require "core/async"
+
 require_relative "request"
 require_relative "response"
 
-require_relative "../null_logger"
-
 class Proc
   module Http
     class Client
+      include Is::Async
+
       def initialize
         @internet = Async::HTTP::Internet.new
-        @responses = {}
       end
 
-      def call(method, uri, params: {}, headers: {}, body: nil, task: nil)
+      def call(method, uri, params: {}, headers: {}, body: nil)
         request = Request.new(method: method, uri: uri, params: params, headers: headers, body: body)
 
-        if task
-          make_request(request)
-        else
-          Async(logger: NullLogger) {
-            make_request(request)
-          }.wait
-        end
+        await {
+          begin
+            response = make_request(request)
+
+            yield response
+          ensure
+            response&.close
+          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
       end
 
-      def count
-        @responses.count
-      end
-
       private def make_request(request)
         async_response = @internet.call(*request.callable)
         wrap_async_response_for_request(async_response, request)
       end
 
       private def wrap_async_response_for_request(async_response, request)
-        @responses[async_response] = Response.new(request, async_response)
+        Response.new(request, async_response)
       end
     end
   end

data/lib/proc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proc
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-26 00:00:00.000000000 Z
+date: 2021-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.52.5
+- !ruby/object:Gem::Dependency
+  name: core-async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -47,13 +61,13 @@ 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/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:
@@ -74,7 +88,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/null_logger.rb

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