rtext 0.8.0 → 0.9.1

data/lib/rtext/default_completer.rb

@@ -1,163 +1,212 @@
-require 'rgen/ecore/ecore_ext'
-
-module RText
-
-class DefaultCompleter
-
-  CompletionOption = Struct.new(:text, :extra)
-
-  # Creates a completer for RText::Language +language+.
-  #
-  def initialize(language)
-    @lang = language
-  end
-
-  # Provides completion options
-  #
-  def complete(context)
-    clazz = context && context.element && context.element.class.ecore
-    if clazz
-      if context.in_block
-        block_options(context, clazz)
-      elsif !context.problem
-        result = []
-        if context.feature
-          add_value_options(context, result)
-        end
-        if !context.after_label
-          add_label_options(context, clazz, result)
-        end
-        result
-      else
-        # missing comma, after curly brace, etc.
-        []
-      end
-    elsif context
-      root_options
-    else
-      []
-    end
-  end
-
-  def block_options(context, clazz)
-    types = []
-    labled_refs = []
-    if context.feature
-      if context.feature.is_a?(RGen::ECore::EReference) && context.feature.containment
-        types = @lang.concrete_types(context.feature.eType)
-      else
-        # invalid, ignore
-      end
-    else
-      # all target types which don't need a label
-      # and all lables which are needed by a potential target type
-      @lang.containments(clazz).each do |r|
-        ([r.eType] + r.eType.eAllSubTypes).select{|t| !t.abstract}.each do |t|
-          if @lang.labeled_containment?(clazz, r) || @lang.containments_by_target_type(clazz, t).size > 1
-            labled_refs << r
-          else
-            types << t
-          end
-        end
-      end
-    end
-    types.uniq.
-      sort{|a,b| a.name <=> b.name}.collect do |c| 
-        class_completion_option(c)
-      end +
-    labled_refs.uniq.collect do |r|
-        CompletionOption.new("#{r.name}:", "<#{r.eType.name}>")
-      end
-  end
-
-  def add_value_options(context, result)
-    if context.feature.is_a?(RGen::ECore::EAttribute) || !context.feature.containment
-      if context.feature.is_a?(RGen::ECore::EReference)
-        result.concat(reference_options(context))
-      elsif context.feature.eType.is_a?(RGen::ECore::EEnum)
-        result.concat(enum_options(context))
-      elsif context.feature.eType.instanceClass == String
-        result.concat(string_options(context))
-      elsif context.feature.eType.instanceClass == Integer 
-        result.concat(integer_options(context))
-      elsif context.feature.eType.instanceClass == Float 
-        result.concat(float_options(context))
-      elsif context.feature.eType.instanceClass == RGen::MetamodelBuilder::DataTypes::Boolean
-        result.concat(boolean_options(context))
-      else
-        # no options 
-      end
-    else
-      # containment reference, ignore
-    end
-  end
-
-  def add_label_options(context, clazz, result)
-    result.concat(@lang.labled_arguments(clazz).
-      select{|f| 
-        !context.element.eIsSet(f.name)}.collect do |f| 
-        CompletionOption.new("#{f.name}:", "<#{f.eType.name}>")
-      end )
-  end
-
-  def root_options
-    @lang.root_classes.
-      sort{|a,b| a.name <=> b.name}.collect do |c| 
-        class_completion_option(c)
-      end 
-  end
-
-  def reference_options(context)
-    []
-  end
-
-  def enum_options(context)
-    context.feature.eType.eLiterals.collect do |l|
-      lname = l.name
-      if lname =~ /^\d|\W/ || lname == "true" || lname == "false"
-        lname =  "\"#{lname.gsub("\\","\\\\\\\\").gsub("\"","\\\"").gsub("\n","\\n").
-          gsub("\r","\\r").gsub("\t","\\t").gsub("\f","\\f").gsub("\b","\\b")}\""
-      end
-      CompletionOption.new("#{lname}", "<#{context.feature.eType.name}>")
-    end
-  end
-
-  def string_options(context)
-    if @lang.unquoted?(context.feature)
-      [ CompletionOption.new("#{context.feature.name.gsub(/\W/,"")}", value_description(context)) ]
-    else
-      [ CompletionOption.new("\"\"", value_description(context)) ]
-    end
-  end
-
-  def integer_options(context)
-    (0..0).collect{|i| CompletionOption.new("#{i}", value_description(context)) }
-  end
-
-  def float_options(context)
-    (0..0).collect{|i| CompletionOption.new("#{i}.0", value_description(context)) }
-  end
-
-  def boolean_options(context)
-    [true, false].collect{|b| CompletionOption.new("#{b}", value_description(context)) }
-  end
-
-  private
-
-  def value_description(context)
-    if context.after_label
-      "<#{context.feature.eType.name}>"
-    else
-      "[#{context.feature.name}] <#{context.feature.eType.name}>"
-    end
-  end
-
-  def class_completion_option(eclass)
-    uargs = @lang.unlabled_arguments(eclass).collect{|a| "<#{a.name}>"}.join(", ")
-    CompletionOption.new(@lang.command_by_class(eclass.instanceClass), uargs)
-  end
-
-end
-
-end
-
+require 'rgen/ecore/ecore_ext'
+
+module RText
+
+class DefaultCompleter
+
+  class CompletionOption
+    
+    attr_accessor :insert
+    attr_accessor :display
+    attr_accessor :extra
+    attr_accessor :description
+
+    def self.from_text_extra(text, extra)
+      self.new(text, text + ' ' + extra, nil, extra)
+    end
+    
+    def self.for_curly_braces(context)
+      self.new("{\n#{context.line_indent}#{context.indent}||\n#{context.line_indent}}", '{}')
+    end
+    
+    def self.for_square_brackets
+      self.new('[ || ]', '[]', '')
+    end
+    
+    def initialize(insert, display, description=nil, extra=nil)
+      @insert = insert
+      @display = display
+      @description = description
+      @extra = extra
+    end
+    
+    def text
+      @insert
+    end
+    
+  end
+
+  # Creates a completer for RText::Language +language+.
+  #
+  def initialize(language)
+    @lang = language
+  end
+
+  # Provides completion options
+  #
+  def complete(context, version=0)
+    clazz = context && context.element && context.element.class.ecore
+    if clazz
+      if context.position.in_block
+        block_options(context, clazz)
+      elsif !context.problem
+        result = []
+        add_value_options(context, result, version) if context.feature
+        add_label_options(context, clazz, result, version) unless context.position.after_label
+        result
+      else
+        # missing comma, after curly brace, etc.
+        if version > 0 && !context.position.before_brace &&
+            context.element.class.ecore.eAllReferences.any? { |r| r.containment }
+          [CompletionOption.for_curly_braces(context)]
+        else
+          []
+        end
+      end
+    elsif context
+      root_options
+    else
+      []
+    end
+  end
+
+  def block_options(context, clazz)
+    types = []
+    labled_refs = []
+    if context.feature
+      if context.feature.is_a?(RGen::ECore::EReference) && context.feature.containment
+        types = @lang.concrete_types(context.feature.eType)
+      else
+        # invalid, ignore
+      end
+    else
+      # all target types which don't need a label
+      # and all lables which are needed by a potential target type
+      @lang.containments(clazz).each do |r|
+        ([r.eType] + r.eType.eAllSubTypes).select{|t| t.concrete}.each do |t|
+          if @lang.labeled_containment?(clazz, r) || @lang.containments_by_target_type(clazz, t).size > 1
+            labled_refs << r
+          else
+            types << t
+          end
+        end
+      end
+    end
+    types.uniq.
+      sort{|a,b| a.name <=> b.name}.collect do |c| 
+        class_completion_option(c)
+      end +
+    labled_refs.uniq.collect do |r|
+        CompletionOption.from_text_extra("#{r.name}:", "<#{r.eType.name}>")
+      end
+  end
+
+  def add_value_options(context, result, version)
+    if context.feature.is_a?(RGen::ECore::EAttribute) || !context.feature.containment
+      if context.feature.is_a?(RGen::ECore::EReference)
+        result.concat(reference_options(context))
+        if version > 0 && !context.position.before_bracket && context.feature.upperBound != 1
+          result << CompletionOption.for_square_brackets
+        end
+      elsif context.feature.eType.is_a?(RGen::ECore::EEnum)
+        result.concat(enum_options(context))
+      elsif context.feature.eType.instanceClass == String
+        result.concat(string_options(context))
+      elsif context.feature.eType.instanceClass == Integer 
+        result.concat(integer_options(context))
+      elsif context.feature.eType.instanceClass == Float 
+        result.concat(float_options(context))
+      elsif context.feature.eType.instanceClass == RGen::MetamodelBuilder::DataTypes::Boolean
+        result.concat(boolean_options(context))
+      else
+        # no options 
+      end
+    else
+      if version > 0 && !context.position.before_bracket && context.feature.upperBound != 1
+        result << CompletionOption.for_square_brackets
+      end
+    end
+  end
+
+  def add_label_options(context, clazz, result, version)
+    result.concat(@lang.labled_arguments(clazz).
+      select{|f| 
+        !context.element.eIsSet(f.name)}.collect do |f| 
+        CompletionOption.from_text_extra("#{f.name}:", "<#{f.eType.name}>")
+    end )
+    if version > 0 && !context.position.after_comma &&
+        context.element.class.ecore.eAllReferences.any? { |r| r.containment } && !context.position.before_brace
+      result << CompletionOption.for_curly_braces(context)
+    end
+  end
+
+  def root_options
+    @lang.root_classes.
+      sort{|a,b| a.name <=> b.name}.collect do |c| 
+        class_completion_option(c)
+      end 
+  end
+
+  def reference_options(context)
+    []
+  end
+
+  def enum_options(context)
+    context.feature.eType.eLiterals.collect do |l|
+      lname = l.name
+      if lname =~ /^\d|\W/ || lname == "true" || lname == "false"
+        lname =  "\"#{lname.gsub("\\","\\\\\\\\").gsub("\"","\\\"").gsub("\n","\\n").
+          gsub("\r","\\r").gsub("\t","\\t").gsub("\f","\\f").gsub("\b","\\b")}\""
+      end
+      CompletionOption.from_text_extra("#{lname}", "<#{context.feature.eType.name}>")
+    end
+  end
+
+  def string_options(context)
+    if @lang.unquoted?(context.feature)
+      [ CompletionOption.from_text_extra("#{context.feature.name.gsub(/\W/,"")}", value_description(context)) ]
+    else
+      [ CompletionOption.from_text_extra("\"\"", value_description(context)) ]
+    end
+  end
+
+  def get_default_value_completion(context)
+    return nil unless context.feature.defaultValue
+    CompletionOption.from_text_extra("#{context.feature.defaultValue}", value_description(context))
+  end
+
+  def integer_options(context)
+    default_comp = get_default_value_completion(context)
+    return [default_comp] if default_comp
+    (0..0).collect{|i| CompletionOption.from_text_extra("#{i}", value_description(context)) }
+  end
+
+  def float_options(context)
+    default_comp = get_default_value_completion(context)
+    return [default_comp] if default_comp
+    (0..0).collect{|i| CompletionOption.from_text_extra("#{i}.0", value_description(context)) }
+  end
+
+  def boolean_options(context)
+    [true, false].collect{|b| CompletionOption.from_text_extra("#{b}", value_description(context)) }
+  end
+
+  private
+
+  def value_description(context)
+    if context.position.after_label
+      "<#{context.feature.eType.name}>"
+    else
+      "[#{context.feature.name}] <#{context.feature.eType.name}>"
+    end
+  end
+
+  def class_completion_option(eclass)
+    uargs = @lang.unlabled_arguments(eclass).collect{|a| "<#{a.name}>"}.join(", ")
+    CompletionOption.from_text_extra(@lang.command_by_class(eclass.instanceClass), uargs)
+  end
+
+end
+
+end
+

data/lib/rtext/default_service_provider.rb

@@ -35,17 +35,17 @@ class DefaultServiceProvider
     end
   end
 
-  def get_completion_options(context)
+  def get_completion_options(context, version=0)
     completer = RText::DefaultCompleter.new(@lang) 
     class << completer
       attr_accessor :service_provider
       def reference_options(context) 
         service_provider.get_reference_completion_options(context).collect {|o|
-          DefaultCompleter::CompletionOption.new(o.identifier, "<#{o.type}>")}
+          DefaultCompleter::CompletionOption.from_text_extra(o.identifier, "<#{o.type}>")}
       end
     end
     completer.service_provider = self
-    completer.complete(context)
+    completer.complete(context, version)
   end
 
   ReferenceCompletionOption = Struct.new(:identifier, :type)

data/lib/rtext/frontend/context.rb

@@ -55,27 +55,27 @@ def filter_lines(lines)
   }
 end
 
-# when joining two lines, all whitespace after the last character of the first line is removed
-# (after , and [); however whitespace at the end of the last of several joined lines is preserved;
-# this way the context is correct even if the cursor is after the end of the last line 
-# (i.e. with whitespace after the last non-whitespace character)
+# when joining two lines, all whitespace is preserved in order to simplify the algorithm
+# whitespace after a backslash is also preserved, only the backslash itself is removed
+# note that whitespace left of the cursor is important for proper context calculation
 def join_lines(lines, pos)
   outlines = []
   while lines.size > 0
     outlines << lines.shift
     while lines.size > 0 && 
-        (outlines.last =~ /,\s*$/ || 
-        (outlines.last =~ /\[\s*$/ && outlines.last =~ /,/) ||
-        (lines.first =~ /^\s*\]/ && outlines.last =~ /,/))
-      outlines.last.rstrip!
+        (outlines.last =~ /[,\\]\s*$/ || 
+          # don't join after a child label
+          (outlines.last !~ /^\s*\w+:/ &&
+            (outlines.last =~ /\[\s*$/ ||
+            (lines.first =~ /^\s*\]/ && outlines.last =~ /\[/))))
       l = lines.shift
+      outlines.last.gsub!("\\","")
       if lines.size == 0
-        # strip only left part, the prefix might have whitespace on the
+        # the prefix might have whitespace on the
         # right hand side which is relevant for the position
-        non_ws_prefix = l[0..pos-1].lstrip
-        pos = outlines.last.size + non_ws_prefix.size
+        pos = outlines.last.size + pos
       end
-      outlines.last.concat(l.lstrip)
+      outlines.last.concat(l)
     end
   end
   [outlines, pos]

data/lib/rtext/language.rb

@@ -260,7 +260,7 @@ class Language
   end
 
   def concrete_types(clazz)
-    ([clazz] + clazz.eAllSubTypes).select{|c| !c.abstract}
+    ([clazz] + clazz.eAllSubTypes).select{|c| c.concrete}
   end
 
   def containments_by_target_type(clazz, type)
@@ -299,7 +299,7 @@ class Language
     @command_by_class = {}
     @has_command = {}
     root_epackage.eAllClasses.each do |c|
-      next if c.abstract
+      next unless c.concrete
       cmd = command_name_provider.call(c)
       @command_by_class[c.instanceClass] = cmd 
       @has_command[cmd] = true
@@ -307,7 +307,7 @@ class Language
       @class_by_command[clazz] ||= {} 
       containments(c).collect{|r|
           [r.eType] + r.eType.eAllSubTypes}.flatten.uniq.each do |t|
-        next if t.abstract
+        next unless t.concrete
         cmw = command_name_provider.call(t)
         raise "ambiguous command name #{cmw}" if @class_by_command[clazz][cmw]
         @class_by_command[clazz][cmw] = t.instanceClass
@@ -315,7 +315,7 @@ class Language
     end
     @class_by_command[nil] = {} 
     @root_classes.each do |c|
-      next if c.abstract
+      next unless c.concrete
       cmw = command_name_provider.call(c)
       raise "ambiguous command name #{cmw}" if @class_by_command[nil][cmw]
       @class_by_command[nil][cmw] = c.instanceClass
@@ -323,7 +323,7 @@ class Language
   end
 
   def default_root_classes(root_package)
-    root_epackage.eAllClasses.select{|c| !c.abstract &&
+    root_epackage.eAllClasses.select{|c| c.concrete &&
       !c.eAllReferences.any?{|r| r.eOpposite && r.eOpposite.containment}}
   end
 

data/lib/rtext/serializer.rb

@@ -179,7 +179,7 @@ class Serializer
           result << v.to_s  
         end
       elsif feature.eType.instanceClass == Object
-        if v.to_s =~ /^\d+(\.\d+)?$|^\w+$|^true$|^false$/ 
+        if v.to_s =~ /^-?\d+(\.\d+)?$|^\w+$|^true$|^false$/
           result << v.to_s  
         else
           result << "\"#{v.to_s.gsub("\\","\\\\\\\\").gsub("\"","\\\"").gsub("\n","\\n").