rtext 0.8.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9cc23fae2c92b80a90a57f2d0271539f47e3838f
-  data.tar.gz: 8f992d322e1a2ed3c2725916aa668e15673f9928
+  metadata.gz: e9e6e9cf51849833ea57ae6f44b6e1b56bc715af
+  data.tar.gz: c63bf26429dee687a2ae1e07e63626a461a493f9
 SHA512:
-  metadata.gz: 9d07b5485e5929f3d966d048c11fe2eec7630076e06c88de7fd99182a48f2bd1e0bcdf50ba68591c68968e44a401ff580a61b4b7440c34bb992f16275bd563a8
-  data.tar.gz: 8ac1a2998803fffbf53b28d80ad138017629a6b7d23bf490554959a1210e571e180a75d01d08a229e472d09a9e5b011c9c69f629e1f61c704ca578b7689e116b
+  metadata.gz: ebe766d35ad7ccb86a7ada1cd5344cf4463fb3318ff2cf40613294e462542b63b464e150f747abe33af2193c94fd747cf6a776c64dcdb0f7535aff55cc37e01d
+  data.tar.gz: 7d576b493c98b55ff22a50e0bda0ed928adb765b032f7bf83fc10edc52e3e26e6067fce2aa6e6ae03b9d24358d7c7c964388030439599c057902130491721f5a

data/CHANGELOG

@@ -87,3 +87,12 @@
 * Fixed frontend content extraction to support line breaks with backslash
 * Fixed frontend content extraction, joining of broken lines
 
+=0.8.2
+
+* Fixed serializer negative decimal quotation
+* Added Object attribute test case
+
+=0.9.0
+
+* Added protocol versioning support
+* Added completion options for square brackets and curly braces

data/RText_Protocol

@@ -4,6 +4,10 @@ RText frontend and backend pass messages containing JSON objects.
 Normally the frontend invokes a backend command by means of a request message and the 
 backend will eventually reply with a response message. 
 
+== Versioning
+
+RText protocol supports versioning mechanism with a single version natural number.
+The actual version of the protocol is 1.
 
 == Encoding
 
@@ -25,8 +29,8 @@ In addition, the character "%" is escaped in the same way, i.e. "%" will always
 
 Example:
 
-The word "�bung" (german: exercise), encoded in ISO-8859-1 would result in the string:
-"%dcbung" (the "�" Umlaut has a byte value of 0xdc is ISO-8859-1).
+The word "Übung" (german: exercise), encoded in ISO-8859-1 would result in the string:
+"%dcbung" (the "Ü" Umlaut has a byte value of 0xdc is ISO-8859-1).
 
 
 == Request Messages
@@ -34,9 +38,12 @@ The word "
 Each request message contains a field ``command`` and a field ``invocation_id``.
 The command field holds the name of the command to be invoked as a string.
 The invocation id field holds an identifier which will be repeated by the backend's response.
+The "version" field was introduced in version 1. It is optional for protocol version 0 requests,
+but mandatory for newer versions.
 
   {
     "type": "request",
+    "version": <protocol_version [integer]>,
     "command": <command>,
     "invocation_id": <invocation_id>
     ...
@@ -65,6 +72,16 @@ There are a number of error message which may be sent in response to a request m
     "invocation_id": <invocation_id>,
     "command": <unknown command [string]>
   }
+  
+=== Unsupported Protocol Version Error
+
+Introduced in version 1.
+
+  {
+    "type": "unsupported_version",
+    "invocation_id": <invocation_id>,
+    "version": <supported version [integer]>
+  }
 
 == Progress Information
 
@@ -90,6 +107,25 @@ The message field may carry information about the currently ongoing subtask.
 For each command, the layout of the request and response messages will be given below.
 Note that the invocation id field is present in every request and response but is omitted for brevity.
 
+=== Backend version request
+
+Introduced in version 1.
+
+This command requests the backend to disclose its supported protocol version.
+
+  {
+    "type": "request",
+    "command": "version"
+  }
+  
+The backend responds with a version information.
+
+  {
+    "type": "response",
+    "version": <version [integer]>
+  }
+  
+The backend supporting protocool version 0 only responds with an 'Unknown Command Error'.
 
 === Load Model
 
@@ -141,7 +177,14 @@ build the set of context lines in the frontend. Column number start at 1.
   }
 
 The backend replies with a list of completion options. 
-The field ``insert`` holds the text to be inserted if the completion option is chosen.
+The field ``insert`` holds the text to be inserted if the completion option is chosen. This text 
+may contains placeholders for cursor position. An editor may use them to assist a user in 
+filling additional completion fields.
+Each placeholder must start and end with a vertical bar character (``|``) and can contain up to
+three optional parts separated by an additional vertical bar character: ordering number, name and
+description of this cursor position. E.g.: ``||``, ``|1|name|Entity name|``, ``|||New value|``.
+Placeholders with the same name must be considered as the same value repeated in different 
+positions.
 The field ``display`` contains the string which should be displayed to the user in some kind of 
 completion option menu. An optional description field may provide more information about a 
 particular option.

data/Rakefile

@@ -8,14 +8,14 @@ DocFiles = [
 
 RTextGemSpec = Gem::Specification.new do |s|
   s.name = %q{rtext}
-  s.version = "0.8.2"
+  s.version = "0.9.0"
   s.date = Time.now.strftime("%Y-%m-%d")
   s.summary = %q{Ruby Textual Modelling}
   s.email = %q{martin dot thiede at gmx de}
   s.homepage = %q{http://ruby-gen.org}
   s.description = %q{RText can be used to derive textual languages from an RGen metamodel with very little effort.}
   s.authors = ["Martin Thiede"]
-  s.add_dependency('rgen', '>= 0.6.1')
+  s.add_dependency('rgen', '>= 0.8.2')
   gemfiles = Rake::FileList.new
   gemfiles.include("{lib,test}/**/*")
   gemfiles.include(DocFiles)

data/lib/rtext/context_builder.rb

@@ -26,7 +26,8 @@ module RText
 #
 module ContextBuilder
 
-  Context = Struct.new(:element, :feature, :prefix, :in_array, :in_block, :after_label, :problem)
+  PositionContext = Struct.new(:in_array, :in_block, :after_label, :after_comma, :before_brace, :before_bracket)
+  Context = Struct.new(:element, :feature, :prefix, :problem, :position, :line_indent, :indent)
 
   class << self
   include RText::Tokenizer
@@ -50,13 +51,37 @@ module ContextBuilder
       else
         feature = nil
       end
-      Context.new(element, feature, context_info.prefix, context_info.in_array, context_info.in_block, after_label, context_info.problem)
+      context_info.position.after_label = after_label
+      Context.new(element, feature, context_info.prefix, context_info.problem, context_info.position,
+                  get_line_indent(context_lines.last), get_indent(context_lines))
     else
-      Context.new(nil, nil, context_info.prefix, context_info.in_array, context_info.in_block, false, context_info.problem)
+      context_info.position.after_label = false
+      Context.new(nil, nil, context_info.prefix, context_info.problem, context_info.position,
+                  get_line_indent(context_lines.last), get_indent(context_lines))
     end
   end
 
   private
+  
+  def get_line_indent(line)
+    return '' unless line
+    match = line.match(/^\s+/)
+    if match.nil?
+      ''
+    else
+      match[0]
+    end
+  end
+  
+  # Compute indent from context lines
+  def get_indent(context_lines)
+    cl = context_lines.dup
+    while true
+      return '  ' if cl.size < 2 # default indentation is 2 spaces
+      indent = get_line_indent(cl.last)[get_line_indent(cl.delete_at(-2)).size..-1]
+      return indent unless indent.nil? || indent.empty?
+    end
+  end
 
   def instantiate_context_element(language, context_info)
     root_elements = []
@@ -72,7 +97,7 @@ module ContextBuilder
   end
 
   def find_leaf_child(element, num_required_children)
-    childs = element.class.ecore.eAllReferences.select{|r| r.containment}.collect{|r|
+    childs = element.class.ecore.eAllReferences.select{|r| r.containment }.collect{|r|
       element.getGenericAsArray(r.name)}.flatten
     if num_required_children == 0
       element
@@ -83,7 +108,7 @@ module ContextBuilder
     end
   end
 
-  ContextInternal = Struct.new(:lines, :num_elements, :role, :prefix, :in_array, :in_block, :problem)
+  ContextInternal = Struct.new(:lines, :num_elements, :role, :prefix, :problem, :position)
 
   # extend +context_lines+ into a set of lines which can be processed by the RText
   def fix_context(language, context_lines, position_in_line)
@@ -95,11 +120,14 @@ module ContextBuilder
     position_in_line ||= context_lines.last.size
     # cut off last line right of cursor
     if position_in_line < 1
-      context_lines.pop
+      tail = context_lines.pop
       context_lines << ""
     else
+      tail = context_lines.last[position_in_line..-1]
       context_lines << context_lines.pop[0..position_in_line-1]
     end
+    before_brace = !tail.nil? && !tail.match(/^\s*\{/).nil?
+    before_bracket = !tail.nil? && !tail.match(/^\s*\[/).nil?
     problem = nil
     line = context_lines.last
     if line =~ /\{\s*$/
@@ -110,7 +138,7 @@ module ContextBuilder
       problem = :after_curly
     end
     
-    num_elements = in_block = in_array = missing_comma = role = prefix = nil
+    num_elements = in_block = in_array = missing_comma = role = prefix = after_comma = nil
     tokens = tokenize(line, language.reference_regexp)
     tokens.pop if tokens.last && tokens.last.kind == :newline
     if tokens.size > 0 && tokens[0].kind == :identifier
@@ -124,6 +152,7 @@ module ContextBuilder
         unlabled_index = 0
         tokens[1..-1].each do |token|
           break if token.kind == :error
+          after_comma = false
           if token.kind == "["
             in_array = true
           elsif token.kind == "]"
@@ -136,6 +165,7 @@ module ContextBuilder
             missing_comma = false
             role = nil unless in_array
             unlabled_index += 1 unless in_array
+            after_comma = true
           end
         end
         if ((tokens.size == 1 && line =~ /\s+$/) || 
@@ -187,6 +217,16 @@ module ContextBuilder
       if context_lines[-2] =~ /^\s*\w+:\s*$/
         context_lines[-1] = context_lines.pop
       end
+    elsif tokens.size == 1 && tokens[0].kind == :label
+      token = tokens[0]
+      role = context_lines.last[token.scol - 1..token.ecol - 2]
+      context_lines << context_lines.pop[0..token.scol - 2]
+      context = fix_context(language, context_lines, context_lines.last.size)
+      context.role = role
+      context.position.in_block = false
+      context.position.before_brace = before_brace
+      context.position.before_bracket = before_bracket
+      return context
     else
       # comment, closing brackets, etc.
       num_elements = 0
@@ -210,7 +250,8 @@ module ContextBuilder
       end
     end
     problem = :missing_comma if !problem && missing_comma
-    ContextInternal.new(context_lines, num_elements, role, prefix, in_array, in_block, problem)
+    ContextInternal.new(context_lines, num_elements, role, prefix, problem,
+                        PositionContext.new(in_array, in_block, false, after_comma, before_brace, before_bracket))
   end
 
   def find_role(context_lines)

data/lib/rtext/default_completer.rb

@@ -4,7 +4,33 @@ module RText
 
 class DefaultCompleter
 
-  CompletionOption = Struct.new(:text, :extra)
+  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
+    
+  end
 
   # Creates a completer for RText::Language +language+.
   #
@@ -14,23 +40,24 @@ class DefaultCompleter
 
   # Provides completion options
   #
-  def complete(context)
+  def complete(context, version=0)
     clazz = context && context.element && context.element.class.ecore
     if clazz
-      if context.in_block
+      if context.position.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
+        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
@@ -52,7 +79,7 @@ class DefaultCompleter
       # 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|
+        ([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
@@ -66,14 +93,17 @@ class DefaultCompleter
         class_completion_option(c)
       end +
     labled_refs.uniq.collect do |r|
-        CompletionOption.new("#{r.name}:", "<#{r.eType.name}>")
+        CompletionOption.from_text_extra("#{r.name}:", "<#{r.eType.name}>")
       end
   end
 
-  def add_value_options(context, result)
+  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
@@ -88,16 +118,22 @@ class DefaultCompleter
         # no options 
       end
     else
-      # containment reference, ignore
+      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)
+  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.new("#{f.name}:", "<#{f.eType.name}>")
-      end )
+        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
@@ -118,34 +154,43 @@ class DefaultCompleter
         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}>")
+      CompletionOption.from_text_extra("#{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)) ]
+      [ CompletionOption.from_text_extra("#{context.feature.name.gsub(/\W/,"")}", value_description(context)) ]
     else
-      [ CompletionOption.new("\"\"", value_description(context)) ]
+      [ 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)
-    (0..0).collect{|i| CompletionOption.new("#{i}", value_description(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)
-    (0..0).collect{|i| CompletionOption.new("#{i}.0", value_description(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.new("#{b}", value_description(context)) }
+    [true, false].collect{|b| CompletionOption.from_text_extra("#{b}", value_description(context)) }
   end
 
   private
 
   def value_description(context)
-    if context.after_label
+    if context.position.after_label
       "<#{context.feature.eType.name}>"
     else
       "[#{context.feature.name}] <#{context.feature.eType.name}>"
@@ -154,7 +199,7 @@ class DefaultCompleter
 
   def class_completion_option(eclass)
     uargs = @lang.unlabled_arguments(eclass).collect{|a| "<#{a.name}>"}.join(", ")
-    CompletionOption.new(@lang.command_by_class(eclass.instanceClass), uargs)
+    CompletionOption.from_text_extra(@lang.command_by_class(eclass.instanceClass), uargs)
   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)