proc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9b1cac83c7cff9f09dc94086b6b58e43cf686c4faa28e95aecda09c73e9eebbc
+  data.tar.gz: e349377c73af33cdff5dfb488dbfd199ec37b9c1db84132e82dde7d65889b71b
+SHA512:
+  metadata.gz: e9b7322deb5945ddac4cff0c12c444d8c90d88b917619176bc2983370e215f54ebafdf83e82a4778424fc94a9ed67149596ebb7fd7378d0bea8d0fcdac611a67
+  data.tar.gz: 91286717d2ee7d67a8021f3aedf2debec4c2da88e2f9abbe34dadd751f02c64f227a40dbdb8e3f6b95ed0ca5ead33557b096683594b3b5e32f10aab5eaf23367

data/LICENSE

@@ -0,0 +1,22 @@
+This software is licensed under the MIT License.
+
+Copyright 2020 Metabahn.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/examples/scratch.rb

@@ -0,0 +1,61 @@
+# Pass `token: "..."` or default to `PROC_ACCESS_TOKEN`:
+#
+client = Proc.connect
+
+# Not chainable, returns the value:
+#
+client.stdlib.echo("bar")
+# => bar
+
+# Create chains using `chain` (perhaps alias as `with`):
+#
+client.chain("foo") { |chain| chain.stdlib.reverse.capitalize.truncate(2) }
+# => Oo
+
+# Or return a chain to pass around:
+#
+chain = client.chain("foo")
+# => <Proc::Chain ...>
+chain.stdlib.echo("bar")
+
+# Call `value` or `perform` to evaluate the chain:
+#
+chain.value
+
+# Calling a non-existent proc raises a Proc::NameError,
+#
+chain.nonexistent
+
+# Pass values through different contexts:
+#
+client.chain("foo") { |chain| chain.stdlib.reverse >> chain.whatever.other }
+
+# Use from the cli (included with the ruby gem OR as a go library):
+#
+# proc echo "bar" -t access-token
+# proc chain "bar" "stdlib.reverse >> whatever.other" -t access-token
+
+#########################################################
+# alternatives so that we don't have to fetch metadata: #
+#########################################################
+
+proc = Proc.connect
+
+# I like this because it's obvious how to get a reference as well as just make the call.
+#
+proc["stdlib.echo"].call("foo")
+
+# This works for simple composition, where the value is simply passed through.
+#
+my_proc = proc["stdlib.reverse"] >> proc["stdlib.capitalize"]
+
+my_proc.call("foo")
+
+# Perhaps something like this, where we compose a proc with arguments. Each is implicitly called, or
+# call explicitly to pass an argument to the proc. I sort of like the simplicity of this.
+#
+my_proc = proc.compose { |context, length:|
+  context["stdlib.reverse"] >> context["stdlib.capitalize"] >> context["stdlib.truncate"].call(length)
+}
+
+my_proc.call("foo", length: 2)

data/lib/proc.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# TODO: Introduce inspectable everywhere (just bundle from pakyow).
+
+require_relative "proc/client"
+
+class Proc
+  def self.connect(authorization, **options)
+    Client.new(authorization, **options)
+  end
+end

data/lib/proc/callable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Proc
+  class Callable
+    attr_reader :proc
+
+    def initialize(proc, client:)
+      @proc = proc
+      @client = client
+    end
+
+    def call(input = nil, **arguments)
+      @client.perform(@proc, input, **arguments)
+    end
+
+    def >>(callable)
+      composed = Composition.new(client: @client)
+      composed << self
+      composed << callable
+      composed
+    end
+  end
+end

data/lib/proc/client.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "oj"
+
+require_relative "callable"
+require_relative "composition"
+
+require_relative "http/client"
+
+class Proc
+  class Error < StandardError
+  end
+
+  class ArgumentError < ::ArgumentError
+  end
+
+  class Undefined < ::NameError
+  end
+
+  class Unauthorized < Error
+  end
+
+  class Unavailable < Error
+  end
+
+  class Client < Http::Client
+    def initialize(authorization, scheme: "https", host: "proc.dev")
+      @authorization = authorization
+      @scheme = scheme
+      @host = host
+
+      super()
+    end
+
+    def [](proc)
+      Callable.new(proc, client: self)
+    end
+
+    def compose(&block)
+      Composition.new(client: self, &block)
+    end
+
+    DEFAULT_HEADERS = {
+      "content-type" => "application/json"
+    }.freeze
+
+    def perform(proc, input, **arguments)
+      body = {
+        input: input, arguments: arguments
+      }
+
+      headers = {
+        "authorization" => "Bearer #{@authorization}"
+      }.merge(DEFAULT_HEADERS)
+
+      begin
+        response = call(:post, build_uri(proc), headers: headers, body: Oj.dump(body, mode: :json))
+      rescue => error
+        raise Proc::Unavailable, error.message
+      end
+
+      payload = if response.body
+        Oj.load(response.body.read, mode: :strict)
+      end
+
+      case response.status
+      when 200
+        payload["value"]
+      when 400
+        raise Proc::ArgumentError, payload.dig("error", "message")
+      when 403
+        raise Proc::Unauthorized, payload.dig("error", "message")
+      when 404
+        raise Proc::Undefined, payload.dig("error", "message")
+      when 500
+        raise Proc::Error, payload.dig("error", "message")
+      end
+    end
+
+    private def build_uri(proc)
+      host_and_path = File.join(@host, proc.split(".").join("/"))
+
+      "#{@scheme}://#{host_and_path}"
+    end
+  end
+end

data/lib/proc/composition.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class Proc
+  class Composition
+    require_relative "composition/deferable"
+    require_relative "composition/evaluator"
+
+    def initialize(client:, &block)
+      @client = client
+      @block = block
+      @callables = []
+    end
+
+    def initialize_copy(_)
+      @callables = @callables.dup
+    end
+
+    def call(input, **arguments)
+      if @block
+        evaluator = @block.call(Evaluator.new, **arguments)
+        @client.perform("compose", input, procs: evaluator.serialize.concat(serialize))
+      else
+        @client.perform("compose", input, procs: serialize)
+      end
+    end
+
+    def >>(callable)
+      composed = dup
+      composed << callable
+      composed
+    end
+
+    def <<(callable)
+      @callables << callable
+    end
+
+    protected def serialize
+      @callables.map(&:proc)
+    end
+  end
+end

data/lib/proc/composition/deferable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Proc
+  class Composition
+    class Deferable
+      attr_reader :proc
+      attr_writer :arguments
+
+      def initialize(proc)
+        @proc = proc
+        @arguments = {}
+      end
+
+      def serialize
+        [@proc, @arguments]
+      end
+    end
+  end
+end

data/lib/proc/composition/evaluator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class Proc
+  class Composition
+    class Evaluator
+      attr_reader :callables
+
+      def initialize
+        @callables = []
+      end
+
+      def initialize_copy(_)
+        @callables = @callables.map(&:dup)
+      end
+
+      def [](proc)
+        evaluator = dup
+        evaluator << Deferable.new(proc)
+        evaluator
+      end
+
+      def <<(proc)
+        @callables << proc
+      end
+
+      def >>(callable)
+        evaluator = dup
+
+        case callable
+        when Evaluator
+          callable.callables.each do |each_callable|
+            evaluator << each_callable
+          end
+        when Callable
+          evaluator << Deferable.new(callable.proc)
+        end
+
+        evaluator
+      end
+
+      def call(**arguments)
+        evaluator = dup
+        evaluator.callables.last.arguments = arguments
+        evaluator
+      end
+
+      def serialize
+        @callables.map(&:serialize)
+      end
+    end
+  end
+end

data/lib/proc/http/client.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "async"
+require "async/http/internet"
+
+require "protocol/http/body/streamable"
+
+require_relative "request"
+require_relative "response"
+
+class Proc
+  module Http
+    class Client
+      class NullLogger
+        class << self
+          def method_missing(*, **)
+          end
+
+          def respond_to_missing?(*)
+            true
+          end
+        end
+      end
+
+      def initialize
+        @internet = Async::HTTP::Internet.new
+        @responses = {}
+      end
+
+      def call(method, uri, params: {}, headers: {}, body: nil)
+        request = Request.new(method: method, uri: uri, params: params, headers: headers, body: body)
+
+        Async(logger: NullLogger) {
+          async_request = @internet.call(*request.callable)
+          wrap_async_response_for_request(async_request, request)
+        }.wait
+      end
+
+      def close
+        @responses.each_value(&:close)
+        @responses.clear
+        @internet.close
+      end
+
+      def count
+        @responses.count
+      end
+
+      private def wrap_async_response_for_request(async_response, request)
+        Protocol::HTTP::Body::Streamable.wrap(async_response) do
+          @responses.delete(async_response)
+        end
+
+        response = Response.new(
+          request: request,
+          status: async_response.status,
+          version: async_response.version,
+          headers: async_response.headers,
+          body: async_response.body
+        )
+
+        @responses[async_response] = response
+      end
+    end
+  end
+end

data/lib/proc/http/request.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Proc
+  module Http
+    class Request
+      attr_reader :method, :uri, :params, :headers, :body
+
+      def initialize(method:, uri:, params:, headers:, body:)
+        @method = method
+        @uri = uri
+        @params = params
+        @headers = headers
+        @body = body
+      end
+
+      def callable
+        return @method.to_s.upcase, finalize_uri(@uri, @params), @headers, @body
+      end
+
+      private def finalize_uri(uri, params)
+        "#{uri}#{query_string(params)}"
+      end
+
+      private def query_string(params)
+        params = params.compact
+
+        if params.any?
+          "?" + params.compact.map { |key, value|
+            "#{key}=#{value}"
+          }.join("&")
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/proc/http/response.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Proc
+  module Http
+    class Response
+      attr_reader :request, :status, :version, :headers, :body
+
+      def initialize(request:, status:, version:, headers:, body:)
+        @request = request
+        @status = status
+        @version = version
+        @headers = headers
+        @body = body
+
+        @stream = nil
+        @stream_blocks = []
+      end
+
+      def stream(&block)
+        @stream_blocks << block
+
+        @stream ||= Async {
+          @body.each do |chunk|
+            @stream_blocks.each do |stream_callback|
+              stream_callback.call(chunk)
+            end
+          end
+        }
+      end
+
+      def close
+        @stream&.stop
+        @stream_blocks.clear
+        @body.close
+      end
+    end
+  end
+end

data/lib/proc/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Proc
+  VERSION = "0.0.1"
+
+  def self.version
+    VERSION
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: proc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Bryan Powell
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.5
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+description: Proc client library.
+email: bryan@metabahn.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/examples/scratch.rb
+- lib/proc.rb
+- lib/proc/callable.rb
+- lib/proc/client.rb
+- lib/proc/composition.rb
+- lib/proc/composition/deferable.rb
+- lib/proc/composition/evaluator.rb
+- lib/proc/http/client.rb
+- lib/proc/http/request.rb
+- lib/proc/http/response.rb
+- lib/proc/version.rb
+homepage: https://proc.dev/
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Proc client library.
+test_files: []