ditto 0.5.0 → 0.6.0

data/lib/ditto/runner.rb

@@ -1,85 +1,67 @@
 require 'yaml'
 require 'ditto'
+require 'data_mapper'
 
 module Ditto
   class Runner
     def initialize(argv)
-      @opts = Options.instance.parse(argv)
-      $: << @opts.modelpath
+      @opts = Options.new(argv)
     end
 
     def run
       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
+	if @opts.check
+	  puts "Checking..." if @opts.verbose > 0
+	  load_files @opts.loadfiles
+	  exit
+	end
+	load_files @opts.loadfiles, '.yaml'
+	raise "dittomart file must be specified!" unless @opts.dittomart
+	puts "dittomart file: #{@opts.dittomart}" if @opts.verbose > 0
+	load_files @opts.martfiles, '.dm'
+	Ditto::Entity.load_entities @opts.entitydir, @opts.verbose
+	store_data
 	return 0
+      rescue Ditto::Error => de
+	STDERR.puts de.message(@opts.debug)
       rescue StandardError => e
-	STDERR.puts "\nERROR: #{e.to_s}"
+	STDERR.puts "\n#{e.class}: #{e.message}"
 	STDERR.puts e.backtrace if @opts.debug
-	return 99
       end
+      return 99
     end
 
-    # Load definitions from Ditto files
+    # Load any filetype depending on it's extension
     #
-    def load_definitions
+    def load_files list, type = nil
       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'
+      list.each do |f|
+	ext = File.extname(f)
+	next if type and ext != type
+	puts "loading #{f}" if @opts.verbose > 0
 	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
+	case ext
+	when '.yaml'
+	  nent = Entity.load_instances f, @opts.verbose
+	  puts "#{nent} instances loaded" if @opts.verbose > 0
+	when '.ditto'
+	  Ditto::Entity.load_from_file f
+	when '.dm'
+	  begin
+	    load File.absolute_path(f)
+	  rescue ScriptError, StandardError => le
+	    loc = le.backtrace[2].split(':')
+	    puts "Error: #{le.to_s} (line #{loc[1]} in #{loc[0]})"
 	  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
+      puts "#{nfiles} files loaded" if @opts.verbose > 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)
@@ -90,13 +72,12 @@ module Ditto
 	else
 	  DataMapper.auto_upgrade!
 	end
-	return Ditto::Entity.store_all
+	return Ditto::Entity.store_all @opts.verbose
       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

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

data/spec/entity_spec.rb

@@ -2,67 +2,91 @@ require_relative '../lib/ditto/entity'
 
 module Ditto
   describe Entity do
+    context "When loading a ditto file" do
+      before(:each) do
+	Ditto::Entity.reset
+      end
+      it "should parse correct format" do
+	Ditto::Entity.load_from_file("spec/fixtures/good.ditto").should be_true
+      end
+      it "should parse correct multiple version format" do
+	Ditto::Entity.load_from_file("spec/fixtures/multiversion.ditto").should be_true
+      end
+      it "should not load duplicate multiple version format" do
+	expect {
+	  Ditto::Entity.load_from_file("spec/fixtures/dupversion.ditto").should be_true
+	}.to raise_error Ditto::Error, /previously defined/
+      end
+      it "should not load the same one twice" do
+	expect {
+	  Ditto::Entity.load_from_file("spec/fixtures/good.ditto").should be_true
+	  Ditto::Entity.load_from_file("spec/fixtures/good.ditto").should be_true
+	}.to raise_error Ditto::Error, /previously defined/
+      end
+      it "should parse a syntax error" do
+	expect {
+	  Ditto::Entity.load_from_file("spec/fixtures/syntax.ditto")
+	}.to raise_error Ditto::Error, /SyntaxError/
+      end
+      it "should identify a comma error" do
+	expect {
+	  Ditto::Entity.load_from_file("spec/fixtures/nocomma.ditto")
+	}.to raise_error Ditto::Error, /missing add/
+      end
+      it "should identify an invalid mapping" do
+	expect {
+	  Ditto::Entity.load_from_file("spec/fixtures/badmap.ditto")
+	}.to raise_error Ditto::Error, /missing block/
+      end
+      it "should parse a method typo" do
+	expect {
+	  Ditto::Entity.load_from_file("spec/fixtures/nomethod.ditto")
+	}.to raise_error Ditto::Error, /NameError/
+      end
+      it "should identify a bad version" do
+	expect {
+	  Ditto::Entity.load_from_file("spec/fixtures/badver.ditto")
+	}.to raise_error Ditto::Error, /Malformed version/
+      end
+    end
     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
+	Ditto::Entity.reset
+	Ditto::Entity.load_from_file("spec/fixtures/currency.ditto")
+	Ditto::Entity.load_from_file("spec/fixtures/currency_group.ditto")
+	Ditto::Entity.load_from_file("spec/fixtures/country.ditto")
+	Ditto::Entity.load_from_file("spec/fixtures/continent.ditto")
+	Ditto::Entity.load_from_file("spec/fixtures/random.ditto")
+	Ditto::Entity.load_from_file("spec/fixtures/circle.ditto")
+	Ditto::Entity.load_from_file("spec/fixtures/bigcircle.ditto")
+	Ditto::Entity.load_from_file("spec/fixtures/dot.ditto")
+      end
+      it "should return empty dependency" do
+	Ditto::Entity.dep_list(:currency_group, [], []).should == [:currency_group]
+      end
+      it "should return simple dependency" do
+	Ditto::Entity.dep_list(:currency, [], []).should == [:currency_group, :currency]
+      end
+      it "should return multilevel dependency" do
+	Ditto::Entity.dep_list(:country, [], []).should == [:currency_group, :currency, :country]
+      end
+      it "should return square dependency" do
+	Ditto::Entity.dep_list(:continent, [], []).should == [:currency_group, :currency, :country, :continent]
+      end
+      it "should detect missing dependency" do
+	expect {
+	  Ditto::Entity.dep_list(:random, [], [])
+	}.to raise_error "missing dependency: stealth"
+      end
+      it "should detect circular dependency" do
+	expect {
+	  Ditto::Entity.dep_list(:circle, [], [])
+	}.to raise_error "circular dependency: circle"
+      end
+      it "should detect bigcircular dependency" do
+	expect {
+	  Ditto::Entity.dep_list(:bigcircle, [], [])
+	}.to raise_error "circular dependency: bigcircle"
       end
     end
   end

data/spec/fixtures/badmap.ditto

@@ -0,0 +1,18 @@
+# Ditto entity definitions and mappings for currency_group
+# Use do/end instead of {} and watch the mapping disappear!
+#
+
+entity :currency_group, '1.0.0', {
+    :code => [ :mandatory, :unique ],
+    :description => nil,
+    :is_commodity => nil
+  },
+  add(CurrencyGroup: '=1.0.0') do |ditto|
+    CurrencyGroup.create(
+      :code => ditto.code,
+      :description => ditto.description,
+      :is_commodity => ditto.is_commodity
+    )
+  end
+
+# vim: set ft=ruby:

data/spec/fixtures/badver.ditto

@@ -0,0 +1,17 @@
+# Bad version number
+#
+
+entity :currency_group, '1.0.a.', {
+    :code => [ :mandatory, :unique ],
+    :description => nil,
+    :is_commodity => nil
+  },
+  add(CurrencyGroup: '=1.0.0') { |ditto|
+    CurrencyGroup.create(
+      :code => ditto.code,
+      :description => ditto.description,
+      :is_commodity => ditto.is_commodity
+    )
+  }
+
+# vim: set ft=ruby:

data/spec/fixtures/bigcircle.ditto

@@ -0,0 +1,17 @@
+# Ditto entity definitions and mappings for bigcircle
+# A simple circular dependency with dot
+#
+
+entity :bigcircle, '1.0.0', {
+    code:	    [ :mandatory, :unique ],
+    description:    nil,
+    dot:	    :related
+  },
+  add(Bigcircle: '~>1.0') { |ditto|
+    Bigcircle.create(
+      :code => ditto.code,
+      :description => ditto.description,
+      :dot => ditto.dot
+    )
+  }
+# vim: set ft=ruby:

data/spec/fixtures/circle.ditto

@@ -0,0 +1,16 @@
+# Ditto entity definitions and mappings for circular reference
+#
+
+entity :circle, '1.0.0', {
+    code:	    [ :mandatory, :unique ],
+    description:    nil,
+    circle:	    :related
+  },
+  add(Circle: '~>1.0') { |ditto|
+    Circle.create(
+      :code => ditto.code,
+      :description => ditto.description,
+      :circle => ditto.circle
+    )
+  }
+# vim: set ft=ruby:

data/spec/fixtures/continent.ditto

@@ -0,0 +1,16 @@
+# Ditto entity definitions and mappings for continent
+#
+
+entity :continent, '1.0.0', {
+    code:	    [ :mandatory, :unique ],
+    description:    nil,
+    country:	    :related
+  },
+  add(Continent: '~>1.0') { |ditto|
+    Continent.create(
+      :code => ditto.code,
+      :description => ditto.description,
+      :country => ditto.country
+    )
+  }
+# vim: set ft=ruby:

data/spec/fixtures/country.ditto

@@ -0,0 +1,16 @@
+# Ditto entity definitions and mappings for country
+#
+
+entity :country, '1.0.0', {
+    code:	    [ :mandatory, :unique ],
+    description:    nil,
+    currency:	    :related
+  },
+  add(Country: '~>1.0') { |ditto|
+    Country.create(
+      :code => ditto.code,
+      :description => ditto.description,
+      :currency => ditto.currency
+    )
+  }
+# vim: set ft=ruby:

data/spec/fixtures/currency.ditto

@@ -0,0 +1,30 @@
+# Ditto entity definitions and mappings for currency
+#
+
+entity :currency, '1.0.0', {
+    code:	    [ :mandatory, :unique ],
+    description:    nil,
+    exchange_rate:  :mandatory,
+    is_designated:  nil,
+    currency_group: :related
+  },
+  add(Currency: '~>1.0', CurrencyGroup: '~>1.0') { |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
+    )
+  }
+  add(Currency: '~>2.0', CurrencyGroup: '~>2.0') { |ditto|
+    cg = CurrencyGroup.get(ditto.currency_group)
+    cg.currencies.create(
+      :code	=> ditto.code,
+      :description => ditto.description,
+      :index => 'ghost',
+      :exchange_rate => ditto.exchange_rate,
+      :is_designated => ditto.is_designated
+    )
+  }
+# vim: set ft=ruby:

data/spec/fixtures/currency_group.ditto

@@ -0,0 +1,17 @@
+# Ditto entity definitions and mappings for currency_group
+#
+
+entity :currency_group, '1.0.0', {
+    :code => [ :mandatory, :unique ],
+    :description => nil,
+    :is_commodity => nil
+  },
+  add(CurrencyGroup: '=1.0.0') { |ditto|
+    CurrencyGroup.create(
+      :code => ditto.code,
+      :description => ditto.description,
+      :is_commodity => ditto.is_commodity
+    )
+  }
+
+# vim: set ft=ruby: