rtext 0.2.0

data/lib/rtext/serializer.rb

@@ -0,0 +1,190 @@
+require 'rtext/language'
+
+module RText
+
+class Serializer
+
+  # Creates a serializer for RText::Language +language+.
+  #
+  def initialize(language)
+    @lang = language
+  end
+
+  # Serialize +elements+ to +writer+. Options:
+  #
+  #  :set_line_number
+  #    if set to true, the serializer will try to update the line number attribute of model
+  #    elements, while they are serialized, given that they have the line_number_attribute
+  #    specified in the RText::Language
+  #    default: don't set line number
+  #
+  #  :fragment_ref
+  #    an object referencing a fragment, this will be set on all model elements while they
+  #    are serialized, given that they have the fragment_ref_attribute specified in the
+  #    RText::Language
+  #    default: don't set fragment reference
+  #
+  def serialize(elements, writer, options={})
+    @writer = writer
+    @set_line_number = options[:set_line_number]
+    @fragment_ref = options[:fragment_ref]
+    @line_number = 1
+    @indent = 0
+    if elements.is_a?(Array)
+      serialize_elements(elements)
+    else
+      serialize_elements([elements])
+    end
+  end
+
+  private
+
+  def serialize_elements(elements)
+    elements.each do |e|
+      serialize_element(e)
+    end
+  end
+  
+  def serialize_element(element)
+    set_fragment_ref(element)
+    set_line_number(element, @line_number) if @set_line_number
+    clazz = element.class.ecore
+
+    # the comment provider may modify the element
+    comment = @lang.comment_provider && @lang.comment_provider.call(element)
+    if comment
+      comment.split(/\r?\n/).each do |l|
+        write("##{l}")
+      end
+    end
+    headline = @lang.command_by_class(clazz.instanceClass)
+    raise "no command name for class #{clazz.instanceClass.to_s}" unless headline
+    args = []
+    @lang.unlabled_arguments(clazz).each do |f|
+      values = serialize_values(element, f)
+      args << values if values
+    end
+    @lang.labled_arguments(clazz).each do |f|
+      values = serialize_values(element, f)
+      args << "#{f.name}: #{values}" if values
+    end
+    headline += " "+args.join(", ") if args.size > 0
+    contained_elements = {}
+    @lang.containments(clazz).each do |f|
+      contained_elements[f] = element.getGenericAsArray(f.name) 
+    end
+    if contained_elements.values.any?{|v| v.size > 0}
+      headline += " {"
+      write(headline)
+      iinc
+      @lang.containments(clazz).each do |f|
+        childs = contained_elements[f]
+        if childs.size > 0
+          if @lang.containments_by_target_type(f.eContainingClass, f.eType).size > 1
+            if childs.size > 1
+              write("#{f.name}: [")
+              iinc
+              serialize_elements(childs)
+              idec
+              write("]")
+            else
+              write("#{f.name}:")
+              iinc
+              serialize_elements(childs)
+              idec
+            end
+          else
+            serialize_elements(childs)
+          end
+        end
+      end
+      idec
+      write("}")
+    else
+      write(headline)
+    end
+  end
+
+  def serialize_values(element, feature)
+    values = element.getGenericAsArray(feature.name).compact
+    result = []
+    arg_format = @lang.argument_format(feature)
+    values.each do |v|
+      if feature.eType.instanceClass == Integer
+        if arg_format 
+          result << sprintf(arg_format, v)
+        else
+          result << v.to_s
+        end
+      elsif feature.eType.instanceClass == String
+        if @lang.unquoted?(feature) && v.to_s =~ /^[a-zA-Z_]\w*$/ && v.to_s != "true" && v.to_s != "false"
+          result << v.to_s
+        else
+          result << "\"#{v.gsub("\\","\\\\\\\\").gsub("\"","\\\"").gsub("\n","\\n").
+            gsub("\r","\\r").gsub("\t","\\t").gsub("\f","\\f").gsub("\b","\\b")}\""
+        end
+      elsif feature.eType.instanceClass == RGen::MetamodelBuilder::DataTypes::Boolean
+        result << v.to_s
+      elsif feature.eType.instanceClass == Float
+        if arg_format 
+          result << sprintf(arg_format, v)
+        else
+          result << v.to_s
+        end
+      elsif feature.eType.is_a?(RGen::ECore::EEnum)
+        if v.to_s =~ /\W/
+          result << "\"#{v.to_s.gsub("\\","\\\\\\\\").gsub("\"","\\\"").gsub("\n","\\n").
+            gsub("\r","\\r").gsub("\t","\\t").gsub("\f","\\f").gsub("\b","\\b")}\""
+        else
+          result << v.to_s  
+        end
+      elsif feature.eType.instanceClass == Object
+        if v.to_s =~ /^\d+(\.\d+)?$|^\w+$|^true$|^false$/ 
+          result << v.to_s  
+        else
+          result << "\"#{v.to_s.gsub("\\","\\\\\\\\").gsub("\"","\\\"").gsub("\n","\\n").
+            gsub("\r","\\r").gsub("\t","\\t").gsub("\f","\\f").gsub("\b","\\b")}\""
+        end
+      elsif feature.is_a?(RGen::ECore::EReference)
+        result << @lang.identifier_provider.call(v, element) 
+      end
+    end
+    if result.size > 1  
+      "[#{result.join(", ")}]"
+    elsif result.size == 1
+      result.first 
+    else
+      nil
+    end
+  end
+
+  def set_line_number(element, line)
+    if @lang.line_number_attribute && element.respond_to?("#{@lang.line_number_attribute}=")
+      element.send("#{@lang.line_number_attribute}=", line)
+    end
+  end
+
+  def set_fragment_ref(element)
+    if @fragment_ref && 
+      @lang.fragment_ref_attribute && element.respond_to?("#{@lang.fragment_ref_attribute}=")
+        element.send("#{@lang.fragment_ref_attribute}=", @fragment_ref)
+    end
+  end
+
+  def write(str)
+    @writer.write(@lang.indent_string * @indent + str + "\n")
+    @line_number += 1
+  end
+
+  def iinc
+    @indent += 1
+  end
+
+  def idec
+    @indent -= 1
+  end
+end
+
+end
+
+

data/lib/rtext/service.rb

@@ -0,0 +1,182 @@
+require 'socket'
+require 'rtext/completer'
+require 'rtext/context_element_builder'
+
+module RText
+
+class Service
+  PortRangeStart = 9001
+  PortRangeEnd   = 9100
+
+  FlushInterval  = 1
+
+  # Creates an RText backend service. Options:
+  #
+  #  :timeout
+  #    idle time in seconds after which the service will terminate itelf
+  #
+  #  :logger
+  #    a logger object on which the service will write its logging output
+  #
+  def initialize(lang, service_provider, options={})
+    @lang = lang
+    @service_provider = service_provider
+    @completer = RText::Completer.new(lang) 
+    @timeout = options[:timeout] || 60
+    @logger = options[:logger]
+  end
+
+  def run
+    socket = create_socket 
+    puts "RText service, listening on port #{socket.addr[1]}"
+    $stdout.flush
+
+    last_access_time = Time.now
+    last_flush_time = Time.now
+    stop_requested = false
+    while !stop_requested
+      begin
+        msg, from = socket.recvfrom_nonblock(65000)
+      rescue Errno::EWOULDBLOCK
+        sleep(0.01)
+        if (Time.now - last_access_time) > @timeout
+          @logger.info("RText service, stopping now (timeout)") if @logger
+          break 
+        end
+        retry
+      end
+      if Time.now > last_flush_time + FlushInterval
+        $stdout.flush
+        last_flush_time = Time.now
+      end
+      last_access_time = Time.now
+      lines = msg.split(/\r?\n/)
+      cmd = lines.shift
+      invocation_id = lines.shift
+      response = nil
+      case cmd
+      when "refresh"
+        response = refresh(lines) 
+      when "complete"
+        response = complete(lines)
+      when "show_problems"
+        response = get_problems(lines)
+      when "get_reference_targets"
+        response = get_reference_targets(lines)
+      when "get_elements"
+        response = get_open_element_choices(lines)
+      when "stop"
+        response = [] 
+        @logger.info("RText service, stopping now (stop requested)") if @logger
+        stop_requested = true
+      else
+        @logger.debug("unknown command #{cmd}") if @logger
+        response = []
+      end
+      send_response(response, invocation_id, socket, from)
+    end
+  end
+
+  private
+
+  def send_response(response, invocation_id, socket, from)
+    @logger.debug(response.inspect) if @logger
+    loop do
+      packet_lines = []
+      size = 0
+      while response.size > 0 && size + response.first.size < 65000
+        size += response.first.size
+        packet_lines << response.shift
+      end
+      if response.size > 0
+        packet_lines.unshift("more\n")
+      else
+        packet_lines.unshift("last\n")
+      end
+      packet_lines.unshift("#{invocation_id}\n")
+      socket.send(packet_lines.join, 0, from[2], from[1])
+      break if response.size == 0 
+    end
+  end
+
+  def create_socket
+    socket = UDPSocket.new
+    port = PortRangeStart
+    begin
+      socket.bind("localhost", port)
+    rescue Errno::EADDRINUSE
+      port += 1
+      retry if port <= PortRangeEnd
+      raise
+    end
+    socket
+  end
+
+  def refresh(lines)
+    @service_provider.load_model
+    []
+  end
+
+  def complete(lines)
+    linepos = lines.shift.to_i
+    context = ContextElementBuilder.build_context_element(@lang, lines, linepos)
+    @logger.debug("context element: #{@lang.identifier_provider.call(context, nil)}") if @logger
+    current_line = lines.pop
+    current_line ||= ""
+    options = @completer.complete(current_line, linepos, 
+      proc {|i| lines[-i]}, 
+      proc {|ref| 
+        @service_provider.get_reference_completion_options(ref, context).collect {|o|
+          Completer::CompletionOption.new(o.identifier, "<#{o.type}>")}
+      })
+    options.collect { |o|
+      "#{o.text};#{o.extra}\n"
+    }
+  end
+
+  def get_problems(lines)
+    # TODO: severity
+    result = []
+    @service_provider.get_problems.each do |fp|
+      result << fp.file+"\n"
+      fp.problems.each do |p| 
+        result << "#{p.line};#{p.message}\n"
+      end
+    end
+    result
+  end
+
+  def get_reference_targets(lines)
+    linepos = lines.shift.to_i
+    context = ContextElementBuilder.build_context_element(@lang, lines, linepos)
+    current_line = lines.last
+    result = []
+    if current_line[linepos..linepos] =~ /[\w\/]/
+      ident_start = (current_line.rindex(/[^\w\/]/, linepos) || -1)+1
+      ident_end = (current_line.index(/[^\w\/]/, linepos) || current_line.size)-1
+      ident = current_line[ident_start..ident_end]
+      result << "#{ident_start};#{ident_end}\n"
+      if current_line[0..linepos+1] =~ /^\s*\w+$/
+        @service_provider.get_referencing_elements(ident, context).each do |t|
+          result << "#{t.file};#{t.line};#{t.display_name}\n"
+        end
+      else
+        @service_provider.get_reference_targets(ident, context, lines, linepos).each do |t|
+          result << "#{t.file};#{t.line};#{t.display_name}\n"
+        end
+      end
+    end
+    result
+  end
+
+  def get_open_element_choices(lines)
+    pattern = lines.shift
+    @service_provider.get_open_element_choices(pattern).collect do |c|
+      "#{c.display_name};#{c.file};#{c.line}\n"
+    end
+  end
+
+end
+
+end
+

data/lib/rtext_plugin/connection_manager.rb

@@ -0,0 +1,59 @@
+module RTextPlugin
+
+class ConnectorManager
+  def start
+  end
+  
+  def stop
+  end
+  
+  def trigger
+  end
+   
+private
+
+  def find_rtext_config_file(file)
+  end
+
+  def extract_file_pattern(file)
+    ext = File.extname
+    if ext.size > 0
+      "*.#{ext}"
+    else
+      File.basename(file)
+    end
+  end
+
+  ServiceSpec = Struct.new(:config_file, :pattern, :command)
+   
+  def parse_rtext_config_file(file)
+    expect = :pattern
+    line = 1
+    pattern = nil
+    specs = []
+    File.open(file) do |f|
+      f.readlines.each do |l|
+        case expect
+        when :pattern
+          if l =~ /(.*):\s*$/
+            pattern = $1.split(",").collect{|s| s.strip} 
+            expect = :command
+          else
+            raise "expected file pattern in line #{line}"
+          end
+        when :command
+          if l =~ /[^:]\s*$/
+            specs << ServiceSpec.new(file, pattern, l)
+          else
+            raise "expected command in line #{line}"
+          end
+        end
+        line += 1
+      end
+    end
+    specs
+  end
+
+end
+
+end

data/test/instantiator_test.rb

@@ -0,0 +1,931 @@
+# coding: binary
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/environment'
+require 'rgen/metamodel_builder'
+require 'rtext/instantiator'
+require 'rtext/language'
+
+class RTextInstantiatorTest < Test::Unit::TestCase
+
+  module TestMM
+    extend RGen::MetamodelBuilder::ModuleExtension
+    class TestNode < RGen::MetamodelBuilder::MMBase
+      SomeEnum = RGen::MetamodelBuilder::DataTypes::Enum.new([:A, :B, :'non-word*chars'])
+      has_attr 'text', String
+      has_attr 'integer', Integer
+      has_attr 'boolean', Boolean
+      has_attr 'enum', SomeEnum
+      has_many_attr 'nums', Integer
+      has_attr 'float', Float
+      has_one 'related', TestNode
+      has_many 'others', TestNode
+      contains_many 'childs', TestNode, 'parent'
+    end
+    class SubNode < TestNode
+    end
+  end
+
+  module TestMM2
+    extend RGen::MetamodelBuilder::ModuleExtension
+    class TestNode < RGen::MetamodelBuilder::MMBase
+      contains_one 'singleChild', TestNode, 'parent'
+    end
+    class TestNode2 < RGen::MetamodelBuilder::MMBase
+    end
+    class TestNode3 < RGen::MetamodelBuilder::MMBase
+    end
+    class TestNode4 < TestNode
+    end
+    TestNode.contains_one 'singleChild2a', TestNode2, 'parentA'
+    TestNode.contains_one 'singleChild2b', TestNode2, 'parentB'
+  end
+
+  module TestMMLinenoFilename
+    extend RGen::MetamodelBuilder::ModuleExtension
+    class TestNode < RGen::MetamodelBuilder::MMBase
+      has_attr 'text', String
+      has_attr 'lineno', Integer
+      has_attr 'filename', String
+      contains_many 'childs', TestNode, 'parent'
+    end
+  end
+
+  module TestMMAbstract
+    extend RGen::MetamodelBuilder::ModuleExtension
+    class TestNode < RGen::MetamodelBuilder::MMBase
+      abstract
+    end
+  end
+
+  module TestMMData
+    extend RGen::MetamodelBuilder::ModuleExtension
+    # class "Data" exists in the standard Ruby namespace
+    class Data < RGen::MetamodelBuilder::MMBase
+      has_attr 'notTheBuiltin', String
+    end
+  end
+
+  module TestMMSubpackage
+    extend RGen::MetamodelBuilder::ModuleExtension
+    module SubPackage
+      extend RGen::MetamodelBuilder::ModuleExtension
+      class TestNodeSub < RGen::MetamodelBuilder::MMBase
+        has_attr 'text', String
+      end
+      class Data < RGen::MetamodelBuilder::MMBase
+        has_attr 'notTheBuiltin', String
+      end
+    end
+  end
+
+  def test_simple
+    env, problems = instantiate(%Q(
+      TestNode text: "some text", nums: [1,2] {
+        TestNode text: "child"
+        TestNode text: "child2"
+      }
+      ), TestMM)
+    assert_no_problems(problems)
+    assert_model_simple(env, :with_nums)
+  end
+
+  def test_multiple_roots
+    env, problems = instantiate(%Q(
+      TestNode
+      TestNode
+    ), TestMM)
+    assert_no_problems(problems)
+    assert_equal 2, env.elements.size
+  end
+
+  def test_comment
+    env, problems = instantiate(%Q(
+      # comment 1
+      TestNode text: "some text" {# comment 1.1
+        childs: [ # comment 1.2
+          # comment 2
+          TestNode text: "child" # comment 2.1
+          # comment 3
+          TestNode text: "child2" #comment 3.1
+          # unassociated
+        ] # comment 1.3
+        # unassociated
+      } # comment 1.4
+      #comment 1
+      TestNode { #comment 1.1
+        childs: # comment 1.2
+          TestNode text: "child" #comment2
+        # unassociated
+      }# comment 1.3
+      # unassociated
+      ), TestMM)
+    assert_no_problems(problems)
+    assert_model_simple(env)
+  end
+
+  def test_comment_only
+    env, problems = instantiate(%Q(
+      # comment 1
+      ), TestMM)
+    assert_no_problems(problems)
+  end
+
+  def test_empty
+    env, problems = instantiate("", TestMM)
+    assert_no_problems(problems)
+  end
+
+  # 
+  # options
+  # 
+
+  def test_line_number_setter
+    env, problems = instantiate(%q(
+      TestNode text: "node1" {
+        TestNode text: "node2"
+
+        #some comment
+        TestNode text: "node3"
+      }
+      TestNode text: "node4"
+    ), TestMMLinenoFilename, :line_number_attribute => "lineno")
+    assert_no_problems(problems)
+    assert_equal 2, env.find(:text => "node1").first.lineno
+    assert_equal 3, env.find(:text => "node2").first.lineno
+    assert_equal 6, env.find(:text => "node3").first.lineno
+    assert_equal 8, env.find(:text => "node4").first.lineno
+  end
+
+  def test_root_elements
+    root_elements = []
+    env, problems = instantiate(%Q(
+      TestNode text: A
+      TestNode text: B
+      TestNode text: C
+    ), TestMM, :root_elements => root_elements)
+    assert_no_problems(problems)
+    assert_equal ["A", "B", "C"], root_elements.text
+  end
+
+  def test_file_name_option
+    env, problems = instantiate(%Q(
+      TestNode text: A
+      TestNode text: B
+      TestNode a problem here 
+    ), TestMM, :file_name => "some_file")
+    assert_equal ["some_file"], problems.collect{|p| p.file}
+  end
+
+  def test_file_name_setter
+    env, problems = instantiate(%Q(
+      TestNode text: A
+    ), TestMMLinenoFilename, :file_name => "some_file", :file_name_attribute => "filename")
+    assert_equal "some_file", env.elements.first.filename 
+  end
+
+  #
+  # children with role
+  #
+
+  def test_child_role
+    env, problems = instantiate(%Q(
+      TestNode text: "some text" {
+        TestNode text: "child"
+        childs:
+          TestNode text: "child2"
+      }
+      ), TestMM)
+    assert_no_problems(problems)
+    assert_model_simple(env)
+  end
+
+  def test_child_role2
+    env, problems = instantiate(%Q(
+      TestNode text: "some text" {
+        childs: [
+          TestNode text: "child"
+          TestNode text: "child2"
+        ]
+      }
+      ), TestMM)
+    assert_no_problems(problems)
+    assert_model_simple(env)
+  end
+
+  def test_child_role3
+    env, problems = instantiate(%Q(
+      TestNode text: "some text" {
+        childs:
+          TestNode text: "child"
+        childs:
+          TestNode text: "child2"
+      }
+      ), TestMM)
+    assert_no_problems(problems)
+    assert_model_simple(env)
+  end
+
+  def test_child_role4
+    env, problems = instantiate(%Q(
+      TestNode text: "some text" {
+        childs: [
+          TestNode text: "child"
+        ]
+        childs: [
+          TestNode text: "child2"
+        ]
+      }
+      ), TestMM)
+    assert_no_problems(problems)
+    assert_model_simple(env)
+  end
+
+  #
+  # whitespace
+  # 
+
+  def test_whitespace1
+    env, problems = instantiate(%Q(
+      TestNode    text:  "some text" , nums: [ 1 , 2 ] {
+
+        # comment
+
+        TestNode text: "child"
+
+        TestNode text: "child2"
+
+      }
+      ), TestMM)
+    assert_no_problems(problems)
+    assert_model_simple(env, :with_nums)
+  end
+
+  def test_whitespace2
+    env, problems = instantiate(%Q(
+      # comment1
+
+      # comment2
+
+      TestNode    text:  "some text"  {
+
+        childs:
+
+        # comment
+
+        TestNode text: "child"
+
+        childs:  [
+
+        TestNode text: "child2"
+
+        ]
+
+      }
+      ), TestMM)
+    assert_no_problems(problems)
+    assert_model_simple(env)
+  end
+
+  #
+  # references
+  # 
+
+  def test_references
+    unresolved_refs = []
+    env, problems = instantiate(%Q(
+      TestNode text: "root" {
+        TestNode related: /
+        TestNode related: //
+        TestNode related: /some
+        TestNode related: //some
+        TestNode related: /some/
+        TestNode related: some/
+        TestNode related: some//
+        TestNode related: some
+        TestNode related: /some/reference
+        TestNode related: /some/reference/
+        TestNode related: some/reference/
+        TestNode related: some/reference
+      }
+    ), TestMM, :unresolved_refs => unresolved_refs)
+    assert_no_problems(problems)
+    ref_targets = [ 
+      "/",
+      "//",
+      "/some",
+      "//some",
+      "/some/",
+      "some/",
+      "some//",
+      "some",
+      "/some/reference",
+      "/some/reference/",
+      "some/reference/",
+      "some/reference"
+    ]
+    assert_equal ref_targets, env.find(:text => "root").first.childs.collect{|c| c.related.targetIdentifier}
+    assert_equal ref_targets, unresolved_refs.collect{|ur| ur.proxy.targetIdentifier}
+  end
+
+  def test_references_many
+    env, problems = instantiate(%Q(
+      TestNode text: "root" {
+        TestNode others: /other
+        TestNode others: [ /other ]
+        TestNode others: [ /other1, /other2 ]
+      }
+    ), TestMM)
+    assert_no_problems(problems)
+    assert_equal [ 
+      [ "/other" ],
+      [ "/other" ],
+      [ "/other1", "/other2" ],
+    ], env.find(:text => "root").first.childs.collect{|c| c.others.collect{|p| p.targetIdentifier}}
+  end
+
+  def test_reference_regexp
+    env, problems = instantiate(%Q(
+      TestNode text: "root" {
+        TestNode related: some
+        TestNode related: ::some
+        TestNode related: some::reference
+        TestNode related: ::some::reference
+      }
+    ), TestMM, :reference_regexp => /\A\w*(::\w*)+/)
+    assert_no_problems(problems)
+    assert_equal [ 
+      "some",
+      "::some",
+      "some::reference",
+      "::some::reference"
+     ], env.find(:text => "root").first.childs.collect{|c| c.related.targetIdentifier}
+  end
+
+  #
+  # unlabled arguments
+  # 
+
+  def test_unlabled_arguments
+    env, problems = instantiate(%Q(
+      TestNode "some text", [1,2] {
+        TestNode "child"
+        TestNode "child2"
+      }
+      ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
+    assert_no_problems(problems)
+    assert_model_simple(env, :with_nums)
+  end
+
+  def test_unlabled_arguments_not_in_front
+    env, problems = instantiate(%Q(
+      TestNode nums: [1,2], "some text" {
+        TestNode "child"
+        TestNode "child2"
+      }
+      ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
+    assert_no_problems(problems)
+    assert_model_simple(env, :with_nums)
+  end
+
+  def test_unlabled_arguments_using_labled
+    env, problems = instantiate(%Q(
+      TestNode text: "some text", nums: [1,2] {
+        TestNode text: "child"
+        TestNode text: "child2"
+      }
+      ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
+    assert_no_problems(problems)
+    assert_model_simple(env, :with_nums)
+  end
+
+  def test_unlabled_arguments_subclass
+    env, problems = instantiate(%Q(
+      SubNode "some text", [1, 2] {
+        TestNode text: "child"
+        TestNode text: "child2"
+      }
+      ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
+    assert_no_problems(problems)
+    assert_model_simple(env, :with_nums)
+  end
+
+  #
+  # problems
+  # 
+
+  def test_unexpected_end_of_file
+    env, problems = instantiate(%Q(
+      TestNode text: "some text" {
+    ), TestMM)
+    assert_problems([/unexpected end of file, expected \}/i], problems)
+  end
+
+  def test_unknown_command
+    env, problems = instantiate(%Q(
+      NotDefined 
+    ), TestMM)
+    assert_problems([/unknown command 'NotDefined'/i], problems)
+  end
+
+  def test_unknown_command_abstract
+    env, problems = instantiate(%Q(
+      TestNode
+    ), TestMMAbstract)
+    assert_problems([/unknown command 'TestNode'/i], problems)
+  end
+
+  def test_unexpected_unlabled_argument
+    env, problems = instantiate(%Q(
+      TestNode "more text"
+    ), TestMM)
+    assert_problems([/unexpected unlabled argument, 0 unlabled arguments expected/i], problems)
+  end
+
+  def test_unknown_child_role
+    env, problems = instantiate(%Q(
+      TestNode {
+        notdefined:
+          TestNode
+      }
+    ), TestMM)
+    assert_problems([/unknown child role 'notdefined'/i], problems)
+  end
+
+  def test_not_a_child_role
+    env, problems = instantiate(%Q(
+      TestNode {
+        text:
+          TestNode
+        others:
+          TestNode
+      }
+    ), TestMM)
+    assert_problems([
+      /role 'text' can not take child elements/i,
+      /role 'others' can not take child elements/i
+    ], problems)
+  end
+
+  def test_not_a_single_child
+    env, problems = instantiate(%Q(
+      TestNode {
+        singleChild: [
+          TestNode
+          TestNode
+        ]
+      }
+    ), TestMM2)
+    assert_problems([
+      /only one child allowed in role 'singleChild'/i,
+    ], problems)
+  end
+
+  def test_not_a_single_child2
+    env, problems = instantiate(%Q(
+      TestNode {
+        singleChild:
+          TestNode
+        singleChild:
+          TestNode
+      }
+    ), TestMM2)
+    assert_problems([
+      /only one child allowed in role 'singleChild'/i,
+    ], problems)
+  end
+
+  def test_wrong_child_role
+    env, problems = instantiate(%Q(
+      TestNode {
+        singleChild:
+          TestNode2
+      }
+    ), TestMM2)
+    assert_problems([
+      /role 'singleChild' can not take a TestNode2, expected TestNode/i,
+    ], problems)
+  end
+
+  def test_wrong_child
+    env, problems = instantiate(%Q(
+      TestNode {
+        TestNode3
+      }
+    ), TestMM2)
+    assert_problems([
+      /this kind of element can not be contained here/i,
+    ], problems)
+  end
+
+  def test_ambiguous_child_role
+    env, problems = instantiate(%Q(
+      TestNode {
+        TestNode2
+      }
+    ), TestMM2)
+    assert_problems([
+      /role of element is ambiguous, use a role label/i,
+    ], problems)
+  end
+
+  def test_non_ambiguous_child_role_subclass
+    env, problems = instantiate(%Q(
+      TestNode {
+        TestNode4
+      }
+    ), TestMM2)
+    assert_no_problems(problems)
+  end
+
+  def test_not_a_single_child3
+    env, problems = instantiate(%Q(
+      TestNode {
+        TestNode
+        TestNode
+      }
+    ), TestMM2)
+    assert_problems([
+      /only one child allowed in role 'singleChild'/i,
+    ], problems)
+  end
+
+  def test_unknown_argument
+    env, problems = instantiate(%Q(
+      TestNode unknown: "some text"
+    ), TestMM)
+    assert_problems([/unknown argument 'unknown'/i], problems)
+  end
+
+  def test_attribute_in_child_reference
+    env, problems = instantiate(%Q(
+      TestNode singleChild: "some text"
+    ), TestMM2)
+    assert_problems([/argument 'singleChild' can only take child elements/i], problems)
+  end
+
+  def test_arguments_duplicate
+    env, problems = instantiate(%Q(
+      TestNode text: "some text", text: "more text"
+    ), TestMM)
+    assert_problems([/argument 'text' already defined/i], problems)
+  end
+
+  def test_unlabled_arguments_duplicate
+    env, problems = instantiate(%Q(
+      TestNode text: "some text", "more text"
+    ), TestMM, :unlabled_arguments => proc {|c| ["text"]})
+    assert_problems([/argument 'text' already defined/i], problems)
+  end
+
+  def test_multiple_arguments_in_non_many_attribute
+    env, problems = instantiate(%Q(
+      TestNode text: ["text1", "text2"]
+    ), TestMM)
+    assert_problems([/argument 'text' can take only one value/i], problems)
+  end
+
+  def test_wrong_argument_type
+    env, problems = instantiate(%Q(
+      TestNode text: 1 
+      TestNode integer: "text" 
+      TestNode integer: true 
+      TestNode integer: 1.2 
+      TestNode integer: a 
+      TestNode integer: /a 
+      TestNode enum: 1 
+      TestNode enum: x 
+      TestNode related: 1
+    ), TestMM)
+    assert_problems([
+      /argument 'text' can not take a integer, expected string/i,
+      /argument 'integer' can not take a string, expected integer/i,
+      /argument 'integer' can not take a boolean, expected integer/i,
+      /argument 'integer' can not take a float, expected integer/i,
+      /argument 'integer' can not take a identifier, expected integer/i,
+      /argument 'integer' can not take a reference, expected integer/i,
+      /argument 'enum' can not take a integer, expected identifier/i,
+      /argument 'enum' can not take value x, expected A, B/i,
+      /argument 'related' can not take a integer, expected reference, identifier/i
+    ], problems)
+  end
+
+  def test_missing_opening_brace
+    env, problems = instantiate(%Q(
+      TestNode 
+      }
+    ), TestMM)
+    assert_problems([/unexpected \}, expected identifier/i], problems)
+  end
+
+  #
+  # command name provider
+  #
+
+  def test_command_name_provider
+    env, problems = instantiate(%Q(
+      TestNodeX text: "some text", nums: [1,2] {
+        TestNodeX text: "child"
+        TestNodeX text: "child2"
+      }
+      ), TestMM, :command_name_provider => proc do |c|
+        c.name + "X"
+      end)
+    assert_no_problems(problems)
+    assert_model_simple(env, :with_nums)
+  end
+
+  def test_command_name_provider_ambiguous
+    begin
+      env, problems = instantiate(%Q(
+        TestNode
+      ), TestMM, :command_name_provider => proc do |c|
+        "Fixed"
+      end)
+      assert false
+    rescue RuntimeError => e
+      assert e.message =~ /ambiguous command name/
+    end
+  end
+
+  #
+  # comment handler
+  # 
+
+  def test_comment_handler
+    proc_calls = 0
+    env, problems = instantiate(%Q(
+      #comment
+      TestNode text: "node1"
+      #comment
+      #  multiline
+      TestNode text: "node2"
+      TestNode text: "node3" #comment
+      #above
+      TestNode text: "node4" {#right1
+        childs: [ #right2
+          #unassociated1
+        ] #right3
+        #unassociated2
+      } #below
+      #above1
+      #above2
+      TestNode text: "node5" { #right1
+        childs: #right2
+          TestNode
+      }#below
+      #comment without
+      #an element following
+    ), TestMM, :comment_handler => proc {|c,k,e,env|
+      proc_calls += 1
+      if e.nil?
+        case proc_calls
+        when 4
+          assert_equal "unassociated1", c
+          assert_equal :unassociated, k
+        when 5
+          assert_equal "unassociated2", c
+          assert_equal :unassociated, k
+        when 15
+          assert_equal "comment without\nan element following", c
+          assert_equal :unassociated, k
+        end
+      elsif e.text == "node1"
+        assert_equal "comment", c
+        assert_equal :above, k
+      elsif e.text == "node2"
+        assert_equal "comment\n  multiline", c
+        assert_equal :above, k
+      elsif e.text == "node3"
+        assert_equal "comment", c
+        assert_equal :eol, k
+      elsif e.text == "node4" 
+        case proc_calls
+        when 6
+          assert_equal "above", c
+          assert_equal :above, k
+        when 7
+          assert_equal "right1", c
+          assert_equal :eol, k
+        when 8
+          assert_equal "right2", c
+          assert_equal :eol, k
+        when 9
+          assert_equal "right3", c
+          assert_equal :eol, k
+        when 10 
+          assert_equal "below", c
+          assert_equal :eol, k
+        end
+      elsif e.text == "node5"
+        case proc_calls
+        when 11 
+          assert_equal "above1\nabove2", c
+          assert_equal :above, k
+        when 12
+          assert_equal "right1", c
+          assert_equal :eol, k
+        when 13
+          assert_equal "right2", c
+          assert_equal :eol, k
+        when 14
+          assert_equal "below", c
+          assert_equal :eol, k
+        end
+      else
+        assert false, "unexpected element in comment handler"
+      end
+      true
+    })
+    assert_no_problems(problems)
+    assert_equal 15, proc_calls
+  end
+
+  def test_comment_handler_comment_not_allowed
+    env, problems = instantiate(%Q(
+      #comment
+      TestNode
+    ), TestMM, :comment_handler => proc {|c,k,e,env|
+      false
+    })
+    assert_problems([/element can not take this comment/], problems)
+  end
+
+  def test_comment_handler_comment_not_allowed_unassociated
+    env, problems = instantiate(%Q(
+      #comment
+    ), TestMM, :comment_handler => proc {|c,k,e,env|
+      false
+    })
+    assert_problems([/Unassociated comment not allowed/], problems)
+  end
+
+  #
+  # subpackages
+  #
+
+  def test_subpackage
+    env, problems = instantiate(%q(
+      TestNodeSub text: "something" 
+    ), TestMMSubpackage)
+    assert_no_problems(problems)
+    assert_equal "something", env.elements.first.text
+  end
+
+  def test_subpackage_no_shortname_opt
+    env, problems = instantiate(%q(
+      TestNodeSub text: "something" 
+    ), TestMMSubpackage, :short_class_names => false)
+    assert_problems([/Unknown command 'TestNodeSub'/], problems)
+  end
+
+  #
+  # values
+  # 
+
+  def test_escapes
+    env, problems = instantiate(%q(
+      TestNode text: "some \" \\\\ \\\\\" text \r xx \n xx \r\n xx \t xx \b xx \f"
+    ), TestMM)
+    assert_no_problems(problems)
+    assert_equal %Q(some " \\ \\" text \r xx \n xx \r\n xx \t xx \b xx \f), env.elements.first.text
+  end
+
+  def test_escape_single_backslash
+    env, problems = instantiate(%q(
+      TestNode text: "a single \\ will be just itself"
+    ), TestMM)
+    assert_no_problems(problems)
+    assert_equal %q(a single \\ will be just itself), env.elements.first.text
+  end
+
+  def test_string_umlauts
+    env, problems = instantiate(%q(
+      TestNode text: "ä, ö, ü"
+    ), TestMM)
+    assert_no_problems(problems)
+    assert_equal %q(ä, ö, ü), env.elements.first.text
+  end
+
+  def test_integer
+    env, problems = instantiate(%q(
+      TestNode integer: 7 
+    ), TestMM)
+    assert_no_problems(problems)
+    assert_equal 7, env.elements.first.integer
+  end
+
+  def test_integer_hex
+    env, problems = instantiate(%q(
+      TestNode text: root {
+        TestNode integer: 0x7 
+        TestNode integer: 0X7 
+        TestNode integer: 0x007 
+        TestNode integer: 0x77
+        TestNode integer: 0xabCDEF
+      }
+    ), TestMM)
+    assert_no_problems(problems)
+    assert_equal [7, 7, 7, 0x77, 0xABCDEF], env.find(:text => "root").first.childs.collect{|c| c.integer}
+  end
+
+  def test_float
+    env, problems = instantiate(%q(
+      TestNode float: 1.23 
+      TestNode float: 1.23e-08 
+      TestNode float: 1.23e+10 
+    ), TestMM)
+    assert_no_problems(problems)
+    assert_equal 1.23, env.elements[0].float
+    assert_equal 1.23e-08, env.elements[1].float
+    assert_equal 1.23e+10, env.elements[2].float
+  end
+
+  def test_boolean
+    env, problems = instantiate(%q(
+      TestNode text: root {
+        TestNode boolean: true 
+        TestNode boolean: false 
+      }
+    ), TestMM)
+    assert_no_problems(problems)
+    assert_equal [true, false], env.find(:text => "root").first.childs.collect{|c| c.boolean}
+  end
+
+  def test_enum
+    env, problems = instantiate(%q(
+      TestNode text: root {
+        TestNode enum: A 
+        TestNode enum: B 
+        TestNode enum: "non-word*chars"
+      }
+    ), TestMM)
+    assert_no_problems(problems)
+    assert_equal [:A, :B, :'non-word*chars'], env.find(:text => "root").first.childs.collect{|c| c.enum}
+  end
+
+  #
+  # conflicts with builtins
+  # 
+
+  def test_conflict_builtin
+    env, problems = instantiate(%q(
+      Data notTheBuiltin: "for sure" 
+    ), TestMMData)
+    assert_no_problems(problems)
+    assert_equal "for sure", env.elements.first.notTheBuiltin
+  end
+
+  def test_builtin_in_subpackage
+    env, problems = instantiate(%q(
+      Data notTheBuiltin: "for sure" 
+    ), TestMMSubpackage)
+    assert_no_problems(problems)
+    assert_equal "for sure", env.elements.first.notTheBuiltin
+  end
+
+  private
+
+  def instantiate(text, mm, options={})
+    env = RGen::Environment.new
+    lang = RText::Language.new(mm.ecore, options)
+    inst = RText::Instantiator.new(lang)
+    problems = []
+    inst.instantiate(text, options.merge({:env => env, :problems => problems}))
+    return env, problems
+  end
+  
+  def assert_no_problems(problems)
+    assert problems.empty?, problems.collect{|p| "#{p.message}, line: #{p.line}"}.join("\n")
+  end
+
+  def assert_problems(expected, problems)
+    remaining = problems.dup
+    probs = []
+    expected.each do |e|
+      p = problems.find{|p| p.message =~ e}
+      probs << "expected problem not present: #{e}" if !p
+      remaining.delete(p)
+    end
+    remaining.each do |p|
+      probs << "unexpected problem: #{p.message}, line: #{p.line}"
+    end
+    assert probs.empty?, probs.join("\n")
+  end
+
+  def assert_model_simple(env, *opts)
+    raise "unknown options" unless (opts - [:with_nums]).empty?
+    root = env.find(:class => TestMM::TestNode, :text => "some text").first
+    assert_not_nil root
+    assert_equal 2, root.childs.size
+    assert_equal [TestMM::TestNode, TestMM::TestNode], root.childs.collect{|c| c.class}
+    assert_equal ["child", "child2"], root.childs.text
+    if opts.include?(:with_nums)
+      assert_equal [1, 2], root.nums
+    end
+  end
+
+end
+	
+