* When reading a vocabulary, don't skip non-english literals.

* When writing a vocabulary, use language-map form for language-tagged literals with any in english serialized as the first entry of the map,
Fixes #432.

Author: gkellogg

lib/rdf/vocab/writer.rb

@@ -50,6 +50,19 @@ class Format < RDF::Format
     #       range: "xsd:float",
     #       type: "owl:DatatypeProperty",
     #       "vs:term_status": "testing"
+    #
+    # @example term definition with language-tagged strings
+    #   @example A term definition with tagged values
+    #       property :actor,
+    #       comment: {en: "Subproperty of as:attributedTo that identifies the primary actor"},
+    #       domain: "https://www.w3.org/ns/activitystreams#Activity",
+    #       label: {en: "actor"},
+    #       range: term(
+    #           type: "http://www.w3.org/2002/07/owl#Class",
+    #           unionOf: list("https://www.w3.org/ns/activitystreams#Object", "https://www.w3.org/ns/activitystreams#Link")
+    #         ),
+    #       subPropertyOf: "https://www.w3.org/ns/activitystreams#attributedTo",
+    #       type: "http://www.w3.org/2002/07/owl#ObjectProperty"
     class Writer < RDF::Writer
       include RDF::Util::Logger
       format RDF::Vocabulary::Format
@@ -272,9 +285,17 @@ def from_node(name, attributes, term_type)
         attributes.keys.sort_by(&:to_s).map(&:to_sym).each do |key|
           value = Array(attributes[key])
           component = key.inspect.start_with?(':"') ? "#{key.to_s.inspect}: " : "#{key}: "
-          value = value.first if value.length == 1
+          value = value.first if value.length == 1 && value.none? {|v| v.is_a?(RDF::Literal) && v.language?}
           component << if value.is_a?(Array)
-            '[' + value.map {|v| serialize_value(v, key, indent: "      ")}.sort.join(", ") + "]"
+            # Represent language-tagged literals as a hash
+            lang_vals, vals = value.partition {|v| v.literal? && v.language?}
+            hash_val = lang_vals.inject({}) {|memo, obj| memo.merge(obj.language => obj.to_s)}
+            vals << hash_val unless hash_val.empty?
+            if vals.length > 1
+              '[' + vals.map {|v| serialize_value(v, key, indent: "      ")}.sort.join(", ") + "]"
+            else
+              serialize_value(vals.first, key, indent: "      ")
+            end
           else
             serialize_value(value, key, indent: "      ")
           end
@@ -284,7 +305,14 @@ def from_node(name, attributes, term_type)
       end
 
       def serialize_value(value, key, indent: "")
-        if value.is_a?(Literal) && %w(: comment definition notation note editorialNote).include?(key.to_s)
+        if value.is_a?(Hash)
+          # Favor English
+          keys = value.keys
+          keys = keys.include?(:en) ? (keys - [:en]).sort.unshift(:en) : keys.sort
+          '{' + keys.map do |k|
+            "#{k.inspect[1..-1]}: #{value[k].inspect}"
+          end.join(', ') + '}'
+        elsif value.is_a?(Literal) && %w(: comment definition notation note editorialNote).include?(key.to_s)
           "#{value.to_s.inspect}"
         elsif value.is_a?(RDF::URI)
           "#{value.to_s.inspect}"

lib/rdf/vocabulary.rb

@@ -521,10 +521,6 @@ def from_graph(graph, url: nil, class_name: nil, extra: nil)
             statement.predicate.to_s.to_sym
           end
 
-          # Skip literals other than plain or english
-          # This is because the ruby representation does not preserve language
-          next if statement.object.literal? && (statement.object.language || :en).to_s !~ /^en-?/
-
           (term[key] ||= []) << statement.object
         end
 

spec/vocab_writer_spec.rb

@@ -10,6 +10,9 @@
     @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
     <http://example.org/Class> a rdfs:Class ; rdfs:Datatype "Class" .
     <http://example.org/prop> a rdf:Property ; rdfs:Datatype "prop" .
+    <http://example.org/lang_prop> a rdf:Property ; rdfs:label "prop"@en .
+    <http://example.org/lang_props> a rdf:Property ; rdfs:label "eigen"@de, "prop"@en .
+    <http://example.org/mixed_props> a rdf:Property ; rdfs:label "prop"@en, "eigen"@de, "none" .
   }}
   let!(:graph) {
     RDF::Graph.new << RDF::Turtle::Reader.new(ttl)
@@ -21,6 +24,9 @@
     /class Foo/,
     %r{term :Class,\s+"http://www.w3.org/2000/01/rdf-schema#Datatype": "Class",\s+type: "http://www.w3.org/2000/01/rdf-schema#Class"}m.freeze,
     %r{property :prop,\s+"http://www.w3.org/2000/01/rdf-schema#Datatype": "prop",\s+type: "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"}m.freeze,
+    %r{property :lang_prop,\s+label: {en: "prop"}}m.freeze,
+    %r{property :lang_props,\s+label: {en: "prop", de: "eigen"}}m.freeze,
+    %r{property :mixed_props,\s+label: \["none", {en: "prop", de: "eigen"}\]}m.freeze,
   ].each do |regexp,|
     it "matches #{regexp}" do
       expect(serialization).to match(regexp)
@@ -57,7 +63,7 @@
       %r{inScheme: "http://eulersharp.sourceforge.net/2003/03swap/countries#iso3166-1-alpha-2"}.freeze,
       /notation: %\(afg\)/.freeze,
       %r{inScheme: "http://eulersharp.sourceforge.net/2003/03swap/countries#iso3166-1-alpha-3"}.freeze,
-      %r{"http://xmlns.com/foaf/0.1/name": "Afghanistan"}.freeze,
+      %r{"http://xmlns.com/foaf/0.1/name": {en: "Afghanistan"}}.freeze,
       %r{isDefinedBy: "http://eulersharp.sourceforge.net/2003/03swap/countries#"}.freeze,
       %r{type: "http://sweet.jpl.nasa.gov/2.3/humanJurisdiction.owl#Country"}.freeze,
     ].each do |regexp,|