fight_csv 0.1.0

data/test/fixtures/cocktails.csv

@@ -0,0 +1,2 @@
+"Should be Cooked?","Should be baked?","Baking Time","Name","Ingredients","Cooking time"
+"No","No",,Gin Tonic,"Gin, Tonic, Crushed Ice",

data/test/fixtures/prog_lang_schema.rb

@@ -0,0 +1,13 @@
+field 'Name', {
+  identifier: :name,
+}
+
+field 'Paradigms', {
+  identifier: :paradigms,
+  validator: /([^,]*,)*[^,]*/,
+  converter: ->(string) { string.split(',') },
+}
+
+field 'Creator' , {
+  identifier: :creator,
+}

data/test/fixtures/programming_languages.csv

@@ -0,0 +1,4 @@
+Name,Paradigms,Creator
+Ruby,"object oriented,imperative,reflective,functional",Yukihiro Matsumoto
+Scheme,"Functional, Procedural, Meta",Guy L. Steele
+Brainfuck,"being lol",'Some random guy'

data/test/fixtures/recipes.csv

@@ -0,0 +1,3 @@
+Name,Ingredients,Cooking time,Should be Cooked?,Should be baked?,Baking Time
+Apple Pie,"2 apples, 500 pound flour, eggs",,No,Yes,20
+Soup,"vegetables, vegetable stack or meat stock, water",30,Yes,No,

data/test/helper.rb

@@ -0,0 +1,41 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'test'
+  add_filter 'help'
+end
+
+require 'minitest/autorun'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'fight_csv'
+
+class MiniTest::Unit::TestCase
+  include FightCSV
+  def fixture(filename)
+    File.join(File.dirname(File.expand_path(__FILE__)), 'fixtures', filename)
+  end
+
+  def refute_raises
+    test = -> do
+      begin	
+        yield
+      rescue => e
+        return false, e
+      else
+        true
+      end
+    end
+    boolean, exception = test.call
+    assert boolean, "Expected no exception, but got #{exception}"
+  end
+end

data/test/test_field.rb

@@ -0,0 +1,119 @@
+require 'helper'
+require 'set'
+
+describe 'Field' do
+  describe 'initialize' do
+    it 'sets the matcher for matching csv fields' do
+      field = FightCSV::Field.new(/Field/, identifier: :field)
+      assert_equal /Field/, field.matcher
+    end
+  end
+
+  describe 'identifier' do
+    it 'defaults to the matcher downcase' do
+      field = FightCSV::Field.new("Field")
+      assert_equal field.identifier, :field
+    end
+
+    it 'raises an error if nor a identifier is present neither the matcher is a string' do
+      field = FightCSV::Field.new(5)
+      assert_raises ArgumentError do
+        field.identifier
+      end
+    end
+  end
+
+  describe 'ivar_symbol' do
+    it 'returns the identifier as an ivar symbol' do
+      field = FightCSV::Field.new(/Field/, identifier: :field)
+      assert_equal :@field, field.ivar_symbol
+    end
+  end
+
+  describe 'validate' do
+    before do
+      @field = FightCSV::Field.new(/(Git-Hash)|(Commit-Hash)/,required: true, validator: /[a-z0-9]{5}/, identifier: :git_hash)
+    end
+
+    it 'checks for every property, returns {valid: true} if valid' do
+      assert_equal({valid: true}, @field.validate(['12abc'], ['Git-Hash']))
+    end
+
+    it 'returns detailed error information if invalid(validate)' do
+      assert_equal({valid: false, error: ":git_hash must match (?-mix:[a-z0-9]{5}), but was \"foo\""},
+                   @field.validate(['foo'], ['Git-Hash']))
+    end
+
+    it 'also accepts a proc as a validator(not valid)' do
+      @field.validator = ->(git_hash) { git_hash === /[a-z0-9]{5}/ }
+      assert_equal({valid: false, error: ":git_hash must pass #{@field.validator}, but was \"foo\""},
+                   @field.validate(['foo'],['Git-Hash']))
+    end
+
+    it 'also accepts a proc as a validator(not valid)' do
+      @field.validator = ->(git_hash) { /[a-z0-9]{5}/ === git_hash  }
+      assert_equal({valid: true},
+                   @field.validate(['5oa9c'],['Git-Hash']))
+    end
+  end
+
+  describe 'match' do
+    before do
+      @row = ['6','7']
+    end
+    describe 'not an integer' do
+      before do
+        @field = FightCSV::Field.new('Foo', identifier: :foo)
+      end
+
+      it 'returns an element, whose header matches the matcher' do
+        header = ['Foo', 'Bar']
+        assert_equal '6', @field.match(@row, header)
+      end
+
+      it 'raises an ArgumentError, if no header is provided' do
+        assert_raises ArgumentError do
+          @field.match(@row)
+        end
+      end
+    end
+
+    describe 'an integer' do
+      it 'returns the element, with the index == matcher - 1' do
+        field = FightCSV::Field.new(1, identifier: :foo)
+        assert_equal '6', field.match(@row)
+      end
+    end
+  end
+
+  describe 'process' do
+    before do
+      @field = FightCSV::Field.new('Foo', identifier: :foo)
+    end
+
+    it 'raises an ArgumentError if no header is present, and the matcher isn\'t an Integer' do
+      assert_raises ArgumentError do
+        @field.process(['bla'])
+      end
+    end
+
+    it 'returns a match if one is present' do
+      row = ['6','7']
+      header = ['Bar','Foo']
+      assert_equal '7', @field.process(row, header)
+    end
+
+    it 'returns "" if it doesnt find a match' do
+      row = ['6']
+      header = ['Bar']
+      assert_equal nil, @field.process(row, header)
+    end
+
+    it 'converts a value if necessary' do
+      @field.converter = proc { |value| value.to_i ** 2 }
+      row = ['6']
+      header = ['Foo']
+      assert_equal 36, @field.process(row, header)
+    end
+  end
+end

data/test/test_fight_csv.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+describe 'Integration' do
+  before do
+
+    schema_file = fixture('prog_lang_schema.rb')
+    ProgrammingLanguage ||= Class.new do
+      include FightCSV::Record
+      schema schema_file
+    end
+
+    @programming_languages = ProgrammingLanguage.records File.open(fixture('programming_languages.csv'))
+  end
+
+  it 'can validate a csv document' do
+    assert_equal true, @programming_languages.all? { |programming_language| programming_language.valid? }
+  end
+
+  it 'converts fields of a csv document and provides dynamic attribut readers' do
+    ruby = @programming_languages.find { |prog_lang| prog_lang.name == 'Ruby' }
+    assert_equal ['object oriented', 'imperative', 'reflective', 'functional'], ruby.paradigms
+  end
+end

data/test/test_record.rb

@@ -0,0 +1,132 @@
+require 'helper'
+describe 'Record' do
+  before do
+    @klass = Class.new do
+      include FightCSV::Record
+    end
+    @schema = FightCSV::Schema.new do
+      field('Foo', identifier: :foo)
+      field('Foz', identifier: :foz)
+    end
+    @klass.schema = @schema
+  end
+
+  describe 'schema=' do
+    it 'automatically refreshes the row' do
+      instance = @klass.new(%w{bar baz}, header: %w{Bar Foz})
+      instance.schema = FightCSV::Schema.new do
+        field('Bar', identifier: :bar)
+      end
+      assert_equal({ bar: 'bar' }, instance.row)
+    end
+  end
+
+  describe 'records' do
+    it 'maps each row to a record object' do
+      records = @klass.records("Foo,Foz\nbar,baz\nfoo,foz")
+      assert records.all? { |r| Record === r }
+      assert_equal 'bar', records.first.foo
+    end
+  end
+
+  describe 'import' do
+    it 'provides an enumerator for iterating over the csv reusing the same record object' do
+      enum = @klass.import("Foo,Foz\nbar,baz\nfoo,foz")
+      assert enum.map(&:object_id).each_cons(2).all? { |a,b| a == b }, 'Expected all records to be the same object'
+      assert_equal({foo: 'bar', foz: 'baz'}, enum.first.row)
+    end
+  end
+
+  describe 'fields' do
+    it 'aggregates fields using the dynamic attribute readers or hard coded readers' do
+      @klass.class_eval { def foo; 1;end }
+      record = @klass.new(['Bar','Baz'], schema: @schema, header: ['Foo', 'Foz'])
+      assert_equal({foo: 1, foz: 'Baz'}, record.fields)
+    end
+  end
+
+  describe 'dynamic attributes' do
+    describe 'readers' do
+      it 'works' do
+        record = @klass.new(['Bar','Baz'], schema: @schema, header: ['Foo', 'Foz'])
+        assert_equal 'Bar', record.foo
+        assert_equal 'Baz', record.foz
+      end
+
+      it 'returns "" if the attribute is not defined' do
+        record = @klass.new(['Bar'], schema: @schema, header: ['Foo'])
+        assert_equal 'Bar', record.foo
+        assert_equal nil, record.foz
+      end
+
+      it 'converts values if necessary' do
+        @schema.fields.find { |f| f.matcher == 'Foo' }.converter = proc { |value| value.downcase.to_sym }
+        record = @klass.new(['Bar'], schema: @schema,header: ['Foo'])
+        assert_equal :bar, record.foo
+      end
+    end
+    describe 'writers' do
+      it 'allow write access to attributes in the row' do
+        record = @klass.new(['Bar'], schema: @schema, header: ['Foo'])
+        record.foo = 4
+        assert_equal 4, record.foo
+      end
+
+      it 'allows to write to fields defined in the schema but not provided through the csv document' do
+        record = @klass.new([], schema: @schema,header: [])
+        record.foo = 4
+        assert_equal 4, record.foo
+      end
+    end
+  end
+
+  describe 'shared test data' do
+    before do
+      @class = Class.new { include FightCSV::Record }
+      @class.schema  do
+        converter = ->(value) { value.to_i }
+        field 'a', identifier: :a, converter: converter
+        field 'b', identifier: :b, converter: converter
+        field 'c', identifier: :c, converter: converter
+      end
+      @record = @class.new %w{1 2 3}, header: ['a','b','c']
+    end
+
+    describe 'row' do
+      it 'returns a hash with identifiers as keys and values as values' do
+        assert_equal Hash[[[:a, 1],[:b,2],[:c,3]]], @record.row
+      end
+    end
+  end
+
+  describe 'schema validation' do
+    before do
+      prog_lang_schema = fixture('prog_lang_schema.rb')
+      @prog_lang = Class.new do
+        include FightCSV::Record
+        schema prog_lang_schema
+      end
+      @prog_langs = @prog_lang.records(File.open(fixture('programming_languages.csv')))
+    end
+
+    describe 'valid?' do
+      it 'returns true if a record is valid' do
+        assert_equal true, @prog_langs.all?(&:valid?)
+      end
+    end
+
+    describe 'errors' do
+      it 'returns a hash includind valid: true if the record is valid' do
+        assert_equal({valid: true, errors: []}, @prog_langs.first.validate)
+      end
+
+      it 'returns a hash inlcuding valid: false and detailed error report' do
+        @prog_lang.schema.fields.find { |f| f.identifier == :creator }.validator = /.+/
+        errors = [ ':creator must match (?-mix:.+), but was ""']
+        instance = @prog_lang.new(['LOLCODE','lolfulness',nil], header: ['Name','Paradigms'])
+        assert_equal false, instance.valid?
+        assert_equal errors, instance.errors
+      end
+    end
+  end
+end

data/test/test_schema.rb

@@ -0,0 +1,34 @@
+require 'helper'
+describe 'Schema' do
+  describe 'DSL' do
+    it 'allows to easily create a field' do
+      schema = FightCSV::Schema.new
+      converter = ->(value) { value.upcase }
+
+      schema.field "Name", {
+        converter: converter,
+        validator: /\w*/,
+        identifier: :name
+      }
+
+      field = schema.fields.first
+      assert_equal converter, field.converter
+      assert_equal /\w*/, field.validator
+    end
+
+    it 'accepts a file name' do
+      schema = Schema.new fixture('prog_lang_schema.rb')
+      assert_equal FightCSV::Schema, schema.class
+      assert_equal 'Name', schema.fields.first.matcher
+      assert_equal 'Creator', schema.fields.last.matcher
+    end
+
+    it 'also responds to a block' do
+      schema = Schema.new do
+        field 'Foo', identifier: :foo
+      end
+
+      assert_equal 'Foo', schema.fields.first.matcher
+    end
+  end
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification 
+name: fight_csv
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Manuel Korfmann
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-18 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: constructable
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 6
+        - 0
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: awesome_print
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+description: "\n\
+  Provides a nice DSL to describe your CSV document.\n\
+  CSV documents can be validated against this description.\n\
+  You can easily define types like Integer or Array for CSV through converters.\n  "
+email: manu@korfmann.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- .document
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- examples/timetracking.rb
+- fight_csv.gemspec
+- lib/fight_csv.rb
+- lib/fight_csv/data_source.rb
+- lib/fight_csv/field.rb
+- lib/fight_csv/record.rb
+- lib/fight_csv/schema.rb
+- tags
+- test/fixtures/cocktails.csv
+- test/fixtures/prog_lang_schema.rb
+- test/fixtures/programming_languages.csv
+- test/fixtures/recipes.csv
+- test/helper.rb
+- test/test_field.rb
+- test/test_fight_csv.rb
+- test/test_record.rb
+- test/test_schema.rb
+has_rdoc: true
+homepage: http://github.com/mkorfmann/fight_csv
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 729338381106442456
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: JSON-Schema + ActiveModel for CSV
+test_files: []
+