proc 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b102aa8b4a6c4f99758cab2f6aefff1800948b60197d920f6279cb76f26decbb
-  data.tar.gz: 37b8a0aa99c4089a584b2b7197ab7e9e9ec7bc555a59bdaf1bbce76f4ab466ac
+  metadata.gz: 4fd5089ba0458dc13c198de1322bfc510a54157ef0ec49f957efa730b6de768e
+  data.tar.gz: d4c05363b54d8ae4607890b9ab552eb9ba3fc486c39251dcaac028aee29e21b7
 SHA512:
-  metadata.gz: 33e2381e9f9d5ff7a6ff10c7ad4a75cc2d0687a4e6890916d4443563ddcaf883d7205b971e7dee63637f81731cea2c5caf80df1a980718db65c78b94db19c0ca
-  data.tar.gz: fc7497fce516a9b003ed4dbf617d26c9c7ca5e6b2696f324cba275f765f85f6f878baaea2e7006d3e2e023a61de73b506aff743d1d3ae1451fa9226c2c9040d4
+  metadata.gz: 11793b5496575f947eb481b53732310b47d6a5fa5601e0826cc2dcc5f79fec498712abeaf14c9be82c683da519e1b9c785b7265e8d1f86e0027178aae6a606f6
+  data.tar.gz: c24ea2e3ef4337788c13cd53b373815e621c2cac9b504015672206c7e57dc7f9cef18b4deb94563eab0f4c9a536802f693687433b5cb21cb98222c2ced48b7db

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+## [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*
+
+  * `chg` [#2](https://github.com/metabahn/proc/pull/2) Update http.rb dependency ([bryanp](https://github.com/bryanp))
+
+

data/lib/proc/callable.rb

@@ -1,19 +1,11 @@
 # frozen_string_literal: true
 
 class Proc
-  class Callable < BasicObject
-    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.
@@ -25,12 +17,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 +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 = ::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
+    private def build_callable(input:, arguments:, proc: @proc)
+      ::Proc::Callable.new(proc, client: @client, input: input, arguments: arguments)
     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
-      )
-    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,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"
@@ -57,7 +60,22 @@ 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
 
     # [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
@@ -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,30 +164,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,7 +190,30 @@ 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
 
@@ -210,7 +234,7 @@ 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
 
@@ -222,7 +246,7 @@ class Proc
       case value
       when ::Symbol
         ["@@", value.to_s, {}]
-      when ::Proc::Argument, ::Proc::Callable, ::Proc::Composition
+      when ::Proc::Composer::Argument, ::Proc::Callable, ::Proc::Composition
         value.serialize
       else
         ["%%", value]

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,105 +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)
-      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/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Proc
-  VERSION = "0.12.0"
+  VERSION = "0.14.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.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-06 00:00:00.000000000 Z
+date: 2021-09-23 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,16 +66,30 @@ 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: []
 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
@@ -87,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 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