welder 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5428ae811f23cbc0f854771f6182c5d10dd915ba
+  data.tar.gz: f1fbe9a58f4f9232c1afddf10268fd56b79cf822
+SHA512:
+  metadata.gz: df3e6580e28d28d88621eb6f4d905da8bd024c1eafe38e19838d8944c0b7acfa42564f9669b0b257a0e7c2d8ed799cc6ee3252e81d3a1e82db1b059818d7b4a8
+  data.tar.gz: 195717328350c2d4ff0ca21e3aec5a71e6acca0b82a6491a817175187ac81b8b13b0779e77a64a86f022c482273189dc28d0aa62cb09c75d6be0122e244387e2

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Lorenzo Arribas
+
+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/README.md

@@ -0,0 +1,59 @@
+# Welder
+
+[![Gem Version](https://badge.fury.io/rb/welder.svg)](https://badge.fury.io/rb/welder)
+[![Build Status](https://travis-ci.org/rb-welder/welder.svg?branch=master)](https://travis-ci.org/rb-welder/welder)
+[![Code Climate](https://codeclimate.com/github/rb-welder/welder/badges/gpa.svg)](https://codeclimate.com/github/rb-welder/welder)
+[![Test Coverage](https://codeclimate.com/github/rb-welder/welder/badges/coverage.svg)](https://codeclimate.com/github/rb-welder/welder/coverage)
+[![Dependency Status](https://gemnasium.com/rb-welder/welder.svg)](https://gemnasium.com/rb-welder/welder)
+[![Inline docs](http://inch-ci.org/github/rb-welder/welder.svg?branch=master)](http://inch-ci.org/github/rb-welder/welder)
+
+**Welder** allows you to define pipelines in a true [Unix style](https://en.wikipedia.org/wiki/Pipeline_(Unix)).
+
+It provides a simple and powerful DSL to define you own pipelines and compose them together. You can define a pipeline out of one or more ruby callables:
+```ruby
+read_file = ->(filename) { File.read(filename) }
+count_words = ->(text) { text.split.size }
+
+count_words_from_file = Welder::Pipeline.new | read_file | count_words  # Define a pipeline
+puts "My book has #{'my_book.txt' | count_words_from_file} words"       # Execute it with a specific value
+```
+
+_Note that, for the pipe operator to work, the first argument has to be a Welder::Pipeline_
+
+
+## Why pipelines?
+In some use cases, pipelines have several advantages over the natural, imperative style of languages like ruby. Take, for instance, the following example:
+```ruby
+puts "My book has #{'my_book.txt' | read_file | count_words} words"
+```
+
+Here, the alternative way to write the word count would be `count_words(read_file('my_book.txt'))`. Pipelines, in contrast:
+* Provide a cleaner syntax that is better at expressing the statement's **order and intent**
+* Ease the instrumentation of the whole process (e.g. for debugging and benchmarking purposes)
+* Allow for ways to abstract the way the different stages in the pipeline are called. For instance, creating pipelines of remote methods using RPC
+
+
+## Valves
+Valves are callables that get called at every step of a pipeline with the input to the step, the function processing it, and the generated output. Valves are useful for logging, debugging and code instrumentation. You set valves like this:
+```ruby
+logged_steps = []
+log = ->(i, l, o) { logged_steps << "Executed step #{l.inspect} with input=#{i.inspect} and got #{o.inspect}" }
+count_words_and_log_steps = (Welder::Pipeline.new | read_file | count_words) -log
+
+'my_book.txt' | count_words_and_log_steps
+puts logged_steps.size  # => 2
+puts logged_steps[0]    # Executed step "..." with input="my_book.txt" and output="this is my book"
+puts logged_steps[1]    # Executed step "..." with input="this is my book" and output=4
+```
+
+
+## Present and Future
+The next step for Welder will be getting a nice toolbelt to start his work (extra gems with useful pipelines our of the box)
+
+
+## Contributing to Welder
+Welder is open for help in any way.
+
+
+## License
+See LICENSE file

data/lib/welder/pipeline.rb

@@ -0,0 +1,124 @@
+require 'welder/support/callable_handler'
+
+module Welder
+  # A wrapper around a sequence of callables (i.e. anything that responds to a
+  # single-argument 'call' method, which includes procs, blocks and other
+  # pipelines)
+  #
+  # Pipelines are immutable. There are mechanisms to create more complex
+  # pipelines out of existing ones, but they will always create a new pipeline
+  class Pipeline
+    include Support::CallableHandler
+
+    # Creates a new pipeline out of a sequence of callables. If a block is
+    # given, it is executed as the last step of the pipeline.
+    # It also accepts valves, with act as witnesses of the steps the pipeline
+    # goes through
+    #
+    # @param lambdas [Array<#call>] Array of callables accepting 1 argument
+    # @param valves [Array<#call>] Array of callables accepting 3 arguments
+    # @param block [Block] A block to execute as the last step in the pipeline
+    #
+    # @raise [CallableExpectedError] When trying to create a pipeline
+    #   out of a non-callable
+    #
+    # @example Create an empty pipeline (with no steps)
+    #   square_and_double = Welder::Pipeline.new
+    #
+    # @example Create a pipeline from an anonymous function
+    #   square = Welder::Pipeline.new(->(x){ x ** 2 })
+    #
+    # @example Create a pipeline from a block
+    #   square_and_double = Welder::Pipeline.new { |x| x ** 2 }
+    def initialize(*lambdas, valves: nil, &block)
+      callable!(*lambdas, *valves)
+
+      @pipes = [*lambdas]
+      @pipes << block if block
+
+      @valves = [*valves]
+    end
+
+    # Apply the sequence of functions to a particular input. Any valves
+    # present in the pipeline are called as a side effect
+    #
+    # @param input [*] The input for the first element of the pipeline
+    # @param valves [Array<#call>] An array of valves to be called at every
+    #   step of the pipeline
+    #
+    # @return [*] The output resulting of passing the input through the whole
+    #   pipeline
+    def call(input, valves = [])
+      valves = @valves.concat(valves)
+
+      @pipes.reduce(input) do |a, e|
+        if e.is_a?(Pipeline)
+          e.call(a, valves)
+        else
+          e.call(a).tap do |output|
+            valves.each { |valve| valve.call(a, e, output) }
+          end
+        end
+      end
+    end
+
+    # Compose a pipeline with another one (or a callable). This method does not
+    # modify existing pipelines. Instead, it creates a new pipeline composed
+    # of the previous two
+    #
+    # @param other [#call] The callable to add as the last step of the
+    #   pipeline, which has to accept 1 argument
+    #
+    # @raise [CallableExpectedError] When trying to create a pipeline
+    #   out of non-callables
+    #
+    # @return [Welder::Pipeline] a new pipeline composed of the current
+    #   one and 'other', in that order
+    def |(other)
+      self.class.new(self, other)
+    end
+
+    # Create a new pipeline that keeps all the steps in the current one,
+    # but adds a valve overseeing the process. The valve will get called
+    # at every stage, as a side effect, but it will never modify the final
+    # outcome of the pipeline
+    #
+    # @param other [#call] The callable to invoke at every step of the
+    #   pipeline. It must accept 3 arguments: (input, lambda, output)
+    def -(other)
+      self.class.new(self, valves: [*other])
+    end
+  end
+end
+
+WELDER_SAVED_PIPE_METHODS = {}
+[Object, Fixnum, TrueClass, FalseClass].each do |klass|
+
+  WELDER_SAVED_PIPE_METHODS[klass] = begin
+    klass.instance_method(:|)
+  rescue NameError
+    nil
+  end
+
+  # The bitwise OR operator is overloaded to force the creation and evaluation
+  # of a pipeline whose first element is not a pipeline, but whose second and
+  # further are.
+  #
+  # For any other case (i.e. a case where Welder::Pipeline is not involved),
+  # the behavior remains the same. Thus, there is no way for this extension
+  # to affect the rest of the application
+  #
+  # @param other [*] second argument for the pipeline operator
+  #
+  # @return [*] an evaluated pipeline (see conditions above) or the expected
+  #   behavior for arbitrary objects
+  klass.class_eval <<EOF
+    def |(other)
+      if other.is_a?(Welder::Pipeline) && !is_a?(Welder::Pipeline)
+        return other.call(self)
+      end
+
+      WELDER_SAVED_PIPE_METHODS[#{klass}].bind(self).call(other) if WELDER_SAVED_PIPE_METHODS[#{klass}]
+    end
+EOF
+end

data/lib/welder/support/callable_handler.rb

@@ -0,0 +1,27 @@
+module Welder
+  module Support
+    # A domain error indicating that there was an attempt to create
+    # a pipeline out of a non-callable (e.g. a string)
+    CallableExpectedError = Class.new(Exception)
+
+    # Mixin that provides several utilities to handle callable objects
+    module CallableHandler
+      # Assert that a series of values are callable (respond to call)
+      #
+      # @param lambdas [Array<*>] Array of values to check
+      #
+      # @raise [CallableExpectedError] If one or more of the values are
+      #   not callable
+      def callable!(*lambdas)
+        non_callable = lambdas.reject { |lambda| lambda.respond_to?(:call) }
+        unless non_callable.empty?
+          raise(
+            CallableExpectedError,
+            "Expected #{non_callable.map(&:to_s).join(', ')} " \
+        "to respond to 'call'"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/welder/version.rb

@@ -0,0 +1,3 @@
+module Welder
+  VERSION = '0.1.1'.freeze
+end

data/lib/welder.rb

@@ -0,0 +1,10 @@
+# The Welder module provides access to the gem's feature set,
+# and offers a few shortcuts to the main Welder entities
+module Welder
+  # Support module containing mixins and exensions required by
+  # several components of the gem
+  module Support
+  end
+end
+
+require 'welder/pipeline'

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: welder
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Lorenzo Arribas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: |2
+      Define your application's processes in a simple and powerful way
+email: lorenzo.arribas@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/welder.rb
+- lib/welder/pipeline.rb
+- lib/welder/support/callable_handler.rb
+- lib/welder/version.rb
+homepage: http://rubygems.org/gems/welder
+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.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.0
+signing_key: 
+specification_version: 4
+summary: Welder
+test_files: []