rtext 0.5.1 → 0.7.0

data/lib/rtext/default_resolver.rb

@@ -0,0 +1,42 @@
+module RText
+
+class DefaultResolver
+
+def initialize(lang)
+  @lang = lang
+end
+
+def resolve_fragment(fragment)
+  @lang.reference_qualifier.call(fragment.unresolved_refs, fragment)
+  fragment.resolve_local(
+    :use_target_type => @lang.per_type_identifier)
+end
+
+def resolve_model(model)
+  @lang.reference_qualifier.call(model.unresolved_refs, model)
+  model.resolve(
+    :fragment_provider => proc {|e|
+        fr = @lang.fragment_ref(e)
+        fr && fr.fragment
+      }, 
+    :use_target_type => @lang.per_type_identifier)
+end
+
+def find_targets(uref, model)
+  @lang.reference_qualifier.call([uref], model)
+  identifier = uref.proxy.targetIdentifier 
+  targets = model.index[identifier]
+  targets ||= []
+  if @lang.per_type_identifier
+    feature = @lang.feature_by_name(uref.element.class.ecore, uref.feature_name)
+    if feature
+      targets = targets.select{|t| t.is_a?(feature.eType.instanceClass)}
+    end
+  end 
+  targets
+end
+
+end
+
+end
+

data/lib/rtext/default_service_provider.rb

@@ -1,7 +1,16 @@
+require 'rtext/default_completer'
+require 'rtext/default_resolver'
+
 module RText
 
 class DefaultServiceProvider
 
+  # Creates a DefaultServiceProvider. Options:
+  #
+  #  :resolver
+  #    a reference resolver responding to the methods provided by DefaultResolver
+  #    default: DefaultResolver
+  #
   def initialize(language, fragmented_model, model_loader, options={})
     @lang = language
     @model = fragmented_model
@@ -11,6 +20,7 @@ class DefaultServiceProvider
     @model.add_fragment_change_listener(proc {|fragment, kind|
       @element_name_index = nil
     })
+    @resolver = options[:resolver] || DefaultResolver.new(language)
   end
 
   def language
@@ -25,17 +35,30 @@ class DefaultServiceProvider
     end
   end
 
+  def get_completion_options(context)
+    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}>")}
+      end
+    end
+    completer.service_provider = self
+    completer.complete(context)
+  end
+
   ReferenceCompletionOption = Struct.new(:identifier, :type)
-  def get_reference_completion_options(reference, context)
+  def get_reference_completion_options(context)
     if @model.environment
-      targets = @model.environment.find(:class => reference.eType.instanceClass)
+      targets = @model.environment.find(:class => context.feature.eType.instanceClass)
     else
-      clazz = reference.eType.instanceClass
+      clazz = context.feature.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, reference, index)
+      ident = @lang.identifier_provider.call(t, context.element, context.feature, index)
       index += 1
       if ident
         ReferenceCompletionOption.new(ident, t.class.ecore.name)
@@ -46,29 +69,34 @@ class DefaultServiceProvider
   end
 
   ReferenceTarget = Struct.new(:file, :line, :display_name)
-  def get_reference_targets(identifier, element, feature, index)
+  def get_link_targets(link_descriptor)
+    if link_descriptor.backward 
+      get_backward_reference_targets(link_descriptor.value, 
+        link_descriptor.element, link_descriptor.feature, link_descriptor.index)
+    else
+      get_forward_reference_targets(link_descriptor.value, 
+        link_descriptor.element, link_descriptor.feature, link_descriptor.index)
+    end
+  end
+
+  def get_forward_reference_targets(identifier, element, feature, index)
     result = []
-    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 feature
-        targets = targets.select{|t| t.is_a?(feature.eType.instanceClass)}
-      end
-    end 
-    targets && targets.each do |t|
-      if @lang.fragment_ref(t)
-        path = File.expand_path(@lang.fragment_ref(t).fragment.location)
-        result << ReferenceTarget.new(path, @lang.line_number(t), "#{identifier} [#{t.class.ecore.name}]")
+    ref_value = element.getGenericAsArray(feature.name)[index]
+    if ref_value.is_a?(RGen::MetamodelBuilder::MMProxy)
+      uref =  RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(
+          element, feature.name, ref_value)
+      targets = @resolver.find_targets(uref, @model)
+      targets.each do |t|
+        if @lang.fragment_ref(t)
+          path = File.expand_path(@lang.fragment_ref(t).fragment.location)
+          result << ReferenceTarget.new(path, @lang.line_number(t), "#{identifier} [#{t.class.ecore.name}]")
+        end
       end
     end
     result
   end
 
-  def get_referencing_elements(identifier, element, feature, index)
+  def get_backward_reference_targets(identifier, element, feature, index)
     result = []
     targets = @model.index[@lang.identifier_provider.call(element, nil, nil, nil)]
     if targets && @lang.per_type_identifier

data/lib/rtext/frontend/connector.rb

@@ -160,6 +160,7 @@ def do_work
       @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
@@ -187,7 +188,7 @@ def do_work
       repeat = false
       data = nil
       begin
-        data = @socket.read_nonblock(100000)
+        data = @socket.read_nonblock(1000000)
       rescue Errno::EWOULDBLOCK
       rescue IOError, EOFError, Errno::ECONNRESET
         socket_closed = true

data/lib/rtext/instantiator.rb

@@ -1,10 +1,12 @@
 require 'rgen/ecore/ecore_ext'
 require 'rgen/instantiator/reference_resolver'
+require 'rtext/tokenizer'
 require 'rtext/parser'
 
 module RText
 
 class Instantiator
+  include RText::Tokenizer
 
   # A problem found during instantiation
   # if the file is not known, it will be nil
@@ -37,8 +39,9 @@ class Instantiator
   #    object which references the fragment being instantiated, will be set on model elements 
   #
   #  :on_progress
-  #    a proc which is called twice for each model element: 
-  #    when the command token is recognized and when the element is instantiated 
+  #    a proc which is called with a number measuring the progress made since the last call;
+  #    progress is measured by the number of command tokens recognized plus the number of
+  #    model elements instantiated.
   #
   def instantiate(str, options={})
     @line_numbers = {}
@@ -50,10 +53,14 @@ class Instantiator
     @fragment_ref = options[:fragment_ref]
     @on_progress_proc = options[:on_progress]
     @context_class_stack = []
-    parser = Parser.new(@lang.reference_regexp)
+    parser = Parser.new
     @root_elements.clear
     parser_problems = []
-    parser.parse(str, 
+    tokens = tokenize(str, @lang.reference_regexp, 
+      :on_command_token => @on_progress_proc && lambda do
+        @on_progress_proc.call(1)
+      end)
+    parser.parse(tokens, 
       :descent_visitor => lambda do |command|
         clazz = @lang.class_by_command(command.value, @context_class_stack.last)
         # in case no class is found, nil will be pushed, this will case the next command
@@ -69,9 +76,6 @@ class Instantiator
           unassociated_comments(args[3])
         end
       end,
-      :on_command_token => @on_progress_proc && lambda do
-        @on_progress_proc.call
-      end,
       :problems => parser_problems)
     parser_problems.each do |p|
       problem(p.message, p.line)
@@ -88,7 +92,7 @@ class Instantiator
 
   def create_element(command, arg_list, element_list, comments, annotation, is_root)
     clazz = @context_class_stack.last 
-    @on_progress_proc.call if @on_progress_proc
+    @on_progress_proc.call(1) if @on_progress_proc
     if !@lang.has_command(command.value)
       problem("Unknown command '#{command.value}'", command.line)
       return
@@ -158,15 +162,21 @@ class Instantiator
       end
       if !feature.many && 
         (element.getGenericAsArray(role).size > 0 || children.size > 1)
-        problem("Only one child allowed in role '#{role}'", line_number(children[0]))
+        if children.size == 1
+          # other child was created under another role lable with same name
+          problem("Only one child allowed in role '#{role}'", line_number(children[0]))
+        else
+          problem("Only one child allowed in role '#{role}'", line_number(children[1]))
+        end
         return
       end
-      expected_type = @lang.concrete_types(feature.eType)
+      expected_type = nil
       children.each do |c|
-        if !expected_type.include?(c.class.ecore)
-          problem("Role '#{role}' can not take a #{c.class.ecore.name}, expected #{expected_type.name.join(", ")}", line_number(c))
-        else
+        begin
           element.setOrAddGeneric(feature.name, c)
+        rescue StandardError
+          expected_type ||= @lang.concrete_types(feature.eType)
+          problem("Role '#{role}' can not take a #{c.class.ecore.name}, expected #{expected_type.name.join(", ")}", line_number(c))
         end
       end
     else
@@ -236,7 +246,16 @@ class Instantiator
         end
         element.setOrAddGeneric(feature.name, proxy)
       else
-        element.setOrAddGeneric(feature.name, v.value)
+        begin
+          element.setOrAddGeneric(feature.name, v.value)
+        rescue StandardError
+          # backward compatibility for RGen versions not supporting BigDecimal
+          if v.value.is_a?(BigDecimal)
+            element.setOrAddGeneric(feature.name, v.value.to_f)
+          else
+            raise
+          end
+        end
       end
     end
     defined_args[name] = true
@@ -283,11 +302,14 @@ class Instantiator
     elsif feature.eType.is_a?(RGen::ECore::EEnum)
       [:identifier, :string]
     else
-      { String => [:string, :identifier],
+      expected = { String => [:string, :identifier],
         Integer => [:integer],
         Float => [:float],
-        RGen::MetamodelBuilder::DataTypes::Boolean => [:boolean]
+        RGen::MetamodelBuilder::DataTypes::Boolean => [:boolean],
+        Object => [:string, :identifier, :integer, :float, :boolean]
       }[feature.eType.instanceClass] 
+      raise "unsupported EType instance class: #{feature.eType.instanceClass}" unless expected
+      expected
     end
   end
 

data/lib/rtext/json_interface.rb

@@ -0,0 +1,31 @@
+require 'json'
+
+module RText
+
+# this module provides an abstract JSON interface;
+# it is a global configuration point for JSON conversion in RText;
+# use +set_o2j_converter+ and +set_j2o_converter+ to use other json implementations
+module JsonInterface
+
+  # set the o2j converter, a proc which takes an object and returns json
+  def self.set_o2j_converter(conv)
+    define_method(:object_to_json, conv)
+  end
+
+  # set the j2o converter, a proc which takes json and returns an object
+  def self.set_j2o_converter(conv)
+    define_method(:json_to_object, conv)
+  end
+
+  def object_to_json(obj)
+    JSON(obj)
+  end
+
+  def json_to_object(json)
+    JSON(json)
+  end
+
+end
+
+end
+

data/lib/rtext/language.rb

@@ -29,6 +29,13 @@ class Language
   #     the serializer will take care to insert quotes if the data is not a valid identifier
   #     the features must also occur in :feature_provider if :feature_provider is provided
   #     default: no unquoted arguments
+  #
+  #  :labeled_containments
+  #     a Proc which receives an EClass and should return the names of this EClass's containment 
+  #     references which are to be serialized with a label.
+  #     note that labels will always automatically be used when references can't be uniquely 
+  #     derived from contained elements
+  #     default: no additional labeled containments
   #  
   #  :argument_format_provider
   #     a Proc which receives an EAttribute and should return a format specification string
@@ -133,6 +140,7 @@ class Language
         reject{|f| f.derived} }
     @unlabled_arguments = options[:unlabled_arguments]
     @unquoted_arguments = options[:unquoted_arguments]
+    @labeled_containments = options[:labeled_containments]
     @argument_format_provider = options[:argument_format_provider]
     @root_classes = options[:root_classes] || default_root_classes(root_epackage)
     command_name_provider = options[:command_name_provider] || proc{|c| c.name}
@@ -215,6 +223,11 @@ class Language
     @unquoted_arguments.call(feature.eContainingClass).include?(feature.name)
   end
 
+  def labeled_containment?(clazz, feature)
+    return false unless @labeled_containments
+    @labeled_containments.call(clazz).include?(feature.name)
+  end
+
   def argument_format(feature)
     @argument_format_provider && @argument_format_provider.call(feature)
   end
@@ -225,9 +238,10 @@ class Language
 
   def containments_by_target_type(clazz, type)
     map = {}
-    clazz.eAllReferences.select{|r| r.containment}.each do |r|
+    containments(clazz).each do |r|
       concrete_types(r.eType).each {|t| (map[t] ||= []) << r}
     end
+    # the following line should be unnecessary with exception of "uniq"
     ([type]+type.eAllSuperTypes).inject([]){|m,t| m + (map[t] || []) }.uniq
   end
 
@@ -244,7 +258,11 @@ class Language
   end
 
   def fragment_ref(element)
-    @fragment_ref_attribute && element.respond_to?(@fragment_ref_attribute) && element.send(@fragment_ref_attribute)
+    begin
+      @fragment_ref_attribute && element.send(@fragment_ref_attribute) 
+    rescue NoMethodError
+      false
+    end
   end
 
   private
@@ -260,7 +278,7 @@ class Language
       @has_command[cmd] = true
       clazz = c.instanceClass
       @class_by_command[clazz] ||= {} 
-      c.eAllReferences.select{|r| r.containment}.collect{|r|
+      containments(c).collect{|r|
           [r.eType] + r.eType.eAllSubTypes}.flatten.uniq.each do |t|
         next if t.abstract
         cmw = command_name_provider.call(t)
@@ -287,11 +305,13 @@ class Language
   end
 
   # caching
-  [ :containments,
+  [ :features,
+    :containments,
     :non_containments,
     :unlabled_arguments,
     :labled_arguments,
     :unquoted?,
+    :labeled_containment?,
     :argument_format,
     :concrete_types,
     :containments_by_target_type,

data/lib/rtext/message_helper.rb

@@ -1,29 +1,18 @@
-require 'json'
+require 'rtext/json_interface'
 
 module RText
 
 module MessageHelper
+include JsonInterface
 
 def serialize_message(obj)
-  each_json_object_string(obj) do |s|
-    s.force_encoding("binary")
-    bytes = s.bytes.to_a
-    s.clear
-    bytes.each do |b|
-      if b >= 128 || b == 0x25 # %
-        s << "%#{b.to_s(16)}".force_encoding("binary")
-      else
-        s << b.chr("binary")
-      end
-    end
-    # there are no non ascii-7-bit characters left
-    s.force_encoding("utf-8")
-  end
-  json = JSON(obj)
+  escape_all_strings(obj)
+  json = object_to_json(obj)
   # the JSON method outputs data in UTF-8 encoding
   # the RText protocol expects message lengths measured in bytes
   # there shouldn't be any non-ascii-7-bit characters, though, so json.size would also be ok
-  "#{json.bytesize}#{json}"
+  json.prepend(json.bytesize.to_s) 
+  json
 end
 
 def extract_message(data)
@@ -40,21 +29,42 @@ def extract_message(data)
       # encode from binary to utf-8 with :undef => :replace turns all non-ascii-7-bit bytes
       # into the replacement character (\uFFFD)
       json.encode!("utf-8", :undef => :replace)
-      obj = JSON(json)
+      obj = json_to_object(json)
     end
   end
   if obj
-    each_json_object_string(obj) do |s|
-      # change encoding back to binary 
-      # there could still be replacement characters (\uFFFD), turn them into "?"
-      s.encode!("binary", :undef => :replace)
-      s.gsub!(/%[0-9a-fA-F][0-9a-fA-F]/){|m| m[1..2].to_i(16).chr("binary")}
-      s.force_encoding("binary")
-    end
+    unescape_all_strings(obj)
   end
   obj
 end
 
+def escape_all_strings(obj)
+  each_json_object_string(obj) do |s|
+    s.force_encoding("binary")
+    bytes = s.bytes.to_a
+    s.clear
+    bytes.each do |b|
+      if b >= 128 || b == 0x25 # %
+        s << "%#{b.to_s(16)}".force_encoding("binary")
+      else
+        s << b.chr("binary")
+      end
+    end
+    # there are no non ascii-7-bit characters left
+    s.force_encoding("utf-8")
+  end
+end
+
+def unescape_all_strings(obj)
+  each_json_object_string(obj) do |s|
+    # change encoding back to binary 
+    # there could still be replacement characters (\uFFFD), turn them into "?"
+    s.encode!("binary", :undef => :replace)
+    s.gsub!(/%[0-9a-fA-F][0-9a-fA-F]/){|m| m[1..2].to_i(16).chr("binary")}
+    s.force_encoding("binary")
+  end
+end
+
 def each_json_object_string(object, &block)
   if object.is_a?(Hash)
     object.each_pair do |k, v|