proc 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a33f3939a8156059653e7edde57a9ac0b0ee46ab04bcb1f08ce098073e884358
-  data.tar.gz: df8c021333f0f03b6acdaa195b2c39035a4054b026fd1f6c09d08df674aef7f9
+  metadata.gz: 0f07ae5d056122c93826012896beb760372534d7c2c83193674580517ff31f86
+  data.tar.gz: 5cd335938ec4121d5170c27518678d81c27dd3b65ff6b0235be72213e05613e2
 SHA512:
-  metadata.gz: 52107c5f8c68d623aead4dab7131fe7ea42c5abc29bf748cb81f2aea80bc0ae2b68447764c02a1d40aca4a21e24521f2bc291e9ae7794bd69d98cb867c7f0959
-  data.tar.gz: 8bcab50d65564adb5ce355b75dd407f82ccf93dee798c1219def178293978251b6bfff6c588a823eecd52732a6784a971226026f796601941f1866d3d0c00035
+  metadata.gz: '08b92c4b033fe05dea3a0db6321c5cea4ce5f8ce3587e3f1b7902b295e7778f95a433e84652f12d71f3eff0e60d2bc53d584cce308bd307e32b54f76ed3213e3'
+  data.tar.gz: ef90d03381df7f8f016460cc83f15c14b3b1f9768dd5078588e85591e61d46df628fd63fd7e804d6d7e1975c7dd9749642f4b51ecaa5bf1e7c19896f64155d72

data/README.md

@@ -0,0 +1,80 @@
+The `proc` gem lets you call codeless web functions through the proc.dev service.
+
+## Getting Started
+
+Install `proc` using the `gem` command from the command line:
+
+```
+gem install proc
+```
+
+You will also need a proc.dev account. Create a free account in seconds at [proc.dev](https://proc.dev/).
+
+## Connecting
+
+Sign in to your proc.dev account and locate your secret key. Use the secret to create a client connection:
+
+```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"
+```
+
+Requests are sent to proc.dev anytime the `call` method is invoked.
+
+## Callable Contexts
+
+Proc lookups create contexts that can be called later:
+
+```ruby
+string = client.core.string
+
+string.reverse.call("hello")
+=> "olleh"
+
+string.truncate.call("hello", length: 3)
+=> "hel"
+```
+
+Contexts can be configured with default input and arguments using the `with` method:
+
+```ruby
+truncate = client.core.string.truncate.with("default", length: 1)
+
+truncate.call
+=> "d"
+```
+
+Default input and/or arguments can be overidden for a specific call:
+
+```ruby
+truncate.call(length: 3)
+=> "def"
+```
+
+Procs can also be looked up using the hash key syntax:
+
+```ruby
+client["core.string.truncate"].call("hello", length: 3)
+=> "hel"
+```
+
+## Compositions
+
+Procs can be composed together to build more complex behavior:
+
+```ruby
+composition = client.core.string.reverse >> client.core.string.truncate(length: 3) >> client.core.string.capitalize
+
+composition.call("hello")
+=> "Oll"
+```
+
+Compositions are sent to proc.dev in a single request.

data/lib/proc/callable.rb

@@ -2,15 +2,26 @@
 
 class Proc
   class Callable
-    attr_reader :proc
+    attr_reader :proc, :input, :arguments
 
-    def initialize(proc, client:)
+    def initialize(proc, client:, input: nil, arguments: {})
       @proc = proc
       @client = client
+      @input = input
+      @arguments = arguments
     end
 
-    def call(input = nil, **arguments)
-      @client.call(@proc, input, **arguments)
+    def initialize_copy(_)
+      @input = input.dup
+      @arguments = arguments.dup
+    end
+
+    def call(input = input_omitted = true, **arguments)
+      @client.call(@proc, input_omitted ? @input : input, **@arguments.merge(arguments))
+    end
+
+    def with(input = input_omitted = true, **arguments)
+      self.class.new(@proc, client: @client, input: input_omitted ? @input : input, arguments: @arguments.merge(arguments))
     end
 
     def >>(other)
@@ -19,5 +30,51 @@ class Proc
       composed << other
       composed
     end
+
+    def serialize
+      {
+        "{}" => {
+          "<<" => serialize_value(@input),
+          "[]" => [[@proc, serialized_arguments]]
+        }
+      }
+    end
+
+    def serialized_arguments
+      @arguments.each_pair.each_with_object({}) { |(key, value), hash|
+        hash[key.to_s] = serialize_value(value)
+      }
+    end
+
+    IGNORE_MISSING = %i[to_hash].freeze
+
+    def method_missing(name, input = input_omitted = true, **arguments)
+      if IGNORE_MISSING.include?(name)
+        super
+      else
+        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)
+      if value.respond_to?(:serialize)
+        value.serialize
+      else
+        value
+      end
+    end
   end
 end

data/lib/proc/client.rb

@@ -60,9 +60,6 @@ class Proc
       @resets_at
     end
 
-    def compose(&block)
-      Composition.new(client: self, &block)
-    end
 
     DEFAULT_HEADERS = {
       "accept" => "application/json",
@@ -71,14 +68,10 @@ class Proc
 
     def call(proc = nil, input = nil, **arguments)
       Async(logger: NullLogger) { |task|
-        body = { "<<" => input }
+        body = { "<<" => serialize_value(input) }
 
         arguments.each_pair do |key, value|
-          body[key.to_s] = if value.respond_to?(:serialize)
-            value.serialize
-          else
-            value
-          end
+          body[key.to_s] = serialize_value(value)
         end
 
         headers = {
@@ -119,10 +112,26 @@ class Proc
       }.wait
     end
 
+    def method_missing(name, input = nil, **arguments)
+      Callable.new(name, client: self, input: input, arguments: arguments)
+    end
+
+    def respond_to_missing?(name, *)
+      true
+    end
+
     private def build_uri(proc)
       host_and_path = File.join(@host, proc.to_s.split(".").join("/"))
 
       "#{@scheme}://#{host_and_path}"
     end
+
+    private def serialize_value(value)
+      if value.respond_to?(:serialize)
+        value.serialize
+      else
+        value
+      end
+    end
   end
 end

data/lib/proc/composition.rb

@@ -2,12 +2,8 @@
 
 class Proc
   class Composition
-    require_relative "composition/deferable"
-    require_relative "composition/evaluator"
-
-    def initialize(client:, &block)
+    def initialize(client:)
       @client = client
-      @block = block
       @callables = []
     end
 
@@ -15,10 +11,8 @@ class Proc
       @callables = @callables.dup
     end
 
-    def call(input = nil, **arguments)
-      # TODO: This will probably call `proc.run`.
-      #
-      @client.call("compose", input, proc: build_evaluator(**arguments))
+    def call(input = input_omitted = true, **arguments)
+      @client.call("exec", input_omitted ? @callables.first.input : input, proc: serialize)
     end
 
     def >>(other)
@@ -31,28 +25,10 @@ class Proc
       @callables << callable
     end
 
-    def with(**arguments)
-      build_evaluator(**arguments)
-    end
-
     def serialize
-      build_evaluator.serialize
-    rescue ::ArgumentError => error
-      raise ::ArgumentError, error.message + " (try using `with' to build a composition with arguments)"
-    end
-
-    private def build_evaluator(**arguments)
-      evaluator = if @block
-        @block.call(Evaluator.new, **arguments)
-      else
-        Evaluator.new
-      end
-
-      @callables.each do |callable|
-        evaluator << Deferable.new(callable.proc)
-      end
-
-      evaluator
+      @callables.map { |callable|
+        [callable.proc, callable.serialized_arguments]
+      }
     end
   end
 end

data/lib/proc/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Proc
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 
   def self.version
     VERSION

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: proc
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-24 00:00:00.000000000 Z
+date: 2020-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http
@@ -50,8 +50,6 @@ files:
 - 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

data/lib/proc/composition/deferable.rb

@@ -1,29 +0,0 @@
-# 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, serialized_arguments]
-      end
-
-      private def serialized_arguments
-        @arguments.each.each_with_object({}) do |(key, value), hash|
-          hash[key] = if value.respond_to?(:serialize)
-            value.serialize
-          else
-            value
-          end
-        end
-      end
-    end
-  end
-end

data/lib/proc/composition/evaluator.rb

@@ -1,52 +0,0 @@
-# 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 >>(other)
-        evaluator = dup
-
-        case other
-        when Evaluator
-          other.callables.each do |each_callable|
-            evaluator << each_callable
-          end
-        when Callable
-          evaluator << Deferable.new(other.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