kiba 2.0.0 → 4.0.0

data/bin/kiba

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative '../lib/kiba/cli'
-
-Kiba::Cli.run(ARGV)

data/lib/kiba/cli.rb

@@ -1,16 +0,0 @@
-require 'kiba'
-
-module Kiba
-  class Cli
-    def self.run(args)
-      unless args.size == 1
-        puts 'Syntax: kiba your-script.etl'
-        exit(-1)
-      end
-      filename = args[0]
-      script_content = IO.read(filename)
-      job_definition = Kiba.parse(script_content, filename)
-      Kiba.run(job_definition)
-    end
-  end
-end

data/lib/kiba/runner.rb

@@ -1,78 +0,0 @@
-module Kiba
-  module Runner
-    extend self
-
-    # allow to handle a block form just like a regular transform
-    class AliasingProc < Proc
-      alias_method :process, :call
-    end
-
-    def run(control)
-      # TODO: add a dry-run (not instantiating mode) to_instances call
-      # that will validate the job definition from a syntax pov before
-      # going any further. This could be shared with the parser.
-      run_pre_processes(control)
-      process_rows(
-        to_instances(control.sources),
-        to_instances(control.transforms, true),
-        destinations = to_instances(control.destinations)
-      )
-      close_destinations(destinations)
-      # TODO: when I add post processes as class, I'll have to add a test to
-      # make sure instantiation occurs after the main processing is done (#16)
-      run_post_processes(control)
-    end
-
-    def run_pre_processes(control)
-      to_instances(control.pre_processes, true, false).each(&:call)
-    end
-
-    def run_post_processes(control)
-      to_instances(control.post_processes, true, false).each(&:call)
-    end
-
-    def close_destinations(destinations)
-      destinations
-      .find_all { |d| d.respond_to?(:close) }
-      .each(&:close)
-    end
-
-    def process_rows(sources, transforms, destinations)
-      sources.each do |source|
-        source.each do |row|
-          transforms.each do |transform|
-            row = transform.process(row)
-            break unless row
-          end
-          next unless row
-          destinations.each do |destination|
-            destination.write(row)
-          end
-        end
-      end
-    end
-
-    # not using keyword args because JRuby defaults to 1.9 syntax currently
-    def to_instances(definitions, allow_block = false, allow_class = true)
-      definitions.map do |definition|
-        to_instance(
-          *definition.values_at(:klass, :args, :block),
-          allow_block, allow_class
-        )
-      end
-    end
-
-    def to_instance(klass, args, block, allow_block, allow_class)
-      if klass
-        fail 'Class form is not allowed here' unless allow_class
-        klass.new(*args)
-      elsif block
-        fail 'Block form is not allowed here' unless allow_block
-        AliasingProc.new(&block)
-      else
-        # TODO: support block passing to a class form definition?
-        fail 'Class and block form cannot be used together at the moment'
-      end
-    end
-  end
-end

data/test/common/runner.rb

@@ -1,137 +0,0 @@
-require 'minitest/mock'
-require_relative '../support/test_enumerable_source'
-
-module SharedRunnerTests
-  def kiba_run(job)
-    Kiba.run(job)
-  end
-
-  def rows
-    @rows ||= [
-      { identifier: 'first-row' },
-      { identifier: 'second-row' }
-    ]
-  end
-  
-  def control
-    @control ||= begin
-      control = Kiba::Control.new
-      # this will yield a single row for testing
-      control.sources << {
-        klass: TestEnumerableSource,
-        args: [rows]
-      }
-      control
-    end
-  end
-  
-  def test_block_transform_processing
-    # is there a better way to assert a block was called in minitest?
-    control.transforms << { block: lambda { |r| @called = true; r } }
-    kiba_run(control)
-    assert_equal true, @called
-  end
-
-  def test_dismissed_row_not_passed_to_next_transform
-    @called = nil
-    control.transforms << { block: lambda { |_| nil } }
-    control.transforms << { block: lambda { |_| @called = true; nil } }
-    kiba_run(control)
-    assert_nil @called
-  end
-
-  def test_post_process_runs_once
-    assert_equal 2, rows.size
-    @called = 0
-    control.post_processes << { block: lambda { @called += 1 } }
-    kiba_run(control)
-    assert_equal 1, @called
-  end
-
-  def test_post_process_not_called_after_row_failure
-    @called = nil
-    control.transforms << { block: lambda { |_| fail 'FAIL' } }
-    control.post_processes << { block: lambda { @called = true } }
-    assert_raises(RuntimeError, 'FAIL') { kiba_run(control) }
-    assert_nil @called
-  end
-  
-  def test_pre_process_runs_once
-    assert_equal 2, rows.size
-    @called = 0
-    control.pre_processes << { block: lambda { @called += 1 } }
-    kiba_run(control)
-    assert_equal 1, @called
-  end
-
-  def test_pre_process_runs_before_source_is_instantiated
-    calls = []
-
-    mock_source_class = MiniTest::Mock.new
-    mock_source_class.expect(:new, TestEnumerableSource.new([1, 2, 3])) do
-      calls << :source_instantiated
-    end
-
-    control = Kiba::Control.new
-    control.pre_processes << { block: lambda { calls << :pre_processor_executed } }
-    control.sources << { klass: mock_source_class }
-    kiba_run(control)
-
-    assert_equal [:pre_processor_executed, :source_instantiated], calls
-    assert_mock mock_source_class
-  end
-  
-  def test_no_error_raised_if_destination_close_not_implemented
-    # NOTE: this fake destination does not implement `close`
-    destination_instance = MiniTest::Mock.new
-
-    mock_destination_class = MiniTest::Mock.new
-    mock_destination_class.expect(:new, destination_instance)
-    
-    control = Kiba::Control.new
-    control.destinations << { klass: mock_destination_class }
-    kiba_run(control)
-    assert_mock mock_destination_class
-  end
-  
-  def test_destination_close_called_if_defined
-    destination_instance = MiniTest::Mock.new
-    destination_instance.expect(:close, nil)
-    mock_destination_class = MiniTest::Mock.new
-    mock_destination_class.expect(:new, destination_instance)
-
-    control = Kiba::Control.new
-    control.destinations << { klass: mock_destination_class }
-    kiba_run(control)
-    assert_mock destination_instance
-    assert_mock mock_destination_class
-  end
-  
-  def test_use_next_to_exit_early_from_block_transform
-    assert_equal 2, rows.size
-
-    # calling "return row" from a block is forbidden, but you can use "next" instead
-    b = lambda do |row|
-      if row.fetch(:identifier) == 'first-row'
-        # demonstrate how to remove a row from the pipeline via next
-        next
-      else
-        # demonstrate how you can reformat via next
-        next({new_identifier: row.fetch(:identifier)})
-      end
-      fail "This should not be called"
-    end
-    control.transforms << { block: b }
-
-    # keep track of the rows
-    @remaining_rows = []
-    checker = lambda { |row| @remaining_rows << row; row }
-    control.transforms << { block: checker }
-
-    kiba_run(control)
-    
-    # the first row should have been removed
-    # and the second row should have been reformatted
-    assert_equal [{new_identifier: 'second-row'}], @remaining_rows
-  end
-end

data/test/fixtures/bogus.etl

@@ -1,2 +0,0 @@
-# this should fail because we have an unknown class
-source UnknownThing

data/test/fixtures/namespace_conflict.etl

@@ -1,9 +0,0 @@
-fail "Context should not be visible without Kiba namespace" if defined?(Context)
-fail "Control should not be visible without Kiba namespace" if defined?(Control)
-fail "Parser should not be visible without Kiba namespace" if defined?(Parser)
-fail "Config should not be visible without Kiba namespace" if defined?(DSLExtensions::Config)
-
-# verify Kiba config (namespaced under Kiba::DSLExtensions::Config)
-# isn't causing troubles to implementers using a top-level DSLExtensions module
-require_relative 'some_extension'
-extend DSLExtensions::SomeExtension

data/test/fixtures/some_extension.rb

@@ -1,4 +0,0 @@
-module DSLExtensions
-  module SomeExtension
-  end
-end

data/test/fixtures/valid.etl

@@ -1 +0,0 @@
-# this does nothing

data/test/test_cli.rb

@@ -1,21 +0,0 @@
-require_relative 'helper'
-require 'kiba/cli'
-
-class TestCli < Kiba::Test
-  def test_cli_launches
-    Kiba::Cli.run([fixture('valid.etl')])
-  end
-
-  def test_cli_reports_filename_and_lineno
-    exception = assert_raises(NameError) do
-      Kiba::Cli.run([fixture('bogus.etl')])
-    end
-
-    assert_match(/uninitialized constant(.*)UnknownThing/, exception.message)
-    assert_includes exception.backtrace.to_s, 'test/fixtures/bogus.etl:2:in'
-  end
-
-  def test_namespace_conflict
-    Kiba::Cli.run([fixture('namespace_conflict.etl')])
-  end
-end

data/test/test_runner.rb

@@ -1,6 +0,0 @@
-require_relative 'helper'
-require_relative 'common/runner'
-
-class TestRunner < Kiba::Test
-  include SharedRunnerTests
-end