proc 0.10.0 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc5ea46072b5407ec2b71822b8406163aeecd2aa6a57d10773e440bb08721ac5
-  data.tar.gz: 4640295398b9266d57361f62aadf461b9d23e69f9fa0d21d60c5d1cd8b00715f
+  metadata.gz: '02639b241bf6aa890c69bebcf99739d987c6f47ea5a4eb5e122f74ff1f84abc4'
+  data.tar.gz: 400d2369a30233dfdeb510087b7ec20b28b7a8b9255d0e4b85ad18d2c57ab39c
 SHA512:
-  metadata.gz: 45bb39ab2f194fe673f22a09d7d681c8514e639c71829a5673ac437991652212260fa6031c46fbdf92c48397865e1552ca7fdda72064a0ce6011c29dbee5e018
-  data.tar.gz: 8d1ae22aa4ec5f39cd4c10e2fdf1fa24ad38355e511d5d12cd8935563cb7f6a835a166683922e56bf7db9cc30a5dda7dc649c4c39f3c47b060c5f528f4077331
+  metadata.gz: e6a9e623c4b14f9103d4df2c0338fc5656723902b2a56553dfeb8ddcb3c9c74001a5727ac06651351ce42cec801b0513c7988816647d5f9eb70cb89355fac805
+  data.tar.gz: bfa20fa9817dca6274b00e216e8853f93890b0b8ec10c6ca99070690c60c9acacb1c6260fec7f13e3734560c290257c0a1bee8aac5167e751bce735bdfd53f25

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## [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,80 +1,58 @@
-The `proc` gem lets you call codeless web functions through the proc.dev service.
+**Superpowers to help you ship web endpoints faster.**
 
-## Getting Started
+Proc is an all-in-one toolchain for building, deploying, and calling custom behavior from any website or app.
 
-Install `proc` using the `gem` command from the command line:
+* [Learn more about Proc](https://proc.dev)
+* [Browse packages](https://proc.dev/packages)
+* [Read the docs](https://proc.dev/docs)
+* [Chat with us](https://discord.gg/aRu8qvkCmy)
 
-```
-gem install proc
-```
-
-You will also need a proc.dev account. Create a free account in seconds at [proc.dev](https://proc.dev/).
-
-## Connecting
+## Install
 
-Sign in to your proc.dev account and locate your secret key. Use the secret to create a client connection:
+Install with `gem install proc`:
 
-```ruby
-client = Proc.connect("secret-key")
 ```
-
-## Calling Procs
-
-You can call available procs through a connected client:
-
-```ruby
-client.core.string.reverse.call("hello")
-=> "olleh"
+gem install proc
 ```
 
-Requests are sent to proc.dev anytime the `call` method is invoked.
+## Usage
 
-## Callable Contexts
-
-Proc lookups create contexts that can be called later:
+Connect to proc using an account secret or limited api key:
 
 ```ruby
-string = client.core.string
-
-string.reverse.call("hello")
-=> "olleh"
+require "proc"
 
-string.truncate.call("hello", length: 3)
-=> "hel"
+client = Proc.connect("{your-proc-authorization}")
 ```
 
-Contexts can be configured with default input and arguments using the `with` method:
+Now you can call procs just like local code:
 
 ```ruby
-truncate = client.core.string.truncate.with("default", length: 1)
+client.type.number.add.call(1, {value: 1});
 
-truncate.call
-=> "d"
+=> 2
 ```
 
-Default input and/or arguments can be overidden for a specific call:
+Build more complex behavior by composing procs together:
 
 ```ruby
-truncate.call(length: 3)
-=> "def"
-```
+time = client.time
 
-Procs can also be looked up using the hash key syntax:
+composition = time.now >> time.format(string: "%A")
 
-```ruby
-client["core.string.truncate"].call("hello", length: 3)
-=> "hel"
-```
+composition.call
 
-## Compositions
+=> "Tuesday"
+````
 
-Procs can be composed together to build more complex behavior:
+Instantly deploy your behavior to a private endpoint and call it from anywhere:
 
 ```ruby
-composition = client.core.string.reverse >> client.core.string.truncate(length: 3) >> client.core.string.capitalize
+client.proc.create.call(name: "day_of_week", proc: composition)
+
+client.self.day_of_week.call
 
-composition.call("hello")
-=> "Oll"
+=> "Tuesday"
 ```
 
-Compositions are sent to proc.dev in a single request.
+Learn more at [proc.dev](https://proc.dev). See you around!

data/lib/proc/callable.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 class Proc
-  class Callable
+  class Callable < BasicObject
     attr_reader :proc, :input, :arguments
 
-    def initialize(proc, client:, input: Proc.undefined, arguments: {})
+    def initialize(proc, client:, input: ::Proc.undefined, arguments: {})
       @proc = proc.to_s
       @client = client
       @input = input
@@ -21,11 +21,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(
+      callable = ::Proc::Callable.new(
         @proc,
         client: @client,
         input: input_omitted ? @input : input,
@@ -38,7 +38,7 @@ 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(
+      callable = ::Proc::Callable.new(
         @proc,
         client: @client,
         input: input_omitted ? @input : input,
@@ -51,11 +51,11 @@ class Proc
     # [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?
+      if ::Kernel.block_given?
         arguments[:proc] = yield
       end
 
-      self.class.new(
+      ::Proc::Callable.new(
         @proc,
         client: @client,
         input: input_omitted ? @input : input,
@@ -66,7 +66,7 @@ class Proc
     # [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 = ::Proc::Composition.new(client: @client, input: @input)
       composed << self
       others.each { |other| composed << other }
       composed
@@ -75,7 +75,7 @@ class Proc
     # [public] Returns a composition built from this callable context and another callable.
     #
     def >>(other)
-      composed = Composition.new(client: @client, input: @input)
+      composed = ::Proc::Composition.new(client: @client, input: @input)
       composed << self
       composed << other
       composed
@@ -84,7 +84,7 @@ class Proc
     def serialize(unwrapped: false)
       serialized = ["()", @proc]
 
-      unless Proc.undefined?(@input)
+      unless ::Proc.undefined?(@input)
         serialized << [">>", serialized_input]
       end
 
@@ -110,7 +110,7 @@ class Proc
     # [public] Returns a callable context for `proc`, nested within this callable context.
     #
     def [](proc)
-      arguments = if block_given?
+      arguments = if ::Kernel.block_given?
         duped = @arguments.dup
         duped[:proc] = yield
         duped
@@ -118,7 +118,7 @@ class Proc
         @arguments
       end
 
-      Callable.new(
+      ::Proc::Callable.new(
         [@proc, proc].join("."),
         client: @client,
         input: @input,
@@ -134,11 +134,11 @@ class Proc
       if IGNORE_MISSING.include?(name)
         super
       else
-        if block_given?
+        if ::Kernel.block_given?
           arguments[:proc] = yield
         end
 
-        Callable.new(
+        ::Proc::Callable.new(
           [@proc, name].join("."),
           client: @client,
           input: input_omitted ? @input : input,
@@ -156,9 +156,10 @@ class Proc
     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::Argument, ::Proc::Callable, ::Proc::Composition
         value.serialize
       else
         ["%%", value]

data/lib/proc/client.rb

@@ -56,8 +56,8 @@ class Proc
 
   # [public] Connection to proc, configured with an authorization.
   #
-  class Client
-    include Is::Async
+  class Client < BasicObject
+    include ::Is::Async
 
     # [public] The configured authorization.
     #
@@ -75,6 +75,8 @@ class Proc
     #
     attr_reader :request_count
 
+    attr_reader :response
+
     DEFAULT_HEADERS = {
       "accept" => "application/vnd.proc+msgpack",
       "content-type" => "application/vnd.proc+msgpack"
@@ -95,10 +97,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
 
@@ -124,8 +126,8 @@ class Proc
     end
 
     private def refresh_rate_limit
-      unless defined?(@rate_limit_reset)
-        self["ping"].call
+      unless defined?(@rate_limit)
+        self["core.ping"].call
       end
     end
 
@@ -133,10 +135,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.undefined, **arguments, &block)
       body = []
 
-      unless Proc.undefined?(input)
+      unless ::Proc.undefined?(input)
         body << [">>", serialize_value(input)]
       end
 
@@ -152,9 +154,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)
             }
@@ -169,25 +171,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
 
@@ -195,9 +197,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
 
@@ -208,18 +210,19 @@ class Proc
     # [public] Builds a named argument with options.
     #
     def argument(name, **options)
-      Argument.new(name, **options)
+      ::Proc::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::Argument, ::Proc::Callable, ::Proc::Composition
         value.serialize
       else
         ["%%", value]
@@ -230,14 +233,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)
@@ -253,7 +257,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

@@ -29,7 +29,7 @@ class Proc
         arguments: @arguments.merge(arguments)
       )
 
-      @client.call("exec", Proc.undefined, proc: callable)
+      @client.call("core.exec", Proc.undefined, proc: callable)
     end
 
     # [public] Dispatches this composition to proc using the client, calling the given block once for each value.
@@ -42,7 +42,7 @@ class Proc
         arguments: @arguments.merge(arguments)
       )
 
-      @client.call("exec", Proc.undefined, proc: callable, &block)
+      @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.
@@ -113,9 +113,10 @@ class Proc
     end
 
     private def serialize_value(value)
-      if value.is_a?(Symbol)
+      case value
+      when Symbol
         ["@@", value.to_s, {}]
-      elsif value.respond_to?(:serialize)
+      when Argument, Callable, Composition
         value.serialize
       else
         ["%%", value]

data/lib/proc/msgpack/types/decimal.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+
 class BigDecimal
   def to_msgpack(packer)
     if precision > 16

data/lib/proc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proc
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.2
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-01 00:00:00.000000000 Z
+date: 2021-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: core-async
@@ -16,28 +16,28 @@ 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: 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
@@ -58,6 +58,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - lib/proc.rb
@@ -68,7 +69,7 @@ files:
 - lib/proc/enumerator.rb
 - lib/proc/msgpack/types/decimal.rb
 - lib/proc/version.rb
-homepage: https://proc.dev/
+homepage: https://proc.dev
 licenses:
 - MPL-2.0
 metadata: {}
@@ -80,14 +81,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.4
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: Proc client library.