rtext 0.5.1 → 0.7.0

data/test/integration/test.rb

@@ -572,6 +572,11 @@ EPackage StatemachineMM {
   |EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
   END
   assert_link_targets context, :begin => 3, :end => 8, :targets => []
+  # bad location
+  context = build_context <<-END
+EPackage S|tatemachineMM {
+  END
+  assert_link_targets context, :begin => 10, :end => 23, :targets => []
 end
 
 def test_link_targets_no_text_after_name
@@ -652,6 +657,7 @@ def assert_link_targets(context, options)
   lines =  RText::Frontend::Context.extract(lines)
   response = @con.execute_command( 
     {"command" => "link_targets", "context" => lines, "column" => context.col})
+  assert_equal "response", response["type"]
   assert_equal options[:targets], response["targets"]
   assert_equal options[:begin], response["begin_column"]
   assert_equal options[:end], response["end_column"]

data/test/message_helper_test.rb

@@ -71,18 +71,18 @@ def test_extract
   # a iso-8859-1 '�' 
   obj = extract_message('19{"key":"umlaut%e4"}'.force_encoding("binary"))
   assert_equal "ASCII-8BIT", obj["key"].encoding.name
-  assert_equal "umlaut\xe4", obj["key"]
+  assert_equal "umlaut\xe4".force_encoding("ascii-8bit"), obj["key"]
   obj = extract_message('19{"key":"umlaut%e4"}'.force_encoding("utf-8"))
   assert_equal "ASCII-8BIT", obj["key"].encoding.name
-  assert_equal "umlaut\xe4", obj["key"]
+  assert_equal "umlaut\xe4".force_encoding("ascii-8bit"), obj["key"]
 
   # a utf-8 '�'
   obj = extract_message('22{"key":"umlaut%c3%a4"}'.force_encoding("binary"))
   assert_equal "ASCII-8BIT", obj["key"].encoding.name
-  assert_equal "umlaut\xc3\xa4", obj["key"]
+  assert_equal "umlaut\xc3\xa4".force_encoding("ascii-8bit"), obj["key"]
   obj = extract_message('22{"key":"umlaut%c3%a4"}'.force_encoding("utf-8"))
   assert_equal "ASCII-8BIT", obj["key"].encoding.name
-  assert_equal "umlaut\xc3\xa4", obj["key"]
+  assert_equal "umlaut\xc3\xa4".force_encoding("ascii-8bit"), obj["key"]
 
   # %
   obj = extract_message('13{"key":"%25"}')

data/test/serializer_test.rb

@@ -1,12 +1,20 @@
 $:.unshift File.join(File.dirname(__FILE__),"..","lib")
 
 require 'test/unit'
+require 'bigdecimal'
+require 'fileutils'
+require 'stringio'
 require 'rgen/environment'
 require 'rgen/metamodel_builder'
 require 'rtext/serializer'
 require 'rtext/language'
 
 class SerializerTest < Test::Unit::TestCase
+  TestOutputFile = ".serializer_test_file"
+
+  def teardown
+    FileUtils.rm_f TestOutputFile
+  end
 
   class StringWriter < String
     alias write concat
@@ -18,6 +26,7 @@ class SerializerTest < Test::Unit::TestCase
       :name => "SomeEnum", :literals => [:A, :B, :'non-word*chars', :'2you'])
     class TestNode < RGen::MetamodelBuilder::MMBase
       has_attr 'text', String
+      has_many_attr 'texts', String
       has_attr 'integer', Integer
       has_attr 'float', Float
       has_attr 'enum', SomeEnum
@@ -40,6 +49,17 @@ TestNode text: "some text" {
 ), output 
   end
 
+  def test_many_attr
+    testModel = TestMM::TestNode.new(:texts => ["a", "b", "c"])
+
+    output = StringWriter.new
+    serialize(testModel, TestMM, output)
+
+    assert_equal %Q(\
+TestNode texts: ["a", "b", "c"]
+), output 
+  end
+
   module TestMMFeatureProvider
     extend RGen::MetamodelBuilder::ModuleExtension
     class TestNode < RGen::MetamodelBuilder::MMBase
@@ -126,8 +146,9 @@ TestNode unquoted: "//"
     testModel = TestMMComment::TestNode.new(
       :comment => "this is a comment",
       :childs => [
-        TestMMComment::TestNode.new(:comment => "comment of a child node\n  multiline"),
-        TestMMComment::TestNode.new(:comment => "don't show")])
+        TestMMComment::TestNode.new(:comment => "\n\ncomment of a child node\n  multiline\n\n\nanother\n\n\n"),
+        TestMMComment::TestNode.new(:comment => "don't show"),
+        TestMMComment::TestNode.new(:comment => "")])
 
     output = StringWriter.new
     serialize(testModel, TestMMComment, output,
@@ -144,10 +165,16 @@ TestNode unquoted: "//"
     assert_equal %Q(\
 #this is a comment
 TestNode {
+  #
+  #
   #comment of a child node
   #  multiline
+  #
+  #
+  #another
   TestNode
   TestNode comment: "don't show"
+  TestNode
 }
 ), output 
   end
@@ -370,6 +397,44 @@ TestNode {
 ), output 
   end
 
+  module TestMMLabeledContainment
+    extend RGen::MetamodelBuilder::ModuleExtension
+    class TestNode < RGen::MetamodelBuilder::MMBase
+      abstract
+      has_attr 'text', String
+      contains_many 'childs', TestNode, 'parent'
+    end
+    class TestNode1 < TestNode
+    end
+    class TestNode2 < TestNode
+    end
+  end
+
+  def test_labeled_containment
+    testModel = TestMMLabeledContainment::TestNode1.new(:text => "some text", :childs => [
+      TestMMLabeledContainment::TestNode2.new(:text => "child", :childs => [
+      TestMMLabeledContainment::TestNode1.new(:text => "nested child")
+      ])])
+
+    output = StringWriter.new
+    serialize(testModel, TestMMLabeledContainment, output, :labeled_containments => proc {|c|
+      if c == TestMMLabeledContainment::TestNode2.ecore
+        ["childs"]
+      else
+        []
+      end
+    })
+
+    assert_equal %Q(\
+TestNode1 text: "some text" {
+  TestNode2 text: "child" {
+    childs:
+      TestNode1 text: "nested child"
+  }
+}
+), output 
+  end
+
   def test_escapes
     testModel = TestMM::TestNode.new(:text => %Q(some " \\ \\" text \r xx \n xx \r\n xx \t xx \b xx \f))
     output = StringWriter.new
@@ -423,6 +488,17 @@ TestNode {
     assert_equal %q(TestNode float: 1.2)+"\n", output
   end
 
+  def test_float_big_decimal
+    begin
+      testModel = TestMM::TestNode.new(:float => BigDecimal.new("1234567890.123456789"))
+    rescue StandardError
+      return
+    end
+    output = StringWriter.new
+    serialize(testModel, TestMM, output) 
+    assert_equal %q(TestNode float: 1234567890.123456789)+"\n", output 
+  end
+
   def test_enum
     testModel = [
       TestMM::TestNode.new(:enum => :A),
@@ -507,12 +583,34 @@ TestNodeX text: "some text" {
 ), output 
   end
 
+  def test_file_output
+    testModel = TestMM::TestNode.new(:text => "some text")
+
+    File.open(TestOutputFile, "w") do |f|
+      serialize(testModel, TestMM, f)
+    end
+
+    assert_equal %Q(\
+TestNode text: "some text"
+), File.read(TestOutputFile)
+  end
+
+  def test_stringio_output
+    testModel = TestMM::TestNode.new(:text => "some text")
+
+    output = StringIO.new
+    serialize(testModel, TestMM, output)
+
+    assert_equal %Q(\
+TestNode text: "some text"
+), output.string
+  end
+
   def serialize(model, mm, output, options={})
     lang = RText::Language.new(mm.ecore, options)
     ser = RText::Serializer.new(lang)
     ser.serialize(model, output)
   end
 
-
 end
 

data/test/tokenizer_test.rb

@@ -105,13 +105,45 @@ end
 
 def test_error
   assert_tokens [
-    Token.new(:error, "\"open", 1, 1, 5),
+    Token.new(:error, "\"", 1, 1, 1),
+    Token.new(:identifier, "open", 1, 2, 5),
     Token.new(:newline, nil, 1, nil, nil)
   ], <<-END
 "open
   END
 end
 
+def test_with_bom
+  assert_tokens [
+    Token.new(:identifier, "TestNode", 1, 1, 8),
+    Token.new(:integer, 1, 1, 10, 10),
+    Token.new(:newline, nil, 1, nil, nil) 
+  ], "\xEF\xBB\xBFTestNode 1"
+end
+
+def test_excessive_newline
+  assert_tokens [
+    Token.new(:identifier, "TestNode", 3, 1, 8),
+    Token.new(:newline, nil, 3, nil, nil),
+    Token.new(:identifier, "TestNode", 5, 1, 8),
+    Token.new(:newline, nil, 5, nil, nil) 
+  ], %Q(
+
+TestNode
+
+TestNode
+
+)
+end
+
+def test_only_newline
+  assert_tokens [
+  ], %Q(
+
+
+)
+end
+
 def do_tokenize(str)
   tokenize(str, /\A\/[\/\w]+/)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rtext
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-07 00:00:00.000000000 Z
+date: 2013-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgen
@@ -39,9 +39,10 @@ extra_rdoc_files:
 - RText_Users_Guide
 - RText_Protocol
 files:
-- lib/rtext/completer.rb
 - lib/rtext/context_builder.rb
+- lib/rtext/default_completer.rb
 - lib/rtext/default_loader.rb
+- lib/rtext/default_resolver.rb
 - lib/rtext/default_service_provider.rb
 - lib/rtext/frontend/config.rb
 - lib/rtext/frontend/connector.rb
@@ -49,6 +50,7 @@ files:
 - lib/rtext/frontend/context.rb
 - lib/rtext/generic.rb
 - lib/rtext/instantiator.rb
+- lib/rtext/json_interface.rb
 - lib/rtext/language.rb
 - lib/rtext/link_detector.rb
 - lib/rtext/message_helper.rb
@@ -64,8 +66,8 @@ files:
 - test/integration/ecore_editor.rb
 - test/integration/frontend.log
 - test/integration/model/invalid_encoding.invenc
-- test/integration/model/test.crashing_backend
 - test/integration/model/test.crash_on_request
+- test/integration/model/test.crashing_backend
 - test/integration/model/test.dont_open_socket
 - test/integration/model/test.invalid_cmd_line
 - test/integration/model/test.not_in_rtext
@@ -110,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Ruby Textual Modelling

data/lib/rtext/completer.rb

@@ -1,128 +0,0 @@
-require 'rgen/ecore/ecore_ext'
-
-module RText
-
-class Completer
-
-  CompletionOption = Struct.new(:text, :extra)
-
-  # Creates a completer for RText::Language +language+.
-  #
-  def initialize(language)
-    @lang = language
-  end
-
-  # Provides completion options
-  #
-  #  :ref_completion_option_provider
-  #    a proc which receives a EReference and should return
-  #    the possible completion options as CompletionOption objects 
-  #    note, that the context element may be nil if this information is unavailable
-  #
-  def complete(context, ref_completion_option_provider=nil)
-    clazz = context && context.element && context.element.class.ecore
-    if clazz
-      if context.in_block
-        # command and lable completion within block
-        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.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
-      elsif !context.problem
-        result = []
-        if context.feature
-          if context.after_label
-            description = "<#{context.feature.eType.name}>"
-          else
-            description = "[#{context.feature.name}] <#{context.feature.eType.name}>"
-          end
-          # value completion
-          if context.feature.is_a?(RGen::ECore::EAttribute) || !context.feature.containment
-            if context.feature.is_a?(RGen::ECore::EReference)
-              if ref_completion_option_provider
-                result += ref_completion_option_provider.call(context.feature)
-              else
-                # no options 
-              end
-            elsif context.feature.eType.is_a?(RGen::ECore::EEnum)
-              result += context.feature.eType.eLiterals.collect do |l|
-                CompletionOption.new("#{l.name}", "<#{context.feature.eType.name}>")
-              end 
-            elsif context.feature.eType.instanceClass == String
-              if @lang.unquoted?(context.feature)
-                result += [ CompletionOption.new("#{context.feature.name.gsub(/\W/,"")}", description) ]
-              else
-                result += [ CompletionOption.new("\"\"", description) ]
-              end
-            elsif context.feature.eType.instanceClass == Integer 
-              result += (0..0).collect{|i| CompletionOption.new("#{i}", description) }
-            elsif context.feature.eType.instanceClass == Float 
-              result += (0..0).collect{|i| CompletionOption.new("#{i}.0", description) }
-            elsif context.feature.eType.instanceClass == RGen::MetamodelBuilder::DataTypes::Boolean
-              result += [true, false].collect{|b| CompletionOption.new("#{b}", description) }
-            else
-              # no options 
-            end
-          else
-            # containment reference, ignore
-          end
-        end
-        if !context.after_label
-          # label completion
-          result += @lang.labled_arguments(clazz).
-            select{|f| 
-              !context.element.eIsSet(f.name)}.collect do |f| 
-              CompletionOption.new("#{f.name}:", "<#{f.eType.name}>")
-            end 
-        end
-        result
-      else
-        # missing comma, after curly brace, etc.
-        []
-      end
-    elsif context
-      # root classes
-      @lang.root_classes.
-        sort{|a,b| a.name <=> b.name}.collect do |c| 
-          class_completion_option(c)
-        end 
-    else
-      []
-    end
-  end
-
-  private
-
-  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
-