iq_rdf 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9b8113dea4da94252393b4f5d662fb83e20dd201b82f8d350d51ea13cf616a6
-  data.tar.gz: a3c5e7299288526e0e8c042b37cfb6b3d20a500e9e361b464fd6667e07ca94f8
+  metadata.gz: 86d24605dfac28de70ab6dc47bbd296adb42c4e855697b137a226a2a92e19f45
+  data.tar.gz: 6d23a834fffa345374df50eac0fbb8c0671a92799adff48ad077cad61df81677
 SHA512:
-  metadata.gz: aef36d79a240d34c0f3f35ce6dc431f02bfc84e836a5b6050714c86cbac1c5a4e138f43be74f3169a8750b4a730989a0c26fbeb1e53cad9520e80330360b7dcd
-  data.tar.gz: d6844c6e75ca177e5707eb8e87ce181a0a3232c754ad288cb086a2608f9feb13c45bcc2fe138be613c465b9c4f032bac50c10c8a543c82da16307a2bdee15c65
+  metadata.gz: e9816318bac2c2959053a30e6ec9c5ec531bc37089bb797d289887fc365524c83c02c460b93a25ba74a6287134ee4181d3002acab00627ec5a02d839b0494cb6
+  data.tar.gz: 5ca38d366409dea8d0cf6c3e0ee099a828223d00650c1068bb7986dc3087b3f77158037a0efcaf324ed232d00e8b53dc36f53feb8a0d28a0f4d1720345020774

data/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+## [0.3.0] - 2026-09-10
+
+* omit `rdf:type rdf:List` from RDF collections. The list structure is fully
+  defined by `rdf:first`/`rdf:rest`/`rdf:nil`, and Turtle's `( ... )` form
+  cannot express the type at all, so emitting it made the same data count
+  differently per format. **Documents containing collections now serialize to
+  fewer triples**, and N-Triples, Turtle and RDF/XML agree on the count. In
+  RDF/XML, list nodes are now `rdf:Description` rather than `rdf:List`.
+
+## [0.2.3] - 2026-09-10
+
+* fix Turtle serialization of literals containing a carriage return. A long
+  string (`"""..."""`) was only used for newlines, so a lone carriage return
+  ended up raw inside a short string - invalid Turtle, which made parsers drop
+  the statement without warning. Quotes are now escaped inside long strings as
+  well, so a value ending in a quote or containing three of them no longer
+  breaks the output.
+* serialize Turtle in linear rather than quadratic time. Building the output
+  with `+=` copied the whole string on every append, which made large documents
+  effectively impossible to serialize.
+* serialize N-Triples faster by not counting a Hash with `Enumerable#count`,
+  which walks and allocates per entry. On a document with many blank nodes this
+  dominated the runtime.
+* add `rdf-turtle` as a development dependency, so that tests can parse
+  generated output back instead of only comparing it to an expected string.
+
+## [0.2.2] - 2026-07-31
+
+* fix N-Triples serialization of literals containing newlines, tabs or
+  carriage returns
+* drop support for end-of-life rubies
+
+## [0.2.1]
+
+* fix a frozen string literal warning

data/iq_rdf.gemspec

@@ -25,15 +25,17 @@ Gem::Specification.new do |s|
   s.homepage    = "http://github.com/innoq/iq_rdf"
   s.summary     = "IqRdf - A builder like rdf library for ruby and rails"
   s.description = s.summary
-  s.extra_rdoc_files = ['README.md', 'LICENSE']
+  s.extra_rdoc_files = ['README.md', 'CHANGELOG.md', 'LICENSE']
 
   s.add_dependency "bundler"
   s.add_dependency "builder"
   s.add_dependency "activesupport"
 
   s.add_development_dependency "minitest"
+  # parses generated output back, so that tests catch invalid serializations
+  s.add_development_dependency "rdf-turtle"
 
-  s.files = %w(LICENSE README.md Rakefile iq_rdf.gemspec) + Dir.glob("{lib,rails,test}/**/*")
+  s.files = %w(LICENSE README.md CHANGELOG.md Rakefile iq_rdf.gemspec) + Dir.glob("{lib,rails,test}/**/*")
   s.test_files = Dir.glob("{test}/**/*")
   s.executables = Dir.glob("{bin}/**/*")
   s.require_paths = ["lib"]

data/lib/iq_rdf/collection.rb

@@ -33,7 +33,9 @@ module IqRdf
       elements ||= @elements.dup
       block.call({},
         lambda {
-          xml.rdf :List do
+          # rdf:Description, not rdf:List: a typed element would assert
+          # rdf:type rdf:List, which Turtle's ( ... ) form cannot express
+          xml.rdf :Description do
             elements.shift.build_xml(xml) do |*args|
               xml.rdf(:first, *args)
             end

data/lib/iq_rdf/document.rb

@@ -62,7 +62,9 @@ module IqRdf
       render_blank_node = lambda do |res|
         node_id = blank_nodes[res]
         unless node_id
-          node_id = blank_nodes.count + 1
+          # size, not count: Hash does not override Enumerable#count, which
+          # walks every entry - once per blank node that is quadratic
+          node_id = blank_nodes.size + 1
           blank_nodes[res] = node_id
         end
         return "_:b#{node_id}"
@@ -75,7 +77,9 @@ module IqRdf
         sublist = list
         total = res.elements.length
         res.elements.each_with_index do |current_element, i|
-          sublist::rdf.build_predicate("type", IqRdf::Rdf::build_uri("List")) # _:b* a rdf:List
+          # No a rdf:List here: rdf:first/rdf:rest/rdf:nil already define the
+          # collection, and Turtle's ( ... ) form cannot express the type at
+          # all - emitting it made the same data count differently per format.
           sublist::rdf.first(current_element) # _:b* rdf:first <...>
           last = i + 1 == total
           if last
@@ -143,18 +147,18 @@ module IqRdf
     end
 
     def to_turtle
-      s = ""
+      s = +""
       @namespaces.values.sort{ |n1, n2| n1.turtle_token <=> n2.turtle_token }.each do |namespace|
-        s += "@prefix #{namespace.turtle_token}: <#{namespace.uri_prefix}>.\n"
+        s << "@prefix #{namespace.turtle_token}: <#{namespace.uri_prefix}>.\n"
       end
-      s += "\n"
+      s << "\n"
       @nodes.each do |subject|
         pref = subject.to_s(@document_language)
         indent = "".ljust(pref.length)
 
         # Render subject, if it is defined as a RDF-type.
         if subject.rdf_type
-          s += "#{pref} a #{subject.rdf_type}"
+          s << "#{pref} a #{subject.rdf_type}"
           pref = ";\n" + indent
         end
 
@@ -163,13 +167,13 @@ module IqRdf
           objects = predicate.nodes.map { |object| object.to_s(indent: indent, lang: predicate.lang || subject.lang || @document_language) }
                              .join(", ")
 
-          s += "#{pref} #{predicate.to_s} #{objects}"
+          s << "#{pref} #{predicate.to_s} #{objects}"
 
           pref = ";\n" + indent
         end
-        s += ".\n"
+        s << ".\n"
         if @config[:empty_line_between_triples]
-          s += "\n"
+          s << "\n"
         end
       end
       s

data/lib/iq_rdf/literal.rb

@@ -15,7 +15,8 @@
 module IqRdf
   class Literal
 
-    NTRIPLES_ESCAPE_MAP = {
+    # Turtle accepts the same escapes as N-Triples, so both formats share this
+    ESCAPE_MAP = {
       "\\" => "\\\\",
       '"'  => '\\"',
       "\n" => "\\n",
@@ -23,6 +24,12 @@ module IqRdf
       "\t" => "\\t"
     }.freeze
 
+    # Inside """...""" line breaks and tabs are legal as they are
+    LONG_ESCAPE_MAP = {
+      "\\" => "\\\\",
+      '"'  => '\\"'
+    }.freeze
+
     def initialize(obj, lang = nil, datatype = nil)
       raise "#{datatype.inspect} is not an URI" unless datatype.nil? || datatype.is_a?(::URI) || datatype.is_a?(IqRdf::Uri)
       @obj = obj
@@ -45,7 +52,6 @@ module IqRdf
     def to_s(options = {})
       lang = @lang || options[:lang] # Use the Literals lang when given
       lang = (lang && lang != :none) ? "@#{lang}" : ""
-      quote = @obj.to_s.include?("\n") ? '"""' : '"'
       datatype = if @datatype.is_a?(::URI)
         "^^<#{@datatype.to_s}>"
       elsif @datatype.is_a?(IqRdf::Uri)
@@ -54,7 +60,17 @@ module IqRdf
         ""
       end
 
-      "#{quote}#{@obj.to_s.gsub("\\", "\\\\\\\\").gsub(/"/, "\\\"")}#{quote}#{lang}#{datatype}"
+      value = @obj.to_s
+
+      if value.match?(/[\n\r]/)
+        # A long string keeps line breaks readable, which is the point of
+        # Turtle over N-Triples. Its grammar allows raw line breaks and tabs,
+        # so only backslashes and quotes need escaping - escaping every quote
+        # also rules out a run of three ending the string prematurely.
+        %("""#{value.gsub(/[\\"]/, LONG_ESCAPE_MAP)}"""#{lang}#{datatype})
+      else
+        %("#{value.gsub(/[\\"\n\r\t]/, ESCAPE_MAP)}"#{lang}#{datatype})
+      end
     end
 
     def to_ntriples(parent_lang = nil)
@@ -67,7 +83,7 @@ module IqRdf
         (lang && lang != :none) ? "@#{lang}" : ""
       end
 
-      "\"#{@obj.to_s.gsub(/[\\"\n\r\t]/, NTRIPLES_ESCAPE_MAP)}\"#{suffix}"
+      "\"#{@obj.to_s.gsub(/[\\"\n\r\t]/, ESCAPE_MAP)}\"#{suffix}"
     end
 
     def build_xml(xml, &block)

data/lib/iq_rdf/version.rb

@@ -13,5 +13,5 @@
 #   limitations under the License.
 
 module IqRdf
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/test/ntriples_test.rb

@@ -101,13 +101,10 @@ _:b2 <http://www.test.de/title> "blubb" .
     document << IqRdf::testemann.testIt([IqRdf::hello, IqRdf::goodbye, "bla"])
 
     assert_equal(<<-rdf.strip, document.to_ntriples.strip)
-_:b2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/1999/02/22-rdf-syntax-ns#List> .
 _:b2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://test.de/hello> .
 _:b2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:b3 .
-_:b3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/1999/02/22-rdf-syntax-ns#List> .
 _:b3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> <http://test.de/goodbye> .
 _:b3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> _:b4 .
-_:b4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/1999/02/22-rdf-syntax-ns#List> .
 _:b4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#first> "bla" .
 _:b4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#rest> <http://www.w3.org/1999/02/22-rdf-syntax-ns#nil> .
 <http://test.de/testemann> <http://test.de/testIt> _:b2 .

data/test/test_helper.rb

@@ -19,3 +19,5 @@ $LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
 require 'iq_rdf'
 
 require 'minitest/autorun'
+
+require 'rdf/turtle'

data/test/turtle_test.rb

@@ -163,6 +163,63 @@ over two lines"""@de;
 rdf
   end
 
+  # A carriage return without a newline used to end up raw inside a short
+  # string, which is invalid Turtle and made parsers drop the statement.
+  def test_control_characters_in_literals
+    document = IqRdf::Document.new('http://www.test.de/', :lang => :none)
+
+    document << IqRdf::testemann do |t|
+      t.carriage_return("first\rsecond")
+      t.tab("left\tright")
+      t.long_with_quote("first\nends with \"")
+      t.long_with_three_quotes("first\nwith \"\"\" inside")
+      t.long_with_backslash("first\nC:\\temp")
+    end
+
+    assert_equal(<<rdf, document.to_turtle)
+@prefix : <http://www.test.de/>.
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
+
+:testemann :carriage_return """first\rsecond""";
+           :tab "left\\tright";
+           :long_with_quote """first
+ends with \\\"""";
+           :long_with_three_quotes """first
+with \\\"\\\"\\\" inside""";
+           :long_with_backslash """first
+C:\\\\temp""".
+rdf
+  end
+
+  # The assertions above compare against an expected string, which cements the
+  # current output but says nothing about whether it is valid Turtle. Parsing
+  # the output back does: it catches escaping that a parser rejects, or that
+  # silently changes the value.
+  def test_literals_survive_a_round_trip
+    {
+      "plain" => "just text",
+      "newline" => "first\nsecond",
+      "carriage return" => "first\rsecond",
+      "carriage return and newline" => "first\r\nsecond",
+      "tab" => "left\tright",
+      "quote" => 'said "hello"',
+      "trailing quote" => 'ends with "',
+      "three quotes" => 'a """ b',
+      "backslash" => 'C:\\temp',
+      "newline and quote" => "first\nends with \"",
+      "newline and three quotes" => "first\nwith \"\"\" inside",
+      "newline and backslash" => "first\nC:\\temp",
+    }.each do |name, value|
+      document = IqRdf::Document.new('http://www.test.de/', :lang => :none)
+      document << IqRdf::testemann.some_predicate(value)
+
+      statements = RDF::Turtle::Reader.new(document.to_turtle, validate: true).to_a
+      assert_equal 1, statements.size, "expected one statement for #{name}"
+      assert_equal value, statements.first.object.value,
+          "#{name} did not survive the round trip"
+    end
+  end
+
   def test_supress_if_empty_otpion
     document = IqRdf::Document.new('http://www.test.de/')
     document.namespaces :foaf => 'http://xmlns.com/foaf/0.1/'

data/test/xml_test.rb

@@ -103,15 +103,15 @@ rdf
   </rdf:Description>
   <rdf:Description rdf:about="http://www.umweltprobenbank.de/testemann">
     <testIt>
-      <rdf:List>
+      <rdf:Description>
         <rdf:first rdf:resource="http://www.umweltprobenbank.de/hello"/>
         <rdf:rest>
-          <rdf:List>
+          <rdf:Description>
             <rdf:first>bla</rdf:first>
             <rdf:rest rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"/>
-          </rdf:List>
+          </rdf:Description>
         </rdf:rest>
-      </rdf:List>
+      </rdf:Description>
     </testIt>
   </rdf:Description>
   <rdf:Description rdf:about="http://www.upb.de/u1023">

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iq_rdf
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Till Schulte-Coerne
@@ -65,15 +65,31 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdf-turtle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: IqRdf - A builder like rdf library for ruby and rails
 email:
 - till.schulte-coerne@innoq.com
 executables: []
 extensions: []
 extra_rdoc_files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile