rtext 0.5.1 → 0.7.0

data/CHANGELOG

@@ -47,3 +47,32 @@
 
 * Fixed service connection problem when ports are in use by other processes
 
+=0.5.2
+
+* Fixed exception in default service provider when trying to follow a reference on an attribute value
+* Ignore BOM in instantiator
+
+=0.5.3
+
+* Fixed completion of enum values which need to be quoted
+* Added support for BigDecimal
+
+=0.6.0
+
+* Changed service provider interface to allow for more customization
+* Changed Completer into DefaultCompleter to allow for customization
+* Added labeled_containments language parameter
+* Made DefaultLoader robust against missing files
+
+=0.7.0
+
+* Added DefaultResolver and support for custom resolvers for DefaultLoader and DefaultServiceProvider
+* Changed instantiator on_progress proc to take a second argument with the number of progress steps
+* Changed tokenizer to start new tokens immediately after error tokens
+* Fixed line number in instantiator problem report for multiple childs in one-role
+* Fixed unit tests for Ruby 2.0
+* Fixed context builder prefixes for strings
+* Fixed DefaultLoader to let fragments calculate their elements list by themselves
+* Minor performance improvements, mainly for instantiator and when passing large RText messages
+* Improved performance of frontend connector especially for large amounts of data
+

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Martin Thiede
+Copyright (c) 2013 Martin Thiede
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/RText_Protocol

@@ -296,94 +296,145 @@ This information can be used to show the commands in a hierarchical menu, e.g. a
     ]
   }
 
-=== Custom Command Invocation
+=== Custom Command Parameters
 
-Custom commands are invoked just like the predefined commands. The frontend uses the command
-identifier returned by the "Custom Commands" request as the value of the ``command`` field in 
-the new invocation request. If the command id was returned by a "Costum Commands" request which
-included context information, the frontend should send the same context information in the new
-invocation request and all repeated requests (see below). If this information was not present 
-in command list request, it should not be send in the new command invocation.
+Before a custom command can be invoked, the frontend must check with the backend if parameters
+are required. This is done by means of the command
 
   {
     "type": "request",
-    "command": <command id>
+    "command": "check_custom_command_parameters",
+    "command_id": <custom command id>
+    "context": <context lines, optional>,
+    "column": <cursor column, optional>
+    "parameters": [
+      { 
+        "name": <parameter name>,
+        "value": <parameter value>
+      }
+      ...
+    ]
   }
 
-On first invocation, the frontend will not send any parameters with the command request.
-Instead, the backend's response may ask for parameters to be included into the next request.
-In this case, the frontend should will prompt the user to enter the required information and then 
-reinvoke the command with the parameters included. This process of asking for more parameters 
-may be repeated several times.
+If the command id was returned by a "Costum Commands" request which
+included context information, the frontend should send the same context information in the new
+invocation request and all repeated requests (see below). If this information was not sent 
+in command list request (non-context sensitive command), it should neither be send in the new 
+command invocation.
 
-More generally, the backend will tell the frontend to display dialogs to the user.
-Dialogs may contain input fields, output fields and hidden fields. 
-Fields may be marked to indicate that their value should be sent to the backend on next invocation.
+If a command requires parameters, the response will have the field `success` set to false and
+will include information for building a user dialog.
 
 The dialogs contain elements of certain types:
 
-* text: text as a string 
-* text 
-* element_list field
-* element_table field
+* label: text presented to the user
+* text: text input field
+* table: table view/input
+* hidden: hidden field used to hold state information
+
+The frontend should keep repeating requests as long as the field ``success`` is set to ``false``.
 
-Each dialog element has the following attributes:
+Note that the backend doesn't hold any state, so that commands can easily be canceled by just 
+not making any additional requests (and not actually invoking the command).
 
-* name: user visible title of the field [String]
-* desc: an optional description of the field [String]
-* editable: if the user can edit the field [Boolean]
-* visible: if the field is visible, there may be hidden fields for internal purpose [Boolean]
-* return: if the value should be sent back with the next request [Boolean]
-* error: an error description, if present the field should be marked to have an error [String]
-* value: the preset value of the field, type is field type specific 
+If the response contains step information (number of steps, current step), the the frontend
+should display buttons for moving forward and backward in a wizard.
 
-The frontend should keep repeating requests as long as the field ``repeat`` is set to ``true``.
+When the frontend receives dialog information, it should display the dialog filled with the
+widgets as specified and with widget content set up properly (text fields preset with strings,
+rows selected in table, etc).
+
+When the user has finished the dialog, the frontend should send all input information back to
+the backend as name/value pairs. This includes:
+
+* hidden fields
+* text fields unless disabled
+* table fields unless disabled
 
   {
     "type": "response",
-    "repeat": <if command should be repeated>, 
+    "success": <true|false, true if command is finshed>, 
+    "num_steps", <number of steps of this (wizard) command, optional>,
+    "current_step", <current wizard step, optional>,
     "dialog": {
       "title": <dialog title>,
-      "desc": <description what to do>,
       "elements": [
         {
-          "type": "text_input",
+          "type": "lable",
+          "text": <text to display>
+        },
+        {
+          "type": "hidden",
           "name": <parameter name>,
-          "value": <preset value>,
-          "error": <error text>
+          "value": <value of hidden filed [string]>
         },
         {
-          "type": "choice_input",
-          "num_min": <min number of elements to choose, default: 1>,
-          "num_max": <max mumber of elements to choose, default: 1>,
-          "choices": [
-            "display": <display name>,
-            "id": <identifier to be sent back>,
-          ],
-          "value": [ <selected choice>, <selected choice>, ...],
+          "type": "text",
+          "name": <parameter name>,
+          "value": <preset value>,
           "error": <error text>
+          "description: <discription of parameter, optional>
+          "disabled:" <true|false, if set to false the input widget can't be changed>
         },
         {
-          "type": "element_input",
+          "type": "table",
+          "name": <parameter name>,
           "num_min": <min number of elements to choose, default: 1>,
-          "num_max": <max mumber of elements to choose, default: 1>,
-          "choices": [
+          "num_max": <max mumber of elements to choose, or * for unlimited, default: 1>,
+          "columns": [
+            {
+              "name": <column name>,
+              "description: <discription of parameter, optional>
+            }
+            ...
+          ],
+          "rows": [
             {
-              "display": <display name>,
               "id": <identifier to be sent back>,
-              "file": <fully qualfied file name, optional>,
-              "line": <line number, optional>,
-              "ancestors": <parent hierarchy, optional",
+              "values" [
+                {
+                  "display": <display name>,
+                  "file": <fully qualfied file name, optional>,
+                  "line": <line number, optional>,
+                }
+                ...
+              ]
             }
             ...
           ],
-          "value": [ <selected choice>, <selected choice>, ...],
-          "error": <error text>
+          "selected": [ <row id>, <row id>, ...],
+          "error": <error text>,
+          "description: <discription of parameter, optional>
+          "disabled:" <true|false, if set to false, no selection can be made>
         }
       ]
     }
   }
 
+=== Custom Command Invocation
+
+Custom commands are invoked using the command id returned by the "Custom Commands" request.
+Before a command can be invoked, the parameters must be figured out by means of the "Check
+Custom Command Parameters" command. Once figured out, the parameters will be sent with the 
+command invocation as a name/value list. 
+
+The context information should be sent as with the "Check Custom Command Parameters" command.
+
+  {
+    "type": "request",
+    "command": "invoke_custom_command",
+    "command_id": <custom command id>
+    "context": <context lines, optional>,
+    "column": <cursor column, optional>
+    "parameters": [
+      { 
+        "name": <parameter name>,
+        "value": <parameter value>
+      }
+      ...
+    ]
+  }
+
 === Stop Service
 
 This command is normally invoked when the frontend terminates or otherwise needs to terminate

data/Rakefile

@@ -8,7 +8,7 @@ DocFiles = [
 
 RTextGemSpec = Gem::Specification.new do |s|
   s.name = %q{rtext}
-  s.version = "0.5.1"
+  s.version = "0.7.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/context_builder.rb

@@ -121,6 +121,7 @@ module ContextBuilder
         missing_comma = false
         unlabled_index = 0
         tokens[1..-1].each do |token|
+          break if token.kind == :error
           if token.kind == "["
             in_array = true
           elsif token.kind == "]"
@@ -151,7 +152,13 @@ module ContextBuilder
         end
         if [:error, :string, :integer, :float, :boolean, :identifier, :reference].
             include?(tokens.last.kind) && line !~ /\s$/
-          prefix = tokens.last.value.to_s
+          last_error = tokens.rindex{|t| t.kind == :error && t.value == '"'}
+          last_string = tokens.rindex{|t| t.kind == :string}
+          if last_error && (!last_string || last_error > last_string)
+            prefix = line[tokens[last_error].scol-1..-1]
+          else
+            prefix = line[tokens.last.scol-1..-1]
+          end
         else
           prefix = ""
         end

data/lib/rtext/default_completer.rb

@@ -0,0 +1,163 @@
+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
+

data/lib/rtext/default_loader.rb

@@ -2,6 +2,7 @@ require 'rgen/environment'
 require 'rgen/util/file_change_detector'
 require 'rgen/fragment/model_fragment'
 require 'rtext/instantiator'
+require 'rtext/default_resolver'
 
 module RText
 
@@ -33,6 +34,10 @@ class DefaultLoader
   #    if set to true, don't reload fragments which have parse errors 
   #    instead keep the existing fragment but attach the new problem list
   #
+  #  :resolver
+  #    a reference resolver responding to the methods provided by DefaultResolver
+  #    default: DefaultResolver
+  #
   def initialize(language, fragmented_model, options={})
     @lang = language
     @model = fragmented_model
@@ -48,6 +53,7 @@ class DefaultLoader
     pattern = options[:pattern]
     @file_provider = options[:file_provider] || proc { Dir.glob(pattern) }
     @dont_reload_with_errors = options[:dont_reload_with_errors]
+    @resolver = options[:resolver] || DefaultResolver.new(language)
   end
 
   # Loads or reloads model fragments from files using the file patterns or file provider 
@@ -83,9 +89,7 @@ class DefaultLoader
     @files_added.each {|f| file_added(f)}
     @files_changed.each {|f| file_changed(f)}
     @files_removed.each {|f| file_removed(f)}
-    @lang.reference_qualifier.call(@model.unresolved_refs, @model)
-    @model.resolve(:fragment_provider => method(:fragment_provider),
-      :use_target_type => @lang.per_type_identifier)
+    @resolver.resolve_model(@model)
   end
 
   private
@@ -109,8 +113,8 @@ class DefaultLoader
       @work_last_sent = @work_done
     end
 
-    def instantiator_progress(frag)
-      @work_done += 1
+    def instantiator_progress(frag, steps)
+      @work_done += steps
       if @work_done > @work_last_sent + 100
         @on_progress_proc.call(frag, @work_done, @work_overall)
         @work_last_sent = @work_done
@@ -219,27 +223,31 @@ class DefaultLoader
     problems = []
     root_elements = []
     inst = RText::Instantiator.new(@lang)
-    File.open(fragment.location, "rb") do |f|
-      inst.instantiate(f.read,
-        :env => env,
-        :unresolved_refs => urefs,
-        :problems => problems,
-        :root_elements => root_elements,
-        :fragment_ref => fragment.fragment_ref,
-        :file_name => fragment.location,
-        :on_progress => lambda do 
-          @progress_monitor.instantiator_progress(fragment)
-        end)
+    begin
+      File.open(fragment.location, "rb") do |f|
+        inst.instantiate(f.read,
+          :env => env,
+          :unresolved_refs => urefs,
+          :problems => problems,
+          :root_elements => root_elements,
+          :fragment_ref => fragment.fragment_ref,
+          :file_name => fragment.location,
+          :on_progress => lambda do |steps|
+            @progress_monitor.instantiator_progress(fragment, steps)
+          end)
+      end
+    rescue Errno::ENOENT
+      # missing file, treat as empty
     end
     # data might have been created during instantiation (e.g. comment or annotation handler)
     fragment.data ||= {}
     fragment.data[:problems] = problems
+    # let the fragment calculate the elements, elements might have been added during
+    # instantiation (e.g. comment or annotation handler)
     fragment.set_root_elements(root_elements,
-      :unresolved_refs => urefs, 
-      :elements => env.elements)
+      :unresolved_refs => urefs)
     fragment.build_index
-    @lang.reference_qualifier.call(urefs, fragment)
-    fragment.resolve_local(:use_target_type => @lang.per_type_identifier)
+    @resolver.resolve_fragment(fragment)
   end
 
 end