rtext 0.8.0 → 0.9.3

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/connector.rb

@@ -21,15 +21,21 @@ def initialize(config, options={})
   @outfile_provider = options[:outfile_provider]
   @keep_outfile = options[:keep_outfile]
   @connection_timeout = options[:connection_timeout] || 10
+  @process_id = nil
 end
 
 def execute_command(obj, options={})
-  timeout = options[:timeout] || 5
+  timeout = options[:timeout] || 10
   @busy = false if @busy_start_time && (Time.now > @busy_start_time + timeout)
   if @busy
     do_work
-    :backend_busy 
-  elsif connected?
+    return :backend_busy 
+  end
+  unless connected?
+    connect unless connecting?
+    do_work
+  end
+  if connected?
     obj["invocation_id"] = @invocation_id
     obj["type"] = "request"
     @socket.send(serialize_message(obj), 0)
@@ -66,9 +72,7 @@ def execute_command(obj, options={})
       result
     end
   else
-    connect unless connecting?
-    do_work
-    :connecting 
+    :connecting
   end
 end
 
@@ -87,23 +91,68 @@ def stop
       sleep(0.1)
     end
   end
+  ensure_process_cleanup(@process_id, @keep_outfile ? nil : @out_file, 10)
+  @process_id = nil
 end
 
 private
 
+def wait_for_process_to_exit(process_id, timeout)
+  with_timeout timeout do
+    begin
+      waitpid(process_id, Process::WNOHANG)
+      process_id = nil
+      true
+    rescue Errno::ECHILD => _
+      false
+    end
+  end
+end
+
+def ensure_process_cleanup(process_id, out_file, timeout)
+  Thread.new do
+    begin
+      unless process_id.nil?
+        process_id = nil if wait_for_process_to_exit(process_id, timeout)
+      end
+    ensure
+      unless process_id.nil?
+        begin
+          Process.kill('QUIT', process_id)
+        rescue Errno::ESRCH => _
+        end
+      end
+      File.unlink(out_file) if !out_file.nil? && File.exist?(out_file)
+    end
+  end
+end
+
+def with_timeout(timeout, sleep_time = 0.1, &block)
+  started = Time.now
+  while true do
+    return true if block.call
+    if Time.now > started + timeout
+      return false
+    end
+    sleep(sleep_time)
+  end
+end
+
+
 def connected?
-  @state == :connected && backend_running?
+  !@process_id.nil? && @state == :read_from_socket && backend_running?
 end
 
 def connecting?
-  @state == :connecting
+  !@process_id.nil? && (@state == :wait_for_file || @state == :wait_for_port)
 end
 
 def backend_running?
   if @process_id
     begin
-      return true unless waitpid(@process_id, Process::WNOHANG)
-    rescue Errno::ECHILD
+      waitpid(@process_id, Process::WNOHANG)
+      return true
+    rescue Errno::ECHILD => _
     end
   end
   false
@@ -121,66 +170,85 @@ def tempfile_name
 end
 
 def connect
-  @state = :connecting
+  return if connected?
   @connect_start_time = Time.now
 
   @logger.info @config.command if @logger
 
   if @outfile_provider
-    @out_file = @outfile_provider.call
+    @out_file = File.expand_path(@outfile_provider.call)
   else
-    @out_file = tempfile_name 
+    @out_file = File.expand_path(tempfile_name) 
   end
-  File.unlink(@out_file) if File.exist?(@out_file)
 
-  Dir.chdir(File.dirname(@config.file)) do
-    @process_id = spawn(@config.command.strip + " > #{@out_file} 2>&1")
+  if @process_id.nil?
+    File.unlink(@out_file) if File.exist?(@out_file)
+    Dir.chdir(File.dirname(@config.file)) do
+      @process_id = spawn(@config.command.strip + " > #{@out_file} 2>&1")
+      @state = :wait_for_file
+    end
   end
-  @work_state = :wait_for_file
 end
 
 def do_work
-  case @work_state
-  when :wait_for_file
-    if File.exist?(@out_file)
-      @work_state = :wait_for_port
-    end
-    if Time.now > @connect_start_time + @connection_timeout
-      cleanup
-      @connection_listener.call(:timeout) if @connection_listener
-      @work_state = :done
-      @state = :off
-      @logger.warn "process didn't startup (connection timeout)" if @logger
+  if @process_id.nil?
+    @state = :off
+    return false
+  end
+  if @state == :wait_for_port && !File.exist?(@out_file)
+    @state = :wait_for_file
+  end
+  if @state == :wait_for_file && File.exist?(@out_file)
+    @state = :wait_for_port
+  end
+  if @state == :wait_for_file
+    while true
+      if Time.now > @connect_start_time + @connection_timeout
+        cleanup
+        @connection_listener.call(:timeout) if @connection_listener
+        @state = :off
+        @logger.warn "process didn't startup (connection timeout)" if @logger
+        return false
+      end
+      sleep(0.1)
+      if File.exist?(@out_file)
+        @state = :wait_for_port
+        break
+      end
     end
-    true
-  when :wait_for_port
-    output = File.read(@out_file)
-    if output =~ /^RText service, listening on port (\d+)/
-      port = $1.to_i
-      @logger.info "connecting to #{port}" if @logger
-      begin
-        @socket = TCPSocket.new("127.0.0.1", port)
-        @socket.setsockopt(:SOCKET, :RCVBUF, 1000000)
-      rescue Errno::ECONNREFUSED
+  end
+  if @state == :wait_for_port
+    while true
+      break unless File.exist?(@out_file)
+      output = File.read(@out_file)
+      if output =~ /^RText service, listening on port (\d+)/
+        port = $1.to_i
+        @logger.info "connecting to #{port}" if @logger
+        begin
+          @socket = TCPSocket.new("127.0.0.1", port)
+          @socket.setsockopt(:SOCKET, :RCVBUF, 1000000)
+        rescue Errno::ECONNREFUSED
+          cleanup
+          @connection_listener.call(:timeout) if @connection_listener
+          @state = :off
+          @logger.warn "could not connect socket (connection timeout)" if @logger
+          return false
+        end
+        @state = :read_from_socket
+        @connection_listener.call(:connected) if @connection_listener
+        break
+      end
+      if Time.now > @connect_start_time + @connection_timeout
         cleanup
         @connection_listener.call(:timeout) if @connection_listener
-        @work_state = :done
         @state = :off
         @logger.warn "could not connect socket (connection timeout)" if @logger
+        return false
       end
-      @state = :connected
-      @work_state = :read_from_socket
-      @connection_listener.call(:connected) if @connection_listener
-    end
-    if Time.now > @connect_start_time + @connection_timeout
-      cleanup
-      @connection_listener.call(:timeout) if @connection_listener
-      @work_state = :done
-      @state = :off
-      @logger.warn "could not connect socket (connection timeout)" if @logger
+      sleep(0.1)
     end
-    true
-  when :read_from_socket
+  end
+  if @state == :read_from_socket
     repeat = true
     socket_closed = false
     response_data = ""
@@ -208,13 +276,12 @@ def do_work
         end
       elsif !backend_running? || socket_closed
         cleanup
-        @work_state = :done
+        @state = :off
         return false
       end
     end
-    true
   end
-
+  true
 end
 
 def cleanup
@@ -224,7 +291,7 @@ def cleanup
     break unless backend_running?
     sleep(0.1)
   end
-  File.unlink(@out_file) unless @keep_outfile
+  ensure_process_cleanup(@process_id, @keep_outfile ? @out_file : nil, 10)
 end
 
 end