proc 0.12.2 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '02639b241bf6aa890c69bebcf99739d987c6f47ea5a4eb5e122f74ff1f84abc4'
-  data.tar.gz: 400d2369a30233dfdeb510087b7ec20b28b7a8b9255d0e4b85ad18d2c57ab39c
+  metadata.gz: a554218f2f2a9cfe6bfa2e6f87ebf17abba0090e840d640ac5646c81b1d84c7c
+  data.tar.gz: cfdd2fab893016a3fb2a1a76995ee611c28cca6ea051024fae03157c22d440d9
 SHA512:
-  metadata.gz: e6a9e623c4b14f9103d4df2c0338fc5656723902b2a56553dfeb8ddcb3c9c74001a5727ac06651351ce42cec801b0513c7988816647d5f9eb70cb89355fac805
-  data.tar.gz: bfa20fa9817dca6274b00e216e8853f93890b0b8ec10c6ca99070690c60c9acacb1c6260fec7f13e3734560c290257c0a1bee8aac5167e751bce735bdfd53f25
+  metadata.gz: 8c82e014b6a876cbe35e9fdfdd2ea10e296e6497b207623728ca6dae8a887fb7ac82e7f199da08febec7571e677b65c743dbc335731c72f2716447f4f367b4db
+  data.tar.gz: 99c5bad156fbcb7d18084ee0523366f6334b5a9d5f2d89410fcad000a533a21be71806c53dea0f6b8f8d2f1ec36b488e86c65b36d5d4e067ca27e022f3f25bb1

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [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,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,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
@@ -210,7 +232,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 +244,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.2"
+  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.12.2
+  version: 0.13.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-20 00:00:00.000000000 Z
+date: 2021-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: core-async
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         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
@@ -52,6 +66,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 +90,6 @@ files:
 - LICENSE
 - README.md
 - lib/proc.rb
-- lib/proc/argument.rb
 - lib/proc/callable.rb
 - lib/proc/client.rb
 - lib/proc/composition.rb

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