simpex 0.0.5 → 0.1.0

data/Gemfile

@@ -3,3 +3,10 @@ source "http://rubygems.org"
 # Specify your gem's dependencies in simpex.gemspec
 gemspec
 
+group :test do
+  gem 'rb-fsevent', :require => false if RUBY_PLATFORM =~ /darwin/i
+  gem 'guard-minitest'
+  gem 'mocha'
+  gem 'growl'
+end
+

data/Gemfile.lock

@@ -1,14 +1,30 @@
 PATH
   remote: .
   specs:
-    simpex (0.0.1)
+    simpex (0.0.5)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    growl (1.0.3)
+    guard (1.4.0)
+      listen (>= 0.4.2)
+      thor (>= 0.14.6)
+    guard-minitest (0.5.0)
+      guard (>= 0.4)
+    listen (0.5.3)
+    metaclass (0.0.1)
+    mocha (0.12.6)
+      metaclass (~> 0.0.1)
+    rb-fsevent (0.9.2)
+    thor (0.16.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  growl
+  guard-minitest
+  mocha
+  rb-fsevent
   simpex!

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'minitest' do
+  # with Minitest::Unit
+  watch(%r|^test/(.*)\/?test_(.*)\.rb|)
+  watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r|^test/test_helper\.rb|)    { "test" }
+
+  # with Minitest::Spec
+  # watch(%r|^spec/(.*)_spec\.rb|)
+  # watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  # watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+
+  # Rails 3.2
+  # watch(%r|^app/controllers/(.*)\.rb|) { |m| "test/controllers/#{m[1]}_test.rb" }
+  # watch(%r|^app/helpers/(.*)\.rb|)     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r|^app/models/(.*)\.rb|)      { |m| "test/unit/#{m[1]}_test.rb" }  
+  
+  # Rails
+  # watch(%r|^app/controllers/(.*)\.rb|) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r|^app/helpers/(.*)\.rb|)     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r|^app/models/(.*)\.rb|)      { |m| "test/unit/#{m[1]}_test.rb" }  
+end

data/Rakefile

@@ -8,6 +8,7 @@ namespace :simpex do
   desc "Generates ImpEx file"
   task :generate do
     output_directory = "tmp"
+    FileUtils.mkdir(output_directory) unless Dir.exist?(output_directory)
     Factory.generate_base_catalog_setup_to(output_directory)
     Factory.generate_base_catalog_setup_to_file(output_directory,"single_file_result.csv")
     puts "Files generated inside #{output_directory}"

data/lib/simpex/impex_result.rb

@@ -25,22 +25,48 @@ class ImpexResult
 
   def impexify(result_file_name="", time_stampify = false)
     stamp = Time.now.strftime("%S_%M_%H_%d_%m_%Y") if time_stampify
+    validate_macros
     if result_file_name.empty?
-      @types.each_with_index do |type, index|
-        if time_stampify
-          file_name = "#{@dest_folder}/#{format_number(@impexify_occurences)}_#{type.name.downcase}_#{stamp}.csv"
-        else
-          file_name = "#{@dest_folder}/#{format_number(@impexify_occurences)}_#{type.name.downcase}.csv"
-        end
-        unless type.empty?
-          puts "writing #{type.name} to #{file_name}"
-          File.open(file_name, 'w') do |f|
-            f.puts type.to_imp 
-          end
-          @impexify_occurences += 1
-        end
-      end
+      write_file_for_each_type(stamp, time_stampify)
     else
+      write_result_to_one_file(result_file_name, stamp, time_stampify)
+    end
+    clean_all_type_entries
+  end 
+
+  def format_number(number_to_format, numeric_positions="4")
+    "%0#{numeric_positions}d" % number_to_format
+  end
+
+  def global_enties_number 
+    @global_enties_number
+  end
+
+  def add_entries_number(added_number)
+    @global_enties_number +=added_number
+    check_for_impexify 
+  end
+
+  private
+  def validate_macros
+    
+    #collect all macros from all types
+    @macros = @types.inject([]) do |result, type|
+      type.macros.each do |macro|
+        result << macro unless result.include?(macro)
+      end
+      result
+    end
+
+    #make sure each macro is used in at least one type
+    @macros.each do |macro|
+      if @types.none? {|type| type.attributes.include?(macro)}
+        raise ArgumentError.new "the macro #{macro} is never used in all declared types"
+      end
+    end
+  end
+  def write_result_to_one_file(result_file_name, stamp, time_stampify)
+      #will write the complete result to one file
       result_file_name = File.basename(result_file_name)
       if time_stampify
         file_name = "#{@dest_folder}/#{stamp}_#{result_file_name}"
@@ -67,36 +93,35 @@ class ImpexResult
       end
       @impexify_occurences += 1
     end
-    clean_all_type_entries
-  end 
-
-  def format_number(number_to_format, numeric_positions="4")
-    "%0#{numeric_positions}d" % number_to_format
-  end
-
-  def global_enties_number 
-    @global_enties_number
-  end
-
-  def add_entries_number(added_number)
-    @global_enties_number +=added_number
-    check_for_impexify 
-  end
-
-  private
-  def clean_all_type_entries
-    @types.each do |type|
-      type.entries.clear
+    def write_file_for_each_type(stamp, time_stampify)
+      @types.each_with_index do |type, index|
+        if time_stampify
+          file_name = "#{@dest_folder}/#{format_number(@impexify_occurences)}_#{type.name.downcase}_#{stamp}.csv"
+        else
+          file_name = "#{@dest_folder}/#{format_number(@impexify_occurences)}_#{type.name.downcase}.csv"
+        end
+        unless type.empty?
+          puts "writing #{type.name} to #{file_name}"
+          File.open(file_name, 'w') do |f|
+            f.puts type.to_imp 
+          end
+          @impexify_occurences += 1
+        end
+      end
     end
-    @global_enties_number = 0
-  end
-  def check_for_impexify
-    if @memory_safe
-      if  @global_enties_number > @max_type_entries_in_tree
-        puts "impexifying all entries since global entries #{@global_enties_number} is bigger then max #{@max_type_entries_in_tree}"
-        self.impexify 
+    def clean_all_type_entries
+      @types.each do |type|
+        type.entries.clear
+      end
+      @global_enties_number = 0
+    end
+    def check_for_impexify
+      if @memory_safe
+        if  @global_enties_number > @max_type_entries_in_tree
+          puts "impexifying all entries since global entries #{@global_enties_number} is bigger then max #{@max_type_entries_in_tree}"
+          self.impexify 
+        end
       end
     end
   end
-end
 

data/lib/simpex/type_entry.rb

@@ -23,8 +23,11 @@ class TypeEntry
         end
       end
     else 
-      if @type.attributes.size != values.size
-        raise ArgumentError.new "The number of given attributes is less then defined, expected are #{@type.attributes.inspect}" 
+      if @type.attributes.size < values.size
+        raise ArgumentError.new "The number of values for the type entry is more (#{values.size}) then defined (#{@type.attributes.size}), inside the type '#{type.name}' following attributes are expected #{type.attributes.inspect}" 
+      end
+      if @type.attributes.size > values.size
+        raise ArgumentError.new "The number of values for the type entry is less (#{values.size}) then defined (#{@type.attributes.size}), inside the type '#{type.name}' following attributes are expected #{type.attributes.inspect}" 
       end
       @type.attributes.each_with_index do |att,index|
         set(att, values[index])

data/lib/simpex/version.rb

@@ -1,4 +1,4 @@
 module Simpex
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end
 

data/test/test_result.rb

@@ -4,12 +4,9 @@ require 'fileutils'
 
 class TestResult < Test::Unit::TestCase
   def setup
-    macros = []
-    macros << "$firstmacro"
-    macros << "$secondmacro"
 
-    @category_type = Type.new("Category", %w{code[unique=true] name[lang=de]}, macros)
-    @product_type = Type.new("Product", %w{code[unique=true] name[lang=en]}, macros)
+    @category_type = Type.new("Category", %w{code[unique=true] name[lang=de]})
+    @product_type = Type.new("Product", %w{code[unique=true] name[lang=en]})
 
     @impex_dest_dir = "test/tmp"
     FileUtils.mkdir(@impex_dest_dir) unless Dir.exist?(@impex_dest_dir)
@@ -29,8 +26,84 @@ class TestResult < Test::Unit::TestCase
     assert File.exist?(@result_file_path), "the file #{@result_file_path} should have been created"
   end
 
-  def teardown
-    #File.delete(@result_file_path)
+  def test_should_recognize_not_used_macros
+    macros = []
+    macros << "$firstmacro"
+    macros << "$secondmacro"
+
+    @category_type = Type.new("Category", %w{code[unique=true] name[lang=de]}, macros)
+    @product_type = Type.new("Product", %w{code[unique=true] name[lang=en]}, macros)
+
+    result = ImpexResult.new(@impex_dest_dir)
+    result << @category_type 
+    result << @product_type
+
+
+    entry = TypeEntry.new(@product_type, %w{555 myproduct555})
+    entry = TypeEntry.new(@category_type, %w{555 mycategory})
+
+    assert_raises ArgumentError do
+      result.impexify("result.csv", false)
+    end 
+
+    @product_type = Type.new("Product", %w{code[unique=true] name[lang=en] $firstmacro}, macros)
+    @category_type = Type.new("Category", %w{code[unique=true] name[lang=de]})
+    result = ImpexResult.new(@impex_dest_dir)
+    result << @category_type 
+    result << @product_type
+    assert_raises ArgumentError do
+      result.impexify("result.csv", false)
+    end
+
+    @product_type = Type.new("Product", %w{code[unique=true] name[lang=en] $firstmacro}, macros)
+    @category_type = Type.new("Category", %w{code[unique=true] name[lang=de] $secondmacro}, macros)
+    result = ImpexResult.new(@impex_dest_dir)
+    result << @category_type 
+    result << @product_type
+    result.impexify("result.csv", false)
+  end
+
+  def test_should_write_the_impex_resupt_to_the_given_folder
+    impex_dest_dir = "test/tmp"
+    FileUtils.mkdir(impex_dest_dir) unless Dir.exist?(impex_dest_dir)
+
+    result = standard_result(impex_dest_dir)
+    result.impexify
+
+    FileUtils.rm_rf(impex_dest_dir)
+  end
+
+  def test_should_write_the_result_in_one_file
+    impex_dest_dir = "test/tmp"
+    FileUtils.mkdir(impex_dest_dir) unless Dir.exist?(impex_dest_dir)
+    result_file_path = "#{impex_dest_dir}/result.csv" 
+
+    assert !File.exist?(result_file_path)
+    result = standard_result(impex_dest_dir)
+    result.impexify("result.csv")
+    assert File.exist?(result_file_path), "the file #{result_file_path} should have been created"
+
+    File.delete(result_file_path)
+  end
+
+  private 
+  def standard_result(impex_dest_dir)
+
+    language_type = Type.new("Language", %w{isocode[unique=true] active})
+    TypeEntry.new(language_type, %w{de true})
+    TypeEntry.new(language_type, %w{en true})
+
+    catalog_type = Type.new("Catalog", %w{id[unique=true] name[lang=de] name[lang=en] defaultCatalog})
+    catalog = TypeEntry.new(catalog_type, %w{simpex_catalog SimpexCatalog SimpexCatalog true})
+
+    catalog_version_type = Type.new("CatalogVersion", %w{catalog(id)[unique=true] version[unique=true] active defaultCurrency(isocode)})
+    TypeEntry.new(catalog_version_type, [catalog.id, "online", "true", "EUR"])
+
+    result = ImpexResult.new(impex_dest_dir)
+    result << language_type 
+    result << catalog_type
+    result << catalog_version_type 
+    result
   end
 
 end

data/test/test_type.rb

@@ -46,6 +46,7 @@ class TestType < Test::Unit::TestCase
     macros = ["$catalogVersion=adsfasdfasdf", "$contentCV=someValue"]
     Type.new("MediaReference", %w{uid[unique=true] name referencedDamMedia(code,$contentCV)[lang=$lang] altText[lang=$lang] $contentCV[unique=true]}, macros)
     Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de] unit(code) $catalogVersion[unique=true] supercategories(code)}, macros)
+    Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de] unit(code,$catalogVersion) $catalogVersion[unique=true] supercategories(code)}, macros)
   end
 
   def test_type_should_validate_the_presence_of_macros_if_no_macros_are_given
@@ -60,77 +61,12 @@ class TestType < Test::Unit::TestCase
     Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de] unit(code) $catalogVe[unique=true] supercategories(code)}, macros)
   end
 
-  def test_shoud_add_an_after_each_statement
-    bash_script = "#%afterEach: "
-    after_each = "impex.getLastImportedItem().setApprovalStatus(impex.getLastImportedItem().getBaseProduct().getApprovalStatus());" 
-    product_type = Type.new("Product", %w{code[unique=true] name[lang=en]})
-    TypeEntry.new(product_type,%w{ 666 denis})
-    product_type.after_each << after_each
-    assert_match /impex/, product_type.after_each.first
-    assert_match /#%afterEach/, product_type.to_imp
-    puts product_type.to_imp
-  end
 
   def test_type_should_generate_nothing_if_no_entries
     assert_equal "", @product_type.to_imp(false)
   end
 
-  def test_should_create_a_type_entry
-    entry = TypeEntry.new(@product_type, {"code" => "333", "name[lang=de]" => "MyName"})
-    @product_type << entry
-    puts entry.inspect
-  end
-
-  def test_entry_should_verity_the_number_of_given_attributes
-    assert_raises ArgumentError do
-      entry = TypeEntry.new(@product_type, %w{66 myname myname pieces})
-    end
-  end
-
-  def test_entry_should_handle_array_containnig_specific_types
-    some_type = Type.new('SomeType', %w{code some_list_attribute})
-    entry = TypeEntry.new(some_type, ["66", [1,2,3,4]])
-  end
 
-  def test_entry_should_reference_other_entries
-    entry = TypeEntry.new(@product_type, {"code" => "333", "name[lang=en]" => "MyName"})
-    @product_type << entry
-
-    assert_equal "333", entry.get("code")
-    assert_equal "MyName", entry.get("name[lang=en]")
-  end
-
-  def test_entry_should_validate_against_the_given_type_attributes
-    product_type = Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de]})
-    assert_raise ArgumentError do
-      entry = TypeEntry.new(product_type, {"co" => "555"})
-    end
-  end
-
-  def test_should_fail_if_wrong_values_given
-    assert_raise ArgumentError do
-      entry = TypeEntry.new(@product_type, "somewrong string")
-    end
-    assert_raise ArgumentError do
-      entry = TypeEntry.new(nil, "somewrong string")
-    end
-  end
-
-  def test_entry_should_accept_array_of_values_and_assign_them_to_columns_according_to_the_order
-    entry = TypeEntry.new(@product_type, %w{555 myproduct555 meinproduct555 pieces SimpexProducts:Online SampleCategory})
-    assert_equal "myproduct555", entry.get("name[lang=en]")
-    assert_equal "meinproduct555", entry.get("name[lang=de]")
-    assert_equal "SampleCategory", entry.get("supercategories(code)")
-  end
-
-
-  def test_entry_should_inforce_to_use_unique_attributes_if_needed_for_fuzzy_matching
-    product_type = Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de]})
-    entry = TypeEntry.new(product_type, %w{555 myproduct555 meinproduct555 })
-    assert_raise ArgumentError do
-      entry.get("name")
-    end
-  end
 
   def test_should_create_impex_list_from_array
     catalog_version_type = Type.new("CatalogVersion", %w{languages(isocode)})
@@ -161,92 +97,10 @@ class TestType < Test::Unit::TestCase
     assert_equal 2, found.size 
   end
 
-  def test_entry_should_match_fuzzy_attribute_names
-    product_type = Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de] unit(code) $catalogVersion supercategories(code)}, @macros)
-    entry = TypeEntry.new(product_type, %w{555 myproduct555 meinproduct555 pieces SimpexProducts:Online SampleCategory})
-
-    assert_equal "555", entry.get("code")
-    assert_equal "pieces", entry.get("unit")
-    assert_equal "SampleCategory", entry.get("supercategories")
-
-    assert_raise ArgumentError do
-      entry.get("supercat")
-    end
-  end
-
   def test_entry_should_match_nested_brakets_attributes
     product_type = Type.new("Product", %w{code[unique=true] catalog(id)[unique=true]})
     entry = TypeEntry.new(product_type, %w{555 myCatalogId})
     assert_equal "myCatalogId", entry.catalog
   end
 
-  def test_entry_should_give_catalog_version_specific_attributes
-    product_type = Type.new("Product", %w{code[unique=true] $catalogVersion}, @macros)
-    entry = TypeEntry.new(product_type, %w{555 myCatalogId:staged })
-    assert_equal "555:myCatalogId:staged", entry.cat_ver_specific("code")
-
-    assert_raise ArgumentError do
-      product_type = Type.new("Product", %w{code[unique=true] someattr})
-      entry = TypeEntry.new(product_type, %w{555 myCatalogId:staged })
-      assert_equal "555:myCatalogId:staged", entry.cat_ver_specific("code")
-    end
-  end
-
-  def test_entry_should_match_macro_attributes
-    product_type = Type.new("Product", %w{code[unique=true] $catalogVersion},"$catalogVersion=asdfadsfasdfasdf")
-    entry = TypeEntry.new(product_type, %w{555 myCatalogId})
-    assert_equal "myCatalogId", entry.catalogVersion
-  end
-
-  def test_entry_should_match_fuzzy_attribute_names_to_real_attributes
-    product_type = Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de] unit(code) $catalogVersion supercategories(code)}, @macros)
-    entry = TypeEntry.new(product_type, %w{555 myproduct555 meinproduct555 pieces SimpexProducts:Online SampleCategory})
-
-    assert_equal "555", entry.code
-    assert_equal "pieces", entry.unit
-    assert_equal "SampleCategory", entry.supercategories
-  end
-
-  def test_should_write_the_impex_resupt_to_the_given_folder
-    impex_dest_dir = "test/tmp"
-    FileUtils.mkdir(impex_dest_dir) unless Dir.exist?(impex_dest_dir)
-
-    result = standard_result(impex_dest_dir)
-    result.impexify
-
-    FileUtils.rm_rf(impex_dest_dir)
-  end
-
-  def test_should_write_the_result_in_one_file
-    impex_dest_dir = "test/tmp"
-    FileUtils.mkdir(impex_dest_dir) unless Dir.exist?(impex_dest_dir)
-    result_file_path = "#{impex_dest_dir}/result.csv" 
-
-    assert !File.exist?(result_file_path)
-    result = standard_result(impex_dest_dir)
-    result.impexify("result.csv")
-    assert File.exist?(result_file_path), "the file #{result_file_path} should have been created"
-
-    File.delete(result_file_path)
-  end
-
-  private 
-  def standard_result(impex_dest_dir)
-
-    language_type = Type.new("Language", %w{isocode[unique=true] active})
-    TypeEntry.new(language_type, %w{de true})
-    TypeEntry.new(language_type, %w{en true})
-
-    catalog_type = Type.new("Catalog", %w{id[unique=true] name[lang=de] name[lang=en] defaultCatalog})
-    catalog = TypeEntry.new(catalog_type, %w{simpex_catalog SimpexCatalog SimpexCatalog true})
-
-    catalog_version_type = Type.new("CatalogVersion", %w{catalog(id)[unique=true] version[unique=true] active defaultCurrency(isocode)})
-    TypeEntry.new(catalog_version_type, [catalog.id, "online", "true", "EUR"])
-
-    result = ImpexResult.new(impex_dest_dir)
-    result << language_type 
-    result << catalog_type
-    result << catalog_version_type 
-    result
-  end
 end

data/test/test_type_entry.rb

@@ -0,0 +1,182 @@
+require 'test/unit'
+require File.expand_path('simpex.rb',  'lib')
+require 'fileutils'
+
+class TestTypeEntry < Test::Unit::TestCase
+  def setup
+    @macros = "$catalogVersion=catalogversion(catalog(id[default='simpexproducts']), version[default='staged'])[unique=true,default='simpexproducts:staged']"
+
+    @category_type = Type.new("Category", %w{code[unique=true] $catalogVersion name[lang=de] name[lang=en]}, @macros)
+
+    @product_type = Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de] unit(code) $catalogVersion supercategories(code)}, @macros)
+  end
+
+
+  def test_shoud_add_an_after_each_statement
+    bash_script = "#%afterEach: "
+    after_each = "impex.getLastImportedItem().setApprovalStatus(impex.getLastImportedItem().getBaseProduct().getApprovalStatus());" 
+    product_type = Type.new("Product", %w{code[unique=true] name[lang=en]})
+    TypeEntry.new(product_type,%w{ 666 denis})
+    product_type.after_each << after_each
+    assert_match /impex/, product_type.after_each.first
+    assert_match /#%afterEach/, product_type.to_imp
+  end
+
+  def test_should_create_a_type_entry
+    entry = TypeEntry.new(@product_type, {"code" => "333", "name[lang=de]" => "MyName"})
+    @product_type << entry
+  end
+
+  def test_entry_should_handle_array_containnig_specific_types
+    some_type = Type.new('SomeType', %w{code some_list_attribute})
+    entry = TypeEntry.new(some_type, ["66", [1,2,3,4]])
+  end
+
+  def test_entry_should_reference_other_entries
+    entry = TypeEntry.new(@product_type, {"code" => "333", "name[lang=en]" => "MyName"})
+    @product_type << entry
+
+    assert_equal "333", entry.get("code")
+    assert_equal "MyName", entry.get("name[lang=en]")
+  end
+
+  def test_entry_should_validate_against_the_given_type_attributes
+    product_type = Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de]})
+    assert_raise ArgumentError do
+      entry = TypeEntry.new(product_type, {"co" => "555"})
+    end
+  end
+
+  def test_should_fail_if_wrong_values_given
+    assert_raise ArgumentError do
+      entry = TypeEntry.new(@product_type, "somewrong string")
+    end
+    assert_raise ArgumentError do
+      entry = TypeEntry.new(nil, "somewrong string")
+    end
+  end
+
+  def test_entry_should_accept_array_of_values_and_assign_them_to_columns_according_to_the_order
+    entry = TypeEntry.new(@product_type, %w{555 myproduct555 meinproduct555 pieces SimpexProducts:Online SampleCategory})
+    assert_equal "myproduct555", entry.get("name[lang=en]")
+    assert_equal "meinproduct555", entry.get("name[lang=de]")
+    assert_equal "SampleCategory", entry.get("supercategories(code)")
+  end
+
+
+  def test_entry_should_inforce_to_use_unique_attributes_if_needed_for_fuzzy_matching
+    product_type = Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de]})
+    entry = TypeEntry.new(product_type, %w{555 myproduct555 meinproduct555 })
+    assert_raise ArgumentError do
+      entry.get("name")
+    end
+  end
+
+  def test_should_create_impex_list_from_array
+    catalog_version_type = Type.new("CatalogVersion", %w{languages(isocode)})
+
+    entry = TypeEntry.new(catalog_version_type, [%w{en de fr it}])
+    assert_equal "en,de,fr,it", entry.languages
+
+    entry2 = TypeEntry.new(catalog_version_type, [["en", nil, "it"]])
+    assert_equal "en,it", entry2.languages
+  end
+
+  def test_type_should_unregister_an_entry_by_attribute
+    product_type = Type.new("Product", %w{code})
+    entry = TypeEntry.new(product_type, %w{555 })
+
+    assert product_type.entries.one?{|e|e.code == "555"}
+    product_type.unregister_by("code", "555")
+    assert product_type.entries.none?{|e|e.code == "555"}
+  end
+
+  def test_type_should_find_entry_by_attribute
+    product_type = Type.new("Product", %w{code})
+    assert product_type.find_by("code", "555").empty?
+    entry = TypeEntry.new(product_type, %w{555})
+    entry = TypeEntry.new(product_type, %w{555})
+    entry = TypeEntry.new(product_type, %w{556})
+    found = product_type.find_by("code", "555")
+    assert_equal 2, found.size 
+  end
+
+  def test_entry_should_match_fuzzy_attribute_names
+    product_type = Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de] unit(code) $catalogVersion supercategories(code)}, @macros)
+    entry = TypeEntry.new(product_type, %w{555 myproduct555 meinproduct555 pieces SimpexProducts:Online SampleCategory})
+
+    assert_equal "555", entry.get("code")
+    assert_equal "pieces", entry.get("unit")
+    assert_equal "SampleCategory", entry.get("supercategories")
+
+    assert_raise ArgumentError do
+      entry.get("supercat")
+    end
+  end
+
+  def test_entry_should_match_nested_brakets_attributes
+    product_type = Type.new("Product", %w{code[unique=true] catalog(id)[unique=true]})
+    entry = TypeEntry.new(product_type, %w{555 myCatalogId})
+    assert_equal "myCatalogId", entry.catalog
+  end
+
+  def test_entry_should_give_catalog_version_specific_attributes
+    product_type = Type.new("Product", %w{code[unique=true] $catalogVersion}, @macros)
+    entry = TypeEntry.new(product_type, %w{555 myCatalogId:staged })
+    assert_equal "555:myCatalogId:staged", entry.cat_ver_specific("code")
+
+    assert_raise ArgumentError do
+      product_type = Type.new("Product", %w{code[unique=true] someattr})
+      entry = TypeEntry.new(product_type, %w{555 myCatalogId:staged })
+      assert_equal "555:myCatalogId:staged", entry.cat_ver_specific("code")
+    end
+  end
+
+  def test_entry_should_match_macro_attributes
+    product_type = Type.new("Product", %w{code[unique=true] $catalogVersion},"$catalogVersion=asdfadsfasdfasdf")
+    entry = TypeEntry.new(product_type, %w{555 myCatalogId})
+    assert_equal "myCatalogId", entry.catalogVersion
+  end
+
+  def test_entry_should_match_fuzzy_attribute_names_to_real_attributes
+    product_type = Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de] unit(code) $catalogVersion supercategories(code)}, @macros)
+    entry = TypeEntry.new(product_type, %w{555 myproduct555 meinproduct555 pieces SimpexProducts:Online SampleCategory})
+
+    assert_equal "555", entry.code
+    assert_equal "pieces", entry.unit
+    assert_equal "SampleCategory", entry.supercategories
+  end
+
+  def test_should_give_feedback_about_wrong_numbers_of_attributes
+    assert_raises ArgumentError do
+      language_type = Type.new("Language", %w{isocode[unique=true] active someOtherAtt})
+      TypeEntry.new(language_type, %w{de true})
+    end
+
+    assert_raises ArgumentError do
+      language_type = Type.new("Language", %w{isocode[unique=true] active})
+      TypeEntry.new(language_type, %w{de true xxx})
+    end
+
+  end
+
+  private 
+  def standard_result(impex_dest_dir)
+
+    language_type = Type.new("Language", %w{isocode[unique=true] active})
+    TypeEntry.new(language_type, %w{de true})
+    TypeEntry.new(language_type, %w{en true})
+
+    catalog_type = Type.new("Catalog", %w{id[unique=true] name[lang=de] name[lang=en] defaultCatalog})
+    catalog = TypeEntry.new(catalog_type, %w{simpex_catalog SimpexCatalog SimpexCatalog true})
+
+    catalog_version_type = Type.new("CatalogVersion", %w{catalog(id)[unique=true] version[unique=true] active defaultCurrency(isocode)})
+    TypeEntry.new(catalog_version_type, [catalog.id, "online", "true", "EUR"])
+
+    result = ImpexResult.new(impex_dest_dir)
+    result << language_type 
+    result << catalog_type
+    result << catalog_version_type 
+    result
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simpex
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-10 00:00:00.000000000Z
+date: 2012-10-04 00:00:00.000000000Z
 dependencies: []
 description: Read more details at the homepage https://github.com/denislutz/simpex
 email:
@@ -23,6 +23,7 @@ files:
 - .rvmrc
 - Gemfile
 - Gemfile.lock
+- Guardfile
 - Rakefile
 - lib/simpex.rb
 - lib/simpex/catalog.rb
@@ -37,6 +38,7 @@ files:
 - test/test_result.rb
 - test/test_rich_types.rb
 - test/test_type.rb
+- test/test_type_entry.rb
 homepage: https://github.com/denislutz/simpex
 licenses: []
 post_install_message: 
@@ -66,3 +68,4 @@ test_files:
 - test/test_result.rb
 - test/test_rich_types.rb
 - test/test_type.rb
+- test/test_type_entry.rb