fall 0.0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f15339eae553d84b9a1535bccf55158dcf4226166351045e8caae18cbdca8eea
+  data.tar.gz: c393bd00a8f670b28976f7a23d3cea46c5984fcb85efd89895e2b7a10997dea5
+SHA512:
+  metadata.gz: 66dffebddc587b01066dfca71b93c596bef8a89e39d37a86f94fb3da2454497c15b64112ebc5350a0244a8f14feb2841b25c0b31a947ec76c78320ba871db1db
+  data.tar.gz: 565d2fa8e2d68f7e402f027064377bb86fdc26bf1464a69b412dd2f1baaae442d90ffb1fce4f36983490a200fb034cf7da7ddb95f9f9cbe751317b1445b873be

data/lib/draft.rb

@@ -0,0 +1,377 @@
+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)

data/lib/fall/version.rb

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

data/lib/fall.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "fall/version"
+
+module Fall
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: fall
+version: !ruby/object:Gem::Version
+  version: 0.0.0.1
+platform: ruby
+authors:
+- " David Gillis"
+bindir: bin
+cert_chain: []
+date: 2025-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An attempt at making CLI-based data processing simpler.
+email:
+- david@flipmine.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/draft.rb
+- lib/fall.rb
+- lib/fall/version.rb
+homepage: https://github.com/gillisd/fall
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/gillisd/fall
+  source_code_uri: https://github.com/gillisd/fall
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.6
+specification_version: 4
+summary: A CLI-based stream processing utility
+test_files: []