kiba 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 502470fc246c67daaa681ca78fb5337899cca7fa
+  data.tar.gz: a125ff166156c79e5a0b0d67bf9dfb980b7e0dba
+SHA512:
+  metadata.gz: ccefac21a401ca860d34c89fdda2473e5a30b51d61223fc8cced50165786f41f328014144bd31486522db34c4e801190060d250cad20408745c691ca937ea1ea
+  data.tar.gz: 6c0bee993d99fdec14504e6811549af4dce40cd8930be951a142f8793da69956283ed7ccf6acececa4a6a108e9e9f424d2190b6ba7d9e45f55207b3ee240418d

data/.gitignore

@@ -0,0 +1,2 @@
+.ruby-version
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.2
+  - 2.1
+  - 2.0
+  - jruby

data/Changes.md

@@ -0,0 +1,4 @@
+0.5.0
+-----
+
+- Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,268 @@
+Writing reliable, concise, well-tested & maintainable data-processing code is tricky.
+
+Kiba lets you define and run such high-quality ETL jobs, using Ruby.
+
+**Note: this is EARLY WORK - the API/syntax may change at any time.**
+
+[![Build Status](https://travis-ci.org/thbar/kiba.svg?branch=master)](https://travis-ci.org/thbar/kiba) [![Code Climate](https://codeclimate.com/github/thbar/kiba/badges/gpa.svg)](https://codeclimate.com/github/thbar/kiba) [![Dependency Status](https://gemnasium.com/thbar/kiba.svg)](https://gemnasium.com/thbar/kiba)
+
+## How do you define ETL jobs with Kiba?
+
+Kiba provides you with a DSL to define ETL jobs:
+
+```ruby
+# declare a ruby method here, for quick reusable logic
+def parse_french_date(date)
+  Date.strptime(date, '%d/%m/%Y')
+end
+
+# or better, include a ruby file which loads reusable assets
+# eg: commonly used sources / destinations / transforms, under unit-test
+require_relative 'common'
+
+# declare a source where to take data from (you implement it - see notes below)
+source MyCsvSource, 'input.csv'
+
+# declare a row transform to process a given field
+transform do |row|
+  row[:birth_date] = parse_french_date(row[:birth_date])
+  # return to keep in the pipeline
+  row
+end
+
+# declare another row transform, dismissing rows conditionally by returning nil
+transform do |row|
+  row[:birth_date].year < 2000 ? row : nil
+end
+
+# declare a row transform as a class, which can be tested properly
+transform ComplianceCheckTransform, eula: 2015
+
+# before declaring a definition, maybe you'll want to retrieve credentials
+config = YAML.load(IO.read('config.yml'))
+
+# declare a destination - like source, you implement it (see below)
+destination MyDatabaseDestination, config['my_database']
+
+# declare a post-processor: a block called after all rows are successfully processed
+post_process do
+  # do something
+end
+```
+
+The combination of sources, transforms, destinations and post-processors defines the data processing pipeline.
+
+Note: you are advised to store your ETL definitions as files with the extension `.etl` (rather than `.rb`). This will make sure you do not end up loading them by mistake from another component (eg: a Rails app).
+
+## How do you run your ETL jobs?
+
+You can use the provided command-line:
+
+```
+bundle exec kiba my-data-processing-script.etl
+```
+
+This command essentially starts a two-step process:
+
+```ruby
+script_content = IO.read(filename)
+# pass the filename to get for line numbers on errors
+job_definition = Kiba.parse(script_content, filename)
+Kiba.run(job_definition)
+```
+
+`Kiba.parse` evaluates your ETL Ruby code to register sources, transforms, destinations and post-processors in a job definition. It is important to understand that you can use Ruby logic at the DSL parsing time. This means that such code is possible, provided the CSV files are available at parsing time:
+
+```ruby
+Dir['to_be_processed/*.csv'].each do |f|
+  source MyCsvSource, file
+end
+```
+
+Once the job definition is loaded, `Kiba.run` will use that information to do the actual row-by-row processing. It currently uses a simple row-by-row, single-threaded processing that will stop at the first error encountered.
+
+## Implementing ETL sources
+
+In Kiba, you are responsible for implementing the sources that do the extraction of data.
+
+Sources are classes implementing:
+- a constructor (to which Kiba will pass the provided arguments in the DSL)
+- the `each` method (which should yield rows one by one)
+
+Rows are usually `Hash` instances, but could be other structures as long as the rest of your pipeline is expecting it.
+
+Since sources are classes, you can (and are encouraged to) unit test them and reuse them.
+
+Here is a simple CSV source:
+
+```ruby
+require 'csv'
+
+class MyCsvSource
+  def initialize(input_file)
+    @csv = CSV.open(input_file, headers: true, header_converters: :symbol)
+  end
+
+  def each
+    @csv.each do |row|
+      yield(row.to_hash)
+    end
+    @csv.close
+  end
+end
+```
+
+## Implementing row transforms
+
+Row transforms can implemented in two ways: as blocks, or as classes.
+
+### Row transform as a block
+
+When writing a row transform as a block, it will be passed the row as parameter:
+
+```ruby
+transform do |row|
+  row[:this_field] = row[:that_field] * 10
+  # make sure to return the row to keep it in the pipeline
+  row
+end
+```
+
+To dismiss a row from the pipeline, simply return `nil` from a transform:
+
+```ruby
+transform { |row| row[:index] % 2 == 0 ? row : nil }
+```
+
+### Row transform as a class
+
+If you implement the transform as a class, it must respond to `process(row)`:
+
+```ruby
+class SamplingTransform
+  def initialize(modulo_value)
+    @modulo_value = modulo_value
+  end
+
+  def process(row)
+    row[:index] % @modulo_value == 0 ? row : nil
+  end
+end
+```
+
+You'll use it this way in your ETL declaration (the parameters will be passed to initialize):
+
+```ruby
+# only keep 1 row over 10
+transform SamplingTransform, 10
+```
+
+Like the block form, it can return `nil` to dismiss the row. The class form allows better testability and reusability across your(s) ETL script(s).
+
+## Implementing ETL destinations
+
+Like sources, destinations are classes that you are providing. Destinations must implement:
+- a constructor (to which Kiba will pass the provided arguments in the DSL)
+- a `write(row)` method that will be called for each non-dismissed row
+- a `close` method that will be called at the end of the processing
+
+Here is an example destination:
+
+```ruby
+require 'csv'
+
+# simple destination assuming all rows have the same fields
+class MyCsvDestination
+  def initialize(output_file)
+    @csv = CSV.open(output_file, 'w')
+  end
+
+  def write(row)
+    unless @headers_written
+      @headers_written = true
+      @csv << row.keys
+    end
+    @csv << row.values
+  end
+
+  def close
+    @csv.close
+  end
+end
+```
+
+## Implementing post-processors
+
+Post-processors are currently blocks, which get called once, after the ETL
+successfully processed all the rows. It won't get called if an error occurred.
+
+```ruby
+count = 0
+
+transform do |row|
+  count += 1
+  row
+end
+
+post_process do
+  Email.send(supervisor_address, "#{count} rows successfully processed")
+end
+```
+
+## Composability, reusability, testability of Kiba components
+
+The way Kiba works makes it easy to create reusable, well-tested ETL components and jobs.
+
+The main reason for this is that a Kiba ETL script can `require` shared Ruby code, which allows to:
+- create well-tested, reusable sources & destinations
+- create macro-transforms as methods, to be reused across sister scripts
+- substitute a component by another (e.g.: try a variant of a destination)
+- use a centralized place for configuration (credentials, IP addresses, etc.)
+
+The fact that the DSL evaluation "runs" the script also allows for simple meta-programming techniques, like pre-reading a source file to extract field names, to be used in transform definitions.
+
+The ability to support that DSL, but also check command line arguments, environment variables and tweak behaviour as needed, or call other/faster specialized tools make Ruby an asset to implement ETL jobs.
+
+Make sure to subscribe to my [Ruby ETL blog](http://thibautbarrere.com) where I'll demonstrate such techniques over time!
+
+## History & Credits
+
+Wow, you're still there? Nice to meet you. I'm [Thibaut](http://thibautbarrere.com), author of Kiba.
+
+I first met the idea of row-based syntax when I started using [Anthony Eden](https://github.com/aeden)'s [Activewarehouse-ETL](https://github.com/activewarehouse/activewarehouse-etl), first published around 2006 (I think), in which Anthony applied the core principles defined by Ralph Kimball in [The Data Warehouse ETL Toolkit](http://www.amazon.com/gp/product/0764567578).
+
+I've been writing and maintaining a number of production ETL systems using Activewarehouse-ETL, then later with an ancestor of Kiba which was named TinyTL.
+
+I took over the maintenance of Activewarehouse-ETL circa 2009/2010, but over time, I could not properly update & document it, given the gradual failure of a large number of dependencies and components. Ultimately in 2014 I had to stop maintaining it, after an already long hiatus.
+
+That said using Activewarehouse-ETL for so long made me realize the row-based processing syntax was great and provided some great assets for maintainability on long time-spans.
+
+Kiba is a completely fresh & minimalistic-on-purpose implementation of that row-based processing pattern.
+
+It is minimalistic to make it more likely that I will be able to maintain it over time.
+
+It makes strong simplicity assumptions (like letting you define the sources, transforms & destinations). MiniTest is an inspiration.
+
+As I developed Kiba, I realize how much this simplicity opens the road for interesting developments such as multi-threaded & multi-processes processing.
+
+Last word: Kiba is 100% sponsored by my company LoGeek SARL (also provider of [WiseCash, a lightweight cash-flow forecasting app](https://www.wisecashhq.com)).
+
+## License
+
+Copyright (c) LoGeek SARL.
+
+Kiba is an Open Source project licensed under the terms of
+the LGPLv3 license.  Please see <http://www.gnu.org/licenses/lgpl-3.0.html>
+for license text.
+
+## Contributing & Legal
+
+Until the API is more stable, I can only accept documentation Pull Requests.
+
+(agreement below borrowed from [Sidekiq Legal](https://github.com/mperham/sidekiq/blob/master/Contributing.md))
+
+By submitting a Pull Request, you disavow any rights or claims to any changes submitted to the Kiba project and assign the copyright of those changes to LoGeek SARL.
+
+If you cannot or do not want to reassign those rights (your employment contract for your employer may not allow this), you should not submit a PR. Open an issue and someone else can do the work.
+
+This is a legal way of saying "If you submit a PR to us, that code becomes ours". 99.9% of the time that's what you intend anyways; we hope it doesn't scare you away from contributing.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/test_*.rb'
+end
+
+task :default => :test

data/bin/kiba

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

data/kiba.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/kiba/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Thibaut Barrère"]
+  gem.email         = ["thibaut.barrere@gmail.com"]
+  gem.description   = gem.summary = "Lightweight ETL for Ruby"
+  gem.homepage      = "http://thbar.github.io/kiba/"
+  gem.license       = "LGPL-3.0"
+  gem.files         = `git ls-files | grep -Ev '^(examples)'`.split("\n")
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.name          = "kiba"
+  gem.require_paths = ["lib"]
+  gem.version       = Kiba::VERSION
+  gem.executables   = ['kiba']
+  
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'awesome_print'
+end

data/lib/kiba.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+require 'kiba/version'
+
+require 'kiba/control'
+require 'kiba/context'
+require 'kiba/parser'
+require 'kiba/runner'
+
+Kiba.extend(Kiba::Parser)
+Kiba.extend(Kiba::Runner)

data/lib/kiba/cli.rb

@@ -0,0 +1,16 @@
+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/context.rb

@@ -0,0 +1,28 @@
+module Kiba
+  class Context
+    def initialize(control)
+      # TODO: forbid access to control from context? use cleanroom?
+      @control = control
+    end
+
+    def source(klass, *initialization_params)
+      @control.sources << {klass: klass, args: initialization_params}
+    end
+
+    def transform(klass = nil, *initialization_params, &block)
+      if klass
+        @control.transforms << {klass: klass, args: initialization_params}
+      else
+        @control.transforms << block
+      end
+    end
+
+    def destination(klass, *initialization_params)
+      @control.destinations << {klass: klass, args: initialization_params}
+    end
+
+    def post_process(&block)
+      @control.post_processes << block
+    end
+  end
+end

data/lib/kiba/control.rb

@@ -0,0 +1,19 @@
+module Kiba
+  class Control
+    def sources
+      @sources ||= []
+    end
+
+    def transforms
+      @transforms ||= []
+    end
+
+    def destinations
+      @destinations ||= []
+    end
+
+    def post_processes
+      @post_processes ||= []
+    end
+  end
+end

data/lib/kiba/parser.rb

@@ -0,0 +1,15 @@
+module Kiba
+  module Parser
+    def parse(source_as_string = nil, source_file = nil, &source_as_block)
+      control = Control.new
+      context = Context.new(control)
+      if source_as_string
+        # this somewhat weird construct allows to remove a nil source_file
+        context.instance_eval(*[source_as_string, source_file].compact)
+      else
+        context.instance_eval(&source_as_block)
+      end
+      control
+    end
+  end
+end

data/lib/kiba/runner.rb

@@ -0,0 +1,44 @@
+module Kiba
+  module Runner
+    def run(control)
+      sources = to_instances(control.sources)
+      destinations = to_instances(control.destinations)
+      transforms = to_instances(control.transforms, true)
+      # not using keyword args because JRuby defaults to 1.9 syntax currently
+      post_processes = to_instances(control.post_processes, true, false)
+
+      sources.each do |source|
+        source.each do |row|
+          transforms.each_with_index do |transform, index|
+            if transform.is_a?(Proc)
+              row = transform.call(row)
+            else
+              row = transform.process(row)
+            end
+            break unless row
+          end
+          next unless row
+          destinations.each do |destination|
+            destination.write(row)
+          end
+        end
+      end
+
+      destinations.each(&:close)
+      post_processes.each(&:call)
+    end
+
+    def to_instances(definitions, allow_block = false, allow_class = true)
+      definitions.map do |d|
+        case d
+        when Proc
+          raise "Block form is not allowed here" unless allow_block
+          d
+        else
+          raise "Class form is not allowed here" unless allow_class
+          d[:klass].new(*d[:args])
+        end
+      end
+    end
+  end
+end

data/lib/kiba/version.rb

@@ -0,0 +1,3 @@
+module Kiba
+  VERSION = "0.5.0"
+end

data/test/fixtures/bogus.etl

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

data/test/fixtures/valid.etl

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

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'kiba'
+
+class Kiba::Test < Minitest::Test
+  extend Minitest::Spec::DSL
+
+  def remove_files(*files)
+    files.each do |file|
+      File.delete(file) if File.exists?(file)
+    end
+  end
+
+  def fixture(file)
+    File.join(File.dirname(__FILE__), 'fixtures', file)
+  end
+end

data/test/support/test_csv_destination.rb

@@ -0,0 +1,21 @@
+require 'csv'
+
+# simple destination, not checking that each row has all the fields
+class TestCsvDestination
+  def initialize(output_file)
+    @csv = CSV.open(output_file, 'w')
+    @headers_written = false
+  end
+
+  def write(row)
+    unless @headers_written
+      @headers_written = true
+      @csv << row.keys
+    end
+    @csv << row.values
+  end
+
+  def close
+    @csv.close
+  end
+end

data/test/support/test_csv_source.rb

@@ -0,0 +1,14 @@
+require 'csv'
+
+class TestCsvSource
+  def initialize(input_file)
+    @csv = CSV.open(input_file, headers: true, header_converters: :symbol)
+  end
+
+  def each
+    @csv.each do |row|
+      yield(row.to_hash)
+    end
+    @csv.close
+  end
+end

data/test/support/test_enumerable_source.rb

@@ -0,0 +1,11 @@
+class TestEnumerableSource
+  def initialize(enumerable)
+    @enumerable = enumerable
+  end
+
+  def each
+    @enumerable.each do |row|
+      yield row
+    end
+  end
+end

data/test/support/test_rename_field_transform.rb

@@ -0,0 +1,11 @@
+class TestRenameFieldTransform
+  def initialize(from, to)
+    @from = from
+    @to = to
+  end
+
+  def process(row)
+    row[@to] = row.delete(@from)
+    row
+  end
+end

data/test/test_cli.rb

@@ -0,0 +1,17 @@
+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
+end

data/test/test_integration.rb

@@ -0,0 +1,88 @@
+require_relative 'helper'
+
+require_relative 'support/test_csv_source'
+require_relative 'support/test_csv_destination'
+require_relative 'support/test_rename_field_transform'
+
+# End-to-end tests go here
+class TestIntegration < Kiba::Test
+  let(:output_file) { 'test/tmp/output.csv' }
+  let(:input_file) { 'test/tmp/input.csv' }
+
+  let(:sample_csv_data) do <<CSV
+first_name,last_name,sex
+John,Doe,M
+Mary,Johnson,F
+Cindy,Backgammon,F
+Patrick,McWire,M
+CSV
+  end
+
+  def setup
+    remove_files(input_file, output_file)
+    IO.write(input_file, sample_csv_data)
+  end
+
+  def teardown
+    remove_files(input_file, output_file)
+  end
+  
+  def test_csv_to_csv
+    # parse the ETL script (this won't run it)  
+    control = Kiba.parse do
+      source TestCsvSource, 'test/tmp/input.csv'
+
+      transform do |row|
+        row[:sex] = case row[:sex]
+        when 'M'; 'Male'
+        when 'F'; 'Female'
+        else 'Unknown'
+        end
+        row # must be returned
+      end
+
+      # returning nil dismisses the row
+      transform do |row|
+        row[:sex] == 'Female' ? row : nil
+      end
+
+      transform TestRenameFieldTransform, :sex, :sex_2015
+
+      destination TestCsvDestination, 'test/tmp/output.csv'
+    end
+
+    # run the parsed ETL script
+    Kiba.run(control)
+
+    # verify the output
+    assert_equal <<CSV, IO.read(output_file)
+first_name,last_name,sex_2015
+Mary,Johnson,Female
+Cindy,Backgammon,Female
+CSV
+  end
+  
+  def test_variable_access
+    message = nil
+    
+    control = Kiba.parse do
+      source TestEnumerableSource, [1, 2, 3]
+      
+      count = 0
+      
+      transform do |r|
+        count += 1
+        r
+      end
+      
+      post_process do
+        message = "#{count} rows processed"
+      end
+    end
+    
+    Kiba.run(control)
+    
+    assert_equal '3 rows processed', message
+  end
+  
+end

data/test/test_parser.rb

@@ -0,0 +1,84 @@
+require_relative 'helper'
+
+require_relative 'support/test_rename_field_transform'
+
+class DummyClass
+end
+
+class TestParser < Kiba::Test
+  def test_source_definition
+    control = Kiba.parse do
+      source DummyClass, 'has', 'args'
+    end
+    
+    assert_equal DummyClass, control.sources[0][:klass]
+    assert_equal ['has', 'args'], control.sources[0][:args]
+  end
+  
+  def test_block_transform_definition
+    control = Kiba.parse do
+      transform { |row| row }
+    end
+
+    assert_instance_of Proc, control.transforms[0]
+  end
+
+  def test_class_transform_definition
+    control = Kiba.parse do
+      transform TestRenameFieldTransform, :last_name, :name
+    end
+
+    assert_equal TestRenameFieldTransform, control.transforms[0][:klass]
+    assert_equal [:last_name, :name], control.transforms[0][:args]
+  end
+  
+  def test_destination_definition
+    control = Kiba.parse do
+      destination DummyClass, 'has', 'args'
+    end
+    
+    assert_equal DummyClass, control.destinations[0][:klass]
+    assert_equal ['has', 'args'], control.destinations[0][:args]
+  end
+  
+  def test_block_post_process_definition
+    control = Kiba.parse do
+      post_process { }
+    end
+    
+    assert_instance_of Proc, control.post_processes[0]
+  end
+  
+  def test_source_as_string_parsing
+    control = Kiba.parse <<RUBY
+      source DummyClass, 'from', 'file'
+RUBY
+    
+    assert_equal 1, control.sources.size
+    assert_equal DummyClass, control.sources[0][:klass]
+    assert_equal ['from', 'file'], control.sources[0][:args]
+  end
+  
+  def test_source_as_file_doing_require
+    IO.write 'test/tmp/etl-common.rb', <<RUBY
+      def common_source_declaration
+        source DummyClass, 'from', 'common'
+      end
+RUBY
+    IO.write 'test/tmp/etl-main.rb', <<RUBY
+      require './test/tmp/etl-common.rb'
+      
+      source DummyClass, 'from', 'main'
+      common_source_declaration
+RUBY
+    control = Kiba.parse IO.read('test/tmp/etl-main.rb')
+    
+    assert_equal 2, control.sources.size
+
+    assert_equal ['from', 'main'], control.sources[0][:args]
+    assert_equal ['from', 'common'], control.sources[1][:args]
+    
+  ensure
+    remove_files('test/tmp/etl-common.rb', 'test/tmp/etl-main.rb')
+  end
+end

data/test/test_runner.rb

@@ -0,0 +1,40 @@
+require_relative 'helper'
+
+require_relative 'support/test_enumerable_source'
+
+class TestRunner < Kiba::Test
+  let(:control) do
+    control = Kiba::Control.new
+    # this will yield a single row for testing
+    control.sources << {klass: TestEnumerableSource, args: [[{field: 'value'}]]} 
+    control
+  end
+
+  def test_block_transform_processing
+    # is there a better way to assert a block was called in minitest?
+    control.transforms << lambda { |r| @called = true; r }
+    Kiba.run(control)
+    assert_equal true, @called
+  end
+
+  def test_dismissed_row_not_passed_to_next_transform
+    control.transforms << lambda { |r| nil }
+    control.transforms << lambda { |r| @called = true; nil}
+    Kiba.run(control)
+    assert_nil @called
+  end
+  
+  def test_post_process_runs
+    control.post_processes << lambda { @called = true }
+    Kiba.run(control)
+    assert_equal true, @called
+  end
+  
+  def test_post_process_not_called_after_row_failure
+    control.transforms << lambda { |r| raise 'FAIL' }
+    control.post_processes << lambda { @called = true }
+    assert_raises(RuntimeError, 'FAIL') { Kiba.run(control) }
+    assert_nil @called
+  end
+
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: kiba
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Thibaut Barrère
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  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: Lightweight ETL for Ruby
+email:
+- thibaut.barrere@gmail.com
+executables:
+- kiba
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Changes.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/kiba
+- kiba.gemspec
+- lib/kiba.rb
+- lib/kiba/cli.rb
+- lib/kiba/context.rb
+- lib/kiba/control.rb
+- lib/kiba/parser.rb
+- lib/kiba/runner.rb
+- lib/kiba/version.rb
+- test/fixtures/bogus.etl
+- test/fixtures/valid.etl
+- test/helper.rb
+- test/support/test_csv_destination.rb
+- test/support/test_csv_source.rb
+- test/support/test_enumerable_source.rb
+- test/support/test_rename_field_transform.rb
+- test/test_cli.rb
+- test/test_integration.rb
+- test/test_parser.rb
+- test/test_runner.rb
+- test/tmp/.gitkeep
+homepage: http://thbar.github.io/kiba/
+licenses:
+- LGPL-3.0
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Lightweight ETL for Ruby
+test_files:
+- test/fixtures/bogus.etl
+- test/fixtures/valid.etl
+- test/helper.rb
+- test/support/test_csv_destination.rb
+- test/support/test_csv_source.rb
+- test/support/test_enumerable_source.rb
+- test/support/test_rename_field_transform.rb
+- test/test_cli.rb
+- test/test_integration.rb
+- test/test_parser.rb
+- test/test_runner.rb
+- test/tmp/.gitkeep