ditto 0.0.1 → 0.5.0

data/bin/ditto

@@ -1,4 +1,11 @@
 #!/usr/bin/ruby
+#
 require 'ditto/runner'
-runner = Ditto::Runner.new(ARGV)
-runner.run
+begin
+  runner = Ditto::Runner.new(ARGV)
+  rc = runner.run
+  exit(rc)
+rescue StandardError => e
+  STDERR.puts e.message
+  exit(10)
+end

data/features/create_entities.feature

@@ -4,57 +4,66 @@ As a user of Ditto
 I want to load data entity definitions
 
 Scenario: Ditto parses a single correct entity
-  Given a file named "simple_entity.rb" with:
+  Given a file named "simple_entity.ditto" with:
   """
-  require 'ditto'
-
   entity :currency, {
     code:	    [ :mandatory, :unique ],
     description:    nil,
     exchange_rate:  :mandatory,
     is_designated:  nil,
   }
-  check!
   """
-  When I run "simple_entity.rb" 
+  When I run ditto on "simple_entity.ditto"
+  Then the exit code should be 0
+  And the stdout should be
+  """
+  checked 1 entities, 0 relationships, 0 errors
+
+  """
+  When I run ditto -v on "simple_entity.ditto"
   Then the exit code should be 0
   And the stdout should be
-  """ 
-  Entities:
+  """
+  1 definition files loaded
+  checking entities...
   currency
-  1 entities, 0 relationships, 0 errors
+  checked 1 entities, 0 relationships, 0 errors
 
   """
+  When I run ditto -vv on "simple_entity.ditto"
+  Then the exit code should be 0
+  And the stdout should be
+  """
+  loading file: simple_entity.ditto
+  1 definition files loaded
+  checking entities...
+  currency
+  checked 1 entities, 0 relationships, 0 errors
 
-Scenario: Ditto parses a faulty entity attribute
-  Given a file named "faulty_attribute.rb" with:
   """
-  require 'ditto'
 
+Scenario: Ditto parses a faulty entity attribute
+  Given a file named "faulty_attribute.ditto" with:
+  """
   entity :currency, {
     code:	    [ :mandatory, :unique, :radar ],
     description:    nil,
     exchange_rate:  :mandatory,
     is_designated:  nil,
   }
-  check!
   """
-  When I run "faulty_attribute.rb" 
-  Then the exit code should be 1
+  When I run ditto on "faulty_attribute.ditto"
+  Then the exit code should be 2
   And the stdout should be
-  """ 
-  Entities:
-  currency
-  unknown properties: radar
-  1 entities, 0 relationships, 1 errors
+  """
+  currency: unknown properties: 'radar'
+  checked 1 entities, 0 relationships, 1 errors
 
   """
 
 Scenario: Ditto parses a correct entity relationship
-  Given a file named "simple_relationship.rb" with:
+  Given a file named "simple_relationship.ditto" with:
   """
-  require 'ditto'
-
   entity :currency, {
     code:	    [ :mandatory, :unique ],
     description:    nil,
@@ -67,15 +76,54 @@ Scenario: Ditto parses a correct entity relationship
     :description => nil,
     :is_commodity => nil
   }
-  check!
   """
-  When I run "simple_relationship.rb" 
+  When I run ditto on "simple_relationship.ditto"
   Then the exit code should be 0
   And the stdout should be
-  """ 
-  Entities:
-  currency
-  currency_group
-  2 entities, 1 relationships, 0 errors
+  """
+  checked 2 entities, 1 relationships, 0 errors
+
+  """
+Scenario: Ditto parses a bad entity relationship
+  Given a file named "bad_relationship.ditto" with:
+  """
+  entity :currency, {
+    code:	    [ :mandatory, :unique ],
+    description:    nil,
+    exchange_rate:  :mandatory,
+    is_designated:  nil,
+    currency_band: :related
+  }
+  entity :currency_group, {
+    :code => [ :mandatory, :unique ],
+    :description => nil,
+    :is_commodity => nil
+  }
+  """
+  When I run ditto on "bad_relationship.ditto"
+  Then the exit code should be 2
+  And the stdout should be
+  """
+  currency: unknown relationship to currency_band
+  checked 2 entities, 1 relationships, 1 errors
+
+  """
+Scenario: Ditto detects duplicate entity definitions
+  Given a file named "simple_entity.ditto" with:
+  """
+  entity :currency, {
+    code:	    [ :mandatory, :unique ],
+    description:    nil,
+    exchange_rate:  :mandatory,
+    is_designated:  nil,
+  }
+  """
+  When I run ditto with the file "simple_entity.ditto" twice
+  Then the exit code should be 2
+  And the stdout should be
+  """
+  currency: duplicate definition of entity
+  (was previously defined at simple_entity.ditto:1)
+  checked 1 entities, 0 relationships, 1 errors
 
   """

data/features/load_entity.feature

@@ -4,11 +4,11 @@ As a user of Ditto
 I want to load data definitions
 
 Scenario: Ditto loads a simple entity
-  Given a file named "simple_entity_data.rb" with:
+  Given a file named "simple_entity.yaml" with:
   """
   version: 1.0.0
   date:    2012-10-13
-  --- 
+  ---
   currency:
     code: GBP
     description: Pounds Sterling
@@ -20,14 +20,34 @@ Scenario: Ditto loads a simple entity
       code: Europe
       description: European Countries
       is_commodity: false
-    version: 1.0.1
   """
-  When I run ditto on "simple_entity.rb" 
+  When I run ditto on "simple_entity.yaml"
+  Then the exit code should be 0
+  And the stdout should be
+  """
+  validated 2 entities, 2 instances
+
+  """
+  When I run ditto -v on "simple_entity.yaml"
   Then the exit code should be 0
   And the stdout should be
-  """ 
-  Data Entities:
-  currency {"code"=>"GBP", "description"=>"Pounds Sterling", "exchange_rate"=>1.5, "is_designated"=>false, "currency_group"=>"Europe"}
-  currency_group {"code"=>"Europe", "description"=>"European Countries", "is_commodity"=>false}
-  2 entities, 1 relationships, 0 errors 
+  """
+  1 data files, 2 instances loaded, 0 errors
+  checking instances...
+  validated 2 entities, 2 instances
+
+  """
+  When I run ditto -vv on "simple_entity.yaml"
+  Then the exit code should be 0
+  Then the stdout should be
+  """
+  loading file: simple_entity.yaml
+  1 data files, 2 instances loaded, 0 errors
+  checking instances...
+  currency
+  {"code"=>"GBP", "description"=>"Pounds Sterling", "exchange_rate"=>1.5, "is_designated"=>false, "currency_group"=>"Europe"}
+  currency_group
+  {"code"=>"Europe", "description"=>"European Countries", "is_commodity"=>false}
+  validated 2 entities, 2 instances
+
   """

data/features/step_definitions/definition_steps.rb

@@ -1,17 +1,9 @@
-require 'tmpdir'
-
 Given /^a file named "(.*?)" with:$/ do |arg1, string|
-  filename = "#{Dir.tmpdir}/#{arg1}"
+  filename = "#{@tmpdir}/#{arg1}"
   File.open(filename,"w") { |f| f.write string }
   @files[arg1] = filename
 end
 
-When /^I run "(.*?)"$/ do |arg1|
-  @out = `ruby -I lib #{@files[arg1]}`
-  raise "Exec failed!" if $?.success?.nil?
-  @rc = $?.exitstatus
-end
-
 Then /^the exit code should be (\d+)$/ do |arg1|
   @rc.should == arg1.to_i
 end
@@ -19,3 +11,33 @@ end
 Then /^the stdout should be$/ do |string|
   @out.should == string
 end
+
+When /^I run ditto on "(.*?)"$/ do |arg1|
+  @out = `ruby -I lib bin/ditto #{@files[arg1]}`
+  raise "Exec failed!" if $?.success?.nil?
+  @rc = $?.exitstatus
+end
+
+When /^I run ditto on two files "(.*?)", "(.*?)"$/ do |arg1,arg2|
+  @out = `ruby -I lib bin/ditto --droptables -d #{@files[arg1]} #{@files[arg2]}`
+  raise "Exec failed!" if $?.success?.nil?
+  @rc = $?.exitstatus
+end
+
+When /^I run ditto \-v on "(.*?)"$/ do |arg1|
+  @out = `ruby -I lib bin/ditto -v #{@files[arg1]}`
+  raise "Exec failed!" if $?.success?.nil?
+  @rc = $?.exitstatus
+end
+
+When /^I run ditto \-vv on "(.*?)"$/ do |arg1|
+  @out = `ruby -I lib bin/ditto -vv #{@files[arg1]}`
+  raise "Exec failed!" if $?.success?.nil?
+  @rc = $?.exitstatus
+end
+
+When /^I run ditto with the file "(.*?)" twice$/ do |arg1|
+  @out = `ruby -I lib bin/ditto #{@files[arg1]} #{@files[arg1]}`
+  raise "Exec failed!" if $?.success?.nil?
+  @rc = $?.exitstatus
+end

data/features/store_entity.feature

@@ -0,0 +1,138 @@
+Feature: Ditto stores entities
+In order to create test data
+As a user of Ditto
+I want to load data
+
+Scenario: Ditto detects missing mappings
+  Given a file named "missing_mapping.ditto" with:
+  """
+  entity :currency, {
+    code:	    [ :mandatory, :unique ],
+    description:    nil,
+    exchange_rate:  :mandatory,
+    is_designated:  nil,
+  }
+  """
+  And a file named "missing_mapping.yaml" with:
+  """
+  version: 1.0.0
+  date:    2012-10-13
+  ---
+  currency:
+    code: GBP
+    description: Pounds Sterling
+    exchange_rate: 1.5
+    is_designated: false
+    currency_group: Europe
+  """
+  When I run ditto on two files "missing_mapping.ditto", "missing_mapping.yaml"
+  Then the exit code should be 5
+  And the stdout should be
+  """
+  checked 1 entities, 0 relationships, 0 errors
+  validated 1 entities, 1 instances
+  currency: no mapping
+
+  """
+
+Scenario: Ditto stores a single correct entity
+  Given a file named "simple_entity.ditto" with:
+  """
+  entity :currency_group, {
+    :code => [ :mandatory, :unique ],
+    :description => nil,
+    :is_commodity => nil
+  }
+  require 'dm/currency_group'
+  require 'dm/currency'
+
+  add :currency_group, :version => '1.0.0' do |ditto|
+    CurrencyGroup.create(
+      :code => ditto.code,
+      :description => ditto.description,
+      :is_commodity => ditto.is_commodity
+    )
+  end
+  """
+  And a file named "simple_entity.yaml" with:
+  """
+  version: 1.0.0
+  date:    2012-10-13
+  ---
+  currency_group:
+    code: Europe
+    description: European Countries
+    is_commodity: false
+  """
+  When I run ditto on two files "simple_entity.ditto", "simple_entity.yaml"
+  Then the exit code should be 0
+  And the stdout should be
+  """
+  checked 1 entities, 0 relationships, 0 errors
+  validated 1 entities, 1 instances
+  stored 1 entities, 1 instances
+
+  """
+
+Scenario: Ditto stores related entities
+  Given a file named "simple_relationship.ditto" with:
+  """
+  entity :currency, {
+    code:	    [ :mandatory, :unique ],
+    description:    nil,
+    exchange_rate:  :mandatory,
+    is_designated:  nil,
+    currency_group: :related
+  }
+  entity :currency_group, {
+    :code => [ :mandatory, :unique ],
+    :description => nil,
+    :is_commodity => nil
+  }
+  require 'dm/currency_group'
+  require 'dm/currency'
+
+  add :currency_group, :version => '1.0.0' do |ditto|
+    CurrencyGroup.create(
+      :code => ditto.code,
+      :description => ditto.description,
+      :is_commodity => ditto.is_commodity
+    )
+  end
+  add :currency, :version => '1.0.0' do |ditto|
+    cg = CurrencyGroup.get(ditto.currency_group)
+    cg.currencies.create(
+      :code	=> ditto.code,
+      :description => ditto.description,
+      :exchange_rate => ditto.exchange_rate,
+      :is_designated => ditto.is_designated
+    )
+  end
+
+  """
+  And a file named "simple_relationship.yaml" with:
+  """
+  version: 1.0.0
+  date:    2012-10-13
+  ---
+  currency:
+    code: GBP
+    description: Pounds Sterling
+    exchange_rate: 1.5
+    is_designated: false
+    currency_group: Europe
+  ---
+    currency_group:
+      code: Europe
+      description: European Countries
+      is_commodity: false
+  """
+  When I run ditto on two files "simple_relationship.ditto", "simple_relationship.yaml"
+  Then the exit code should be 0
+  And the stdout should be
+  """
+  checked 2 entities, 1 relationships, 0 errors
+  validated 2 entities, 2 instances
+  stored 2 entities, 2 instances
+
+  """

data/features/support/hooks.rb

@@ -1,3 +1,5 @@
+require 'tmpdir'
 Before do
+  @tmpdir = Dir.tmpdir
   @files = {}
 end

data/lib/ditto.rb

@@ -1,3 +1,10 @@
-require_relative 'ditto/entity'
-require_relative 'ditto/dsl'
+require 'ditto/version'
+require 'ditto/options'
+require 'ditto/entity'
+require 'ditto/dsl'
 include Ditto::DSL
+module Ditto
+  def self.symbolize_keys h
+    h.inject({}) { |opts,(k,v)| opts[(k.to_sym rescue k) || k] = v; opts }
+  end
+end

data/lib/ditto/dsl.rb

@@ -1,13 +1,20 @@
 # Define the DSL for Ditto
 #
+require_relative 'entity'
+require_relative 'map'
+
 module Ditto
   module DSL
+    def version (*args, &block)
+      Ditto::Entity.set_version(*args, &block)
+    end
     def entity (*args, &block)
       Ditto::Entity.define_entity(*args, &block)
     end
-    def check! (*args, &block)
-      nerr = Ditto::Entity.check(*args, &block)
-      exit(nerr)
+    def add (name, opts = {}, &block)
+      Ditto::Map.add name, opts, &block
     end
   end
 end
+
+include Ditto::DSL

data/lib/ditto/entity.rb

@@ -1,34 +1,143 @@
 # Entity support for Ditto
+# Note that Entities are not objects in the current implementation, so we don't
+# use a Class, we use a Module.
 #
 module Ditto
-  class Entity
+  module Entity
     PROPS = [ :mandatory, :unique, :related ].freeze
-    @entities = {}
+    @entities = {} # Hash containing definition hashes for each entity
+    @definitions = {} # Hash remembering where entities were defined
+    @instances = Hash.new {|h,k| h[k] = []} # Arrays of instance hashes for each entity
+    @deps = {} # Arrays of dependencies for each entity
+    @errors = 0
+
+    def self.set_version version
+      @version = version
+    end
+
+    # Maps to the 'entity' DSL keyword
+    #
     def self.define_entity name, details
-      raise "Entity details must be a hash!" unless details.kind_of? Hash
-      raise "Entity #{name.to_sym} already exists" if @entities.has_key?(name.to_sym)
-      @entities[name.to_sym] = details
+      src = Thread.current.backtrace[2].split(':')[0..1]
+      src[0] = File.basename(src[0]) unless Ditto::Options.instance.debug
+      error("entity details must be a hash!", name, src) unless details.kind_of? Hash
+
+      if @entities.has_key?(name.to_sym)
+	error "duplicate definition of entity", name, src,
+	"(was previously defined at #{@definitions[name.to_sym].join(':')})"
+      end
+      @entities[name.to_sym] = Ditto.symbolize_keys details
+      @definitions[name.to_sym] = src
     end
-    def self.check
+
+    # Check that the entities are well defined
+    # return true/false
+    #
+    def self.check_definitions verbose = 0
+      return true if @entities.size == 0
       nrel = 0
-      nerr = 0
       nkey = 0
-      puts "Entities:"
+      puts "checking entities..." if verbose > 0
       @entities.each do |name,fields|
-	puts name
+	puts name if verbose > 0
+	@deps[name] = []
 	fields.each do |field, props|
 	  symprops = Array(props).select{|p| p.is_a? Symbol}
 	  duffprops = symprops - PROPS
 	  unless duffprops.empty?
-	    puts "unknown properties: #{duffprops.join(' ,')}"
-	    nerr += 1
+	    error("unknown properties: '#{duffprops.join(' ,')}'", name, @definitions[name])
 	  end
 	  nkey += symprops.count(:unique)
-	  nrel += symprops.count(:related)
+	  if symprops.include? :related
+	    nrel += 1
+	    if @entities.has_key? field
+	      @deps[name] << field
+	    else
+	      error("unknown relationship to #{field}", name, @definitions[name])
+	    end
+	  end
+	end
+      end
+      puts "checked #{@entities.size} entities, #{nrel} relationships, #{@errors} errors"
+      return error?
+    end
+
+    def self.load_instance name, instance
+      @instances[name] << instance
+    end
+
+    def self.validate_instances verbose = 0
+      return true if instance_count == 0
+      puts "checking instances..." if verbose > 0
+      ninst = nerr = 0
+      @instances.each do |entity_name,entities|
+	puts entity_name if verbose > 1
+	entities.each do |e|
+	  puts e.inspect if verbose > 1
+	  if Ditto::Entity.validate(entity_name, e)
+	    ninst += 1
+	  else
+	    nerr += 1
+	  end
 	end
       end
-      puts "#{@entities.size} entities, #{nrel} relationships, #{nerr} errors"
-      return nerr
+      puts "validated #{@instances.keys.size} entities, #{ninst} instances"
+      return (nerr == 0)
+    end
+
+    # Compute dependencies recursively
+    #
+    def self.dep_list(name, list, dephash)
+      if deps = dephash[name]
+	dephash.delete name
+	deps.each do |dep|
+	  self.dep_list dep, list, dephash
+	end
+	list << name unless list.include? name
+      else
+	return if list.include? name # we did it earlier
+	raise "Missing or circular dependency on #{name}"
+      end
+    end
+
+    # Before storing, sort the instances by dependency
+    #
+    def self.store_all
+      seq = []
+      deps = @deps.dup # shallow copy as deleting entries...
+      @deps.each_key do |entity|
+	self.dep_list entity, seq, deps
+      end
+      return false if Ditto::Map.check_maps(seq, @definitions) > 0
+      n = Ditto::Map.add_all seq, @instances
+      puts "stored #{@instances.keys.size} entities, #{n} instances"
+      return true
+    end
+
+    def self.validate name, instance
+      return true
+      return false unless @entities.has_key?(name)
+    end
+
+    def self.instance_count
+      return @instances.keys.size
+    end
+
+    def self.entity_count
+      return @entities.keys.size
+    end
+
+  private
+    def self.error?
+      return @errors == 0
+    end
+
+    def self.error msg, name, src, extra = nil
+      print "#{name}: #{msg}"
+      print " at line #{src[1]} in file #{src[0]}" if !src and Ditto::Options.instance.debug
+      print "\n";
+      puts extra if extra
+      @errors += 1
     end
   end
 end

data/lib/ditto/map.rb

@@ -0,0 +1,39 @@
+# Mapping support for Ditto
+#
+require 'ostruct'
+require 'data_mapper'
+
+module Ditto
+  module Map
+    @maps = {}
+
+    def self.add name, opts, &block
+      @maps[name] = block
+    end
+
+    def self.check_maps seq, definitions
+      nerr = 0
+      seq.each do |entity|
+	unless @maps.has_key? entity
+	  nerr += 1
+	  Ditto::Entity.error("no mapping", entity, definitions[entity])
+	end
+      end
+      return nerr
+    end
+
+    def self.add_all seq, data
+      ninst = 0
+      seq.each do |entity|
+	instances = data[entity]
+	instances.each do |ihash|
+	  puts "adding #{entity} #{ihash.inspect}" if Ditto::Options.instance.verbose > 1
+	  instance = OpenStruct.new ihash
+	  @maps[entity].call instance
+	  ninst += 1
+	end
+      end
+      return ninst
+    end
+  end
+end

data/lib/ditto/options.rb

@@ -1,33 +1,63 @@
 require 'optparse'
+require 'ostruct'
+require 'singleton'
 
 module Ditto
-  class Options
-    DEFAULT_CONNSTRING = "user/password@//localhost:1521/test"
-    attr_reader :connstring, :files_to_load
-    def initialize(argv)
-      @connstring = DEFAULT_CONNSTRING
-      parse(argv)
-      @files_to_load = argv
+  class Options < OpenStruct
+    include Singleton
+
+    DEFAULTS = {
+	:connstring => ENV['DATABASE_URL'] || 'nodb://a/b',
+	:modelpath  => '.',
+	:debug	    => false,
+	:droptables => false,
+	:verbose    => 0,
+	:loadpaths  => nil
+    }
+    def initialize
+      super(DEFAULTS)
     end
-    private
-    def parse(argv) 
+
+    def parse argv
+
+      Ditto::Options::DEFAULTS.each do |k,v|
+	self.send "#{k}=".to_s, v
+      end
+
       OptionParser.new do |opts|
-	opts.banner = "Usage: ditto [ options ] files..."
-	opts.on("-d", "--database string", String, "DB Connection string") do |s|
-	  @connstring = s
+	opts.banner = "Usage: ditto [ options ] paths..."
+	opts.separator "Paths will be searched for .ditto files (definitions) and .yaml files (data)"
+	opts.on("-c STRING", "--connection", String, "Database connection string",
+		"Defaults to environment variable DATABASE_URL",
+		"Current default is #{DEFAULTS[:connstring]}") do |s|
+	  self.connstring = s
+	end
+	opts.on("-m PATH", "--modelpath", String, "Path to load DataMapper models from (default #{DEFAULTS[:modelpath]})") do |m|
+	  raise "Modelpath #{m} does not exist!" unless Dir.exist?(m)
+	  self.modelpath = m
+	end
+	opts.on("-d", "--debug", "Debug") do |s|
+	  self.debug = true
+	end
+	opts.on("-v", "--verbose", "Verbose (repeat for more)") do
+	  self.verbose += 1
+	end
+	opts.on("--droptables", "Delete existing database tables!") do
+	  self.droptables = true
 	end
-	opts.on("-h", "--help", "Show this message") do
+	opts.on("-?", "-h", "--help", "Show this message") do
 	  puts opts
 	  exit
 	end
 	begin
-	  argv = ["-h"] if argv.empty?
 	  opts.parse!(argv)
 	rescue OptionParser::ParseError => e
 	  STDERR.puts e.message, "\n", opts
 	  exit(-1)
 	end
       end
+      self.loadpaths = argv
+      return self
     end
   end
 end

data/lib/ditto/runner.rb

@@ -1,13 +1,102 @@
-require_relative 'dsl'
-require_relative 'options'
+require 'yaml'
+require 'ditto'
 
 module Ditto
   class Runner
     def initialize(argv)
-      @options = Options.new(argv)
+      @opts = Options.instance.parse(argv)
+      $: << @opts.modelpath
     end
+
     def run
-      puts "Ditto has run with options #{@options}"
+      begin
+	return 1 unless load_definitions
+	return 2 unless Ditto::Entity.check_definitions(@opts.verbose)
+	return 3 unless load_data
+	return 4 unless Ditto::Entity.validate_instances(@opts.verbose)
+	return 5 unless store_data
+	return 0
+      rescue StandardError => e
+	STDERR.puts "\nERROR: #{e.to_s}"
+	STDERR.puts e.backtrace if @opts.debug
+	return 99
+      end
+    end
+
+    # Load definitions from Ditto files
+    #
+    def load_definitions
+      nfiles = 0
+      nerr = 0
+      Dir.glob(@opts.loadpaths) do |f|
+	next unless File.extname(f) == '.ditto'
+	puts "loading file: #{File.basename(f)}" if @opts.verbose > 1
+	begin
+	  load File.absolute_path(f)
+	  nfiles += 1
+	rescue LoadError => le
+	  loc = le.backtrace[2].split(':')
+	  puts "Error: #{le.to_s} (line #{loc[1]} in #{loc[0]})\nDid you set --modelpath ?"
+	  nerr += 1
+	end
+      end
+      puts "#{nfiles} definition files loaded" if (nfiles > 0 and @opts.verbose > 0)
+      return nerr == 0
+    end
+
+    # Load data from YAML files into the in-memory representation
+    # return true if all OK
+    #
+    def load_data
+      nfiles = nent = nerr = 0
+      Dir.glob(@opts.loadpaths) do |f|
+	next unless File.extname(f) == '.yaml'
+	nfiles += 1
+	puts "loading file: #{File.basename(f)}" if @opts.verbose > 1
+	header = nil
+	YAML::load_documents(File.open(f)) do |doc|
+	  unless header
+	    header = doc
+	    puts "Header info is #{header.to_s}" if @opts.verbose > 2
+	    next
+	  end
+	  e = doc.flatten
+	  if e.size != 2
+	    nerr += 1
+	    puts "ERROR: entity instance has multiple keys"
+	    next
+	  end
+	  Ditto::Entity.load_instance e[0].to_sym, e[1]
+	  nent += 1
+	end
+      end
+      puts "#{nfiles} data files, #{nent} instances loaded, #{nerr} errors" if (nfiles > 0 and @opts.verbose > 0)
+      return nerr == 0
     end
+
+    # Add the data to the database
+    #
+    def store_data
+      return true if Ditto::Entity.instance_count == 0
+      return true if Ditto::Entity.entity_count == 0
+
+      puts "Running against: #{@opts.connstring}" if @opts.verbose > 0
+      DataMapper::Logger.new(STDOUT, (@opts.verbose > 1) ? :debug : :info)
+      DataMapper.setup(:default, @opts.connstring)
+      DataMapper.finalize
+      begin
+	if @opts.droptables
+	  DataMapper.auto_migrate!
+	else
+	  DataMapper.auto_upgrade!
+	end
+	return Ditto::Entity.store_all
+      rescue StandardError => e
+	STDERR.puts "\nERROR: #{e.to_s}"
+	STDERR.puts e.backtrace if @opts.debug
+	return false
+      end
+    end
+
   end
 end

data/lib/ditto/version.rb

@@ -0,0 +1,3 @@
+module Ditto
+  VERSION = '0.5.0'
+end

data/spec/entity_spec.rb

@@ -0,0 +1,69 @@
+require_relative '../lib/ditto/entity'
+
+module Ditto
+  describe Entity do
+    context "Checking dependencies" do
+      before (:each) do
+	@deps = {
+	  :currency_group => [],
+	  :currency => [:currency_group],
+	  :country => [:currency],
+	  :continent => [:currency, :country],
+	  :circle => [:circle],
+	  :bigcircle => [:loop],
+	  :loop => [:detour, :country],
+	  :detour => [:bigcircle],
+	  :random => [:stealth],
+	}
+      end
+      context "Checking dep_list()" do
+	it "should return empty dependency" do
+	  Ditto::Entity.dep_list(:currency_group, [], @deps).should == [:currency_group]
+	end
+	it "should return simple dependency" do
+	  Ditto::Entity.dep_list(:currency, [], @deps).should == [:currency_group, :currency]
+	end
+	it "should return multilevel dependency" do
+	  Ditto::Entity.dep_list(:country, [], @deps).should == [:currency_group, :currency, :country]
+	end
+	it "should return square dependency" do
+	  Ditto::Entity.dep_list(:continent, [], @deps).should == [:currency_group, :currency, :country, :continent]
+	end
+	it "should detect missing dependency" do
+	  expect {
+	    Ditto::Entity.dep_list(:random, [], @deps)
+	  }.to raise_error "Missing or circular dependency on stealth"
+	end
+	it "should detect circular dependency" do
+	  expect {
+	    Ditto::Entity.dep_list(:circle, [], @deps)
+	  }.to raise_error "Missing or circular dependency on circle"
+	end
+	it "should detect bigcircular dependency" do
+	  expect {
+	    Ditto::Entity.dep_list(:bigcircle, [], @deps)
+	  }.to raise_error "Missing or circular dependency on bigcircle"
+	end
+      end
+      context "as used in store_all()" do
+	it "should work" do
+	  @deps = {
+	    :currency_group => [],
+	    :currency => [:currency_group],
+	  }
+	  seq = []
+	  Ditto::Entity.dep_list(:currency_group, seq, @deps)
+	  Ditto::Entity.dep_list(:currency, seq, @deps)
+	  seq.should == [:currency_group, :currency]
+	end
+	it "should work with 3" do
+	  seq = []
+	  Ditto::Entity.dep_list(:currency_group, seq, @deps)
+	  Ditto::Entity.dep_list(:currency, seq, @deps)
+	  Ditto::Entity.dep_list(:country, seq, @deps)
+	  seq.should == [:currency_group, :currency, :country]
+	end
+      end
+    end
+  end
+end

data/spec/options_spec.rb

@@ -2,29 +2,75 @@ require_relative '../lib/ditto/options'
 
 module Ditto
   describe Options do
-    context "specifying no database" do
-      it "should return default" do
-	opts = Ditto::Options.new(["testfile"])
-	Ditto::Options::DEFAULT_CONNSTRING.should == opts.connstring
+    context "specifying no options" do
+      it "should return defaults" do
+	opts = Ditto::Options.instance
+	opts.parse([])
+	opts.connstring.should == Ditto::Options::DEFAULTS[:connstring]
+	opts.modelpath.should == Ditto::Options::DEFAULTS[:modelpath]
+	opts.verbose.should == 0
+	opts.debug.should be_false
+	opts.droptables.should be_false
+	opts.loadpaths.size.should == 0
+      end
+      it "should return single path" do
+	opts = Ditto::Options.instance.parse(["testfile"])
+	opts.connstring.should == Ditto::Options::DEFAULTS[:connstring]
+	opts.modelpath.should == Ditto::Options::DEFAULTS[:modelpath]
+	opts.verbose.should == 0
+	opts.debug.should be_false
+	opts.droptables.should be_false
+	opts.loadpaths.should == ["testfile"]
+      end
+    end
+    context "specifying a model path" do
+      it "should return it" do
+	mpath = "spec"
+	opts = Ditto::Options.instance.parse(["-m", "#{mpath}", "afile"])
+	opts.modelpath.should == mpath
+      end
+    end
+    context "specifying a model path that doesn't exist" do
+      it "should fail" do
+	mpath = "zz/zz/zz/zz"
+	expect {
+	  opts = Ditto::Options.instance.parse(["-m", "#{mpath}", "afile"])
+	}.to raise_error(RuntimeError, "Modelpath #{mpath} does not exist!")
       end
     end
-    context "specifying a database" do
+    context "specifying a connection string" do
       it "should return it" do
 	mydb = "username/password@//myserver:1521/my.service.com"
-	opts = Ditto::Options.new(["-d", "#{mydb}", "afile"])
+	opts = Ditto::Options.instance.parse(["-c", "#{mydb}", "afile"])
 	opts.connstring.should == mydb
       end
     end
-    context "specifying files and no connection string" do
-      it "should return the files" do
-	opts = Ditto::Options.new(["file1", "file2"])
-	opts.files_to_load.should == ["file1", "file2"]
+    context "specifying paths and no connection string" do
+      it "should return the paths" do
+	opts = Ditto::Options.instance.parse(["file1", "path1"])
+	opts.loadpaths.should == ["file1", "path1"]
       end
     end
-    context "specifying files and a dictionary" do
+    context "specifying files and a connection string" do
       it "should return the files" do
-	opts = Ditto::Options.new(["-d", "u/p@//serv:1521/mydb", "file1", "file2"])
-	opts.files_to_load.should == ["file1", "file2"]
+	opts = Ditto::Options.instance.parse(["-c", "u/p@//serv:1521/mydb", "file1", "path1"])
+	opts.loadpaths.should == ["file1", "path1"]
+      end
+    end
+    context "specifying droptables" do
+      it "should set the options" do
+	opts = Ditto::Options.instance.parse(["--droptables", "file1", "path1"])
+	opts.droptables.should be_true
+      end
+    end
+    context "specifying verbose" do
+      it "should set verbose flag" do
+	opts = Ditto::Options.instance.parse(["-v", "file1"])
+	opts.verbose.should == 1
+      end
+      it "should set verbose flag twice" do
+	opts = Ditto::Options.instance.parse(["-vv", "file1"])
+	opts.verbose.should == 2
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ditto
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,6 +11,22 @@ bindir: bin
 cert_chain: []
 date: 2012-10-12 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: data_mapper
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -18,7 +34,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,53 +42,69 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.11'
 description: ! 'Database Independent Test Objects (Ditto)
 
 
   Ditto defines a simple DSL that allows test data to be expressed in a database independent
-  format. When the underlying tables are remapped the QA team don''t have to go and
-  change all the historical test cases.
+  format.
+
+  When the underlying tables are remapped the QA team don''t have to go and change
+  all the historical test cases.
 
 
-  There are two parts, both of them versioned:
+  There are three parts, all of them versioned:
 
   1. The data declarations
 
   2. The mappings to the underlying database
 
+  3. The data itself
+
 
   Idea is to replace an XML dialect with something simpler. See sample at simple_object.xml
 
 
+  Notes on DSL
+
+  ------------
+
+
+  The entity declaration style uses verb and hash only, without a block.
+
+  Contrast this with mapping style which uses verb, params and then block. Of course
+
+  mappings need code and so the block usage is natural. This could also be done
+
+  for the declarations, very similar to the way the gem ''datamapper'' does it.
+
+
+
   Nick Townsend, Oct 2012
 
 '
 email: nick.townsend@mac.com
-executables: []
+executables:
+- ditto
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/ditto/dsl.rb
+- lib/ditto/options.rb
+- lib/ditto/entity.rb
+- lib/ditto/version.rb
+- lib/ditto/map.rb
+- lib/ditto/runner.rb
+- lib/ditto.rb
 - bin/ditto
-- CHANGELOG
-- ditto.gemspec
 - features/create_entities.feature
 - features/load_entity.feature
 - features/step_definitions/definition_steps.rb
+- features/store_entity.feature
 - features/support/hooks.rb
-- lib/ditto/dsl.rb
-- lib/ditto/entity.rb
-- lib/ditto/options.rb
-- lib/ditto/runner.rb
-- lib/ditto.rb
-- rakefile
-- README
-- samples/simple_object.xml
-- samples/simple_object.yaml
-- samples/simple_object_seq.yaml
-- samples/simple_object_sym.yaml
+- spec/entity_spec.rb
 - spec/options_spec.rb
-homepage: http://rubygems.org/gems/ditto
+homepage: https://github.com/townsen/ditto
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -96,4 +128,11 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Database independent test objects
-test_files: []
+test_files:
+- features/create_entities.feature
+- features/load_entity.feature
+- features/step_definitions/definition_steps.rb
+- features/store_entity.feature
+- features/support/hooks.rb
+- spec/entity_spec.rb
+- spec/options_spec.rb

data/CHANGELOG

@@ -1 +0,0 @@
-Version 0.0.1: Initial attempts

data/README

@@ -1,11 +0,0 @@
-Database Independent Test Objects (Ditto)
-
-Ditto defines a simple DSL that allows test data to be expressed in a database independent format. When the underlying tables are remapped the QA team don't have to go and change all the historical test cases.
-
-There are two parts, both of them versioned:
-1. The data declarations
-2. The mappings to the underlying database
-
-Idea is to replace an XML dialect with something simpler. See sample at simple_object.xml
-
-Nick Townsend, Oct 2012

data/ditto.gemspec

@@ -1,16 +0,0 @@
-Gem::Specification.new do |s|
-  s.name        = 'ditto'
-  s.version     = '0.0.1'
-  s.date        = '2012-10-12'
-  s.summary     = "Database independent test objects"
-  s.description = File.read(File.join(File.dirname(__FILE__), 'README'))
-  s.authors     = ["Nick Townsend"]
-  s.email       = 'nick.townsend@mac.com'
-  s.platform	= Gem::Platform::RUBY
-  s.required_ruby_version = '>=1.9' 
-  s.files	= Dir['**/**']
-  s.homepage    = 'http://rubygems.org/gems/ditto'
-#  s.add_runtime_dependency "daemons", ["= 1.1.0"]
-  s.add_development_dependency "rspec", [">= 0"]
-  s.has_rdoc	= false
-end

data/rakefile

@@ -1,8 +0,0 @@
-# Rakefile for Ditto
-#
-task :default => :test
-
-task :test do
-  sh "rspec -c"
-  sh "cucumber -f progress features"
-end

data/samples/simple_object.xml

@@ -1,23 +0,0 @@
----------------------------------------- DEFINITIONS ----------------------------------------
-<object_classes>
-<object name='currency'>
-	<property name='code' mandatory='Y' is_key='Y' />
-	<property name='description'/>
-	<property name='exchange_rate' mandatory='Y' />
-	<property name='is_designated'/>
-	<relation name='currency_group' relation_object='currency_group' relation_type='unique'/>
-</object>
-<object name='currency_group'>
-	<property name='code' mandatory='Y' is_key='Y'/>
-	<property name='description'/>
-	<property name='is_commodity'/>
-</object>
-</object_classes>
-
----------------------------------------- DATA ----------------------------------------
-<object_instances>
-<currency code ='GBP' description='Great Britain Pound' exchange_rate='1.5' is_designated='false'>
-	<currency_group code='Europe' />
-</currency>
-<currency_group code='Europe' description='European countries' is_commodity='false'/>
-</object_instances>

data/samples/simple_object.yaml

@@ -1,21 +0,0 @@
-# This format has multiple YAML streams: 
-# The first contains version info, date and author etc.
-# The subsequent are hashes, each being an entity with key the entity name
-# Note that strings are used as keys and not symbols for user clarity
-#
-version: 1.0.0
-date:    2012-10-13
-author:  Nick Townsend
---- 
-currency:
-  code: GBP
-  description: Pounds Sterling
-  exchange_rate: 1.5
-  is_designated: false
-  currency_group: Europe
----
-currency_group:
-  code: Europe
-  description: European Countries
-  is_commodity: false
-version: 1.0.1

data/samples/simple_object_seq.yaml

@@ -1,18 +0,0 @@
-# This format has two streams, the first version info etc.
-# The second is a sequence of hashes, each has being an entity
-#
-:version: 1.0.0
---- 
--
-  :currency:
-    :code: GBP
-    :description: Pounds Sterling
-    :exchange_rate: 1.5
-    :is_designated: false
-    :currency_group: Europe
--
-  :currency_group:
-    :code: Europe
-    :description: European Countries
-    :is_commodity: false
-  :version: 1.0.1

data/samples/simple_object_sym.yaml

@@ -1,19 +0,0 @@
-# This format has multiple streams, the first version info etc.
-# The subsequent are hashes, each has being an entity
-# Symbols are used throughout
-#
-:version: 1.0.0
-:date:    2012-10-13
---- 
-:currency:
-  :code: GBP
-  :description: Pounds Sterling
-  :exchange_rate: 1.5
-  :is_designated: false
-  :currency_group: Europe
----
-  :currency_group:
-    :code: Europe
-    :description: European Countries
-    :is_commodity: false
-  :version: 1.0.1