proc 0.12.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf87f2913659211107f5af2ac54f61887291e8cbbcfe060e93044bc7cc7be8f2
-  data.tar.gz: 2b17972efabec76c0a5281aae6b4d07136c5841301fa4b2bf3cebcfefe32cd82
+  metadata.gz: 9c4e2f8e75f833c305540a05b7a5fb4b401f954296a68e8bd06dabf89be7042d
+  data.tar.gz: d254fb835c6d38bae8a7d5c2232f50cd05387ba7324280d1ba3c1761dec4525f
 SHA512:
-  metadata.gz: ef1780eeb35c9a584403e41a54eb0f30f9759439f5477940765017baacd16626eef7af15f6291fbdf7e67a4fe464e5419cff83c1c47d1ab27094af2c078654cb
-  data.tar.gz: b6c82ad621724a2062e767d68006d06f4cfdbb4740942a658b87275b46bb1b5c773fa07f8e6d8a05959dabe06255cdf6e94d51cffe197900cbd49719e61030fe
+  metadata.gz: 022c5d8baf6791533e5d5407831a512e922f0013df71da6f35b4595f5c9ee6fc4a85cb01e909a9c9d9c2113a50be0a5818fe8a81ab3169d74fb2a0230b41912e
+  data.tar.gz: 41656a469f4b6505578ff2ecc0da00b77f3178904d8167964e4bdb6adbdcc9346230b9b9a1e1501be649993e7e475437a6727f83d4e1786d75fafb7036798f29

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [v0.15.0](https://github.com/metabahn/proc/releases/tag/2022-01-13)
+
+*released on 2022-01-13*
+
+  * `dep` [#22](https://github.com/metabahn/proc/pull/22) Update dependencies ([bryanp](https://github.com/bryanp))
+  * `chg` [#20](https://github.com/metabahn/proc/pull/20) Rename client `request_count` to `count` ([bryanp](https://github.com/bryanp))
+  * `chg` [#16](https://github.com/metabahn/proc/pull/16) Update Ruby client to use proc.run ([bryanp](https://github.com/bryanp))
+
+## [v0.14.0](https://github.com/metabahn/proc/releases/tag/2021-09-22)
+
+*released on 2021-09-22*
+
+  * `chg` [#14](https://github.com/metabahn/proc/pull/14) Change Ruby client error handling to fallback to returning a result ([bryanp](https://github.com/bryanp))
+
+## [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*

data/lib/proc/callable.rb

@@ -1,19 +1,13 @@
 # frozen_string_literal: true
 
 class Proc
-  class Callable < BasicObject
-    attr_reader :proc, :input, :arguments
+  class Callable < Composer::Callable
+    inspects :@client
 
-    def initialize(proc, client:, input: ::Proc.undefined, arguments: {})
-      @proc = proc.to_s
+    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.
@@ -25,12 +19,7 @@ class Proc
         arguments[:proc] = yield
       end
 
-      callable = ::Proc::Callable.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,132 +27,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 = ::Proc::Callable.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 ::Kernel.block_given?
-        arguments[:proc] = yield
-      end
-
-      ::Proc::Callable.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 = ::Proc::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 = ::Proc::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 ::Kernel.block_given?
-        duped = @arguments.dup
-        duped[:proc] = yield
-        duped
-      else
-        @arguments
-      end
-
-      ::Proc::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 ::Kernel.block_given?
-          arguments[:proc] = yield
-        end
-
-        ::Proc::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)
-      case value
-      when ::Symbol
-        ["@@", value.to_s, {}]
-      when ::Proc::Argument, ::Proc::Callable, ::Proc::Composition
-        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,18 @@
 # frozen_string_literal: true
 
 require "core/async"
+require "core/global"
+require "core/inspect"
+
 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"
@@ -57,7 +61,24 @@ class Proc
   # [public] Connection to proc, configured with an authorization.
   #
   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
+    include ::Is::Inspectable
+    inspects :@scheme, :@host, ::Core::Inspect::Inspection.new(name: :@authorization, resolver: :safe_authorization), :@count
 
     # [public] The configured authorization.
     #
@@ -73,7 +94,7 @@ class Proc
 
     # [public] The number of requests this client has performed.
     #
-    attr_reader :request_count
+    attr_reader :count
 
     attr_reader :response
 
@@ -82,11 +103,11 @@ 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: "proc.run")
       @authorization = authorization
       @scheme = scheme
       @host = host
-      @request_count = 0
+      @count = 0
 
       @__base_url = "#{@scheme}://#{host}"
       @__headers = {
@@ -135,10 +156,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,30 +167,13 @@ 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
-      when 200
-        result = extract_output(payload)
-
-        if (cursor = headers["x-cursor"])
-          enumerator = if cursor.empty?
-            ::Proc::Enumerator.new(result)
-          else
-            ::Proc::Enumerator.new(result) {
-              arguments[:cursor] = cursor.to_s
-              call(proc, input, **arguments)
-            }
-          end
-
-          if block
-            enumerator.each(&block)
-          else
-            enumerator
-          end
-        else
-          result
-        end
       when 400
         ::Kernel.raise ::Proc::Invalid, extract_error_message(payload)
       when 401
@@ -189,14 +193,58 @@ class Proc
       when 508
         ::Kernel.raise ::Proc::Error, extract_error_message(payload)
       else
-        ::Kernel.raise ::Proc::Error, "unhandled"
+        result = extract_output(payload)
+
+        if !result.nil?
+          if (cursor = headers["x-cursor"])
+            enumerator = if cursor.empty?
+              ::Proc::Enumerator.new(result)
+            else
+              ::Proc::Enumerator.new(result) {
+                arguments[:cursor] = cursor.to_s
+                call(proc, input, **arguments)
+              }
+            end
+
+            if block
+              enumerator.each(&block)
+            else
+              enumerator
+            end
+          else
+            result
+          end
+        elsif (error = extract_error_message(payload))
+          ::Kernel.raise ::Proc::Error, error
+        end
       end
     end
 
+    IGNORE_MISSING = %i[
+    ].freeze
+
+    KERNEL_DELEGATE = %i[
+      class
+      instance_variables
+      instance_variable_get
+      instance_variable_set
+      object_id
+      public_send
+      respond_to?
+    ].freeze
+
     # [public] Allows callable contexts to be built through method lookups.
     #
-    def method_missing(name, input = input_omitted = true, *, **arguments)
-      if input_omitted
+    def method_missing(name, input = input_omitted = true, *parameters, **arguments, &block)
+      if IGNORE_MISSING.include?(name)
+        super
+      elsif KERNEL_DELEGATE.include?(name)
+        if input_omitted
+          ::Kernel.instance_method(name).bind_call(self, *parameters, **arguments, &block)
+        else
+          ::Kernel.instance_method(name).bind_call(self, input, *parameters, **arguments, &block)
+        end
+      elsif input_omitted
         ::Proc::Callable.new(name, client: self, arguments: arguments)
       else
         ::Proc::Callable.new(name, client: self, input: input, arguments: arguments)
@@ -210,10 +258,17 @@ class Proc
     # [public] Builds a named argument with options.
     #
     def argument(name, **options)
-      ::Proc::Argument.new(name, **options)
+      ::Proc::Composer::Argument.new(name, **options)
     end
     alias_method :arg, :argument
 
+    # [public] Returns a partial representation of the authorization that is safe to include in logs.
+    #
+    def safe_authorization
+      return unless @authorization
+      "#{@authorization[0..7]}...#{@authorization[-5..]}"
+    end
+
     private def build_uri(proc)
       ::File.join(@__base_url, proc.to_s.split(".").join("/"))
     end
@@ -222,16 +277,18 @@ class Proc
       case value
       when ::Symbol
         ["@@", value.to_s, {}]
-      when ::Proc::Argument, ::Proc::Callable, ::Proc::Composition
-        value.serialize
       else
-        ["%%", value]
+        if value.respond_to?(:serialize)
+          value.serialize
+        else
+          ["%%", value]
+        end
       end
     end
 
     private def get_payload(proc:, body:)
       await {
-        @request_count += 1
+        @count += 1
 
         response = ::HTTP.headers(@__headers).post(build_uri(proc), body: ::MessagePack.pack(body))
 

data/lib/proc/composition.rb

@@ -1,18 +1,13 @@
 # frozen_string_literal: true
 
 class Proc
-  class Composition
-    attr_reader :input, :callables, :arguments
+  class Composition < Composer::Composition
+    inspects :@client
 
-    def initialize(client:, input:, callables: [], arguments: {})
+    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,105 +17,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(
-        client: @client,
-        input: input_omitted ? @input : input,
-        callables: @callables.dup,
-        arguments: @arguments.merge(arguments)
-      )
-
-      @client.call("core.exec", Proc.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(
+      callable = build_composition(
         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)]
-      }
+      @client.call("core.exec", Proc::Composer.undefined, proc: callable, &block)
     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)
-      case value
-      when Symbol
-        ["@@", value.to_s, {}]
-      when Argument, Callable, Composition
-        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/enumerator.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
+require "core/inspect"
+
 class Proc
   class Enumerator
     include Enumerable
 
+    include Is::Inspectable
+    inspects :@values
+
     attr_reader :values, :next_block
 
     def initialize(values, &next_block)

data/lib/proc/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Proc
-  VERSION = "0.12.1"
+  VERSION = "0.15.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.12.1
+  version: 0.15.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-13 00:00:00.000000000 Z
+date: 2022-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: core-async
@@ -16,14 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '0.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: core-global
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: core-inspect
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: http
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !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: []
@@ -62,7 +104,6 @@ files:
 - LICENSE
 - README.md
 - lib/proc.rb
-- lib/proc/argument.rb
 - lib/proc/callable.rb
 - lib/proc/client.rb
 - lib/proc/composition.rb
@@ -88,7 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Proc client library.

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