fall 0.0.0.1 → 0.0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f15339eae553d84b9a1535bccf55158dcf4226166351045e8caae18cbdca8eea
-  data.tar.gz: c393bd00a8f670b28976f7a23d3cea46c5984fcb85efd89895e2b7a10997dea5
+  metadata.gz: b82c155af7534aac00b7de737df75c664d1ea0d36040deb15b6d070814c0efd5
+  data.tar.gz: 047eced7160cd08676f866e75607387cc692fd817c1aeab4d0446e50fbd02432
 SHA512:
-  metadata.gz: 66dffebddc587b01066dfca71b93c596bef8a89e39d37a86f94fb3da2454497c15b64112ebc5350a0244a8f14feb2841b25c0b31a947ec76c78320ba871db1db
-  data.tar.gz: 565d2fa8e2d68f7e402f027064377bb86fdc26bf1464a69b412dd2f1baaae442d90ffb1fce4f36983490a200fb034cf7da7ddb95f9f9cbe751317b1445b873be
+  metadata.gz: f03f3f0d8b4499e57efed80f8ce29ffefca323cbae6bb9780520bdaffd97d472005f6c7d11f71dd8f18f0bd9ff59d11c1e53a55e7f733c29718c8d21a066ce74
+  data.tar.gz: a5dcebb13c3460e1f8062290cf79c0e5a3e193a9d3cc0a6b9d158f00b3792b55950b2a5f78d48ad8c4faa64549d685acb2acf7190527480cc0e7fbd0f1af58b0

data/exe/fall

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+root_path = File.expand_path('../', __dir__)
+require File.join(root_path, 'lib', 'fall.rb')
+require 'optparse'
+
+options = {
+  input_delimiter: ' ',
+  output_delimiter: ' ',
+  requirements: [],
+}
+
+OptionParser.new do |opts|
+  opts.banner = 'Usage: fall [options]'
+
+  opts.on('-i', '--input-delimiter DELIMITER', 'Input delimiter') do |delimiter|
+    options[:input_delimiter] = delimiter
+  end
+
+  opts.on('-o', '--output-delimiter DELIMITER', 'Output delimiter') do |delimiter|
+    options[:output_delimiter] = delimiter
+  end
+
+  opts.on('-r', '--require LIB', 'Require a gem or file') do |lib|
+    options[:requirements] << lib
+  end
+end.parse!
+
+options => { input_delimiter:, output_delimiter:, requirements: }
+
+requirements.each do |lib|
+  require lib
+end
+
+command = ARGV.shift
+enum = ARGF.each_line
+           .map(&:chomp)
+           .map { |row| row.split(input_delimiter) }
+           .lazy
+
+parser = Fall::Parser.new(command)
+operations = parser.parse
+pipeline = Fall::Pipeline.new(enum)
+
+operations.each do |operation|
+  pipeline.add_operation(operation)
+end
+
+pipeline.to_enum
+        .map { _1.respond_to?(:join) ? _1.join(output_delimiter) : _1 }
+        .each { puts _1 }

data/lib/fall/ext/enumerable.rb

@@ -0,0 +1,11 @@
+module Fall
+  module Ext
+    module Enumerable
+      def window_timestamps(window_size_seconds = 3600)
+        group_by { |ts| (ts.to_time.to_i / window_size_seconds) * window_size_seconds }
+          .transform_keys { |ts| Time.at(ts) }
+          .map { |k, v| { k => v } }
+      end
+    end
+  end
+end

data/lib/fall/ext/enumerator/lazy.rb

@@ -0,0 +1,11 @@
+module Fall
+  module Ext
+    module Enumerator
+      class Lazy
+        def stream
+          self
+        end
+      end
+    end
+  end
+end

data/lib/fall/helpers.rb

@@ -0,0 +1,35 @@
+module Fall
+  module Helpers
+    def deflate(...)
+      Zlib::Deflate.deflate(...)
+    end
+
+    def inflate(...)
+      Zlib::Inflate.inflate(...)
+    end
+
+    def deflate!(...)
+      Zlib::Deflate.deflate(...).force_encoding('ASCII-8BIT')
+    end
+
+    def inflate!(...)
+      Zlib::Inflate.inflate(...).force_encoding('ASCII-8BIT')
+    end
+
+    def deflate64(...)
+      Base64.strict_encode64(deflate(...))
+    end
+
+    def inflate64(foo)
+      inflate(Base64.strict_decode64(foo))
+    end
+
+    def inflate64bed(...)
+      Bed.infer(inflate64(...))
+    end
+
+    def parsedate(...)
+      DateTime.parse(...)
+    end
+  end
+end

data/lib/fall/parser.rb

@@ -0,0 +1,67 @@
+module Fall
+  class Parser
+    def initialize(string)
+      @string = string
+    end
+
+    def stages
+      @string.split('|')
+             .map(&:strip)
+    end
+
+    def parse
+      stages
+        .then { identify_streams(_1) }
+        .then { consolidate_streams(_1) }
+        .then { create_operations(_1) }
+    end
+
+    private
+
+    def create_operations(tuples)
+      result = tuples.reduce([]) do |accum, (type, stages)|
+        klass = operation_klass(type)
+        operations = stages.map { klass.from_code(_1) }
+        [*accum, *operations]
+      end
+
+      result
+    end
+
+    def operation_klass(type)
+      case type
+      in :record
+        RecordOperation
+      in :stream
+        StreamOperation
+      else
+        raise ArgumentError, 'Invalid operation type'
+      end
+
+    end
+
+    def identify_streams(operations)
+      case operations
+      in [/^stream/] => stream
+        [:stream, [stream]]
+      in [/^stream/ => stream, *rest]
+        [[:stream, [stream]], *identify_streams(rest)]
+      in [*pre, /^stream/ => stream]
+        [*identify_streams(pre), [:stream, [stream]]]
+      in [*pre, /^stream/ => stream, *rest]
+        [*identify_streams(pre), [:stream, [stream]], *identify_streams(rest)]
+      else
+        [[:record, [*operations]]]
+      end
+    end
+
+    def consolidate_streams(operations)
+      case operations
+      in [*pre, [:stream, op_1], [:stream, op_2], *post]
+        consolidate_streams([*pre, [:stream, [*op_1, *op_2]], *post])
+      else
+        operations
+      end
+    end
+  end
+end

data/lib/fall/pipeline.rb

@@ -0,0 +1,38 @@
+module Fall
+  class Pipeline
+    def initialize(source = [].lazy)
+      @source = source
+      @currently_building_pipeline = nil
+    end
+
+    def add_operation(operation)
+      operation.add_to_pipeline(self)
+    end
+
+    def add_record_operation(operation)
+      ensure_current_stage_type(RecordOperationPipeline)
+      @currently_building_pipeline.add_operation(operation)
+    end
+
+    def add_stream_operation(operation)
+      ensure_current_stage_type(StreamOperationPipeline)
+      @currently_building_pipeline.add_operation(operation)
+    end
+
+    def to_enum
+      @currently_building_pipeline.to_enum
+    end
+
+    private
+
+    def ensure_current_stage_type(expected_pipeline_klass)
+      seal_current_stage unless @currently_building_pipeline in ^expected_pipeline_klass | nil
+      @currently_building_pipeline ||= expected_pipeline_klass.new(@source.to_enum)
+    end
+
+    def seal_current_stage
+      @source = @currently_building_pipeline.to_enum
+      @currently_building_pipeline = nil
+    end
+  end
+end

data/lib/fall/record.rb

@@ -0,0 +1,90 @@
+module Fall
+  class Record
+    include Fall::Helpers
+
+    attr_reader :value
+
+    alphabet = 'abcdefghijklmnopqrstuvwxyz'
+    alphabet.chars.each_with_index do |char, index|
+      define_method char do
+        case @value
+        in Enumerable
+          self.class.wrap(self.value[index]).value
+        else
+          self.value
+        end
+      end
+    end
+
+    def self.wrap(value)
+      case value
+      in Record
+        value
+      else
+        new(value)
+      end
+    end
+
+    private_class_method :new
+
+    def initialize(value)
+      @value = value
+    end
+
+    def zip(other)
+      to_ary.zip(other.to_ary)
+    end
+
+    def discard?
+      case value
+      in :__discard then true
+      in [*, :__discard, *] then true
+      else false
+      end
+    end
+
+    def value
+      @parsed_value ||= (
+        case @value
+        in /^[1-9][0-9]*$/
+          @value.to_i
+        in /^[0-9\.]+$/
+          @value.to_f
+        in /{.*?".*?".*?}/
+          JSON.parse(@value)
+        else
+          @value
+        end
+      )
+    end
+
+    def to_ary
+      case value
+      in Array
+        value
+      else
+        [value]
+      end
+    end
+
+    alias to_a to_ary
+
+    private
+
+    def method_missing(method_name, *args, &block)
+      if @value.respond_to?(method_name)
+        @value.public_send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      if @value.respond_to?(method_name)
+        true
+      else
+        super
+      end
+    end
+  end
+end

data/lib/fall/record_operation.rb

@@ -0,0 +1,50 @@
+module Fall
+  class RecordOperation
+    attr_reader :func
+
+    def self.from_code(code)
+      func = instance_eval <<~RUBY
+        lambda do |record|
+          return record if record.discard?
+
+          result = Record.wrap(record.instance_eval { [#{code}] })
+
+         filtered = result.zip(record).reject { _1.size != 2 }.map do |result, original_record|
+                         case result
+                         in true then original_record
+                         in false then :__discard
+                         else result
+                        end
+                      end 
+         Record.wrap(filtered)
+         end
+      RUBY
+      new(func)
+    end
+
+    def initialize(func)
+      @func = func
+    end
+
+    def add_to_pipeline(pipeline)
+      pipeline.add_record_operation(self)
+    end
+
+    def call(record)
+      @func.call(record)
+    end
+
+    def chain(operation)
+      identity = ->(i) { i }
+
+      composed = (func >> (operation.func >> identity))
+      self.class.new(composed)
+    end
+
+    alias >> chain
+
+    def to_proc
+      @func
+    end
+  end
+end

data/lib/fall/record_operation_pipeline.rb

@@ -0,0 +1,24 @@
+module Fall
+  class RecordOperationPipeline
+    def initialize(source)
+      @source = source
+      @operation = RecordOperation.new(->(args) { args })
+    end
+
+    def add_operation(operation)
+      @operation = @operation.chain(operation)
+    end
+
+    alias add_record_operation add_operation
+
+    def to_enum(...)
+      @source
+        .lazy
+        .map { |value| Record.wrap(value) }
+        .map { |record| @operation.call(record) }
+        .reject(&:discard?)
+        .map(&:value)
+        .to_enum(...)
+    end
+  end
+end

data/lib/fall/stream_operation.rb

@@ -0,0 +1,40 @@
+module Fall
+  class StreamOperation
+    attr_reader :func
+
+    def self.from_code(code)
+      func = instance_eval <<~RUBY
+        proc do |stream|
+          #{code}
+        end
+      RUBY
+      new(func)
+    end
+
+    def initialize(func)
+      @func = func
+    end
+
+    def add_to_pipeline(pipeline)
+      pipeline.add_stream_operation(self)
+    end
+
+    def to_proc
+      @func
+    end
+
+    def call(stream)
+      stream.map { Record.wrap(_1) }
+            .then {
+              @func.call(_1)
+            }
+    end
+
+    def chain(operation)
+      identity = ->(i) { i }
+
+      composed = (func >> (operation.func >> identity))
+      self.class.new(composed)
+    end
+  end
+end

data/lib/fall/stream_operation_pipeline.rb

@@ -0,0 +1,18 @@
+module Fall
+  class StreamOperationPipeline
+    def initialize(source)
+      @source = source
+      @operation = StreamOperation.new(->(stream) { stream })
+    end
+
+    def add_operation(operation)
+      @operation = @operation.chain(operation)
+    end
+
+    alias add_stream_operation add_operation
+
+    def to_enum
+      @operation.call(@source)
+    end
+  end
+end

data/lib/fall/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fall
-  VERSION = "0.0.0.1"
+  VERSION = "0.0.0.3"
 end

data/lib/fall.rb

@@ -1,7 +1,20 @@
 # frozen_string_literal: true
 
-require_relative "fall/version"
+require 'zeitwerk'
+require 'active_support/core_ext/hash'
+require 'base64'
+require 'zlib'
+require 'date'
+require '~/repos/bed/lib/bed.rb'
+
+RubyVM::YJIT.enable rescue nil
+loader = Zeitwerk::Loader.for_gem
+loader.setup
 
 module Fall
   class Error < StandardError; end
 end
+
+module Enumerable
+  include Fall::Ext::Enumerable
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: fall
 version: !ruby/object:Gem::Version
-  version: 0.0.0.1
+  version: 0.0.0.3
 platform: ruby
 authors:
 - " David Gillis"
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2025-04-06 00:00:00.000000000 Z
+date: 2025-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -72,8 +72,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/draft.rb
+- exe/fall
 - lib/fall.rb
+- lib/fall/ext/enumerable.rb
+- lib/fall/ext/enumerator/lazy.rb
+- lib/fall/helpers.rb
+- lib/fall/parser.rb
+- lib/fall/pipeline.rb
+- lib/fall/record.rb
+- lib/fall/record_operation.rb
+- lib/fall/record_operation_pipeline.rb
+- lib/fall/stream_operation.rb
+- lib/fall/stream_operation_pipeline.rb
 - lib/fall/version.rb
 homepage: https://github.com/gillisd/fall
 licenses:

data/lib/draft.rb

@@ -1,377 +0,0 @@
-require 'active_support/core_ext/hash'
-require 'base64'
-require 'zlib'
-require 'date'
-require '~/repos/bed/lib/bed.rb'
-
-options = { delimiter: ' ', code: nil }
-
-RubyVM::YJIT.enable rescue nil
-
-# OptionParser.new do |o|
-#   o.on('-d DELIMITER', '--delimiter DELIMITER') do |d|
-#     options[:delimiter] = d
-#   end
-#
-#   o.on('-e CODE', '--eval CODE') do |e|
-#     options[:code] = e
-#   end
-#
-# end.parse!
-
-def deflate(...)
-  Zlib::Deflate.deflate(...)
-end
-
-def inflate(...)
-  Zlib::Inflate.inflate(...)
-end
-
-def deflate!(...)
-  Zlib::Deflate.deflate(...).force_encoding('ASCII-8BIT')
-end
-
-def inflate!(...)
-  Zlib::Inflate.inflate(...).force_encoding('ASCII-8BIT')
-end
-
-def deflate64(...)
-  Base64.strict_encode64(deflate(...))
-end
-
-def inflate64(...)
-  inflate(Base64.decode64(...))
-end
-
-def inflate64bed(...)
-  Bed.infer(inflate64(...))
-end
-
-module Enumerable
-  def window_timestamps(window_size_seconds = 3600)
-    group_by { |ts| (ts.to_time.to_i / window_size_seconds) * window_size_seconds }
-      .transform_keys { |ts| Time.at(ts) }
-      .map { |k, v| { k => v } }
-  end
-end
-
-def parsedate(...)
-  DateTime.parse(...)
-end
-
-alphabet = 'abcdefghijklmnopqrstuvwxyz'
-Array.class_eval do
-  alphabet.chars.each_with_index do |char, index|
-    define_method char do
-      self[index]
-    end
-  end
-end
-
-Enumerator::Lazy.class_eval do
-  define_method :stream do
-    self
-  end
-end
-
-def lines(enum = ARGF.readlines.lazy)
-  enum
-end
-
-def identify_streams(operations)
-  case operations
-  in [/^stream/] => stream
-    [:stream, [stream]]
-  in [/^stream/ => stream, *rest]
-    [[:stream, [stream]], *identify_streams(rest)]
-  in [*pre, /^stream/ => stream]
-    [*identify_streams(pre), [:stream, [stream]]]
-  in [*pre, /^stream/ => stream, *rest]
-    [*identify_streams(pre), [:stream, [stream]], *identify_streams(rest)]
-  else
-    [[:record, [*operations]]]
-  end
-end
-
-def consolidate_streams(operations)
-  case operations
-  in [*pre, [:stream, op_1], [:stream, op_2], *post]
-    consolidate_streams([*pre, [:stream, [*op_1, *op_2]], *post])
-  else
-    operations
-  end
-end
-
-def groupup(code)
-  code = code.split('|')
-             .map(&:strip)
-
-  consolidate_streams(identify_streams(code))
-end
-
-class Transformer
-  attr_accessor :source, :func
-
-  def initialize(source:, func:)
-    @source = source
-    @func = func
-  end
-
-  def to_enum(...)
-    source.map { |*record| func.call(*record) }
-          .reject do |args|
-      case args
-      in [*, :__discard, *] then true
-      in :__discard then true
-      else false
-      end
-    end
-          .to_enum(...)
-  end
-end
-
-class StreamOperation
-  attr_reader :func
-
-  def self.from_code(code)
-    func = instance_eval <<~RUBY
-      proc do |stream|
-        #{code}
-      end
-    RUBY
-    new(func)
-  end
-
-  def initialize(func)
-    @func = func
-  end
-
-  def add_to_pipeline(pipeline)
-    pipeline.add_stream_operation(pipeline)
-  end
-
-  def to_proc
-    @func
-  end
-
-  def call(*args)
-    @func.call(*args)
-  end
-
-  def chain(operation)
-    identity = ->(i) { i }
-
-    composed = (func >> (operation.func >> identity))
-    self.class.new(composed)
-  end
-end
-
-class RecordOperation
-  attr_reader :func
-
-  def self.from_code(code)
-    func = instance_eval <<~RUBY
-      proc do |*args|
-
-        results = args.flatten(1).instance_eval { [#{code}] }
-
-        foo = results.zip(args).reject { _1.size != 2 }.map do |result, arg|
-                       case result
-                       in true then arg
-                       in false then :__discard
-                       else result
-                      end
-                    end 
-       end
-    RUBY
-    new(func)
-  end
-
-  def initialize(func)
-    @func = func
-  end
-
-  def add_to_pipeline(pipeline)
-    pipeline.add_record_operation(pipeline)
-  end
-
-  def call(*args)
-    @func.call(*args)
-  end
-
-  def chain(operation)
-    identity = ->(i) { i }
-
-    composed = (func >> (operation.func >> identity))
-    self.class.new(composed)
-  end
-
-  alias >> chain
-
-  def to_proc
-    @func
-  end
-end
-
-class RecordOperationPipeline
-  def initialize(source)
-    @source = source
-    @operation = RecordOperation.new(->(*args) { args })
-  end
-
-  def add_operation(operation)
-    @operation = @operation.chain(operation)
-  end
-
-  def to_enum(...)
-    @source.map { |*record| @operation.call(*record) }
-           .reject do |args|
-      case args
-      in [*, :__discard, *] then true
-      in :__discard then true
-      else false
-      end
-    end
-           .to_enum(...)
-  end
-end
-
-class StreamOperationPipeline
-  def initialize(source)
-    @source = source
-    @operation = StreamOperation.new(->(stream) { stream })
-  end
-
-  def add_operation(operation)
-    @operation = @operation.chain(operation)
-  end
-
-  def to_enum
-    @operation.call(@source)
-  end
-end
-
-class Pipeline
-  def initialize(source = [].lazy)
-    @source = source
-    @currently_building_pipeline = nil
-  end
-
-  def add_operation(operation)
-    operation.add_to_pipeline(self)
-  end
-
-  def add_record_operation(operation)
-    ensure_current_stage_type(RecordOperationPipeline)
-    @currently_building_pipeline.add_operation(operation)
-  end
-
-  def add_stream_operation(operation)
-    ensure_current_stage_type(StreamOperationPipeline)
-    @currently_building_pipeline.add_operation(operation)
-  end
-
-  def to_enum
-    @currently_building_pipeline.to_enum
-  end
-
-  private
-
-  def ensure_current_stage_type(expected_pipeline_klass)
-    seal_current_stage unless @currently_building_pipeline in ^expected_pipeline_klass | nil
-    @currently_building_pipeline ||= expected_pipeline_klass.new(@source.to_enum)
-  end
-
-  def seal_current_stage
-    @source = @currently_building_pipeline.to_enum
-    @currently_building_pipeline = nil
-  end
-end
-
-Processor = lambda do |enum, **input_options|
-
-  options.merge(input_options) => { code:, delimiter: }
-  operations = groupup code
-
-  lams = operations.map do |type, pipeline|
-    composed = (
-      case type
-      in :record
-        ops = pipeline.map do |op|
-          proc do |errors, it|
-            code = "[#{op}].flatten(1)"
-            if code
-              begin
-                [errors, it.instance_eval(code)]
-              rescue => e
-                warn e
-                errors << e.full_message
-                [errors, it]
-              end
-            else
-              [errors, it]
-            end
-          end
-        end
-        identity = ->(i) { i }
-        composed = ops.reverse.reduce(identity) { |accum, fn| fn >> accum }
-        composed.curry(2)[[]]
-      in :stream
-        ops = pipeline.map do |op|
-          proc do |stream|
-            begin
-              stream = [stream] unless stream.is_a?(Enumerator)
-              stream.instance_eval(op)
-            rescue => e
-              warn e
-            end
-          end
-        end
-        identity = ->(i) { i }
-        ops.reverse.reduce(identity) { |accum, fn| fn >> accum }
-      else
-        raise "Unknown type: #{type}"
-      end
-    )
-    [type, composed]
-  end
-
-  enum
-    .map(&:chomp)
-    .map { |line| line.split(options[:delimiter]) }
-    .map { |line| line.reduce([0, {}]) { |(index, hash), field| hash[alphabet[index]] = field; [index + 1, hash] } }
-    .map(&:last)
-    .map do |i|
-    Bed.infer(i)
-  end
-    .then { |enum|
-      lams.reduce(enum) { |accum, (type, lam)|
-        case type
-        in :record
-          accum.map(&lam).map(&:last)
-        in :stream
-          [[lam.call(accum.flat_map(&:last))].flatten(1)]
-        else
-          raise "Unknown type: #{type}"
-        end
-      }
-    }
-    .then { |obj|
-      case obj
-      in [Array => arr]
-        arr
-      in [[Enumerator::Lazy => lazy]]
-        lazy
-      in [Enumerator::Lazy => lazy]
-        lazy
-      else
-        obj
-      end
-    }
-  # .map do |record|
-  # record.join(delimiter) if record.respond_to?(:join)
-  # puts record
-  # end
-end
-
-# process.call(options, ARGF.each_line.lazy)