rtext 0.2.1 → 0.3.0

data/lib/rtext/default_service_provider.rb

@@ -2,11 +2,12 @@ module RText
 
 class DefaultServiceProvider
 
-  def initialize(language, fragmented_model, model_loader)
+  def initialize(language, fragmented_model, model_loader, options={})
     @lang = language
     @model = fragmented_model
     @loader = model_loader 
     @element_name_index = nil
+    @result_limit = options[:result_limit]
     @model.add_fragment_change_listener(proc {|fragment, kind|
       @element_name_index = nil
     })
@@ -25,7 +26,7 @@ class DefaultServiceProvider
       targets = @model.index.values.flatten.select{|e| e.is_a?(clazz)}
     end
     targets.collect{|t| 
-      ident = @lang.identifier_provider.call(t, context)
+      ident = @lang.identifier_provider.call(t, context.element)
       if ident
         ReferenceCompletionOption.new(ident, t.class.ecore.name)
       else
@@ -35,20 +36,13 @@ class DefaultServiceProvider
   end
 
   ReferenceTarget = Struct.new(:file, :line, :display_name)
-  def get_reference_targets(identifier, context, lines, linepos)
+  def get_reference_targets(identifier, context)
     result = []
-    identifier = @lang.qualify_reference(identifier, context)
+    identifier = @lang.qualify_reference(identifier, context.element)
     targets = @model.index[identifier]
     if targets && @lang.per_type_identifier
-      current_line = lines.last
-      linestart = current_line[0..linepos-1]
-      if linestart =~ /\s*(\w+)\s+(?:[^,]+,)*\s*(\w+):\s*(\S*)$/
-        command, fn, prefix = $1, $2, $3
-        clazz = @lang.class_by_command(command)
-        feature = clazz && @lang.non_containments(clazz.ecore).find{|f| f.name == fn}
-        if feature
-          targets = targets.select{|t| t.is_a?(feature.eType.instanceClass)}
-        end
+      if context.feature
+        targets = targets.select{|t| t.is_a?(context.feature.eType.instanceClass)}
       end
     end 
     targets && targets.each do |t|
@@ -62,9 +56,9 @@ class DefaultServiceProvider
 
   def get_referencing_elements(identifier, context)
     result = []
-    targets = @model.index[@lang.identifier_provider.call(context, nil)]
+    targets = @model.index[@lang.identifier_provider.call(context.element, nil)]
     if targets && @lang.per_type_identifier
-      targets = targets.select{|t| t.class == context.class}
+      targets = targets.select{|t| t.class == context.element.class}
     end
     if targets && targets.size == 1
       target = targets.first
@@ -114,8 +108,9 @@ class DefaultServiceProvider
     result = []
     return result unless pattern
     sub_index = element_name_index[pattern[0..0].downcase]
+    truncate_result = false
     sub_index && sub_index.each_pair do |ident, elements|
-      if ident.split(/\W/).last.downcase.index(pattern.downcase) == 0
+      if !truncate_result && ident.split(/\W/).last.downcase.index(pattern.downcase) == 0
         elements.each do |e|
           if @lang.fragment_ref(e)
             non_word_index = ident.rindex(/\W/)
@@ -129,12 +124,20 @@ class DefaultServiceProvider
             display_name = "#{name} [#{e.class.ecore.name}]"
             display_name += " - #{scope}" if scope.size > 0
             path = File.expand_path(@lang.fragment_ref(e).fragment.location)
-            result << OpenElementChoice.new(display_name, path, @lang.line_number(e))
+            if !@result_limit || result.size < @result_limit
+              result << OpenElementChoice.new(display_name, path, @lang.line_number(e))
+            else
+              truncate_result = true
+            end
           end
         end
       end
     end
-    result.sort{|a,b| a.display_name <=> b.display_name}
+    result = result.sort{|a,b| a.display_name <=> b.display_name}
+    if truncate_result
+      result << OpenElementChoice.new("--- result truncated, showing first #{@result_limit} entries ---", "/", 1)
+    end
+    result
   end
 
   def element_name_index

data/lib/rtext/instantiator.rb

@@ -44,16 +44,26 @@ class Instantiator
     @root_elements = options[:root_elements] || []
     @file_name = options[:file_name]
     @fragment_ref = options[:fragment_ref]
+    @context_class_stack = []
     parser = Parser.new(@lang.reference_regexp)
     begin
       @root_elements.clear
-      parser.parse(str) do |*args|
-        if args[0]
-          create_element(*args)
-        else
-          unassociated_comments(args[3])
-        end
-      end
+      parser.parse(str, 
+        :descent_visitor => lambda do |command|
+          clazz = @lang.class_by_command(command.value, @context_class_stack.last)
+          # in case no class is found, nil will be pushed, this will case the next command
+          # lookup to act as if called from toplevel
+          @context_class_stack.push(clazz)
+        end,
+        :ascent_visitor => lambda do |*args|
+          if args[0]
+            element =create_element(*args)
+            @context_class_stack.pop
+            element
+          else
+            unassociated_comments(args[3])
+          end
+        end)
     rescue Parser::Error => e
       problem(e.message, e.line)
       @unresolved_refs.clear if @unresolved_refs
@@ -75,10 +85,18 @@ class Instantiator
   end
 
   def create_element(command, arg_list, element_list, comments, is_root)
-    clazz = @lang.class_by_command(command.value)  
-    if !clazz 
+    clazz = @context_class_stack.last 
+    if !@lang.has_command(command.value)
       problem("Unknown command '#{command.value}'", command.line)
       return
+    elsif !clazz 
+      if is_root
+        problem("Command '#{command.value}' can not be used on root level", command.line)
+        return
+      else
+        problem("Command '#{command.value}' can not be used in this context", command.line)
+        return
+      end
     end
     if clazz.ecore.abstract
       problem("Unknown command '#{command.value}' (metaclass is abstract)", command.line)
@@ -153,6 +171,7 @@ class Instantiator
       return if child.nil?
       feature = @lang.containments_by_target_type(element.class.ecore, child.class.ecore)
       if feature.size == 0
+        # this should never happen since the scope of an element is already checked when it's created
         problem("This kind of element can not be contained here", line_number(child))
         return
       end

data/lib/rtext/language.rb

@@ -35,11 +35,6 @@ class Language
   #     (in sprintf syntax) which will be used by the serializer for integers and floats.
   #     default: if not present or the proc returns nil, then #to_s is used
   #
-  #  :short_class_names
-  #     if true, the metamodel is searched for classes by unqualified class name recursively
-  #     if false, classes can only be found in the root package, not in subpackages 
-  #     default: true
-  #
   #  :reference_regexp  
   #     a Regexp which is used by the tokenizer for identifying references 
   #     it must only match at the beginning of a string, i.e. it should start with \A
@@ -75,6 +70,10 @@ class Language
   #     default: no reference qualifier, i.e. all identifiers returned by the identifier provider 
   #              must be globally unique
   #
+  #  :root_classes
+  #     an Array of EClass objects representing classes which can be used on root level
+  #     default: all classes which can't be contained by any class
+  #
   #  :line_number_attribute
   #     the name of the attribute which will be used to associate the line number with a model element
   #     default: no line number
@@ -87,9 +86,10 @@ class Language
   #     the name of the attribute which will be used to associate a model fragment with a model element
   #
   #  :comment_handler 
-  #     a Proc which will be invoked when a new element has been instantiated. receives an 
-  #     element, the comment as a string, and the environment to which the element has been
-  #     added to. then environment may be nil.  it should add the comment to the element and 
+  #     a Proc which will be invoked when a new element has been instantiated. receives  
+  #     the comment as a string, the comment kind (one of [:above, :eol, :unassociated]), the
+  #     element and the environment to which the element has been added to.
+  #     the environment may be nil.  it should add the comment to the element and 
   #     return true. if the element can take no comment, it should return false.
   #     default: no handling of comments 
   #  
@@ -113,18 +113,9 @@ class Language
     @unlabled_arguments = options[:unlabled_arguments]
     @unquoted_arguments = options[:unquoted_arguments]
     @argument_format_provider = options[:argument_format_provider]
-    @class_by_command = {}
+    @root_classes = options[:root_classes] || default_root_classes(root_epackage)
     command_name_provider = options[:command_name_provider] || proc{|c| c.name}
-    ((!options.has_key?(:short_class_names) || options[:short_class_names]) ?
-      root_epackage.eAllClasses : root_epackage.eClasses).each do |c|
-        next if c.abstract
-        command_name = command_name_provider.call(c)
-        raise "ambiguous command name #{command_name}" if @class_by_command[command_name]
-        @class_by_command[command_name] = c.instanceClass
-      end
-    # there can't be multiple commands for the same class as the command name provider
-    # can only return one command per class
-    @command_by_class = @class_by_command.invert 
+    setup_commands(root_epackage, command_name_provider)
     @reference_regexp = options[:reference_regexp] || /\A\w*(\/\w*)+/
     @identifier_provider = options[:identifier_provider] || 
       proc { |element, context|
@@ -142,6 +133,7 @@ class Language
   end
 
   attr_reader :root_epackage
+  attr_reader :root_classes
   attr_reader :reference_regexp
   attr_reader :identifier_provider
   attr_reader :line_number_attribute
@@ -152,8 +144,13 @@ class Language
   attr_reader :indent_string
   attr_reader :per_type_identifier
 
-  def class_by_command(command)
-    @class_by_command[command]
+  def class_by_command(command, context_class)
+    map = @class_by_command[context_class]
+    map && map[command]
+  end
+
+  def has_command(command)
+    @has_command[command]
   end
 
   def command_by_class(clazz)
@@ -225,6 +222,39 @@ class Language
 
   private
 
+  def setup_commands(root_epackage, command_name_provider)
+    @class_by_command = {}
+    @command_by_class = {}
+    @has_command = {}
+    root_epackage.eAllClasses.each do |c|
+      next if c.abstract
+      cmd = command_name_provider.call(c)
+      @command_by_class[c.instanceClass] = cmd 
+      @has_command[cmd] = true
+      clazz = c.instanceClass
+      @class_by_command[clazz] ||= {} 
+      c.eAllReferences.select{|r| r.containment}.collect{|r|
+          [r.eType] + r.eType.eAllSubTypes}.flatten.uniq.each do |t|
+        next if t.abstract
+        cmw = command_name_provider.call(t)
+        raise "ambiguous command name #{cmw}" if @class_by_command[clazz][cmw]
+        @class_by_command[clazz][cmw] = t.instanceClass
+      end
+    end
+    @class_by_command[nil] = {} 
+    @root_classes.each do |c|
+      next if c.abstract
+      cmw = command_name_provider.call(c)
+      raise "ambiguous command name #{cmw}" if @class_by_command[nil][cmw]
+      @class_by_command[nil][cmw] = c.instanceClass
+    end
+  end
+
+  def default_root_classes(root_package)
+    root_epackage.eAllClasses.select{|c| !c.abstract &&
+      !c.eAllReferences.any?{|r| r.eOpposite && r.eOpposite.containment}}
+  end
+
   def features(clazz)
     @feature_provider.call(clazz)
   end

data/lib/rtext/parser.rb

@@ -6,8 +6,9 @@ class Parser
     @reference_regexp = reference_regexp
   end
 
-  def parse(str, &visitor)
-    @visitor = visitor
+  def parse(str, options)
+    @dsc_visitor = options[:descent_visitor]
+    @asc_visitor = options[:ascent_visitor]
     @tokens = tokenize(str, @reference_regexp)
     @last_line = @tokens.last && @tokens.last.line 
     while next_token
@@ -22,6 +23,7 @@ class Parser
     if (next_token && next_token == :identifier) || !allow_unassociated_comment
       comments << [ comment, :above] if comment
       command = consume(:identifier)
+      @dsc_visitor.call(command)
       arg_list = []
       parse_argument_list(arg_list)
       element_list = []
@@ -31,11 +33,11 @@ class Parser
       eol_comment = parse_eol_comment
       comments << [ eol_comment, :eol ] if eol_comment
       consume(:newline)
-      @visitor.call(command, arg_list, element_list, comments, is_root)
+      @asc_visitor.call(command, arg_list, element_list, comments, is_root)
     elsif comment
       # if there is no statement, the comment is non-optional
       comments << [ comment, :unassociated ]
-      @visitor.call(nil, nil, nil, comments, nil)
+      @asc_visitor.call(nil, nil, nil, comments, nil)
       nil
     else
       # die expecting an identifier (next token is not an identifier)

data/lib/rtext/serializer.rb

@@ -80,7 +80,8 @@ class Serializer
       @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
+          child_classes = childs.collect{|c| c.class.ecore}.uniq
+          if child_classes.any?{|c| @lang.containments_by_target_type(element.class.ecore, c).size > 1}
             if childs.size > 1
               write("#{f.name}: [")
               iinc
@@ -132,7 +133,7 @@ class Serializer
           result << v.to_s
         end
       elsif feature.eType.is_a?(RGen::ECore::EEnum)
-        if v.to_s =~ /^\d|\W/
+        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

data/lib/rtext/service.rb

@@ -1,6 +1,6 @@
 require 'socket'
 require 'rtext/completer'
-require 'rtext/context_element_builder'
+require 'rtext/context_builder'
 
 module RText
 
@@ -119,13 +119,11 @@ class Service
 
   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
+    context = ContextBuilder.build_context(@lang, lines, linepos)
+    @logger.debug("context element: #{@lang.identifier_provider.call(context.element, nil)}") if @logger
     current_line = lines.pop
     current_line ||= ""
-    options = @completer.complete(current_line, linepos, 
-      proc {|i| lines[-i]}, 
-      proc {|ref| 
+    options = @completer.complete(context, lambda {|ref| 
         @service_provider.get_reference_completion_options(ref, context).collect {|o|
           Completer::CompletionOption.new(o.identifier, "<#{o.type}>")}
       })
@@ -148,10 +146,10 @@ class Service
 
   def get_reference_targets(lines)
     linepos = lines.shift.to_i
-    context = ContextElementBuilder.build_context_element(@lang, lines, linepos)
     current_line = lines.last
+    context = ContextBuilder.build_context(@lang, lines, lines.last.size)
     result = []
-    if current_line[linepos..linepos] =~ /[\w\/]/
+    if context && 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]
@@ -161,7 +159,7 @@ class Service
           result << "#{t.file};#{t.line};#{t.display_name}\n"
         end
       else
-        @service_provider.get_reference_targets(ident, context, lines, linepos).each do |t|
+        @service_provider.get_reference_targets(ident, context).each do |t|
           result << "#{t.file};#{t.line};#{t.display_name}\n"
         end
       end

data/test/completer_test.rb

@@ -0,0 +1,332 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/metamodel_builder'
+require 'rtext/language'
+require 'rtext/context_builder'
+require 'rtext/completer'
+
+class CompleterTest < Test::Unit::TestCase
+
+module TestMM
+  extend RGen::MetamodelBuilder::ModuleExtension
+  class TestNode2 < RGen::MetamodelBuilder::MMBase
+    has_attr 'text', String
+  end
+  class TestNode < RGen::MetamodelBuilder::MMBase
+    has_attr 'text', String
+    has_attr 'unlabled1', String
+    has_attr 'unlabled2', Integer
+    has_many_attr 'nums', Integer
+    has_one 'related', TestNode
+    has_many 'others', TestNode
+    contains_many 'childs', TestNode, 'parent'
+    contains_one 'child2RoleA', TestNode2, 'parentA'
+    contains_many 'child2RoleB', TestNode2, 'parentB'
+  end
+  SomeEnum = RGen::MetamodelBuilder::DataTypes::Enum.new(
+    :name => "SomeEnum", :literals => [:A, :B, :'non-word*chars'])
+  class TestNode3 < RGen::MetamodelBuilder::MMBase
+    has_attr 'bool', Boolean
+    has_attr 'float', Float
+    has_attr 'enum', SomeEnum
+  end
+  class TextNode < RGen::MetamodelBuilder::MMBase
+  end
+end
+
+def test_after_command
+  options = complete TestMM, <<-END
+  TestNode |
+  END
+  assert_options([
+    ["<unlabled1>", "<EString>"],
+    ["nums:", "<EInt>"],
+    ["others:", "<TestNode>"],
+    ["related:", "<TestNode>"],
+    ["text:", "<EString>"]
+  ], options)
+end
+
+def test_lable_prefix
+  options = complete TestMM, <<-END
+  TestNode t|
+  END
+  assert_options([
+    ["text:", "<EString>"]
+  ], options)
+end
+
+def test_unlabled_prefix
+  options = complete TestMM, <<-END
+  TestNode u|
+  END
+  assert_options([
+    ["<unlabled1>", "<EString>"]
+  ], options)
+end
+
+def test_after_labled_value
+  options = complete TestMM, <<-END
+  TestNode nums: 1, |
+  END
+  assert_options([
+    ["others:", "<TestNode>"],
+    ["related:", "<TestNode>"],
+    ["text:", "<EString>"]
+  ], options)
+end
+
+def test_after_unlabled_value
+  options = complete TestMM, <<-END
+  TestNode "bla", |
+  END
+  assert_options([
+    ["<unlabled2>", "<EInt>"],
+    ["nums:", "<EInt>"],
+    ["others:", "<TestNode>"],
+    ["related:", "<TestNode>"],
+    ["text:", "<EString>"]
+  ], options)
+end
+
+def test_after_unlabled_value2
+  options = complete TestMM, <<-END
+  TestNode "bla", 1, |
+  END
+  assert_options([
+    ["nums:", "<EInt>"],
+    ["others:", "<TestNode>"],
+    ["related:", "<TestNode>"],
+    ["text:", "<EString>"]
+  ], options)
+end
+
+def test_after_array
+  options = complete TestMM, <<-END
+  TestNode nums: [1, 2], |
+  END
+  assert_options([
+    ["others:", "<TestNode>"],
+    ["related:", "<TestNode>"],
+    ["text:", "<EString>"]
+  ], options)
+end
+
+def test_after_array_direct
+  options = complete TestMM, <<-END
+  TestNode nums: [1, 2]|
+  END
+  assert_options([
+  ], options)
+end
+
+def test_value_int
+  options = complete TestMM, <<-END
+  TestNode nums: | 
+  END
+  assert_options([
+    ["0", nil],
+    ["1", nil],
+    ["2", nil],
+    ["3", nil],
+    ["4", nil]
+  ], options)
+end
+
+def test_value_boolean
+  options = complete TestMM, <<-END
+  TestNode3 bool: | 
+  END
+  assert_options([
+    ["true", nil],
+    ["false", nil],
+  ], options)
+end
+
+def test_value_float
+  options = complete TestMM, <<-END
+  TestNode3 float: | 
+  END
+  assert_options([
+    ["0.0", nil],
+    ["1.0", nil],
+    ["2.0", nil],
+    ["3.0", nil],
+    ["4.0", nil]
+  ], options)
+end
+
+def test_value_enum
+  options = complete TestMM, <<-END
+  TestNode3 enum: | 
+  END
+  assert_options([
+    ["A", nil],
+    ["B", nil],
+    ["non-word*chars", nil]
+  ], options)
+end
+
+def test_array_value
+  options = complete TestMM, <<-END
+  TestNode nums: [|
+  END
+  assert_options([
+    ["0", nil],
+    ["1", nil],
+    ["2", nil],
+    ["3", nil],
+    ["4", nil]
+  ], options)
+end
+
+def test_array_value2
+  options = complete TestMM, <<-END
+  TestNode nums: [1,|
+  END
+  assert_options([
+    ["0", nil],
+    ["1", nil],
+    ["2", nil],
+    ["3", nil],
+    ["4", nil]
+  ], options)
+end
+
+def test_reference_value
+  options = complete(TestMM, %Q(\
+  TestNode related: |\
+  ), lambda { |r| [
+    RText::Completer::CompletionOption.new("A", "a"),
+    RText::Completer::CompletionOption.new("B", "b") ] })
+  assert_options([
+    ["A", "a"],
+    ["B", "b"],
+  ], options)
+end
+
+def test_reference_value_no_ref_completion_provider
+  options = complete TestMM, <<-END
+  TestNode related: |
+  END
+  assert_options([
+  ], options)
+end
+
+def test_children
+  options = complete TestMM, <<-END
+  TestNode { 
+    |
+  END
+  assert_options([
+    ["TestNode", "<unlabled1>, <unlabled2>"],
+    ["child2RoleA:", "<TestNode2>"],
+    ["child2RoleB:", "<TestNode2>"]
+  ], options)
+end
+
+def test_children_with_role
+  options = complete TestMM, <<-END
+  TestNode { 
+    child2RoleA:
+      |
+  END
+  assert_options([
+    ["TestNode2", ""],
+  ], options)
+end
+
+def test_children_with_role_array
+  options = complete TestMM, <<-END
+  TestNode { 
+    child2RoleB: [
+      |
+  END
+  assert_options([
+    ["TestNode2", ""],
+  ], options)
+end
+
+def test_children_prefix
+  options = complete TestMM, <<-END
+  TestNode { 
+    child2RoleB: [
+      X|
+  END
+  assert_options([
+  ], options)
+end
+
+def test_children_inside_childrole
+  options = complete TestMM, <<-END
+  TestNode { 
+    child2RoleA:
+      TestNode2 | 
+  END
+  assert_options([
+    ["text:", "<EString>"]
+  ], options)
+end
+
+def test_children_inside_childrole_array
+  options = complete TestMM, <<-END
+  TestNode { 
+    child2RoleB: [
+      TestNode2 | 
+  END
+  assert_options([
+    ["text:", "<EString>"]
+  ], options)
+end
+
+def test_root
+  options = complete TestMM, <<-END
+  |
+  END
+  assert_options([
+    ["TestNode", "<unlabled1>, <unlabled2>"],
+    ["TestNode2", ""],
+    ["TestNode3", ""],
+    ["TextNode", ""]
+  ], options)
+end
+
+def test_root_no_context_lines
+  options = complete TestMM, ""
+  assert_options([
+    ["TestNode", "<unlabled1>, <unlabled2>"],
+    ["TestNode2", ""],
+    ["TestNode3", ""],
+    ["TextNode", ""]
+  ], options)
+end
+
+def test_root_prefix
+  options = complete TestMM, <<-END
+  Text|
+  END
+  assert_options([
+    ["TextNode", ""]
+  ], options)
+end
+
+def assert_options(expected, options)
+  assert_equal(expected, options.collect { |o| [o.text, o.extra] })
+end
+
+def complete(mm, text, ref_comp_option_provider=nil)
+  context_lines = text.split("\n")
+  if context_lines.last
+    pos_in_line = context_lines.last.index("|")
+    context_lines.last.sub!("|", "")
+  end
+  lang = RText::Language.new(mm.ecore,
+    :root_classes => mm.ecore.eAllClasses,
+    :unlabled_arguments => lambda {|c| ["unlabled1", "unlabled2"]})
+  context = RText::ContextBuilder.build_context(lang, context_lines, pos_in_line)
+  RText::Completer.new(lang).complete(context, ref_comp_option_provider)
+end
+
+end
+