simple_etl 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :development do
+  gem 'rake'
+  gem 'guard'
+  gem 'growl'
+  gem 'guard-rspec'
+end
+
+group :development, :test do
+  gem 'rspec'
+end

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+  
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/README.md

@@ -0,0 +1,117 @@
+simple_etl
+==========
+
+An easy-to-use toolkit to help you with ETL (Extract Transform Load) operations.
+
+Simple ETL 'would be' (:D) framework-agnostic and easy to use.
+
+
+## Source
+
+Source namespace is responsible of input files parsing.
+
+First of all you have to define a "source template" inside a definition file (for example _my_template.stl_):
+
+```ruby
+    define :format_name do
+      field :name
+      field :surname
+    end
+```
+
+Then you will load the template with the following code:
+
+```ruby
+    my_template = SimpleEtl::Source.load './etl/my_template.stl'
+```
+
+At this point you can parse a source and process the result as with the following code:
+
+```ruby
+    my_template.parse '....', :type => :inline # load data inline
+    result = my_template.parse 'source.dat' # load from file
+
+    if result.valid?
+      result.rows.each do |row|
+        puts "|\t#{row.name}\t|\t#{row.surname}\t|"
+      end
+      puts "Parse Completed!"
+    else
+      result.errors.each do |error|
+        puts "Error while parsing line #{error.row_index}: #{error.message}"
+      end
+    end
+```
+
+As you can see the result is valid if there are no errors.
+
+The rows array contains all the parsed rows. Each row contains the parsed attributes as accessors.
+
+The errors array contains all the generated errors. Each error is an object with 'row_index', 'message' and 'exception' properties.
+
+## Structure of the template definition
+
+A template definition is composed by three layers:
+- raw fields
+- transformations
+- generators
+
+### Fields
+
+```ruby
+    field :name
+    field :surname, :type => :string, :required => true
+```
+
+By default type is 'object'. It means it's not converted in any format. Other possible types are:
+
+- *string*: field is stripped by extra spaces;
+
+- *integer*: field is stripped. If the input value is nil or empty, nil is returned; it's converted in integer if the value contains numbers; a CastError is raised otherwise;
+
+- *float*: field is stripped. If the input value is nil or empty, nil is returned; it's converted in float if the value contains numbers; a CastError is raised otherwise;
+
+- *boolean* field is stripped. If the input value is nil or empty, nil is returned; it's converted in boolean if the input value is true,false,1,0; a CastError is raised otherwise;
+
+The template definition will provide you an helper for each defined type. So you can write:
+
+```ruby
+    string :name
+    integer :age
+```
+
+For each helper, an additional 'required' helper will also be available:
+
+```ruby
+    required_string :name
+    required_integer :age
+```
+
+Remember: *every format plugin will define its own field syntax, so remember to read the [Wiki](https://github.com/nicolaracco/simple_etl/wiki)*
+
+
+### Transformers and generators
+
+They are functions that help you manipulate the parsed raw data:
+
+```ruby
+    transform :name { |name| name.downcase } # => name field is transformed in downcase
+
+    # a full_name field will be present in the row
+    generate :full_name do |row|
+      "#{row.name} #{row.surname}"
+    end
+
+    generate :company do |row|
+      if cmp = Company.find(row.company_id)
+        cmp
+      else
+        raise ParseError.new "Cannot find a company with id #{row.company_id}"
+      end
+    end
+```
+
+A transformer is a code block that transform a particular value. It's executed as soon as the input value is parsed (if it's valid).
+
+A generator is a code block that generates a new property for the current row.
+All the generators are executed when the entire row as been read and transformed.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc "Run those specs"
+task :spec do
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = %w{--colour --format progress}
+    t.pattern = 'spec/**/*_spec.rb'
+    t.rspec_path = 'bundle exec rspec'
+  end
+end

data/lib/simple_etl/source/base.rb

@@ -0,0 +1,72 @@
+module SimpleEtl
+  module Source
+    class Base
+      attr_reader :errors
+
+      attr_reader :context
+
+      def initialize context, &block
+        @errors = []
+        @context = context
+        context.send :instance_eval, &block if block
+      end
+
+      def fetch_field_from_row row, field
+        raise 'Abstract Method'
+      end
+
+      def parse_row row, args = {}
+        row_index = args[:row_index]
+        result = args[:result] || ParseResult.new
+        row_obj = Row.new
+        context.fields.each do |field|
+          begin
+            row_obj.attributes[field[:name]] = parse_field row, field, row_obj
+          rescue SimpleEtl::Source::ParseError
+            row_info = row_index && "row #{row_index}" || ''
+            result.append_error row_index, "Error parsing #{row_info}, column #{field[:name]}: #{$!.message}", $!
+          end
+        end
+        if result.valid?
+          context.generators.each do |field|
+            begin
+              row_obj.attributes[field[:name]] = generate_field field, row_obj
+            rescue SimpleEtl::Source::ParseError
+              row_info = row_index && "for row #{row_index}" || ''
+              result.append_error row_index, "Error generating #{field[:name]} #{row_info}: #{$!.message}", $!
+            end
+          end
+        end
+        result.rows << row_obj
+        result
+      end
+
+      def parse src, args = {}
+        result = args[:result] || ParseResult.new
+        if args[:type] == :inline
+          lines = src.lines.map &:chomp
+        else
+          lines = File.readlines(src).map &:chomp
+        end
+        lines.each_with_index do |row, index|
+          parse_row row, :row_index => index, :result => result
+        end
+        result
+      end
+
+      def parse_field row, field, row_obj
+        value = FieldCaster.send "parse_#{field[:type]}", fetch_field_from_row(row, field)
+        raise FieldRequiredError if field[:required] &&
+          (value.nil? || value == '')
+        if transformer = context.transformations[field[:name]]
+          value = row_obj.instance_exec value, &transformer
+        end
+        value
+      end
+
+      def generate_field field, row_obj
+        row_obj.instance_exec &field[:block]
+      end
+    end
+  end
+end

data/lib/simple_etl/source/base_context.rb

@@ -0,0 +1,47 @@
+module SimpleEtl
+  module Source
+    class BaseContext
+      attr_reader :fields
+      attr_reader :transformations
+      attr_reader :generators
+
+      def initialize
+        @fields = []
+        @transformations = {}
+        @generators = []
+      end
+
+      def field name, args = {}
+        args = {:required => false, :type => :object}.merge args
+        unless FieldCaster.respond_to? "parse_#{args[:type]}"
+          raise FieldArgumentError.new "#{name}:type (#{args[:type]}) is unknown"
+        end
+        fields << { :name => name }.merge(args)
+      end
+
+      def transform field, &block
+        field = field.to_sym
+        raise FieldNotFoundError.new(field) unless
+          fields.detect { |d| d[:name] == field }
+        transformations[field.to_sym] = block
+      end
+
+      def generate name, args = {}, &block
+        generators << args.merge(:name => name, :block => block)
+      end
+
+      def method_missing name, *params, &block
+        md = name.to_s.match /^(required_)?(\w+)$/
+        type = md && md[2].to_sym
+        if type && FieldCaster.respond_to?("parse_#{type}")
+          params << {} unless params.last.is_a? Hash
+          params.last[:type] = type
+          params.last[:required] = true if md[1]
+          field *params
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/simple_etl/source/errorable.rb

@@ -0,0 +1,7 @@
+module SimpleEtl
+  module Source
+    module Errorable
+
+    end
+  end
+end

data/lib/simple_etl/source/exceptions.rb

@@ -0,0 +1,11 @@
+module SimpleEtl
+  module Source
+    class Error < Exception; end
+    class ParseError < Error; end
+
+    class FieldNotFoundError < Error; end
+    class FieldArgumentError < ParseError; end
+    class FieldRequiredError < ParseError; end
+    class CastError < ParseError; end
+  end
+end

data/lib/simple_etl/source/field_caster.rb

@@ -0,0 +1,51 @@
+module SimpleEtl
+  module Source
+    module FieldCaster
+      extend self
+
+      def parse_object o; o; end
+
+      def parse_string o
+        o && o.strip
+      end
+
+      def parse_boolean o
+        if o.nil? || o =~ /^\s*$/
+          nil
+        else
+          if %w(true 1).include? o.strip
+            true
+          elsif %w(false 0).include? o.strip
+            false
+          else
+            raise(CastError.new "Cannot cast '#{o}' to 'boolean'")
+          end
+        end
+      end
+
+      def parse_integer o
+        if o.nil? || o =~ /^\s*$/
+          nil
+        else
+          if o =~ /^\s*\d+\s*$/
+            o.to_i
+          else
+            raise(CastError.new "Cannot cast '#{o}' to 'integer'")
+          end
+        end
+      end
+
+      def parse_float o
+        if o.nil? || o =~ /^\s*$/
+          nil
+        else
+          if o =~ /^\s*\d*([\.\,]\d+)?\s*$/
+            o.gsub(/\,/, '.').to_f
+          else
+            raise(CastError.new "Cannot cast '#{o}' to 'float'")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simple_etl/source/fixed_width/context.rb

@@ -0,0 +1,19 @@
+module SimpleEtl
+  module Source
+    module FixedWidth
+      class Context < SimpleEtl::Source::BaseContext
+        def field name, start, length, args = {}
+          raise(FieldArgumentError.new "#{name}::start required") unless start
+          raise(FieldArgumentError.new "#{name}::length required") unless length
+          start = Integer(start) rescue
+            raise(FieldArgumentError.new "#{name}::start (#{start}) is not integer")
+          if length != :eol
+            length = Integer(length) rescue
+              raise(FieldArgumentError.new "#{name}::length (#{length}) is not integer")
+          end
+          super name, { :start => start, :length => length }.merge(args)
+        end
+      end
+    end
+  end
+end

data/lib/simple_etl/source/fixed_width/parser.rb

@@ -0,0 +1,19 @@
+module SimpleEtl
+  module Source
+    module FixedWidth
+      class Parser < SimpleEtl::Source::Base
+        def initialize &block
+          super Context.new, &block
+        end
+
+        def fetch_field_from_row row, field
+          length = field[:length]
+          length = row.length - field[:start] if length == :eol
+          row[field[:start], length]
+        end
+      end
+    end
+
+    formats[:fixed_width] = FixedWidth::Parser
+  end
+end

data/lib/simple_etl/source/parse_result.rb

@@ -0,0 +1,28 @@
+require 'ostruct'
+
+module SimpleEtl
+  module Source
+    class ParseResult
+      attr_reader :errors, :rows
+
+      def initialize
+        @errors = []
+        @rows = []
+      end
+
+      def valid?; @errors.empty?; end
+
+      def append_row attributes
+        @rows << Row.new(attributes)
+      end
+
+      def append_error row_index, message, e
+        @errors << OpenStruct.new({
+          :row_index => row_index,
+          :message   => message,
+          :exception => e
+        })
+      end
+    end
+  end
+end

data/lib/simple_etl/source/row.rb

@@ -0,0 +1,21 @@
+module SimpleEtl
+  module Source
+    class Row
+      attr_reader :attributes
+
+      def initialize attributes = {}
+        @attributes = attributes
+      end
+
+      def method_missing name, *args, &block
+        md = name.to_s.match /^(\w+)(=)?$/
+        if md && attributes.has_key?(md[1].to_sym)
+          field = md[1].to_sym
+          md[2] && (attributes[field] = args.first) || attributes[field]
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/simple_etl/source.rb

@@ -0,0 +1,29 @@
+module SimpleEtl
+  module Source
+    extend self
+
+    @@formats = {}
+
+    def formats; @@formats; end
+
+    def define format, &block
+      format_class = formats[format]
+      raise "Format #{format} not found" unless format_class
+      format_class.new &block
+    end
+
+    def load file
+      raise "Cannot find file" unless File.exist? file
+      module_eval File.read file
+    end
+  end
+end
+
+dir = File.expand_path File.dirname __FILE__
+%w(exceptions field_caster row parse_result base_context base).each do |file|
+  require File.join dir, "source/#{file}"
+end
+
+%w(context parser).each do |file|
+  require File.join dir, "source/fixed_width/#{file}"
+end

data/lib/simple_etl/version.rb

@@ -0,0 +1,3 @@
+module SimpleEtl
+  VERSION = "0.0.1"
+end

data/lib/simple_etl.rb

@@ -0,0 +1,7 @@
+require 'simple_etl/version'
+
+require 'simple_etl/source'
+
+module SimpleEtl
+  # Your code goes here...
+end

data/simple_etl.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "simple_etl/version"
+
+Gem::Specification.new do |s|
+  s.name        = "simple_etl"
+  s.version     = SimpleEtl::VERSION
+  s.authors     = ["Nicola Racco"]
+  s.email       = ["nicola@nicolaracco.com"]
+  s.homepage    = ""
+  s.summary     = %q{An easy-to-use toolkit to help you with ETL (Extract Transform Load) operations}
+  s.description = %q{An easy-to-use toolkit to help you with ETL (Extract Transform Load) operations. Simple ETL 'would be' (:D) framework-agnostic and easy to use.}
+
+  s.rubyforge_project = "simple_etl"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  #s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'growl'
+  s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'rspec'
+end

data/spec/fixtures/sample.stl

@@ -0,0 +1,3 @@
+define :fixed_width do
+  integer :sample, 10, 12
+end

data/spec/lib/simple_etl/source/base_context_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module SimpleEtl
+  module Source
+    describe BaseContext do
+      subject { BaseContext.new }
+
+      describe '#field' do
+        it 'should append the field definition in the fields list' do
+          subject.field :name
+          subject.fields.should =~ [{:name => :name, :required => false, :type => :object}]
+        end
+
+        it 'should raise error if type is present and unknown' do
+          expect{
+            subject.field :name, :type => 'pippo'
+          }.to raise_error FieldArgumentError
+        end
+      end
+
+      describe 'field helpers' do
+        it 'should have an helper for each caster' do
+          subject.string :name
+          subject.fields.should =~ [{:name => :name, :type => :string, :required => false}]
+        end
+
+        it 'should have a required helper for each caster' do
+          subject.required_string :name
+          subject.fields.should =~ [{:name => :name, :type => :string, :required => true}]
+        end
+      end
+
+      describe 'transform' do
+        it 'should append to transformations' do
+          subject.field :name
+          expect {
+            subject.transform :name do; end
+          }.to change(subject.transformations, :size).by 1
+        end
+
+        it 'should raise error if field is not specified' do
+          expect {
+            subject.transform :name do; end
+          }.to raise_error FieldNotFoundError
+        end
+      end
+
+      describe 'generate' do
+        it 'should append to generators' do
+          expect {
+            subject.generate :name do; end
+          }.to change(subject.generators, :size).by 1
+        end
+      end
+    end
+  end
+end

data/spec/lib/simple_etl/source/base_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+module SimpleEtl
+  module Source
+    describe Base do
+      subject { Base.new BaseContext.new }
+
+      describe '#parse_field' do
+        before do
+          subject.stub :fetch_field_from_row do |row, field|
+            row
+          end
+        end
+
+        it 'should socks at brush' do
+          expect {
+            subject.parse_field 'ITM', { :name => 'IT', :type => :object }, Row.new
+          }.to_not raise_error
+        end
+
+        context 'when there is a transformation' do
+          it 'should apply it' do
+            subject.context.field :foo
+            subject.context.transform :foo do |s|
+              "pippo"
+            end
+            subject.parse_field('ITM', { :name => :foo, :type => :object }, Row.new).should == "pippo"
+          end
+
+          it 'should set the context to the current row object' do
+            context = subject.context
+            context.field :foo
+            context.transform(:foo) { |s| self.class.should == Row }
+            subject.parse_field 'ITM', { :name => :foo, :type => :object }, Row.new
+          end
+
+          it 'passes the field value as argument' do
+            subject.stub(:fetch_field_from_row) { |row, field| 'pippo' }
+            subject.context.field :foo
+            subject.context.transform(:foo) { |s| s.should == 'pippo' }
+            subject.parse_field 'ITM', { :name => :foo, :type => :object }, Row.new
+          end
+        end
+      end
+
+      describe '#generate_field' do
+        let(:r) { Row.new :foo => 'w' }
+
+        it 'should set the context to the current row' do
+          block = lambda { self.class.should == Row }
+          subject.generate_field({ :name => :mio, :block => block }, r)
+        end
+
+        it 'should socks at brush' do
+          subject.generate_field({ :name => :mio, :block => lambda { foo } }, r).should == r.foo
+        end
+
+        it 'can raise ParseError without specifing path' do
+          block = lambda { raise ParseError }
+          expect {
+            subject.generate_field({ :name => :mio, :block => block }, r)
+          }.to raise_error ParseError
+        end
+      end
+
+      describe '#parse_row' do
+        before do
+          subject.stub :fetch_field_from_row do |row, field|
+            row
+          end
+        end
+
+        it 'should return a ParseResult object' do
+          subject.parse_row('').should be_kind_of ParseResult
+        end
+
+        it 'should insert attributes in row' do
+          subject.context.field :sample
+          subject.parse_row('ITM').rows.first.sample.should == 'ITM'
+        end
+
+        context 'when row is not valid' do
+          it 'should not execute generators' do
+            subject.stub :fetch_field_from_row do |row, field|
+              raise ParseError
+            end
+            subject.context.field :sample
+            subject.context.generate :foo do |s|
+              "pippo"
+            end
+            subject.parse_row('ITM').public_methods.should_not include :foo
+          end
+        end
+
+        context 'when row is valid' do
+          it 'launches the generator giving the row instance' do
+            subject.context.field :sample
+            # it will raise error if s not have sample
+            subject.context.generate :foo do
+              sample
+            end
+            expect { subject.parse_row('ITM') }.to_not raise_error
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/simple_etl/source/field_caster_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module SimpleEtl
+  module Source
+    describe FieldCaster do
+      subject { FieldCaster }
+
+      describe '::parse_integer' do
+        it 'returns nil if input is blank' do
+          subject.parse_integer(nil).should be_nil
+          subject.parse_integer('').should be_nil
+        end
+
+        it 'returns a number if input has only digits' do
+          subject.parse_integer('43').should == 43
+          subject.parse_integer('00048').should == 48
+        end
+
+        it 'automatically strips spaces' do
+          subject.parse_integer('  043  ').should == 43
+        end
+
+        it 'returns error with chars' do
+          expect {
+            subject.parse_integer 'a'
+          }.to raise_error CastError
+        end
+
+        it 'returns error with commas' do
+          expect {
+            subject.parse_integer '1.2'
+          }.to raise_error CastError
+        end
+      end
+
+      describe '::parse_float' do
+        it 'returns nil if input is blank' do
+          subject.parse_float(nil).should be_nil
+          subject.parse_float('').should be_nil
+        end
+
+        it 'returns a number if input has only digits' do
+          subject.parse_float('43').should == 43.0
+          subject.parse_float('00048').should == 48.0
+        end
+
+        it 'returns a number if input has also ONE separator' do
+          subject.parse_float('43.1').should == 43.1
+          subject.parse_float('43,1').should == 43.1
+          expect {
+            subject.parse_float '43.2.1'
+          }.to raise_error CastError
+        end
+
+        it 'automatically strips spaces' do
+          subject.parse_integer('  043  ').should == 43
+        end
+
+        it 'returns error in every other situation' do
+          expect {
+            subject.parse_integer 'a'
+          }.to raise_error CastError
+        end
+      end
+    end
+  end
+end

data/spec/lib/simple_etl/source/fixed_width/context_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module SimpleEtl
+  module Source
+    module FixedWidth
+      describe Context do
+        subject { FixedWidth::Parser.new.context }
+
+        describe '#field' do
+          it 'should append the field definition in the fields list' do
+            subject.field :name, 10, 20
+            subject.fields.should =~ [{:name => :name, :start => 10, :length => 20, :required => false, :type => :object}]
+          end
+
+          it 'should raise error if start arg is missing' do
+            expect{
+              subject.field :name, nil, 10
+            }.to raise_error FieldArgumentError
+          end
+
+          it 'should raise error if length arg is missing' do
+            expect{
+              subject.field :name, 10, nil
+            }.to raise_error FieldArgumentError
+          end
+
+          it 'should raise error if start is not an integer' do
+            expect {
+              subject.field :name, 'pippo', 20
+            }.to raise_error FieldArgumentError
+          end
+
+          it 'should raise error if length is not an integer' do
+            expect {
+              subject.field :name, 5, 'pippo'
+            }.to raise_error FieldArgumentError
+          end
+
+          it 'should accept the special :eol length' do
+            expect {
+              subject.field :name, 5, :eol
+            }.to_not raise_error
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/simple_etl/source/fixed_width/parser_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module SimpleEtl
+  module Source
+    module FixedWidth
+      describe Parser do
+        describe '::new' do
+          it 'should execute the block in the context' do
+            FixedWidth::Parser.new { self.class.should == FixedWidth::Context }
+          end
+        end
+
+        describe '#fetch_field_from_row' do
+          it 'should use field attributes to fetch a field' do
+            subject.fetch_field_from_row('ITM', { :start => 0, :length => 2 }).should == 'IT'
+          end
+
+          it 'should fetch till the end of line if length is :eol' do
+            subject.fetch_field_from_row('ITM', { :start => 1, :length => :eol }).should == 'TM'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/simple_etl/source/parse_result_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module SimpleEtl
+  module Source
+    describe ParseResult do
+      describe '#valid?' do
+        it 'is true if there are no errors' do
+          subject.should be_valid
+        end
+
+        it 'is false if there are errors' do
+          subject.append_error 0, 'm', Exception.new
+          subject.should_not be_valid
+        end
+      end
+    end
+  end
+end

data/spec/lib/simple_etl/source/row_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+module SimpleEtl
+  module Source
+    describe Row do
+      it 'should use reflection over its attributes' do
+        r = Row.new :name => 'w'
+        r.name.should == 'w'
+      end
+    end
+  end
+end

data/spec/lib/simple_etl/source_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module SimpleEtl
+  describe Source do
+    describe '::define' do
+      it 'should return a new template' do
+        tpl = SimpleEtl::Source.define :fixed_width do
+          integer :name, 10, 12
+        end
+        tpl.context.fields.size.should == 1
+      end
+
+      it 'should raise error if format not exist' do
+        expect {
+          SimpleEtl::Source.define :piipo do; end
+        }.to raise_error
+      end
+    end
+
+    describe '::load' do
+      it 'should raise an error if file not exist' do
+        expect {
+          SimpleEtl::Source.load 'pappopappo'
+        }.to raise_error
+      end
+
+      it 'should load correctly' do
+        file = File.join FIXTURES_PATH, "sample.stl"
+        SimpleEtl::Source.load(file).should be_kind_of SimpleEtl::Source::Base
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# Load the Sinatra app
+require File.dirname(__FILE__) + '/../lib/simple_etl'
+require 'rspec'
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+FIXTURES_PATH = File.expand_path File.join File.dirname(__FILE__), "fixtures"
+
+RSpec.configure do |conf|
+  conf.before :suite do
+  end
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification 
+name: simple_etl
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nicola Racco
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-03 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: guard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: growl
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: An easy-to-use toolkit to help you with ETL (Extract Transform Load) operations. Simple ETL 'would be' (:D) framework-agnostic and easy to use.
+email: 
+- nicola@nicolaracco.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- lib/simple_etl.rb
+- lib/simple_etl/source.rb
+- lib/simple_etl/source/base.rb
+- lib/simple_etl/source/base_context.rb
+- lib/simple_etl/source/errorable.rb
+- lib/simple_etl/source/exceptions.rb
+- lib/simple_etl/source/field_caster.rb
+- lib/simple_etl/source/fixed_width/context.rb
+- lib/simple_etl/source/fixed_width/parser.rb
+- lib/simple_etl/source/parse_result.rb
+- lib/simple_etl/source/row.rb
+- lib/simple_etl/version.rb
+- simple_etl.gemspec
+- spec/fixtures/sample.stl
+- spec/lib/simple_etl/source/base_context_spec.rb
+- spec/lib/simple_etl/source/base_spec.rb
+- spec/lib/simple_etl/source/field_caster_spec.rb
+- spec/lib/simple_etl/source/fixed_width/context_spec.rb
+- spec/lib/simple_etl/source/fixed_width/parser_spec.rb
+- spec/lib/simple_etl/source/parse_result_spec.rb
+- spec/lib/simple_etl/source/row_spec.rb
+- spec/lib/simple_etl/source_spec.rb
+- spec/spec_helper.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: simple_etl
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: An easy-to-use toolkit to help you with ETL (Extract Transform Load) operations
+test_files: 
+- spec/fixtures/sample.stl
+- spec/lib/simple_etl/source/base_context_spec.rb
+- spec/lib/simple_etl/source/base_spec.rb
+- spec/lib/simple_etl/source/field_caster_spec.rb
+- spec/lib/simple_etl/source/fixed_width/context_spec.rb
+- spec/lib/simple_etl/source/fixed_width/parser_spec.rb
+- spec/lib/simple_etl/source/parse_result_spec.rb
+- spec/lib/simple_etl/source/row_spec.rb
+- spec/lib/simple_etl/source_spec.rb
+- spec/spec_helper.rb