rtext 0.2.1 → 0.3.0

data/CHANGELOG

@@ -2,7 +2,15 @@
 
 * First public release
 
-=0.2.1
+=0.3.0
 
-* Fixed serialization of enum literals starting with a digit
+* Added context sensitive commands
+* Show child role lables in auto completer
+* Show unlabled arguments in auto completer
+* Show only arguments in auto completer which don't have a value yet
+* Fixed auto completion within array values
+* Fixed generation of child role labels in serializer
+* Added :after_load hook to DefaultLoader
+* Added result limit option to DefaultServiceProvider
+* Removed short_class_names option from Language
 

data/Rakefile

@@ -8,7 +8,7 @@ DocFiles = [
 
 RTextGemSpec = Gem::Specification.new do |s|
   s.name = %q{rtext}
-  s.version = "0.2.1"
+  s.version = "0.3.0"
   s.date = Time.now.strftime("%Y-%m-%d")
   s.summary = %q{Ruby Textual Modelling}
   s.email = %q{martin dot thiede at gmx de}

data/lib/rtext/completer.rb

@@ -14,74 +14,99 @@ class Completer
 
   # Provides completion options
   #
-  #  :linestart
-  #    the content of the current line before the cursor
-  #
-  #  :prev_line_provider
-  #    is a proc which must return lines above the current line
-  #    it receives an index parameter in the range 1..n
-  #    1 is the line just above the current one, 2 is the second line above, etc.
-  #    the proc must return the line as a string or nil if there is no more line
-  #
   #  :ref_completion_option_provider
   #    a proc which receives a EReference and should return
   #    the possible completion options as CompletionOption objects 
   #    note, that the context element may be nil if this information is unavailable
   #
-  def complete(line, linepos, prev_line_provider, ref_completion_option_provider=nil)
-    linestart = line[0..linepos-1]
-    # command
-    if linestart =~ /^\s*(\w*)$/ 
-      prefix = $1
-      classes = completion_classes(prev_line_provider)
-      classes = classes.select{|c| c.name.index(prefix) == 0} if prefix
-      classes.sort{|a,b| a.name <=> b.name}.collect do |c| 
-        uargs = @lang.unlabled_arguments(c).collect{|a| "<#{a.name}>"}.join(", ")
-        CompletionOption.new(c.name, uargs)
-      end
-    # attribute
-    elsif linestart =~ /^\s*(\w+)\s+(?:[^,]+,)*\s*(\w*)$/
-      command, prefix = $1, $2
-      clazz = @lang.class_by_command(command)
-      if clazz
-        features = @lang.labled_arguments(clazz.ecore)
-        features = features.select{|f| f.name.index(prefix) == 0} if prefix
-        features.sort{|a,b| a.name <=> b.name}.collect do |f| 
-          CompletionOption.new("#{f.name}:", "<#{f.eType.name}>")
+  def complete(context, ref_completion_option_provider=nil)
+    clazz = context && context.element && context.element.class.ecore
+    if clazz
+      if context.in_block
+        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
+          clazz.eAllReferences.select{|r| r.containment}.each do |r|
+            ([r.eType] + r.eType.eAllSubTypes).select{|t| !t.abstract}.each do |t|
+              if @lang.containments_by_target_type(clazz, t).size > 1
+                labled_refs << r
+              else
+                types << t
+              end
+            end
+          end
         end
+        types.uniq.select{|c| c.name.index(context.prefix) == 0}.
+          sort{|a,b| a.name <=> b.name}.collect do |c| 
+            class_completion_option(c)
+          end +
+        labled_refs.uniq.select{|r| r.name.index(context.prefix) == 0}.
+          sort!{|a,b| a.name <=> b.name}.collect do |r|
+            CompletionOption.new("#{r.name}:", "<#{r.eType.name}>")
+          end
       else
-        []
-      end
-    # value
-    elsif 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
-        if feature.is_a?(RGen::ECore::EReference)
-          if ref_completion_option_provider
-            ref_completion_option_provider.call(feature)
+        if context.feature
+          # value completion
+          if context.feature.is_a?(RGen::ECore::EAttribute) || !context.feature.containment
+            if context.feature.is_a?(RGen::ECore::EReference)
+              if ref_completion_option_provider
+                ref_completion_option_provider.call(context.feature)
+              else
+                []
+              end
+            elsif context.feature.eType.is_a?(RGen::ECore::EEnum)
+              context.feature.eType.eLiterals.collect do |l|
+                CompletionOption.new("#{l.name}")
+              end 
+            elsif context.feature.eType.instanceClass == String
+              [ CompletionOption.new("\"\"") ]
+            elsif context.feature.eType.instanceClass == Integer 
+              (0..4).collect{|i| CompletionOption.new("#{i}") }
+            elsif context.feature.eType.instanceClass == Float 
+              (0..4).collect{|i| CompletionOption.new("#{i}.0") }
+            elsif context.feature.eType.instanceClass == RGen::MetamodelBuilder::DataTypes::Boolean
+              [true, false].collect{|b| CompletionOption.new("#{b}") }
+            else
+              []
+            end
           else
-            []
+            # containment reference, ignore
           end
-        elsif feature.eType.is_a?(RGen::ECore::EEnum)
-          feature.eType.eLiterals.collect do |l|
-            CompletionOption.new("#{l.name}")
-          end 
-        elsif feature.eType.instanceClass == String
-          [ CompletionOption.new("\"\"") ]
-        elsif feature.eType.instanceClass == Integer 
-          (0..4).collect{|i| CompletionOption.new("#{i}") }
-        elsif feature.eType.instanceClass == Float 
-          (0..4).collect{|i| CompletionOption.new("#{i}.0") }
-        elsif feature.eType.instanceClass == RGen::MetamodelBuilder::DataTypes::Boolean
-          [true, false].collect{|b| CompletionOption.new("#{b}") }
         else
-          []
+          result = []
+          if !@lang.labled_arguments(clazz).any?{|f| 
+              context.element.getGenericAsArray(f.name).size > 0}
+            result += @lang.unlabled_arguments(clazz).
+              select{|f| f.name.index(context.prefix) == 0 && 
+                context.element.getGenericAsArray(f.name).empty?}[0..0].
+              sort{|a,b| a.name <=> b.name}.collect do |f| 
+                CompletionOption.new("<#{f.name}>", "<#{f.eType.name}>")
+              end
+          end
+          # label completion
+          result += @lang.labled_arguments(clazz).
+            select{|f| f.name.index(context.prefix) == 0 && 
+              context.element.getGenericAsArray(f.name).empty?}.
+            sort{|a,b| a.name <=> b.name}.collect do |f| 
+              CompletionOption.new("#{f.name}:", "<#{f.eType.name}>")
+            end 
+          result
         end
-      else
-        []
       end
+    elsif context
+      # root classes
+      @lang.root_classes.select{|c| c.name.index(context.prefix) == 0}.
+        sort{|a,b| a.name <=> b.name}.collect do |c| 
+          class_completion_option(c)
+        end 
     else
       []
     end
@@ -89,61 +114,9 @@ class Completer
 
   private
 
-  def completion_classes(prev_line_provider)
-    clazz, feature = context(prev_line_provider)
-    if clazz
-      if feature
-        @lang.concrete_types(feature.eType)
-      else
-        refs_by_class = {}
-        clazz.eAllReferences.select{|r| r.containment}.each do |r|
-          @lang.concrete_types(r.eType).each { |c| (refs_by_class[c] ||= []) << r }
-        end
-        refs_by_class.keys.select{|c| refs_by_class[c].size == 1}
-      end
-    else
-      @lang.root_epackage.eAllClasses.select{|c| !c.abstract &&
-        !c.eAllReferences.any?{|r| r.eOpposite && r.eOpposite.containment}}
-    end
-  end
-
-  def context(prev_line_provider)
-    command, role = parse_context(prev_line_provider)
-    clazz = command && @lang.root_epackage.eAllClasses.find{|c| c.name == command}
-    feature = role && clazz && clazz.eAllReferences.find{|r| r.containment && r.name == role}
-    [clazz, feature]
-  end
-
-  def parse_context(prev_line_provider)
-    block_nesting = 0
-    array_nesting = 0
-    non_empty_lines = 0
-    role = nil
-    i = 0
-    while line = prev_line_provider.call(i+=1)
-      # empty or comment
-      next if line =~ /^\s*$/ || line =~ /^\s*#/
-      # role
-      if line =~ /^\s*(\w+):\s*$/
-        role = $1 if non_empty_lines == 0
-      # block open
-      elsif line =~ /^\s*(\S+).*\{\s*$/
-        block_nesting -= 1
-        return [$1, role] if block_nesting < 0
-      # block close
-      elsif line =~ /^\s*\}\s*$/
-        block_nesting += 1
-      # array open
-      elsif line =~ /^\s*(\w+):\s*\[\s*$/
-        array_nesting -= 1
-        role = $1 if array_nesting < 0
-      # array close
-      elsif line =~ /^\s*\]\s*$/
-        array_nesting += 1
-      end
-      non_empty_lines += 1
-    end
-    [nil, nil]
+  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

data/lib/rtext/context_builder.rb

@@ -0,0 +1,188 @@
+require 'rtext/instantiator'
+
+module RText
+
+# The ContextBuilder builds context information for a set of context lines and the 
+# cursor position in the current line. The context consists of 
+#
+# * the context element, i.e. the element surrounding the current cursor position,
+#   the element is a new stand-alone element with all parent elements set up to the root,
+#   all attributes and non-containment references before the cursor position will be set,
+#   values right or below of the current cursor position will be ommitted,
+#   the value directly left of the cursor with no space in between will also be ommitted,
+#   (it is assumed that the value is currently being completed)
+#   references are not being resolved
+#
+# * the current feature or nil if it can not be determined
+#   if the cursor is inside or directly behind a role label, this label will be ignored
+#   (it is assumed that the lable is currently being completed)
+#
+# * the completion prefix, this is the word directly left of the cursor
+#
+# * flag if cursor is in an array (i.e. within square brackets)
+#
+# * flag if the cursor is in the content block of the context element (i.e. within curly braces)
+#
+module ContextBuilder
+
+  Context = Struct.new(:element, :feature, :prefix, :in_array, :in_block)
+
+  class << self
+
+  # Builds the context information based on a set of +content_lines+. Content lines
+  # are the RText lines containing the nested command headers in the original order.
+  # The cursor is assumed to be in the last context line at column +position_in_line+
+  def build_context(language, context_lines, position_in_line)
+    context_info = fix_context(context_lines, position_in_line)
+    return nil unless context_info
+    element = instantiate_context_element(language, context_info)
+    if element
+      feature = context_info.role &&
+        element.class.ecore.eAllStructuralFeatures.find{|f| f.name == context_info.role}
+      Context.new(element, feature, context_info.prefix, context_info.in_array, context_info.in_block)
+    else
+      Context.new(nil, nil, context_info.prefix, context_info.in_array, context_info.in_block)
+    end
+  end
+
+  private
+
+  def instantiate_context_element(language, context_info)
+    root_elements = []
+    problems = []
+    text = context_info.lines.join("\n")
+    Instantiator.new(language).instantiate(text,
+      :root_elements => root_elements, :problems => problems)
+    if root_elements.size > 0
+      find_leaf_child(root_elements.first, context_info.num_elements-1)
+    else
+      nil
+    end
+  end
+
+  def find_leaf_child(element, num_required_children)
+    childs = element.class.ecore.eAllReferences.select{|r| r.containment}.collect{|r|
+      element.getGenericAsArray(r.name)}.flatten
+    if childs.size > 0
+      find_leaf_child(childs.first, num_required_children-1)
+    elsif num_required_children == 0
+      element
+    else
+      nil
+    end
+  end
+
+  ContextInternal = Struct.new(:lines, :num_elements, :role, :prefix, :in_array, :in_block)
+
+  # extend +context_lines+ into a set of lines which can be processed by the RText
+  def fix_context(context_lines, position_in_line)
+    context_lines = context_lines.dup
+    # make sure there is at least one line
+    # the frontent may ommit the last context line if the cursor is at collumn 0
+    if context_lines.empty? || (position_in_line == 0 && context_lines.last != "")
+      context_lines << ""
+    end
+    position_in_line ||= context_lines.last.size
+    # cut off last line right of cursor
+    context_lines << context_lines.pop[0..position_in_line-1]
+    line = context_lines.last
+    if line =~ /^\s*\w+\s+/
+      # this line contains a new element
+      num_elements = 1
+      in_block = false
+      # labled array value
+      if line =~ /\W(\w+):\s*\[([^\]]*)$/
+        role = $1
+        array_content = $2
+        in_array = true
+        if array_content =~ /,\s*(\S*)$/
+          prefix = $1
+          line.sub!(/,\s*\S*$/, "]")
+        else 
+          array_content =~ /\s*(\S*)$/
+          prefix = $1
+          line.sub!(/\[[^\]]*$/, "[]")
+        end
+      # labled value
+      elsif line =~ /\W(\w+):\s*(\S*)$/
+        role = $1
+        prefix = $2
+        in_array = false
+        line.sub!(/\s*\w+:\s*\S*$/, "")
+        line.sub!(/,$/, "")
+      # unlabled value or label
+      elsif line =~ /[,\s](\S*)$/
+        role = nil
+        prefix = $1
+        in_array = false
+        line.sub!(/\s*\S*$/, "")
+        line.sub!(/,$/, "")
+      # TODO: unlabled array value
+      else 
+        # parse problem
+        return nil
+      end
+    else
+      # this line is in the content block
+      num_elements = 0
+      in_block = true
+      # role or new element
+      if line =~ /^\s*(\w*)$/
+        prefix = $1
+        role, in_array = find_role(context_lines[0..-2])
+        # fix single role lable
+        if context_lines[-2] =~ /^\s*\w+:\s*$/
+          context_lines[-1] = context_lines.pop
+        end
+      else
+        # comment, closing brackets, etc.
+        return nil
+      end
+    end
+    context_lines.reverse.each do |l|
+      if l =~ /\{\s*$/
+        context_lines << "}"
+        num_elements += 1
+      elsif l =~ /\[\s*$/
+        context_lines << "]"
+      end
+    end
+    ContextInternal.new(context_lines, num_elements, role, prefix, in_array, in_block)
+  end
+
+  def find_role(context_lines)
+    block_nesting = 0
+    array_nesting = 0
+    non_empty_lines = 0
+    context_lines.reverse.each do |line|
+      # empty or comment
+      next if line =~ /^\s*$/ || line =~ /^\s*#/
+      # role
+      if line =~ /^\s*(\w+):\s*$/
+        return [$1, false] if non_empty_lines == 0
+      # block open
+      elsif line =~ /^\s*(\S+).*\{\s*$/
+        block_nesting -= 1
+        return [nil, false] if block_nesting < 0
+      # block close
+      elsif line =~ /^\s*\}\s*$/
+        block_nesting += 1
+      # array open
+      elsif line =~ /^\s*(\w+):\s*\[\s*$/
+        array_nesting -= 1
+        return [$1, true] if array_nesting < 0
+      # array close
+      elsif line =~ /^\s*\]\s*$/
+        array_nesting += 1
+      end
+      non_empty_lines += 1
+    end
+    [nil, false]
+  end
+
+  end
+
+end
+
+end
+

data/lib/rtext/default_loader.rb

@@ -50,8 +50,13 @@ class DefaultLoader
   #    into and a symbol indicating the kind of loading: :load, :load_cached, :load_update_cache
   #    default: no before load proc
   # 
+  #  :after_load
+  #    a proc which is called after a file has been loaded, receives the fragment loaded
+  #    default: no after load proc
+  #
   def load(options={})
     @before_load_proc = options[:before_load]
+    @after_load_proc = options[:after_load]
     files = @file_provider.call 
     @change_detector.check_files(files)
     @model.resolve(:fragment_provider => method(:fragment_provider),
@@ -99,12 +104,15 @@ class DefaultLoader
         @before_load_proc && @before_load_proc.call(fragment, :load_update_cache)
         load_fragment(fragment)
         @cache.store(fragment)
+      @after_load_proc && @after_load_proc.call(fragment)
       else
         @before_load_proc && @before_load_proc.call(fragment, :load_cached)
+      @after_load_proc && @after_load_proc.call(fragment)
       end
     else
       @before_load_proc && @before_load_proc.call(fragment, :load)
       load_fragment(fragment)
+    @after_load_proc && @after_load_proc.call(fragment)
     end
   end