dump-parser 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+group :development do
+  gem 'rspec',     '~> 2'
+  gem 'yard',      '~> 0.7'
+  gem 'bundler',   '~> 1.0'
+  gem 'jeweler',   '~> 1.6'
+  gem 'rcov',      '>= 0'
+  gem 'reek',      '~> 1.2'
+  gem 'roodi',     '~> 2.1'
+end

data/Gemfile.lock

@@ -0,0 +1,44 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    rcov (0.9.9)
+    reek (1.2.8)
+      ruby2ruby (~> 1.2)
+      ruby_parser (~> 2.0)
+      sexp_processor (~> 3.0)
+    roodi (2.1.0)
+      ruby_parser
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    ruby2ruby (1.2.5)
+      ruby_parser (~> 2.0)
+      sexp_processor (~> 3.0)
+    ruby_parser (2.0.6)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.5)
+    yard (0.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  jeweler (~> 1.6)
+  rcov
+  reek (~> 1.2)
+  roodi (~> 2.1)
+  rspec (~> 2)
+  yard (~> 0.7)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Markus Schirp
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,50 @@
+= dump-parser
+
+I found my self doing this serveral times:
+
+* Start a project where I have to import data from legacy (CSV) formats
+* Need to parse strings into various formats (Date,Time,Integer,Symbols,Domain-Specific)
+* There are many (more than 40) string based conversion formats per project
+* Maintaining this domain knowlege consistent and error free over project livetime
+* Really hate to maintain "a dsl free big clumb of sequencial and self repeating code"
+
+Goal of this gem is to provide a clean DSL to parse strings (CSV fields) into usable objects.
+
+== Example
+
+  require 'dump-parser'
+
+  DumpParser.register :dd_mm_yyyy_date_time do
+    nil_if_empty
+    require_format %r(\A(\d{2})\.(\d{2})\.(\d{4})\Z)
+    begin
+      DateTime.new(match[3].to_i,match[2].to_i,match[1].to_i)
+    rescue ArgumentError
+      error 'is invalid date'
+    end
+  end
+
+  DumpParser.register :required_integer do
+    require_format %r(\A\d+\Z)
+    value.to_i(10)
+  end
+
+  DumpParser.execute :dd_mm_yyyy_date_time, ""  # returns nil
+  DumpParser.execute :dd_mm_yyyy_date_time, "10.01.1901"  # returns DateTime.new(1901,01,10)
+  DumpParser.execute :dd_mm_yyyy_date_time, "invalid"     # raises DumpParser::ParseException.new('dd_mm_yyyy_date: value "invalid" does not match required format')
+  DumpParser.execute :dd_mm_yyyy_date_time, "31.02.2011"  # raises DumpParser::ParseException.new('dd_mm_yyyy_date: value "31.02.2011" is invalid date')
+
+== Contributing to dump-parser
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Markus Schirp. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'rubygems'
+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 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "dump-parser"
+  gem.homepage = "http://github.com/mbj/dump-parser"
+  gem.license = "MIT"
+  gem.summary = %Q{Simple string2value DSL}
+  gem.description = %Q{Provides an easy way to manage a huge amount of domain specific string2value conversions. Mostly useful to convert legacy CSV-Fields from strings with domain specific rules}
+  gem.email = "mbj@seonic.net"
+  gem.authors = ["Markus Schirp"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+require 'reek/rake/task'
+Reek::Rake::Task.new do |t|
+  t.fail_on_error = true
+  t.verbose = false
+  t.source_files = 'lib/**/*.rb'
+end
+
+require 'roodi'
+require 'roodi_task'
+RoodiTask.new do |t|
+  t.verbose = false
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/dump-parser.gemspec

@@ -0,0 +1,79 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dump-parser}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Markus Schirp"]
+  s.date = %q{2011-07-18}
+  s.description = %q{Provides an easy way to manage a huge amount of domain specific string2value conversions. Mostly useful to convert legacy CSV-Fields from strings with domain specific rules}
+  s.email = %q{mbj@seonic.net}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "dump-parser.gemspec",
+    "lib/dump-parser.rb",
+    "spec/integration/dump-parser_spec.rb",
+    "spec/quality/dump-parser_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/unit/dump_parser/class_methods/execute_spec.rb",
+    "spec/unit/dump_parser/class_methods/has_parser_spec.rb",
+    "spec/unit/dump_parser/class_methods/lookup_spec.rb",
+    "spec/unit/dump_parser/class_methods/names_spec.rb",
+    "spec/unit/dump_parser/class_methods/new_spec.rb",
+    "spec/unit/dump_parser/class_methods/register_spec.rb",
+    "spec/unit/dump_parser/class_methods/reset_spec.rb",
+    "spec/unit/dump_parser/execute_spec.rb",
+    "spec/unit/dump_parser_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/mbj/dump-parser}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Simple string2value DSL}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2"])
+      s.add_development_dependency(%q<yard>, ["~> 0.7"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<reek>, ["~> 1.2"])
+      s.add_development_dependency(%q<roodi>, ["~> 2.1"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2"])
+      s.add_dependency(%q<yard>, ["~> 0.7"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<reek>, ["~> 1.2"])
+      s.add_dependency(%q<roodi>, ["~> 2.1"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2"])
+    s.add_dependency(%q<yard>, ["~> 0.7"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<reek>, ["~> 1.2"])
+    s.add_dependency(%q<roodi>, ["~> 2.1"])
+  end
+end
+

data/lib/dump-parser.rb

@@ -0,0 +1,142 @@
+# Implements a really dump value 2 value parser DSL
+class DumpParser
+  # Error raised when parser was feed with an invalid value
+  class ParseError < RuntimeError; end
+
+  DEFAULT_MAP_BLOCK = Proc.new { fetch_map }
+
+  attr_reader :name
+
+  def initialize(name,map=nil,block=nil)
+    unless block || map
+      raise ArgumentError,'need map block or both'
+    end
+
+    block ||= DEFAULT_MAP_BLOCK
+
+    @name,@map,@block = name,map,block
+  end
+
+  def execute(value)
+    unless value.kind_of? String
+      raise '+value+ must be kind of String'
+    end
+    @value = value
+    begin
+      catch :done do
+        @result = instance_eval(&@block)
+      end
+      returning @result do
+        @result = nil
+      end
+    ensure
+      reset!
+    end
+  end
+
+  protected
+
+  attr_reader :value
+
+  protected :value
+
+  def nil_if_empty
+    value = self.value
+    if value.empty? 
+      @result = nil
+      throw :done
+    else
+      value
+    end
+  end
+
+  def error_if_empty
+    value = self.value
+    if value.empty?
+      parse_error 'must not be empty'
+    else
+      value
+    end
+  end
+
+  def require_format(format)
+    value = self.value
+    @last_match = format.match value
+    if @last_match
+      value
+    else
+      parse_error 'does not match required format'
+    end
+  end
+
+  def match
+    @last_match || raise(RuntimeError,'no current match available')
+  end
+
+  def reset!
+    @value = @result = @match = nil
+  end
+
+  def map
+    @map || raise(RuntimeError,'this parser does not have a map')
+  end
+
+  def returning(value)
+    yield
+    value
+  end
+
+  def fetch_map
+    map,value = self.map,self.value
+    unless map.key? value
+      parse_error('is not valid')
+    else
+      map.fetch value
+    end
+  end
+
+
+  def parse_error(message)
+    raise ParseError.new("#{name}: value #{value.inspect} #{message}")
+  end
+
+  class << self
+
+    def execute(name,value)
+      parser = lookup name
+      parser.execute(value)
+    end
+
+    def register(name,map=nil,&block)
+      if has_parser? name
+        raise ArgumentError,"a parser named #{name.inspect} is already registred"
+      end
+      parser = self.new(name,map,block)
+      registry[name]=parser
+    end
+
+    def lookup(name)
+      registry[name] || raise(ArgumentError,"a parser named #{name.inspect} is not registred")
+    end
+
+    alias :[] :lookup
+
+    def has_parser?(name)
+      registry.key? name
+    end
+
+    def reset!
+      @registry = nil
+    end
+
+    def names
+      registry.keys
+    end
+
+    protected
+
+    def registry
+      @registry ||= {}
+    end
+  end
+end

data/spec/integration/dump-parser_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe DumpParser do
+  before :all do
+    DumpParser.register :simple_map, {
+      'a' => 'A',
+      'b' => 'B',
+      'c' => 'C'
+    }
+
+    DumpParser.register :dd_mm_yyyy_datetime do
+      nil_if_empty
+      require_format /\A(\d{2})\.(\d{2})\.(\d{4})\Z/
+      begin
+        DateTime.new match[3].to_i, match[2].to_i, match[1].to_i
+      rescue ArgumentError
+        parse_error 'is an invalid date'
+      end
+    end
+
+    DumpParser.register :required_integer do
+      require_format /\A(?:\d+)\Z/
+      value.to_i(10)
+    end
+  end
+
+  def execute(value)
+    DumpParser.execute name,value
+  end
+
+  describe 'simple_map' do
+    let(:name) { :simple_map }
+    specify do
+      execute('a').should == 'A'
+      execute('b').should == 'B'
+      execute('c').should == 'C'
+      expect { execute 'unkown' }.to raise_error(DumpParser::ParseError,'simple_map: value "unkown" is not valid')
+    end
+  end
+
+  describe 'dd_mm_yyyy_datetime' do
+    let(:name) { :dd_mm_yyyy_datetime }
+    specify do
+      execute('10.01.1901').should == DateTime.new(1901,1,10)
+      expect { execute 'unkown' }.to raise_error(DumpParser::ParseError,'dd_mm_yyyy_datetime: value "unkown" does not match required format')
+      expect { execute '31.02.1901' }.to raise_error(DumpParser::ParseError,'dd_mm_yyyy_datetime: value "31.02.1901" is an invalid date')
+    end
+  end
+end

data/spec/quality/dump-parser_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe DumpParser do
+  it 'should not contain reek' do 
+    (Dir["#{File.dirname(__FILE__)}/../../lib/**/*.rb"]).should_not reek
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'dump-parser'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+require 'reek/spec'
+RSpec.configure do |config|
+  config.include Reek::Spec
+end

data/spec/unit/dump_parser/class_methods/execute_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe DumpParser,'.execute' do
+  let(:object)     { described_class }
+
+  let(:name)       { :test }
+  let(:value)      { 'value' }
+  let(:parser)     { Object.new }
+
+
+  it 'should lookup and execute the parser' do
+    DumpParser.should_receive(:lookup).with(name).and_return(parser)
+    parser.should_receive(:execute).with(value).and_return(nil)
+    DumpParser.execute(name,value).should be_nil
+  end
+end

data/spec/unit/dump_parser/class_methods/has_parser_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe DumpParser,'.has_parser?' do
+  let(:object)        { described_class }
+  let(:name)          { :test }
+
+  before do
+    object.reset!
+  end
+
+  subject { object.has_parser? name }
+
+  context 'when parser with name exists' do
+    before do
+      object.register name, {}
+    end
+
+    it { should be_true }
+  end
+
+  context 'when parser with name does not exist' do
+    it { should be_false }
+  end
+end

data/spec/unit/dump_parser/class_methods/lookup_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+describe DumpParser do
+  let(:object) { described_class }
+  let(:parser) { object.register name, {} }
+
+
+  let(:name) { :test }
+
+  let(:lookup_name) { name }
+  
+
+  before :each do
+    object.reset!
+    parser
+  end
+
+  subject { object.lookup lookup_name }
+
+  context 'when requested parser was not registred' do
+    let(:lookup_name) { :unkown }
+    specify do
+      expect { subject }.to raise_error(ArgumentError,'a parser named :unkown is not registred')
+    end
+  end
+
+  context 'when requested parser was registred' do
+    it { should == parser }
+  end
+end

data/spec/unit/dump_parser/class_methods/names_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe DumpParser, '.names' do
+  let(:object)  { described_class }
+  let(:subject) { object.names }
+
+  before do
+    DumpParser.reset!
+  end
+
+
+  context 'when a parser named :test was registred' do
+    before do
+      object.register :test, {}
+    end
+   
+    it { should == [:test] }
+  end
+
+  context 'when no parser was registred' do
+    it { should == [] }
+  end
+
+  context 'when many parsers where registred' do
+    before do
+      object.register :a, {}
+      object.register :b, {}
+      object.register :c, {}
+    end
+
+    it 'should return parser names in registration order' do
+      should == [:a,:b,:c]
+    end
+  end
+end

data/spec/unit/dump_parser/class_methods/new_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe DumpParser, '.new' do
+  subject { object.new(*arguments) }
+
+  let(:name)      { :test }
+  let(:map)       { {} }
+  let(:block)     { lambda {}  }
+
+  let(:object) { described_class }
+
+  shared_examples_for 'a dump parser' do
+    it { should be_instance_of(object) }
+    its(:name) { should == name }
+  end
+
+  context 'with name and map' do
+    let(:arguments) { [name,map] }
+
+    it_should_behave_like 'a dump parser'
+  end
+
+  context 'with name map and block' do
+    let(:arguments) { [name,map,block] }
+
+    it_should_behave_like 'a dump parser'
+  end
+
+  context 'without name and block' do
+    let(:arguments) { [name] }
+
+    it do
+      expect { subject }.to raise_error(ArgumentError,'need map block or both')
+    end
+  end
+end
+

data/spec/unit/dump_parser/class_methods/register_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe DumpParser, '.register' do
+  let(:object)      { described_class }
+  let(:name)        { :test }
+  let(:block)       { nil }
+  let(:map)         { nil }
+  let(:parser)      { Object.new }
+
+  let(:returned_parser) { @returned_parser }
+
+  before do
+    object.reset!
+    object.should_receive(:new).with(name,map,block).and_return(parser)
+    @returned_parser = object.register(name,map,&block)
+  end
+
+  shared_examples_for 'a parser registration' do
+    context 'returned parser' do
+      subject { returned_parser }
+      it { should == parser }
+    end
+
+    context 'registry' do
+      subject { object }
+      it { should have_parser name }
+      its(:names) { should include(name) }
+    end
+  end
+
+  context 'with block' do
+    let(:block) { lambda { "value" } }
+    it_should_behave_like 'a parser registration'
+  end
+
+  context 'with map' do
+    let(:map) { {} }
+    it_should_behave_like 'a parser registration'
+  end
+
+  context 'with map and block' do
+    let(:block) { lambda { "value" } }
+    let(:map) { {} }
+    it_should_behave_like 'a parser registration'
+  end
+
+  context 'name was already regsitred' do
+    specify do
+      expect { object.register name,{} }.to raise_error(ArgumentError,"a parser named :test is already registred")
+    end
+  end
+end

data/spec/unit/dump_parser/class_methods/reset_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe DumpParser, '.reset!' do
+  subject { object }
+  let(:object)           { DumpParser }
+  let(:name)             { :test }
+
+  before do
+    object.register(name) { "value" }
+    object.reset!
+  end
+
+  it { should_not have_parser(name) }
+  its(:names) { should == [] }
+end

data/spec/unit/dump_parser/execute_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe DumpParser, '#execute' do
+  let(:name)   { :test }
+  let(:map)    { nil }
+  let(:block)  { nil }
+  let(:object) { described_class.new(name,map,block) }
+
+  subject { object.execute(value) }
+
+  after :each do
+    object.send(:value).should be_nil
+    object.instance_variable_get(:'@match').should be_nil 
+    object.instance_variable_get(:'@result').should be_nil
+  end
+
+  context 'with map' do
+    let(:map) { { 'a' => 'b' } }
+
+    context 'when value was in map' do
+      let(:value) { 'a' }
+      it { should == 'b' }
+    end
+
+    context 'when value was not in map' do
+      let(:value) { 'invalid' }
+      specify do
+        expect { subject }.to raise_error(DumpParser::ParseError,'test: value "invalid" is not valid')
+      end
+    end
+  end
+
+  context 'with block' do
+    context 'when no string was given' do
+      let(:value) { Object.new }
+      let(:block) { Proc.new {} }
+      specify do
+        expect { subject }.to raise_error(RuntimeError,'+value+ must be kind of String')
+      end
+    end
+
+    context 'all blocks' do
+      let(:block) { Proc.new { 'test' } }
+      let(:value) { 'test' }
+      it 'should return last expression from block' do
+        should == 'test' 
+      end
+    end
+
+    context 'nil_if_empty' do
+      let(:block) { Proc.new { nil_if_empty } }
+
+      context 'when empty' do
+        let(:value) { '' }
+        it { should == nil }
+      end
+
+      context 'when not empty' do
+        let(:value) { 'test' }
+        it { should == value }
+      end
+
+      context 'in sequence with other actions' do
+        let(:value) { '' }
+        let(:block) { Proc.new { nil_if_empty; require_format /\w+/ } }
+        it 'should stop execution flow' do
+          should be_nil
+        end
+      end
+    end
+
+    context 'error_if_empty' do
+      let(:block) { Proc.new { error_if_empty } }
+
+      context 'when empty' do
+        let(:value) { '' }
+        specify do 
+          expect { subject }.to raise_error(DumpParser::ParseError,'test: value "" must not be empty')
+        end
+      end
+
+      context 'when not empty' do
+        let(:value) { 'test' }
+        it { should == value } 
+      end
+    end
+
+    context 'require_format' do
+      let(:pattern) { %r(\Aabc\Z) }
+      let(:block) { pattern = self.pattern; Proc.new { require_format pattern } }
+
+      context 'when match format' do
+        let(:value) { 'abc' }
+        it { should == value }
+
+        it 'should remember match for later processing' do
+          subject
+          object.send(:match).should == pattern.match(value)
+        end
+      end
+
+      context 'when not match format' do
+        let(:value) { 'invalid' }
+        specify do
+          expect { subject }.to raise_error(DumpParser::ParseError,'test: value "invalid" does not match required format')
+        end
+      end
+    end
+  end
+end

data/spec/unit/dump_parser_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+describe DumpParser do
+  specify { described_class.should be_kind_of Class }
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: dump-parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Markus Schirp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-18 00:00:00.000000000 +02:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &26502400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: *26502400
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &26497860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: *26497860
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &26497260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *26497260
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &26496480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: *26496480
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &26495840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *26495840
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: &26495200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: *26495200
+- !ruby/object:Gem::Dependency
+  name: roodi
+  requirement: &26494620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: *26494620
+description: Provides an easy way to manage a huge amount of domain specific string2value
+  conversions. Mostly useful to convert legacy CSV-Fields from strings with domain
+  specific rules
+email: mbj@seonic.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- dump-parser.gemspec
+- lib/dump-parser.rb
+- spec/integration/dump-parser_spec.rb
+- spec/quality/dump-parser_spec.rb
+- spec/spec_helper.rb
+- spec/unit/dump_parser/class_methods/execute_spec.rb
+- spec/unit/dump_parser/class_methods/has_parser_spec.rb
+- spec/unit/dump_parser/class_methods/lookup_spec.rb
+- spec/unit/dump_parser/class_methods/names_spec.rb
+- spec/unit/dump_parser/class_methods/new_spec.rb
+- spec/unit/dump_parser/class_methods/register_spec.rb
+- spec/unit/dump_parser/class_methods/reset_spec.rb
+- spec/unit/dump_parser/execute_spec.rb
+- spec/unit/dump_parser_spec.rb
+has_rdoc: true
+homepage: http://github.com/mbj/dump-parser
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1500261755431801748
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Simple string2value DSL
+test_files: []