tiny_pipe 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 32e78e9a4423c88ebe178b9013eb14a6a33a867c5eba7af4a12f8f19bf4553db
+  data.tar.gz: ca11e754a546566b2caa18840eb419e08649dcd4286b20db00bf1eedfbe2eaaa
+SHA512:
+  metadata.gz: d1e7758f6ce08561adfa405389f13a0695a46e08b12baf44fce035374878f4c59c326bc6d64fa9956d6cc2bebd5f14759f4846e672a67224417e02a27f6aba13
+  data.tar.gz: 000d3635802eb9b81ff006b1bee53838355f0d7934dec4f4c981953c69ef80d405769b9aaf10b5207f597441ef0811fb0327b4ae6790b584aa533e814e77b2b5

data/lib/tiny_pipe.rb

@@ -0,0 +1,91 @@
+# this class wraps a reusable pipeline of Procs, similar to chaining method
+# calls from the Enumerable module, except you can chain long and complicated
+# things all in one object and then reuse that pipeline anywhere. sure you could
+# do basically the same thing by defining a method - not disagreeing there.
+#
+# this was originally built to be the basis of a pipeline for processing complex
+# and inconsistently formatted lines of text from log files.
+#
+# Usage:
+#   let's look at a text processing example where you want to process lines from
+#   a log file and convert it into a more helpful data structure. let's start
+#   with this line from a log file:
+#   2022-11-19T17:34:05.299295Z  25888 INFO loading configuration from ./config.yml\n
+#
+#   ... and let's say that we want to extract the parts of this line into a
+#   Hash, then we might build a pipeline like this:
+#
+#   line = "2022-11-19T17:34:05.299295Z  25888 INFO loading configuration from ./config.yml\n"
+#   p = TinyPipe.new(
+#         line,
+#         [
+#           TinyPipe::MAP_STRIP,                    # the list of procs
+#           ->(line){ line.split(' ', 4),
+#           ->(list){
+#             {
+#               timestamp: DateTime.parse(list[0]),
+#               process_id: list[1].to_i,
+#               log_level: list[2].downcase.to_sym,
+#               log_line: list[3]
+#             }
+#           },
+#         ]
+#       )
+#   
+#   parts = p.pipe(line)
+#
+# If you had a whole log file of lines then you just warp the above with
+# something like this:
+#
+#   results = log_file.each_line.map{|l| p.pipe(l) }
+#   [ ... an array of Hashes ... ]
+#
+# TinyPipe comes with a few common pipeline steps for common text processing
+# cases that you can pass in as elements of the procs parameter to the
+# initialize method.
+class TinyPipe
+  SUPPORTED_INPUT_CLASSES = [String, Array, IO].freeze
+
+  # some pre-build procs for common text processing steps
+  MAP_STRIP = ->(l){ l.strip }
+  MAP_UPCASE = ->(l){ l.upcase }
+  MAP_DOWNCASE = ->(l){ l.downcase }
+
+  JOIN = ->(l){ l.join }
+  JOIN_SPACE = ->(l){ l.join(' ') }
+  JOIN_COMMA = ->(l){ l.join(',') }
+  JOIN_TAB = ->(l){ l.join("\t") }
+  JOIN_PIPE = ->(l){ l.join('|') }
+
+  SPLIT_SPACE = ->(l){ l.split }
+  SPLIT_COMMA = ->(l){ l.split(',') }
+  SPLIT_TAB = ->(l){ l.split("\t") }
+  SPLIT_PIPE = ->(l){ l.split('|') }
+
+  FIELD_FIRST = ->(l){ l.first }
+  FIELD_LAST = ->(l){ l.last }
+
+  SELECT_EMPTY = ->(l){ l.empty? ? l : nil }
+  REJECT_EMPTY = ->(l){ l.empty? ? nil : l }
+
+  # procs: the list of procs to be run over the input lines, in the order in
+  #   which they should be run
+  def initialize(procs)
+    @procs = procs
+  end
+
+  # process a single input item, returning the processed item
+  #
+  # NOTE: the pipeline will exit early if any step within the pipeline returns
+  # nil
+  def pipe(item)
+    dup = item.dup
+
+    @procs.each do |p|
+      break if dup.nil?
+      dup = p.call(dup)
+    end
+
+    dup
+  end
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: tiny_pipe
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jeff Lunt
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-11-21 00:00:00.000000000 Z
+dependencies: []
+description: reusable pipelines of Procs, like one tiny level above Enumerable
+email: jefflunt@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tiny_pipe.rb
+homepage: https://github.com/jefflunt/tiny_pipe
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: want reusable Proc-based pipelines, and absolutely nothing else? then this
+  library is for you.
+test_files: []