rtext 0.4.0 → 0.5.0

data/lib/rtext/default_service_provider.rb

@@ -13,9 +13,13 @@ class DefaultServiceProvider
     })
   end
 
+  def language
+    @lang
+  end
+
   def load_model(options={})
     if options[:on_progress]
-      @loader.load(:after_load => options[:on_progress])
+      @loader.load(:on_progress => options[:on_progress])
     else
       @loader.load
     end
@@ -29,8 +33,10 @@ class DefaultServiceProvider
       clazz = reference.eType.instanceClass
       targets = @model.index.values.flatten.select{|e| e.is_a?(clazz)}
     end
+    index = 0
     targets.collect{|t| 
-      ident = @lang.identifier_provider.call(t, context.element)
+      ident = @lang.identifier_provider.call(t, context.element, reference, index)
+      index += 1
       if ident
         ReferenceCompletionOption.new(ident, t.class.ecore.name)
       else
@@ -40,13 +46,17 @@ class DefaultServiceProvider
   end
 
   ReferenceTarget = Struct.new(:file, :line, :display_name)
-  def get_reference_targets(identifier, context)
+  def get_reference_targets(identifier, element, feature, index)
     result = []
-    identifier = @lang.qualify_reference(identifier, context.element)
+    urefs = [ 
+      RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(element, feature.name,
+        element.getGenericAsArray(feature.name)[index]) ] 
+    @lang.reference_qualifier.call(urefs, @model)
+    identifier = urefs.first.proxy.targetIdentifier 
     targets = @model.index[identifier]
     if targets && @lang.per_type_identifier
-      if context.feature
-        targets = targets.select{|t| t.is_a?(context.feature.eType.instanceClass)}
+      if feature
+        targets = targets.select{|t| t.is_a?(feature.eType.instanceClass)}
       end
     end 
     targets && targets.each do |t|
@@ -58,22 +68,26 @@ class DefaultServiceProvider
     result
   end
 
-  def get_referencing_elements(identifier, context)
+  def get_referencing_elements(identifier, element, feature, index)
     result = []
-    targets = @model.index[@lang.identifier_provider.call(context.element, nil)]
+    targets = @model.index[@lang.identifier_provider.call(element, nil, nil, nil)]
     if targets && @lang.per_type_identifier
-      targets = targets.select{|t| t.class == context.element.class}
+      targets = targets.select{|t| t.class == element.class}
     end
     if targets && targets.size == 1
       target = targets.first
-      elements = target.class.ecore.eAllReferences.select{|r|
-        r.eOpposite && !r.containment && !r.eOpposite.containment}.collect{|r|
-          target.getGenericAsArray(r.name)}.flatten
+      refs = target.class.ecore.eAllReferences.select{|r|
+        r.eOpposite && !r.containment && !r.eOpposite.containment}
+      # we only want references configured in the RText language that point to this element
+      # thus we don't follow references here which are configured in the language
+      # (because for those the other direction is not configured in the language)
+      refs -= @lang.non_containments(target.class.ecore)
+      elements = refs.collect{|r| target.getGenericAsArray(r.name)}.flatten
       elements.each do |e|
         if @lang.fragment_ref(e)
           path = File.expand_path(@lang.fragment_ref(e).fragment.location)
           display_name = ""
-          ident = @lang.identifier_provider.call(e, nil)
+          ident = @lang.identifier_provider.call(e, nil, nil, nil)
           display_name += "#{ident} " if ident
           display_name += "[#{e.class.ecore.name}]"
           result << ReferenceTarget.new(path, @lang.line_number(e), display_name)
@@ -148,7 +162,9 @@ class DefaultServiceProvider
     return @element_name_index if @element_name_index
     @element_name_index = {}
     @model.index.each_pair do |ident, elements|
-      key = ident.split(/\W/).last[0..0].downcase
+      last_part = ident.split(/\W/).last
+      next unless last_part
+      key = last_part[0..0].downcase
       @element_name_index[key] ||= {} 
       @element_name_index[key][ident] = elements
     end

data/lib/rtext/frontend/config.rb

@@ -0,0 +1,58 @@
+module RText
+module Frontend
+
+module Config
+
+def self.find_service_config(file)
+  last_dir = nil
+  dir = File.expand_path(File.dirname(file))
+  search_pattern = file_pattern(file)
+  while dir != last_dir
+    config_file = "#{dir}/.rtext"
+    if File.exist?(config_file)
+      configs = parse_config_file(config_file)
+      config = configs.find{|s| s.patterns.any?{|p| p == search_pattern}}
+      return config if config
+    end
+    last_dir = dir
+    dir = File.dirname(dir)
+  end
+  nil
+end
+
+def self.file_pattern(file)
+  ext = File.extname(file)
+  if ext.size > 0
+    "*#{ext}"
+  else
+    File.basename(file)
+  end
+end
+
+ServiceConfig = Struct.new(:file, :patterns, :command)
+ 
+def self.parse_config_file(file)
+  configs = []
+  File.open(file) do |f|
+    lines = f.readlines
+    l = lines.shift
+    while l
+      if l =~ /^(.+):\s*$/
+        patterns = $1.split(",").collect{|s| s.strip} 
+        l = lines.shift
+        if l && l =~ /\S/ && l !~ /:\s*$/
+          configs << ServiceConfig.new(file, patterns, l)
+          l = lines.shift
+        end
+      else
+        l = lines.shift
+      end
+    end
+  end
+  configs
+end
+
+end
+
+end
+end

data/lib/rtext/frontend/connector.rb

@@ -0,0 +1,233 @@
+require 'socket'
+require 'tmpdir'
+require 'rtext/message_helper'
+
+module RText
+module Frontend
+
+class Connector
+include Process
+include RText::MessageHelper
+
+def initialize(config, options={})
+  @config = config
+  @logger = options[:logger]
+  @state = :off
+  @invocation_id = 1
+  @invocations = {}
+  @busy = false
+  @busy_start_time = nil
+  @connection_listener = options[:connect_callback]
+  @outfile_provider = options[:outfile_provider]
+  @keep_outfile = options[:keep_outfile]
+  @connection_timeout = options[:connection_timeout] || 10
+end
+
+def execute_command(obj, options={})
+  timeout = options[:timeout] || 5
+  @busy = false if @busy_start_time && (Time.now > @busy_start_time + timeout)
+  if @busy
+    do_work
+    :backend_busy 
+  elsif connected?
+    obj["invocation_id"] = @invocation_id
+    obj["type"] = "request"
+    @socket.send(serialize_message(obj), 0)
+    result = nil
+    @busy = true
+    @busy_start_time = Time.now
+    if options[:response_callback]
+      @invocations[@invocation_id] = lambda do |r|
+        if r["type"] == "response" || r["type"] =~ /error$/
+          @busy = false
+        end
+        options[:response_callback].call(r)
+      end
+      @invocation_id += 1
+      do_work
+      :request_pending 
+    else
+      @invocations[@invocation_id] = lambda do |r|
+        if r["type"] == "response" || r["type"] =~ /error$/ 
+          result = r
+          @busy = false
+        end
+      end
+      @invocation_id += 1
+      while !result
+        if Time.now > @busy_start_time + timeout
+          result = :timeout
+          @busy = false
+        else
+          sleep(0.1)
+          do_work
+        end
+      end
+      result
+    end
+  else
+    connect unless connecting?
+    do_work
+    :connecting 
+  end
+end
+
+def resume
+  do_work
+end
+
+def stop
+  while connecting?
+    do_work
+    sleep(0.1)
+  end
+  if connected?
+    execute_command({"type" => "request", "command" => "stop"})
+    while do_work 
+      sleep(0.1)
+    end
+  end
+end
+
+private
+
+def connected?
+  @state == :connected && backend_running?
+end
+
+def connecting?
+  @state == :connecting
+end
+
+def backend_running?
+  if @process_id
+    begin
+      return true unless waitpid(@process_id, Process::WNOHANG)
+    rescue Errno::ECHILD
+    end
+  end
+  false
+end
+
+def tempfile_name
+  dir = Dir.tmpdir
+  i = 0
+  file = nil 
+  while !file || File.exist?(file)
+    file = dir+"/rtext.temp.#{i}"
+    i += 1
+  end
+  file
+end
+
+def connect
+  @state = :connecting
+  @connect_start_time = Time.now
+
+  @logger.info @config.command if @logger
+
+  if @outfile_provider
+    @out_file = @outfile_provider.call
+  else
+    @out_file = 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")
+  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
+    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)
+      rescue Errno::ECONNREFUSED
+        cleanup
+        @connection_listener.call(:timeout) if @connection_listener
+        @work_state = :done
+        @state = :off
+        @logger.warn "could not connect socket (connection timeout)" if @logger
+      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
+    end
+    true
+  when :read_from_socket
+    repeat = true
+    socket_closed = false
+    response_data = ""
+    while repeat
+      repeat = false
+      data = nil
+      begin
+        data = @socket.read_nonblock(100000)
+      rescue Errno::EWOULDBLOCK
+      rescue IOError, EOFError, Errno::ECONNRESET
+        socket_closed = true
+        @logger.info "server socket closed (end of file)" if @logger
+      end
+      if data
+        repeat = true
+        response_data.concat(data)
+        while obj = extract_message(response_data)
+          inv_id = obj["invocation_id"] 
+          callback = @invocations[inv_id]
+          if callback
+            callback.call(obj)
+          else
+            @logger.error "unknown answer" if @logger
+          end
+        end
+      elsif !backend_running? || socket_closed
+        cleanup
+        @work_state = :done
+        return false
+      end
+    end
+    true
+  end
+
+end
+
+def cleanup
+  @socket.close if @socket
+  # wait up to 2 seconds for backend to shutdown
+  for i in 0..20 
+    break unless backend_running?
+    sleep(0.1)
+  end
+  File.unlink(@out_file) unless @keep_outfile
+end
+
+end
+
+end
+end
+

data/lib/rtext/frontend/connector_manager.rb

@@ -0,0 +1,81 @@
+require 'digest'
+require 'rtext/frontend/config'
+require 'rtext/frontend/connector'
+
+module RText
+module Frontend
+
+class ConnectorManager
+
+def initialize(options={})
+  @logger = options[:logger]
+  @connector_descs = {}
+  @connector_listener = options[:connect_callback]
+  @keep_outfile = options[:keep_outfile]
+  @outfile_provider = options[:outfile_provider]
+  @connection_timeout = options[:connection_timeout]
+end
+
+ConnectorDesc = Struct.new(:connector, :checksum)
+
+def connector_for_file(file)
+  config = Config.find_service_config(file)
+  if config
+    file_pattern = Config.file_pattern(file)
+    key = desc_key(config, file_pattern)
+    desc = @connector_descs[key]
+    if desc
+      if desc.checksum == config_checksum(config)
+        desc.connector
+      else
+        # connector must be replaced
+        desc.connector.stop
+        create_connector(config, file_pattern) 
+      end
+    else
+      create_connector(config, file_pattern)
+    end
+  else
+    nil
+  end
+end
+
+def all_connectors
+  @connector_descs.values.collect{|v| v.connector}
+end
+
+private
+
+def create_connector(config, pattern)
+  con = Connector.new(config, :logger => @logger, :keep_outfile => @keep_outfile,
+    :outfile_provider => @outfile_provider,
+    :connection_timeout => @connection_timeout,
+    :connect_callback => lambda do |state|
+      @connector_listener.call(con, state) if @connector_listener
+    end)
+  desc = ConnectorDesc.new(con, config_checksum(config))
+  key = desc_key(config, pattern)
+  @connector_descs[key] = desc
+  desc.connector
+end
+
+def desc_key(config, pattern)
+  config.file.downcase + "," + pattern
+end
+
+def config_checksum(config)
+  if File.exist?(config.file)
+    sha1 = Digest::SHA1.new
+    sha1.file(config.file)
+    sha1.hexdigest
+  else
+    nil
+  end
+end
+
+
+end
+
+end
+end
+