simpex 0.0.1

data/.bundle/config

@@ -0,0 +1,2 @@
+--- {}
+

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@simpex --create

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in simpex.gemspec
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    simpex (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  simpex!

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require File.expand_path('simpex.rb', 'lib')
+
+require 'rubygems'
+
+namespace :simpex do
+  desc "Generates ImpEx file"
+  task :generate do
+    output_directory = "tmp"
+    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}"
+  end
+
+  desc "Run all tests"
+  Rake::TestTask.new("test") do |t|
+    t.pattern = 'test/test_*.rb'
+    t.verbose = true
+    t.warning = true
+  end 
+end

data/lib/simpex.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.dirname(__FILE__) + '/simpex/version')
+require File.expand_path(File.dirname(__FILE__) + '/simpex/type')
+require File.expand_path(File.dirname(__FILE__) + '/simpex/type_entry')
+require File.expand_path(File.dirname(__FILE__) + '/simpex/impex_result')
+require File.expand_path(File.dirname(__FILE__) + '/simpex/factory')
+require File.expand_path(File.dirname(__FILE__) + '/simpex/catalog')

data/lib/simpex/catalog.rb

@@ -0,0 +1,12 @@
+class Catalog < TypeEntry
+
+  def initialize(values)
+    super(@@type, values)
+  end
+
+  @@type = Type.new("Catalog", %w{activeCatalogVersion(catalog(id),version) backRefPK buyer(uid) creationtime[forceWrite=true,dateformat=dd.MM.yyyy hh:mm:ss] defaultCatalog[allownull=true] id[unique=true,allownull=true] name[lang=de] name[lang=en] name[lang=fr] name[lang=it] owner(Customer.uid) previewURLTemplate supplier(uid) urlPatterns})
+
+  def Catalog.type
+    @@type
+  end
+end

data/lib/simpex/factory.rb

@@ -0,0 +1,37 @@
+class Factory 
+  def Factory.generate_base_catalog_setup_to_file(impex_dest_dir, result_file_name)
+    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", "de,en"])
+
+    result = ImpexResult.new(impex_dest_dir)
+    result << language_type 
+    result << catalog_type
+    result << catalog_version_type 
+    result.impexify(result_file_name)
+  end
+
+  def Factory.generate_base_catalog_setup_to(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.impexify
+  end
+end

data/lib/simpex/impex_result.rb

@@ -0,0 +1,98 @@
+class ImpexResult
+
+  attr_writer :memory_safe, :max_type_entries_in_tree
+
+  def initialize(dest_folder)
+    raise "Given dest folder #{dest_folder} is either nil or does not exist!" if dest_folder.nil? || !Dir.exist?(dest_folder)
+    @dest_folder = dest_folder
+    @types = []
+    @max_type_entries_in_tree = 2000 
+    @global_enties_number = 0
+    @impexify_occurences = 0
+    @memory_safe = false
+  end
+
+  def <<(type)
+    @types << type
+    if @memory_safe
+      type.memory_safe = true
+    end
+    type.impex_result = self
+    raise "no result set on type" unless type.impex_result 
+    add_entries_number(type.entries.size)
+    check_for_impexify
+  end
+
+  def impexify(result_file_name="", time_stampify = true)
+    if result_file_name.empty?
+      stamp = Time.now.strftime("%S_%M_%H_%d_%m_%Y") if 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
+    else
+      result_file_name = File.basename(result_file_name)
+      file_name = "#{@dest_folder}/#{result_file_name}"
+      puts "writing complete result to the file #{file_name}"
+      result_file_name = File.basename(result_file_name)
+      raise "You gave the directory #{result_file_name} instead of a single file" if File.directory?(result_file_name)
+      File.open(file_name, "w") do |f|
+        all_macros = []
+        @types.each do |type|
+          type.macros.each do |macro|
+            all_macros << macro unless all_macros.include?(macro)
+          end
+        end
+        all_macros.each do |m|
+          f.puts m
+        end
+        f.puts "\n"
+        @types.each do |type|
+          f.puts type.to_imp(false) unless type.empty?
+        end
+      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
+    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
+

data/lib/simpex/type.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'csv'
+
+class Type 
+  attr_reader :attributes, :entries, :name, :macros, :impex_command, :impex_result, :after_each
+  attr_writer :impex_command, :impex_result, :memory_safe, :after_each
+
+  def  initialize(name, type_attributes, macros=[])
+    raise "Type name was not given, use e.g. 'Product'  or 'Category'" if name.empty?
+    raise ArgumentError.new("Attribute values must be given in an array, use '%w{code name description catalog}'") unless type_attributes.kind_of?(Array)
+    raise "Macros was given but is nil" if macros.nil?
+
+    if macros.kind_of? String
+      @macros = [macros]
+    else
+      @macros = macros
+    end
+    @attributes = []
+    type_attributes.each do |attribute|
+      next if attribute.nil? || attribute.empty?
+      if attribute.kind_of?(Hash)
+        @attributes += resolve_to_attributes(attribute)
+      else
+        @attributes << attribute
+        if attribute =~ /^\$/
+          if @macros.empty? || @macros.none?{|m| m.split("=").first == attribute}
+            raise ArgumentError.new "You are using a macro that is not defined: #{attribute}, declared macros are #{@macros}" 
+          end
+        end
+      end
+    end
+    @name = name 
+    @entries = []
+    @impex_command = "INSERT_UPDATE"
+    @impex_result = nil
+    @memory_safe = false
+    @after_each = []
+    @before_each = []
+  end
+
+  def <<(entry)
+    @entries << entry
+    if @impex_result 
+      @impex_result.add_entries_number(1)
+    elsif @memory_safe
+      raise "impex result object is not set, but we are running in a memory safe impex generation"
+    end
+  end
+
+  def empty?
+    self.entries.empty?
+  end
+
+  def to_imp(macros=true)
+    result = ""
+    return result if @entries.empty?
+    if (!@macros.empty? && macros)
+      @macros.each do |macro|
+        result << macro 
+        result << "\n" 
+      end
+      result << "\n" 
+    end
+    result << "#{@impex_command} #{@name}" +  impexify(@attributes)
+    unless after_each.empty?
+      result << "\"#%afterEach:\n" 
+      after_each.each do |bash_line|
+        result << bash_line << "\n"
+      end
+      result << "\"\n" 
+    end
+    @entries.each do |entry|
+      result << entry.to_imp
+    end
+    result << "\n" 
+    unless after_each.empty?
+      result << "\"#%afterEach:end\"" 
+    end
+    result
+  end
+
+  def unregister_by(attribute, value)
+    self.entries.reject!{|entry| entry.send(attribute) == value}
+  end
+
+  def find_by(attribute, value)
+    self.entries.find_all{|entry| entry.send(attribute) == value}
+  end
+
+  private
+  def resolve_to_attributes(attrib)
+    raise "The feature of reading hashes of attrbite names is planned but not implemented yet, implement it here"
+  end
+
+  def impexify(array)
+    CSV.generate_line([nil] + array + [nil], :col_sep => ";")
+  end
+
+end
+

data/lib/simpex/type_entry.rb

@@ -0,0 +1,94 @@
+require 'csv'
+
+class TypeEntry
+
+  attr :type, :values
+
+  def  initialize(type, values)
+    raise ArgumentError.new("Type must be a Type") unless type.kind_of? Type
+    raise ArgumentError.new("Values must be a hash or an array") if (!values.kind_of?(Hash) ) && !values.kind_of?(Array)
+
+    @type = type
+
+    @values = @type.attributes.inject({}) do |result, att|
+      result[att] = nil
+      result
+    end 
+
+    if values.kind_of?(Hash)
+      values.each do |key, value|
+        real_att_name = guess_attribute(key)
+        if real_att_name
+          set(real_att_name, value)
+        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}" 
+      end
+      @type.attributes.each_with_index do |att,index|
+        set(att, values[index])
+      end
+    end
+    type << self
+  end
+
+  def get(att_name)
+    attr_names = @values.keys
+    if attr_names.include?(att_name)
+      @values[att_name]
+    else
+      @values[guess_attribute(att_name)]
+    end
+  end
+
+  def method_missing(id, *args)
+    self.get("#{id}")
+  end
+
+  def set(attributes)
+    @values.merge!(attributes)
+  end
+
+  def set(key, value)
+    if value.kind_of?(Array)
+      @values[key] = value.reject{|v| v.nil? || v.empty? }.join(",")
+    else
+      @values[key] = value
+    end
+  end
+
+  def to_imp
+    impexify(@values.values)
+  end
+
+  def cat_ver_specific(attr_name)
+    self.get(attr_name) + ":" + self.get("catalogVersion")
+  end
+  
+  private
+  def guess_attribute(att_name)
+    attr_names = @values.keys
+    guessed_attribute_matches = attr_names.select{|e| e.split("(").first == att_name || 
+                                                      e.split("[").first == att_name || 
+                                                      e.split("$").last == att_name }
+
+    if guessed_attribute_matches.size > 1
+      error_msg = "There is more than one matching attribute name for the given 
+                        name #{att_name}, matches are #{guessed_attribute_matches.inspect}, 
+                      using of full attribute names is advised"
+                      raise ArgumentError.new error_msg
+    else
+      guessed_attribute = guessed_attribute_matches.first
+      if guessed_attribute
+        guessed_attribute
+      else
+        raise ArgumentError.new "No attribte '#{att_name}' was found for the type '#{self.type.name}', declared attributes: #{attr_names.inspect}"
+      end
+    end
+  end
+
+  def impexify(array)
+    CSV.generate_line([nil] + array + [nil], :col_sep => ";")
+  end
+end

data/lib/simpex/version.rb

@@ -0,0 +1,4 @@
+module Simpex
+  VERSION = "0.0.1"
+end
+

data/readme.textile

@@ -0,0 +1,82 @@
+h1. Simpex – Ruby library for simple ImpEx generation
+
+The impex torture is over guys! Enjoy your hybris projects with a nice ruby api for impex generation!
+
+Simpex will make your life easier because:
+
+* it will remove the "csv noise" from your eyes
+* let you focus on the important stuff, building relationships between your impex tables
+* process any incoming format like xml, excel, csv with the power of ruby
+* do basic impex validations for you before hybris does it: asserting number of attributes and values, asserting the presense of macros
+* handle huge file sets and write to a file after 20000 entries in the whole tree ( set @memory_safe = true and setup the  max_type_entries_in_tree all in the impex_result.rb)
+* generate the right files names with right index numbers so hyris can process them in the right order
+* simpex is bullet proof and was used and developed for a huge ecommerce project in cooperation with namics.com
+
+
+Ready? Here it comes:
+
+product_type = Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de] unit(code) $catalogVersion supercategories(code)})
+
+product = TypeEntry.new(product_type, %w{555 myproduct555 meinproduct555 pieces SimpexProducts:Online SampleCategory})
+
+assert_equal "555", product.code
+
+assert_equal "pieces", product.unit
+
+assert_equal "SampleCategory", product.supercategories
+
+
+
+Never worry about the order of rows any more just create a hash specifying the attributes:
+
+product2 = TypeEntry.new(product_type, {"code" => "333", "name" => "MyName"})
+
+
+Just use full string attribute names for ambigious attributes like
+
+
+assert_equal "myproduct555", product.get("name[lang=en]")
+
+assert_equal "meinproduct555", product.get("name[lang=de]")
+
+
+Now lets build some real references:
+
+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)})
+catalog_version = TypeEntry.new(catalog_version_type, [catalog.id, "online", "true", "EUR", "de,en"])
+
+
+Now add averything to a main object managing the files creation:
+
+result = ImpexResult.new("your/impex/folder")
+
+catalog_type << catalog
+product_type << product
+
+result << catalog_type
+result << product_type
+
+result.impexify # => will write separate files for each type 
+result.impexify("basic_setup.csv") # => will write all tables to one file in the folder your/impex/folder
+
+
+Thats it!
+
+h2. Setup
+
+rvm install 1.9.1
+cd to directory and run _bundle install_
+
+h2. ImpEx file generation
+
+For now it only generates a dummy ImpEx file.
+Run _rake simpex:generate_
+You can find the generated file in 'tmp/'
+
+Run _rake simpex:test_ to execute all tests
+
+
+

data/simpex.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "simpex/version"
+
+Gem::Specification.new do |s|
+  s.name        = "simpex"
+  s.version     = Simpex::VERSION
+  s.authors     = ["Denis Lutz"]
+  s.email       = ["denis.lutz@gmail.com"]
+  s.homepage    = "https://github.com/denislutz/simpex"
+  s.summary     = %q{Simpex is gem to confortably create hybris impex format files in an object oriented way.}
+  s.description = %q{Read more details at the homepage https://github.com/denislutz/simpex}
+
+  s.rubyforge_project = "simpex"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end
+

data/test/test_result.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require File.expand_path('simpex.rb',  'lib')
+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)
+
+    @impex_dest_dir = "test/tmp"
+    FileUtils.mkdir(@impex_dest_dir) unless Dir.exist?(@impex_dest_dir)
+    @result_file_path = File.expand_path("result.csv",  @impex_dest_dir)
+
+    #assert !File.exist?(@result_file_path)
+  end
+
+  def test_should_collect_all_marcros_in_a_given_file
+    entry = TypeEntry.new(@product_type, %w{555 myproduct555})
+    entry = TypeEntry.new(@category_type, %w{555 mycategory})
+
+    result = ImpexResult.new(@impex_dest_dir)
+    result << @category_type 
+    result << @product_type 
+    result.impexify("result.csv")
+    assert File.exist?(@result_file_path), "the file #{@result_file_path} should have been created"
+  end
+
+  def teardown
+    #File.delete(@result_file_path)
+  end
+
+end

data/test/test_rich_types.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require File.expand_path('simpex.rb',  'lib')
+require 'fileutils'
+
+class TestRichTypes < Test::Unit::TestCase
+
+  def setup
+    @impex_dest_dir = "test/tmp"
+    FileUtils.mkdir(@impex_dest_dir) unless Dir.exist?(@impex_dest_dir)
+  end
+
+  def teardown
+    FileUtils.rm_rf(@impex_dest_dir)
+  end
+
+  def test_should_create_catalog_with_specific_type
+    file_name = "specific_type.csv"
+    assert_equal false, File.exist?(File.expand_path(file_name, "test/tmp"))
+
+    catalog = Catalog.new("id" => "mycatalog")
+    assert_not_nil catalog
+    assert_equal "mycatalog", catalog.id
+
+    result = ImpexResult.new(@impex_dest_dir)
+    result << Catalog.type 
+    result.impexify(file_name)
+    assert_equal true, File.exist?(File.expand_path(file_name, "test/tmp"))
+  end
+end

data/test/test_type.rb

@@ -0,0 +1,225 @@
+require 'test/unit'
+require File.expand_path('simpex.rb',  'lib')
+require 'fileutils'
+
+class TestType < 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_validate_type_input_on_creation
+    assert_raise ArgumentError do
+      @category_type = Type.new("MyType", "wrong;string")
+    end
+  end
+
+  def test_should_have_setter_getter_for_impex_command
+    assert_equal "INSERT_UPDATE", @product_type.impex_command
+    @product_type.impex_command = "update"
+    assert_equal "update", @product_type.impex_command
+  end
+
+  def test_should_create_a_type
+    assert_not_nil @category_type.attributes
+    assert_not_nil @category_type.entries
+    puts @category_type.inspect
+  end
+
+  def test_type_should_validate_the_presence_of_macros
+    assert_raises ArgumentError do
+      Type.new("Product", %w{code[unique=true] name[lang=en] name[lang=de] unit(code) $catalogVersion supercategories(code)})
+    end
+
+    macros = ["$catalogVersion=adsfasdfasdf"]
+    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
+      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_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_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

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: simpex
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Denis Lutz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-17 00:00:00.000000000Z
+dependencies: []
+description: Read more details at the homepage https://github.com/denislutz/simpex
+email:
+- denis.lutz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .bundle/config
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- lib/simpex.rb
+- lib/simpex/catalog.rb
+- lib/simpex/factory.rb
+- lib/simpex/impex_result.rb
+- lib/simpex/type.rb
+- lib/simpex/type_entry.rb
+- lib/simpex/version.rb
+- readme.textile
+- simpex.gemspec
+- test/test_result.rb
+- test/test_rich_types.rb
+- test/test_type.rb
+homepage: https://github.com/denislutz/simpex
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: simpex
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Simpex is gem to confortably create hybris impex format files in an object
+  oriented way.
+test_files:
+- test/test_result.rb
+- test/test_rich_types.rb
+- test/test_type.rb