ttl2html 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d181672a5b0aa4cd6f7f1599fb20b6102c5232b3f774069038023bfc65d05a0
-  data.tar.gz: 313970beef022f77e7f4d5bac9da410adcc6203a6dd7d073d6ab2b49a516ebae
+  metadata.gz: 179d7c92158302822e387bc70e386abc8ebc592c36b2ddf675f52471fda5a087
+  data.tar.gz: 3d8a36b2de920b07401a7360b11bdb501c0dfa41ffcae314746919d703d415da
 SHA512:
-  metadata.gz: fdd4152bfc2ab82d97bed51c63dd8814e89a40b31d2e84ca2a64406dcfd4be373a393ccf8b2ebd477adb8e1f4df844f355872537232e7ec9357063ff2c123760
-  data.tar.gz: 7821d98735d0fadf33671017573accb9d765e2e2bd571c9fb66435251a056cedab6e05ec20b760c940cc2f1daa16bbdde11496cadcf4045fa9016344904e36db
+  metadata.gz: fa1f3bf8f3e62ae2a73474b2469a86818af359f1ce67797f1f29f2738577b9edc12b9d2a91aada8c6d381404518815a33abb830186df2a722e488e80cb49848a
+  data.tar.gz: 1084e5c116dac281ec54a4ab79bedf13a545cb989ada95294d937deae6fdfd4663b52eb251927a4b1fea8f79012a46408235887b8ca7bcfeda026727d9bbe2ec

data/lib/ttl2html/template.rb

@@ -24,8 +24,7 @@ module TTL2HTML
     def output_to(file, param = {})
       param = @param.merge(param)
       param[:output_file] = file
-      dir = File.dirname(file)
-      FileUtils.mkdir_p(dir) if not File.exist?(dir)
+      FileUtils.mkdir_p(File.dirname(file))
       File.open(file, "w") do |io|
         io.print to_html(param)
       end
@@ -41,7 +40,9 @@ module TTL2HTML
       tmpl = File.open(template) { |io| io.read }
       erb = ERB.new(tmpl, trim_mode: "-")
       erb.filename = template
-      erb.result(binding)
+      I18n.with_locale(@param[:locale] || I18n.default_locale) do
+        erb.result(binding)
+      end
     end
 
     def find_template_path(fname)
@@ -51,14 +52,15 @@ module TTL2HTML
       end
       @template_path.each do |dir|
         file = File.join(dir, fname)
-        return file if File.exist? file
+        return file if File.file? file
       end
-      return nil
+      nil
     end
 
-    def expand_shape(data, uri, prefixes = {})
+    def expand_shape(data, uri, prefixes = {}, depth = 0)
       return nil if not data[uri]
       return nil if not data[uri]["http://www.w3.org/ns/shacl#property"]
+      return nil if depth > 10
       prefix_used = {}
       result = data[uri]["http://www.w3.org/ns/shacl#property"].sort_by do |e|
         e["http://www.w3.org/ns/shacl#order"]
@@ -87,14 +89,14 @@ module TTL2HTML
             node_or = data[data[node]["http://www.w3.org/ns/shacl#or"].first]
             node_mode = :or
             nodes = []
-            nodes << expand_shape(data, node_or["http://www.w3.org/1999/02/22-rdf-syntax-ns#first"].first, prefixes)
+            nodes << expand_shape(data, node_or["http://www.w3.org/1999/02/22-rdf-syntax-ns#first"].first, prefixes, depth + 1)
             rest = node_or["http://www.w3.org/1999/02/22-rdf-syntax-ns#rest"].first
             while data[rest] do
-              nodes << expand_shape(data, data[rest]["http://www.w3.org/1999/02/22-rdf-syntax-ns#first"].first, prefixes)
+              nodes << expand_shape(data, data[rest]["http://www.w3.org/1999/02/22-rdf-syntax-ns#first"].first, prefixes, depth + 1)
               rest = data[rest]["http://www.w3.org/1999/02/22-rdf-syntax-ns#rest"].first
             end
           else
-            nodes = expand_shape(data, node, prefixes)
+            nodes = expand_shape(data, node, prefixes, depth + 1)
           end
           #p nodes
         end
@@ -126,8 +128,7 @@ module TTL2HTML
         }
       end
       template = "shape-table.html.erb"
-      tmpl = Template.new(template)
-      tmpl.to_html_raw(template, { properties: result, prefix: prefix_used })
+      to_html_raw(template, { properties: result, prefix: prefix_used })
     end
 
     # helper method:
@@ -138,9 +139,15 @@ module TTL2HTML
       if dest_uri.absolute?
         path = dest
       else
-        src = Pathname.new(src).relative_path_from(Pathname.new(@param[:output_dir])) if @param[:output_dir]
+        dest.sub!(/^\/+/, "")
+        #p [:relative_path, src, dest]
+        if @param[:output_dir]
+          src = Pathname.new(src).relative_path_from(Pathname.new(@param[:output_dir]))
+        else
+          src = Pathname.new(File.expand_path(src)).relative_path_from(Pathname.new(File.expand_path(".")))
+        end
         path = Pathname(dest).relative_path_from(Pathname(File.dirname src))
-        if @param[:output_dir] and File.directory?(Pathname.new(@param[:output_dir]) + path)
+        if @param[:output_dir] and File.directory?(File.join(@param[:output_dir], path))
           path = path.to_s + "/"
         elsif File.directory?(path)
           path = path.to_s + "/"
@@ -222,6 +229,7 @@ module TTL2HTML
       type = param[:type] || {}
       data = param[:data] || {}
       if /\Ahttps?:\/\// =~ object.to_s
+        #p [:format_object_uri, param[:output_file], object]
         rel_path = relative_path_uri(param[:output_file], object)
         if param[:data_global][object]
           result = "<a href=\"#{rel_path}\">#{get_title(param[:data_global][object]) or ERB::Util.html_escape(object)}</a>"
@@ -325,6 +333,7 @@ module TTL2HTML
           "http://www.w3.org/2000/01/rdf-schema#label",
           "http://purl.org/dc/terms/title",
           "http://purl.org/dc/elements/1.1/title",
+          "https://schema.org/name",
           "http://schema.org/name",
           "http://www.w3.org/2004/02/skos/core#prefLabel"
         ].each do |prop|
@@ -343,6 +352,7 @@ module TTL2HTML
       results = []
       [
          "http://purl.org/linked-data/cube#order",
+         "https://schema.org/position",
          "http://schema.org/position",
       ].each do |order_elem|
         if resource and resource[order_elem]

data/lib/ttl2html/util.rb

@@ -42,6 +42,23 @@ module TTL2HTML
       path << suffix
       #p [uri, path]
       path
-    end  
+    end
+    def safe_output_path(file)
+      base = if @config[:output_dir]
+               File.expand_path(@config[:output_dir])
+             else
+               File.expand_path(".")
+             end
+      target = File.expand_path(file)
+      unless target == base || target.start_with?(base + File::SEPARATOR)
+        if @config[:output_dir]
+          warn "Attempting to write outside of output_dir: #{file}"
+        else
+          warn "Attempting to write outside of current directory: #{file}"
+        end
+        return nil
+      end
+      target
+    end
   end
-end
+end

data/lib/ttl2html/version.rb

@@ -1 +1 @@
-TTL2HTML::VERSION = "3.1.1"
+TTL2HTML::VERSION = "3.2.0"

data/lib/ttl2html.rb

@@ -72,51 +72,60 @@ module TTL2HTML
       $stderr.puts "#{count} triples. #{subjects.size} subjects."
       @data
     end
+
     QB_ORDER_URI = "http://purl.org/linked-data/cube#order"
     SCHEMA_POSITION_URI = "http://schema.org/position"
+    SCHEMA_POSITION_URI_S = "https://schema.org/position"
     SHACL_ORDER_URI = "http://www.w3.org/ns/shacl#order"
-    def sort_key_for_resource(resource, depth = 1)
+    def sort_key_for_resource(resource)
       qb_order = Float::INFINITY
       schema_position = Float::INFINITY
       shacl_order = Float::INFINITY
       if @data[resource.to_s]
         qb_order = @data[resource.to_s][QB_ORDER_URI].first.to_i if @data[resource.to_s][QB_ORDER_URI]
         schema_position = @data[resource.to_s][SCHEMA_POSITION_URI].first.to_i if @data[resource.to_s][SCHEMA_POSITION_URI]
+        schema_position = @data[resource.to_s][SCHEMA_POSITION_URI_S].first.to_i if @data[resource.to_s][SCHEMA_POSITION_URI_S]
         shacl_order = @data[resource.to_s][SHACL_ORDER_URI].first.to_i if @data[resource.to_s][SHACL_ORDER_URI]
       end
-      if resource.to_s =~ /^_:/ and depth < 5
-        [ schema_position, qb_order, shacl_order,
-          format_turtle(resource, depth + 1, true)
-        ]
+      if resource.to_s =~ /^_:/ and @data[resource.to_s]
+        resource_str = "{" + @data[resource.to_s].sort_by do |p, o|
+          [p, o]
+        end.join("\t") + "}"
+        [ schema_position, qb_order, shacl_order, resource_str ]
       else
-        [ schema_position, qb_order, shacl_order, resource.to_s]
+        [ schema_position, qb_order, shacl_order, resource.to_s ]
+      end
+    end
+    def format_uri(uri, writer = RDF::Turtle::Writer.new(nil, prefixes: @prefix))
+      result = writer.format_uri(RDF::URI(uri))
+      if result =~ /^#{RDF::Turtle::Terminals::PN_PREFIX}?:/
+        @used_prefixes << result.split(":").first
       end
+      result
     end
     def format_turtle(subject, depth = 1, force = false)
-      turtle = RDF::Turtle::Writer.new
+      turtle_writer = RDF::Turtle::Writer.new(nil, prefixes: @prefix)
       result = ""
       #p [:format_turtle, subject, depth, force]
       return result if !force && @cache[:output_turtle_files].include?(subject)
       if subject =~ /^_:/
         result << "[\n#{"  "*depth}"
       else
-        result << "<#{subject}>\n#{"  "*depth}"
+        result << format_uri(subject) << "\n#{"  "*depth}"
       end
       result << @data[subject.to_s].keys.sort.map do |predicate|
-        str = "<#{predicate}> "
+        str = format_uri(predicate, turtle_writer) << " "
         #p [subject, predicate, @data[subject.to_s][predicate]]
         str << @data[subject.to_s][predicate].sort_by do |object|
           #p [subject, predicate, object, depth]
-          sort_key_for_resource(object, depth)
+          sort_key_for_resource(object)
         end.map do |object|
           if /^_:/ =~ object.to_s # blank node:
             format_turtle(object, depth + 1, force)
           elsif RDF::URI::IRI =~ object.to_s
-            turtle.format_uri(RDF::URI.new object)
-          elsif object.respond_to?(:first) and object.first.kind_of?(Symbol)
-            turtle.format_literal(RDF::Literal.new(object[1], language: object[0]))
+            format_uri(object, turtle_writer)
           else
-            turtle.format_literal(object)
+            turtle_writer.format_literal(object)
           end
         end.join(", ")
         str
@@ -138,27 +147,37 @@ module TTL2HTML
       end.join
     end
     def collect_inverse_triples(object, triples = Set.new, visited = Set.new)
-      return triples if object.to_s.start_with?("_:")
-      return triples unless object.to_s.start_with?(@config[:base_uri].to_s)
-      return triples unless @data_inverse.key?(object.to_s)
       return triples if visited.include?(object.to_s)
       visited << object.to_s
-      @data_inverse[object.to_s].each do |predicate, subjects|
-        subjects.each do |subject|
-          triples << [subject.to_s, predicate.to_s, object.to_s]
-          collect_inverse_triples_for_bnode(subject.to_s, triples, visited) if subject.to_s.start_with?("_:")
+      if @data_inverse.key?(object.to_s)
+        @data_inverse[object.to_s].each do |predicate, subjects|
+          subjects.each do |subject|
+            triples << [subject.to_s, predicate.to_s, object.to_s]
+            collect_inverse_triples_for_bnode(subject.to_s, triples, visited) if subject.to_s.start_with?("_:")
+          end
         end
       end
       triples
     end
     def collect_inverse_triples_for_bnode(node, triples, visited)
-      return triples unless @data_inverse.key?(node)
       return triples if visited.include?(node)
       visited << node
-      @data_inverse[node].each do |predicate, subjects|
-        subjects.each do |subject|
+      if @data.key?(node)
+        @data[node].each do |predicate, objects|
+          objects.each do |object|
+            triples << [node, predicate.to_s, object]
+            if object.to_s.start_with?("_:")
+              collect_inverse_triples_for_bnode(object.to_s, triples, visited)
+            end
+          end
+        end
+      end
+      if @data_inverse.key?(node)
+        @data_inverse[node].each do |predicate, subjects|
+          subjects.each do |subject|
             triples << [subject.to_s, predicate.to_s, node]
             collect_inverse_triples_for_bnode(subject.to_s, triples, visited) if subject.to_s.start_with?("_:")
+          end
         end
       end
       triples
@@ -183,13 +202,15 @@ module TTL2HTML
     def find_inverse_roots(by_subject)
       all_subjects = by_subject.keys
       all_objects  = by_subject.values.flat_map { |preds| preds.values.flatten }.uniq
-      all_subjects.reject do |subject|
-        subject.start_with?("_:") || all_objects.include?(subject)
-      end.sort
+      roots = all_subjects.reject do |subject|
+        all_objects.include?(subject)
+      end
+      roots.sort_by { |subject| sort_key_for_resource(subject) }
     end
     def format_inverse_subject(subject, by_subject, ref_count, visited, depth = 1)
+      turtle_writer = RDF::Turtle::Writer.new(nil, prefixes: @prefix)
       props = by_subject[subject]
-      return format_node(subject) if props.nil? || props.empty?
+      return format_node(subject, turtle_writer) if props.nil? || props.empty?
       indent = "  " * (depth - 1)
       inner  = "  " * depth
       if subject.start_with?("_:")
@@ -199,18 +220,18 @@ module TTL2HTML
         head = "[\n#{inner}"
         tail = "\n#{indent}]"
       else
-        head = "<#{subject}> "
+        head = format_uri(subject, turtle_writer) << " "
         tail = ""
       end
       body = props.keys.sort.map do |predicate|
         objects = props[predicate].sort.map do |object|
-          format_inverse_object(object, by_subject, ref_count, visited, depth + 1)
+          format_inverse_object(object, by_subject, ref_count, visited, depth + 1, turtle_writer)
         end.join(", ")
-        "<#{predicate}> #{objects}"
+        format_uri(predicate, turtle_writer) << " " << objects
       end.join(";\n#{inner}")
       head + body + tail
     end
-    def format_inverse_object(object, by_subject, ref_count, visited, depth = 1)
+    def format_inverse_object(object, by_subject, ref_count, visited, depth = 1, turtle_writer = RDF::Turtle::Writer.new(nil, prefixes: @prefix))
       if object.to_s.start_with?("_:") && by_subject.key?(object.to_s)
         if ref_count[object.to_s] <= 1
           format_inverse_subject(object.to_s, by_subject, ref_count, visited, depth)
@@ -218,19 +239,16 @@ module TTL2HTML
           object.to_s
         end
       else
-        format_node(object)
+        format_node(object, turtle_writer)
       end
     end
-    def format_node(value)
-      turtle = RDF::Turtle::Writer.new
+    def format_node(value, writer = RDF::Turtle::Writer.new(nil, prefixes: @prefix))
       if value.to_s.start_with?("_:")
         value.to_s
       elsif RDF::URI::IRI =~ value.to_s
-        "<#{value}>"
-      elsif value.respond_to?(:first) && value.first.kind_of?(Symbol)
-        turtle.format_literal(RDF::Literal.new(value[1], language: value[0]))
+        format_uri(value, writer)
       else
-        turtle.format_literal(value)
+        writer.format_literal(value)
       end
     end
 
@@ -243,8 +261,8 @@ module TTL2HTML
       data = @data.keys.sort_by do|uri|
         local_path = uri_mapping_to_path(uri, @config, ".html")
         #p [ local_path.size, local_path.count("/"), local_path ]
-        [ local_path.size, local_path.count("/"), local_path ]
-      end.reverse
+        [ -(local_path.count("/")), -(local_path.size), local_path ]
+      end
       Parallel.each(data, progress: progressbar_options) do |uri|
         next if not uri.start_with? @config[:base_uri]
         yield uri, @data[uri]
@@ -275,7 +293,7 @@ module TTL2HTML
         end
       end
       @config[:orders_with_class] = shapes2orders(shapes)
-      Dir.mkdir @config[:output_dir] if @config[:output_dir] and not File.exist? @config[:output_dir]
+      FileUtils.mkdir_p(@config[:output_dir]) if @config[:output_dir]
       template = Template.new("default.html.erb", @config)
       each_data(:output_html_files) do |uri, v|
         param = @config.dup
@@ -297,11 +315,14 @@ module TTL2HTML
         if @config[:output_dir]
           file = File.join(@config[:output_dir], file)
         end
-        if template.find_template_path("_default.html.erb")
-          param[:additional_content] = template.to_html_raw("_default.html.erb", param)
+        file = safe_output_path(file)
+        if file
+          if template.find_template_path("_default.html.erb")
+            param[:additional_content] = template.to_html_raw("_default.html.erb", param)
+          end
+          param[:about_file] = about_file if about_required
+          template.output_to(file, param)
         end
-        param[:about_file] = about_file if about_required
-        template.output_to(file, param)
       end
       index_html = "index.html"
       index_html = File.join(@config[:output_dir], "index.html") if @config[:output_dir]
@@ -343,7 +364,8 @@ module TTL2HTML
           param[:output_file] = index_html
           param[:index_list] = template.to_html_raw("index-list.html.erb", param)
           param[:about_file] = about_file if about_required
-          template.output_to(index_html, param)
+          index_html = safe_output_path(index_html)
+          template.output_to(index_html, param) if index_html
         end
       end
       if about_required
@@ -388,7 +410,8 @@ module TTL2HTML
             order: orders,
           }
         end
-        template.output_to(about_html, param)
+        about_html = safe_output_path(about_html)
+        template.output_to(about_html, param) if about_html
       end
     end
 
@@ -620,20 +643,29 @@ module TTL2HTML
     end
 
     def output_turtle_files
-      Dir.mkdir @config[:output_dir] if @config[:output_dir] and not File.exist? @config[:output_dir]
+      FileUtils.mkdir_p(@config[:output_dir]) if @config[:output_dir]
       each_data(:output_turtle_files) do |uri, v|
         file = uri_mapping_to_path(uri, @config, ".ttl")
         if @config[:output_dir]
-          Dir.mkdir @config[:output_dir] if not File.exist? @config[:output_dir]
           file = File.join(@config[:output_dir], file)
         end
+        file = safe_output_path(file)
+        next if not file
         dir = File.dirname(file)
         FileUtils.mkdir_p(dir) if not File.exist?(dir)
         @cache ||= {}
         @cache[:output_turtle_files] = Set.new
+        @used_prefixes = Set.new
         str = format_turtle(uri)
         str << format_turtle_inverse(uri)
-        open(file, "w") do |io|
+        File.open(file, "w") do |io|
+          @used_prefixes.each do |prefix|
+            if prefix.empty?
+              io.puts "@prefix : <#{@prefix[nil]}>."
+            else
+              io.puts "@prefix #{prefix}: <#{@prefix[prefix.to_sym]}>."
+            end
+          end
           io.puts str.strip
         end
       end
@@ -653,30 +685,42 @@ module TTL2HTML
       end.each do |uri, v|
         html_file = uri_mapping_to_path(uri, @config, ".html")
         html_file = File.join(@config[:output_dir], html_file) if @config[:output_dir]
-        dirs << File.dirname(html_file)
-        File.unlink html_file if File.exist? html_file
+        html_file = safe_output_path(html_file)
+        if html_file and File.file? html_file
+          dirs << File.dirname(html_file)
+          File.unlink html_file
+        end
         ttl_file = uri_mapping_to_path(uri, @config, ".ttl")
         ttl_file = File.join(@config[:output_dir], ttl_file) if @config[:output_dir]
-        File.unlink ttl_file if File.exist? ttl_file
-        dir = uri.sub(@config[:base_uri], "")
-        dir = File.join(@config[:output_dir], dir) if @config[:output_dir]
-        dirs << dir
+        ttl_file = safe_output_path(ttl_file)
+        if ttl_file and File.file? ttl_file
+          dirs << File.dirname(ttl_file)
+          File.unlink ttl_file
+        end
       end
       index_html = "index.html"
       index_html = File.join(@config[:output_dir], "index.html") if @config[:output_dir]
-      if @config[:top_class] and File.exist? index_html
+      index_html = safe_output_path(index_html)
+      if index_html and @config[:top_class] and File.file? index_html
         File.unlink index_html
       end
       about_html = (@config[:about_file] || "about.html")
       about_html = File.join(@config[:output_dir], about_html) if @config[:output_dir]
-      File.unlink about_html if File.exist? about_html
+      about_html = safe_output_path(about_html)
+      if about_html and File.file? about_html
+        File.unlink about_html
+      end
 
       dirs = dirs.uniq.sort_by{|e| -(e.size) }
       #p dirs
       dirs.each do |dir|
-        next if dir == "." # failsafe...
-        next if dir == @config[:output_dir] # failsafe...
-        FileUtils.remove_entry_secure(dir) if File.exist? dir
+        dir = safe_output_path(dir)
+        next unless dir
+        next if dir == File.expand_path(".") # failsafe...
+        next if @config[:output_dir] and dir == File.expand_path(@config[:output_dir]) # failsafe...
+        if dir and File.exist?(dir) and File.directory?(dir)
+          FileUtils.remove_entry_secure(dir)
+        end
       end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ttl2html
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Masao Takaku
 bindir: bin
 cert_chain: []
-date: 2026-04-29 00:00:00.000000000 Z
+date: 2026-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri