proc 0.11.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 165ffe3b7cd5976e7091d46261724665b2ba65b8b40144d5b5a12bcfde0dcf21
-  data.tar.gz: c79d592b4e21d9109268cc50929ae1f8f0e4daff8297fc3755da99bff05d47b5
+  metadata.gz: a554218f2f2a9cfe6bfa2e6f87ebf17abba0090e840d640ac5646c81b1d84c7c
+  data.tar.gz: cfdd2fab893016a3fb2a1a76995ee611c28cca6ea051024fae03157c22d440d9
 SHA512:
-  metadata.gz: 02ce5abfc9089157d26a2430a3d6af2b74510d726698a5326a00c6f5cfa433f5a03d44e143cd8efb08d8b5ff6145cfde6a96746b4160cc584779c0be6f42005e
-  data.tar.gz: 3e37e7b6d53001aec939303c7c7371f9fe63e78c874b5e00d14b652fcd0ca9aa2531d2e75e7083ee9cb1df56d9ebf53816c266c2fe17078cf7d76382b00bc7b3
+  metadata.gz: 8c82e014b6a876cbe35e9fdfdd2ea10e296e6497b207623728ca6dae8a887fb7ac82e7f199da08febec7571e677b65c743dbc335731c72f2716447f4f367b4db
+  data.tar.gz: 99c5bad156fbcb7d18084ee0523366f6334b5a9d5f2d89410fcad000a533a21be71806c53dea0f6b8f8d2f1ec36b488e86c65b36d5d4e067ca27e022f3f25bb1

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+## [v0.13.0](https://github.com/metabahn/proc/releases/tag/2021-09-15)
+
+*released on 2021-09-15*
+
+  * `chg` [#10](https://github.com/metabahn/proc/pull/10) Extract proc-composer from the proc client library for ruby ([bryanp](https://github.com/bryanp))
+  * `chg` [#7](https://github.com/metabahn/proc/pull/7) Update Ruby client to call api.proc.dev ([bryanp](https://github.com/bryanp))
+  * `add` [#3](https://github.com/metabahn/proc/pull/3) Introduce global authorization/instance to the Ruby client ([bryanp](https://github.com/bryanp))
+
+## [v0.12.1](https://github.com/metabahn/proc/releases/tag/2021-05-13)
+
+*released on 2021-05-13*
+
+  * `chg` [#2](https://github.com/metabahn/proc/pull/2) Update http.rb dependency ([bryanp](https://github.com/bryanp))
+
+

data/README.md

@@ -1,9 +1,11 @@
-**This is the official Ruby client for Proc: Serverless web functions with superpowers.**
+**Superpowers to help you ship web endpoints faster.**
+
+Proc is an all-in-one toolchain for building, deploying, and calling custom behavior from any website or app.
 
 * [Learn more about Proc](https://proc.dev)
-* [Browse available packages](https://proc.dev/packages)
+* [Browse packages](https://proc.dev/packages)
 * [Read the docs](https://proc.dev/docs)
-* [Join chat](https://discord.gg/aRu8qvkCmy)
+* [Chat with us](https://discord.gg/aRu8qvkCmy)
 
 ## Install
 
@@ -31,7 +33,7 @@ client.type.number.add.call(1, {value: 1});
 => 2
 ```
 
-Build more complex behaviors by composing procs together:
+Build more complex behavior by composing procs together:
 
 ```ruby
 time = client.time
@@ -43,7 +45,7 @@ composition.call
 => "Tuesday"
 ````
 
-Deploy custom endpoints instantly and call them from anywhere:
+Instantly deploy your behavior to a private endpoint and call it from anywhere:
 
 ```ruby
 client.proc.create.call(name: "day_of_week", proc: composition)

data/lib/proc/callable.rb

@@ -1,19 +1,11 @@
 # frozen_string_literal: true
 
 class Proc
-  class Callable
-    attr_reader :proc, :input, :arguments
-
-    def initialize(proc, client:, input: Proc.undefined, arguments: {})
-      @proc = proc.to_s
+  class Callable < Composer::Callable
+    def initialize(proc, client:, **kwargs)
       @client = client
-      @input = input
-      @arguments = arguments
-    end
 
-    def initialize_copy(_)
-      @input = input.dup
-      @arguments = arguments.dup
+      super(proc, **kwargs)
     end
 
     # [public] Dispatches this callable context to proc using the client.
@@ -21,16 +13,11 @@ class Proc
     # If a block is passed, it will be called to prior to dispatch and its result passed as a nested context.
     #
     def call(input = input_omitted = true, **arguments)
-      if block_given?
+      if ::Kernel.block_given?
         arguments[:proc] = yield
       end
 
-      callable = self.class.new(
-        @proc,
-        client: @client,
-        input: input_omitted ? @input : input,
-        arguments: @arguments.merge(arguments)
-      )
+      callable = build_callable(input: input_omitted ? @input : input, arguments: @arguments.merge(arguments))
 
       @client.call(@proc, callable.input, **callable.arguments)
     end
@@ -38,131 +25,17 @@ class Proc
     # [public] Dispatches this callable context to proc using the client, calling the given block once for each value.
     #
     def each(input = input_omitted = true, **arguments, &block)
-      callable = self.class.new(
-        @proc,
-        client: @client,
-        input: input_omitted ? @input : input,
-        arguments: @arguments.merge(arguments)
-      )
+      callable = build_callable(input: input_omitted ? @input : input, arguments: @arguments.merge(arguments))
 
       @client.call(@proc, callable.input, **callable.arguments, &block)
     end
 
-    # [public] Creates a new callable context based on this one, with a new input and/or arguments.
-    #
-    def with(input = input_omitted = true, **arguments)
-      if block_given?
-        arguments[:proc] = yield
-      end
-
-      self.class.new(
-        @proc,
-        client: @client,
-        input: input_omitted ? @input : input,
-        arguments: @arguments.merge(arguments)
-      )
-    end
-
-    # [public] Returns a composition built from this callable context and one or more other callables.
-    #
-    def compose(*others)
-      composed = Composition.new(client: @client, input: @input)
-      composed << self
-      others.each { |other| composed << other }
-      composed
-    end
-
-    # [public] Returns a composition built from this callable context and another callable.
-    #
-    def >>(other)
-      composed = Composition.new(client: @client, input: @input)
-      composed << self
-      composed << other
-      composed
-    end
-
-    def serialize(unwrapped: false)
-      serialized = ["()", @proc]
-
-      unless Proc.undefined?(@input)
-        serialized << [">>", serialized_input]
-      end
-
-      serialized.concat(serialized_arguments)
-
-      if unwrapped
-        serialized
-      else
-        ["{}", serialized]
-      end
-    end
-
-    def serialized_input
-      serialize_value(@input)
-    end
-
-    def serialized_arguments
-      @arguments.map { |key, value|
-        ["$$", key.to_s, serialize_value(value)]
-      }
-    end
-
-    # [public] Returns a callable context for `proc`, nested within this callable context.
-    #
-    def [](proc)
-      arguments = if block_given?
-        duped = @arguments.dup
-        duped[:proc] = yield
-        duped
-      else
-        @arguments
-      end
-
-      Callable.new(
-        [@proc, proc].join("."),
-        client: @client,
-        input: @input,
-        arguments: arguments
-      )
+    private def build_callable(input:, arguments:, proc: @proc)
+      ::Proc::Callable.new(proc, client: @client, input: input, arguments: arguments)
     end
 
-    IGNORE_MISSING = %i[to_hash].freeze
-
-    # [public] Allows nested callable contexts to be built through method lookups.
-    #
-    def method_missing(name, input = input_omitted = true, **arguments)
-      if IGNORE_MISSING.include?(name)
-        super
-      else
-        if block_given?
-          arguments[:proc] = yield
-        end
-
-        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.is_a?(Symbol)
-        ["@@", value.to_s, {}]
-      elsif value.respond_to?(:serialize)
-        value.serialize
-      else
-        ["%%", value]
-      end
+    private def build_composition(input:)
+      ::Proc::Composition.new(client: @client, input: input)
     end
   end
 end

data/lib/proc/client.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
 require "core/async"
+require "core/global"
+
 require "http"
 require "msgpack"
 
+require "proc/composer"
+
 require_relative "msgpack/types/decimal"
 MessagePack::DefaultFactory.register_type(0x00, Proc::Msgpack::Types::Decimal)
 MessagePack::DefaultFactory.register_type(-1, Time, packer: MessagePack::Time::Packer, unpacker: MessagePack::Time::Unpacker)
 
-require_relative "argument"
 require_relative "callable"
 require_relative "composition"
 require_relative "enumerator"
@@ -56,8 +59,23 @@ class Proc
 
   # [public] Connection to proc, configured with an authorization.
   #
-  class Client
-    include Is::Async
+  class Client < BasicObject
+    class << self
+      def authorization
+        ::ENV.fetch("PROC_AUTH") {
+          auth_file_path = ::Pathname.new("~/.proc/auth").expand_path
+
+          if auth_file_path.exist?
+            auth_file_path.read
+          else
+            ""
+          end
+        }.strip
+      end
+    end
+
+    include ::Is::Async
+    include ::Is::Global
 
     # [public] The configured authorization.
     #
@@ -82,7 +100,7 @@ class Proc
       "content-type" => "application/vnd.proc+msgpack"
     }.freeze
 
-    def initialize(authorization, scheme: "https", host: "proc.dev")
+    def initialize(authorization = ::Proc::Client.authorization, scheme: "https", host: "api.proc.dev")
       @authorization = authorization
       @scheme = scheme
       @host = host
@@ -97,10 +115,10 @@ class Proc
     # [public] Returns a callable context for `proc`.
     #
     def [](proc)
-      if block_given?
-        Callable.new(proc, client: self, arguments: {proc: yield})
+      if ::Kernel.block_given?
+        ::Proc::Callable.new(proc, client: self, arguments: {proc: yield})
       else
-        Callable.new(proc, client: self)
+        ::Proc::Callable.new(proc, client: self)
       end
     end
 
@@ -135,10 +153,10 @@ class Proc
     #
     # If a block is passed and the proc returns an enumerable, the block will be called with each value.
     #
-    def call(proc = nil, input = Proc.undefined, **arguments, &block)
+    def call(proc = nil, input = ::Proc::Composer.undefined, **arguments, &block)
       body = []
 
-      unless Proc.undefined?(input)
+      unless ::Proc::Composer.undefined?(input)
         body << [">>", serialize_value(input)]
       end
 
@@ -146,6 +164,10 @@ class Proc
         body << ["$$", key.to_s, serialize_value(value)]
       end
 
+      process(proc: proc, body: body, input: input, arguments: arguments, &block)
+    end
+
+    private def process(proc:, body:, input:, arguments:, &block)
       status, headers, payload = get_payload(proc: proc, body: body)
 
       case status
@@ -154,9 +176,9 @@ class Proc
 
         if (cursor = headers["x-cursor"])
           enumerator = if cursor.empty?
-            Enumerator.new(result)
+            ::Proc::Enumerator.new(result)
           else
-            Enumerator.new(result) {
+            ::Proc::Enumerator.new(result) {
               arguments[:cursor] = cursor.to_s
               call(proc, input, **arguments)
             }
@@ -171,25 +193,25 @@ class Proc
           result
         end
       when 400
-        raise Proc::Invalid, extract_error_message(payload)
+        ::Kernel.raise ::Proc::Invalid, extract_error_message(payload)
       when 401
-        raise Proc::Unauthorized, extract_error_message(payload)
+        ::Kernel.raise ::Proc::Unauthorized, extract_error_message(payload)
       when 403
-        raise Proc::Forbidden, extract_error_message(payload)
+        ::Kernel.raise ::Proc::Forbidden, extract_error_message(payload)
       when 404
-        raise Proc::Undefined, extract_error_message(payload)
+        ::Kernel.raise ::Proc::Undefined, extract_error_message(payload)
       when 408
-        raise Proc::Timeout, extract_error_message(payload)
+        ::Kernel.raise ::Proc::Timeout, extract_error_message(payload)
       when 413
-        raise Proc::Invalid, extract_error_message(payload)
+        ::Kernel.raise ::Proc::Invalid, extract_error_message(payload)
       when 429
-        raise Proc::Limited, extract_error_message(payload)
+        ::Kernel.raise ::Proc::Limited, extract_error_message(payload)
       when 500
-        raise Proc::Error, extract_error_message(payload)
+        ::Kernel.raise ::Proc::Error, extract_error_message(payload)
       when 508
-        raise Proc::Error, extract_error_message(payload)
+        ::Kernel.raise ::Proc::Error, extract_error_message(payload)
       else
-        raise Proc::Error, "unhandled"
+        ::Kernel.raise ::Proc::Error, "unhandled"
       end
     end
 
@@ -197,9 +219,9 @@ class Proc
     #
     def method_missing(name, input = input_omitted = true, *, **arguments)
       if input_omitted
-        Callable.new(name, client: self, arguments: arguments)
+        ::Proc::Callable.new(name, client: self, arguments: arguments)
       else
-        Callable.new(name, client: self, input: input, arguments: arguments)
+        ::Proc::Callable.new(name, client: self, input: input, arguments: arguments)
       end
     end
 
@@ -210,18 +232,19 @@ class Proc
     # [public] Builds a named argument with options.
     #
     def argument(name, **options)
-      Argument.new(name, **options)
+      ::Proc::Composer::Argument.new(name, **options)
     end
     alias_method :arg, :argument
 
     private def build_uri(proc)
-      File.join(@__base_url, proc.to_s.split(".").join("/"))
+      ::File.join(@__base_url, proc.to_s.split(".").join("/"))
     end
 
     private def serialize_value(value)
-      if value.is_a?(Symbol)
+      case value
+      when ::Symbol
         ["@@", value.to_s, {}]
-      elsif value.respond_to?(:serialize)
+      when ::Proc::Composer::Argument, ::Proc::Callable, ::Proc::Composition
         value.serialize
       else
         ["%%", value]
@@ -232,15 +255,15 @@ class Proc
       await {
         @request_count += 1
 
-        response = HTTP.headers(@__headers).post(build_uri(proc), body: MessagePack.pack(body))
+        response = ::HTTP.headers(@__headers).post(build_uri(proc), body: ::MessagePack.pack(body))
 
         update_rate_limit(response)
         @response = response
 
-        [response.status, response.headers, MessagePack.unpack(response.to_s)]
+        [response.status, response.headers, ::MessagePack.unpack(response.to_s)]
       }
     rescue
-      raise Proc::Unavailable
+      ::Kernel.raise ::Proc::Unavailable
     end
 
     private def update_rate_limit(response)
@@ -256,7 +279,7 @@ class Proc
       end
 
       @rate_limit_reset = if (reset = response.headers["x-rate-limit-reset"])
-        Time.at(reset.to_s.to_i)
+        ::Time.at(reset.to_s.to_i)
       end
     end
 

data/lib/proc/composition.rb

@@ -1,18 +1,11 @@
 # frozen_string_literal: true
 
 class Proc
-  class Composition
-    attr_reader :input, :callables, :arguments
-
-    def initialize(client:, input:, callables: [], arguments: {})
+  class Composition < Composer::Composition
+    def initialize(client:, **kwargs)
       @client = client
-      @input = input
-      @callables = callables
-      @arguments = arguments
-    end
 
-    def initialize_copy(_)
-      @callables = @callables.dup
+      super(**kwargs)
     end
 
     # [public] Dispatches this composition to proc using the client.
@@ -22,104 +15,29 @@ class Proc
         arguments[:proc] = yield
       end
 
-      callable = self.class.new(
-        client: @client,
+      callable = build_composition(
         input: input_omitted ? @input : input,
-        callables: @callables.dup,
-        arguments: @arguments.merge(arguments)
+        arguments: @arguments.merge(arguments),
+        callables: @callables.dup
       )
 
-      @client.call("core.exec", Proc.undefined, proc: callable)
+      @client.call("core.exec", Proc::Composer.undefined, proc: callable)
     end
 
     # [public] Dispatches this composition to proc using the client, calling the given block once for each value.
     #
     def each(input = input_omitted = true, **arguments, &block)
-      callable = self.class.new(
+      callable = build_composition(
         client: @client,
         input: input_omitted ? @input : input,
-        callables: @callables.dup,
         arguments: @arguments.merge(arguments)
       )
 
-      @client.call("core.exec", Proc.undefined, proc: callable, &block)
+      @client.call("core.exec", Proc::Composer.undefined, proc: callable, &block)
     end
 
-    # [public] Creates a new composition based on this one, with a new input and/or arguments.
-    #
-    def with(input = input_omitted = true, **arguments)
-      if block_given?
-        arguments[:proc] = yield
-      end
-
-      self.class.new(
-        client: @client,
-        input: input_omitted ? @input : input,
-        callables: @callables.dup,
-        arguments: @arguments.merge(arguments)
-      )
-    end
-
-    # [public] Returns a composition from this composition and one or more other callables.
-    #
-    def compose(*others)
-      composed = dup
-      others.each { |other| composed << other }
-      composed
-    end
-
-    # [public] Returns a composition built from this composition and another callable.
-    #
-    def >>(other)
-      composed = dup
-      composed << other
-      composed
-    end
-
-    def <<(callable)
-      case callable
-      when Composition
-        merge(callable)
-      when Callable
-        @callables << callable
-      end
-    end
-
-    def serialize
-      serialized = ["{}"]
-
-      unless Proc.undefined?(@input)
-        serialized << [">>", serialized_input]
-      end
-
-      serialized + serialized_arguments + @callables.map { |callable| callable.serialize(unwrapped: true) }
-    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.is_a?(Symbol)
-        ["@@", value.to_s, {}]
-      elsif value.respond_to?(:serialize)
-        value.serialize
-      else
-        ["%%", value]
-      end
+    private def build_composition(callables:, input:, arguments:)
+      self.class.new(client: @client, input: input, callables: callables, arguments: arguments)
     end
   end
 end

data/lib/proc/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Proc
-  VERSION = "0.11.1"
+  VERSION = "0.13.0"
 
   # [public]
   #

data/lib/proc.rb

@@ -7,16 +7,8 @@ class Proc
   class << self
     # [public] Connect a client with an authorization.
     #
-    def connect(authorization, **options)
-      Client.new(authorization, **options)
-    end
-
-    def undefined
-      @_undefined ||= ::Object.new
-    end
-
-    def undefined?(value)
-      value == undefined
+    def connect(authorization = Proc::Client.authorization, client: Proc::Client, **options)
+      client.new(authorization, **options)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proc
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.13.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-19 00:00:00.000000000 Z
+date: 2021-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: core-async
@@ -16,28 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: core-global
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
 - !ruby/object:Gem::Dependency
   name: http
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.4'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.4'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement
@@ -52,23 +66,37 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
-description: Proc Ruby client.
+- !ruby/object:Gem::Dependency
+  name: proc-composer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+description: Proc client library.
 email: bryan@metabahn.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/proc.rb
-- lib/proc/argument.rb
 - lib/proc/callable.rb
 - lib/proc/client.rb
 - lib/proc/composition.rb
 - lib/proc/enumerator.rb
 - lib/proc/msgpack/types/decimal.rb
 - lib/proc/version.rb
-homepage: https://github.com/metabahn/proc-rb/
+homepage: https://proc.dev
 licenses:
 - MPL-2.0
 metadata: {}
@@ -90,5 +118,5 @@ requirements: []
 rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
-summary: Proc Ruby client.
+summary: Proc client library.
 test_files: []

data/lib/proc/argument.rb

@@ -1,28 +0,0 @@
-# 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