derivative-rodeo 0.2.0

data/lib/derivative_rodeo/generators/base_generator.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module DerivativeRodeo
+  ##
+  # Generators execute a transformation on files and return new files.
+  #
+  # A new generator should inherit from {BaseGenerator}.
+  #
+  # @see BaseGenerator
+  module Generators
+    ##
+    # The Base Generator defines the interface and common methods.
+    #
+    # In extending a BaseGenerator you:
+    #
+    # - must assign an {.output_extension}
+    # - must impliment a {#build_step} method
+    # - may override {#with_each_requisite_location_and_tmp_file_path}
+    class BaseGenerator
+      ##
+      # @!group Class Attributes
+      # @!attribute [rw]
+      #
+      # @return [String] of the form that starts with a string and may contain periods (though
+      #         likely not as the first character).
+      class_attribute :output_extension
+      # @!endgroup Class Attributes
+
+      attr_reader :input_uris,
+                  :logger,
+                  :output_location_template,
+                  :preprocessed_location_template
+
+      ##
+      # @param input_uris [Array<String>]
+      # @param output_location_template [String] the template used to transform the given :input_uris
+      #        via {Services::ConvertUriViaTemplateService}.
+      # @param preprocessed_location_template [NilClass, String] when `nil` ignore, otherwise attempt
+      #        to find preprocessed uris by transforming the :input_uris via
+      #        {Services::ConvertUriViaTemplateService} with the given
+      #        :preprocessed_location_template.
+      # @param logger [Logger]
+      def initialize(input_uris:, output_location_template:, preprocessed_location_template: nil, logger: DerivativeRodeo.config.logger)
+        @input_uris = Array.wrap(input_uris)
+        @output_location_template = output_location_template
+        @preprocessed_location_template = preprocessed_location_template
+        @logger = logger
+
+        return if valid_instantiation?
+
+        raise Errors::ExtensionMissingError.new(klass: self.class)
+      end
+
+      ##
+      # @api private
+      #
+      # @return [Boolean]
+      def valid_instantiation?
+        # When we have a BaseGenerator and not one of it's children or when we've assigned the
+        # output_extension.  instance_of? is more specific than is_a?
+        instance_of?(DerivativeRodeo::Generators::BaseGenerator) || output_extension
+      end
+
+      ##
+      # @api public
+      #
+      # @param input_location [StorageLocations::BaseLocation] the input source of the generation
+      # @param output_location [StorageLocations::BaseLocation] the output location of the generation
+      # @param input_tmp_file_path [String] the temporary path to the location of the given :input_location to
+      #        enable further processing on the file.
+      #
+      # @return [StorageLocations::BaseLocation]
+      # @see #generated_files
+      def build_step(input_location:, output_location:, input_tmp_file_path:)
+        raise NotImplementedError, "#{self.class}#build_step"
+      end
+
+      ##
+      # @api public
+      #
+      # @return [Array<StorageLocations::BaseLocation>]
+      #
+      # @see #build_step
+      # @see #with_each_requisite_location_and_tmp_file_path
+      def generated_files
+        return @generated_files if defined?(@generated_files)
+
+        # As much as I would like to use map or returned values; given the implementations it's
+        # better to explicitly require that; reducing downstream implementation headaches.
+        #
+        # In other words, this little bit of ugly in a method that has yet to change in a subclass
+        # helps ease subclass implementations of the #with_each_requisite_location_and_tmp_file_path or
+        # #build_step
+        @generated_files = []
+        with_each_requisite_location_and_tmp_file_path do |input_location, input_tmp_file_path|
+          generated_file = destination(input_location)
+          @generated_files << if generated_file.exist?
+                                generated_file
+                              else
+                                build_step(input_location: input_location, output_location: generated_file, input_tmp_file_path: input_tmp_file_path)
+                              end
+        end
+        @generated_files
+      end
+
+      ##
+      # @return [Array<String>]
+      # @see #generated_files
+      def generated_uris
+        # TODO: what do we do about nils?
+        generated_files.map { |file| file&.file_uri }
+      end
+
+      ##
+      # @api public
+      #
+      # The files that are required as part of the {#generated_files} (though more precisely the
+      # {#build_step}.)
+      #
+      # This method is responsible for one thing:
+      #
+      # - yielding a {StorageLocations::BaseLocation} and the path (as String) to the files
+      #   location in the temporary working space.
+      #
+      # This method allows child classes to modify the file_uris for example, to filter out files
+      # that are not of the correct type or as a means of having "this" generator depend on another
+      # generator.  The {Generators::HocrGenerator} requires that the input_location be a monochrome;
+      # so it does conversions of each given input_location.  The {Generators::PdfSplitGenerator} uses
+      # this method to take each given PDF and generated one image per page of each given PDF.
+      # Those images are then treated as the requisite locations.
+      #
+      # @yieldparam input_location [StorageLocations::BaseLocations] the from location as represented by
+      #             a URI.
+      # @yieldparam tmp_file_path [String] where to find the input_location's file in the processing tmp
+      #             space.
+      #
+      # @see Generators::HocrGenerator
+      # @see Generators::PdfSplitGenerator
+      def with_each_requisite_location_and_tmp_file_path
+        input_files.each do |input_location|
+          input_location.with_existing_tmp_path do |tmp_file_path|
+            yield(input_location, tmp_file_path)
+          end
+        end
+      end
+
+      ##
+      # @return [Array<StorageLocations::BaseLocation>]
+      def input_files
+        @input_files ||= input_uris.map do |file_uri|
+          DerivativeRodeo::StorageLocations::BaseLocation.from_uri(file_uri)
+        end
+      end
+
+      ##
+      # Returns the location destination for the given :input_file.  The file at the location
+      # destination might exist or might not.  In the case of non-existence, then the {#build_step}
+      # will create the file.
+      #
+      # @param input_location [StorageLocations::BaseLocation]
+      #
+      # @return [StorageLocations::BaseLocation] the derivative of the given :file based on either the
+      #         {#output_location_template} or {#preprocessed_location_template}.
+      #
+      # @see [StorageLocations::BaseLocation#exist?]
+      def destination(input_location)
+        output_location = input_location.derived_file_from(template: output_location_template)
+
+        return output_location if output_location.exist?
+        return output_location unless preprocessed_location_template
+
+        preprocessed_location = input_location.derived_file_from(template: preprocessed_location_template)
+        # We only want
+        return preprocessed_location if preprocessed_location&.exist?
+
+        # NOTE: The file does not exist at the output_location; but we pass this information along so
+        # that the #build_step knows where to write the file.
+        output_location
+      end
+
+      ##
+      # A bit of indirection to create a common interface for running a shell command.
+      #
+      # @param command [String]
+      # @return [String]
+      def run(command)
+        logger.debug "* Start command: #{command}"
+        # TODO: What kind of error handling do we want?
+        result = `#{command}`
+        logger.debug "* Result: \n*  #{result.gsub("\n", "\n*  ")}"
+        logger.debug "* End  command: #{command}"
+        result
+      end
+    end
+  end
+end
+
+Dir.glob(File.join(__dir__, '**/*')).sort.each do |file|
+  require file unless File.directory?(file) || file.match?(/base_generator/)
+end

data/lib/derivative_rodeo/generators/concerns/copy_file_concern.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module DerivativeRodeo
+  module Generators
+    ##
+    # A helper module for copying files from one location to another.
+    module CopyFileConcern
+      ##
+      # Copy files from one adapter to another.
+      #
+      # @param output_location [StorageLocations::BaseLocation]
+      # @param input_tmp_file_path [String]
+      #
+      # @return [StorageLocations::BaseLocation]
+      def build_step(output_location:, input_tmp_file_path:, **)
+        copy(input_tmp_file_path, output_location)
+      end
+
+      ##
+      # @api private
+      def copy(from_path, output_location)
+        output_location.with_new_tmp_path do |out_path|
+          # We can move here because we are done with the tmp file after this.
+          FileUtils.mv(from_path, out_path)
+        end
+      end
+    end
+  end
+end

data/lib/derivative_rodeo/generators/copy_generator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require 'derivative_rodeo/generators/concerns/copy_file_concern'
+
+module DerivativeRodeo
+  module Generators
+    ##
+    # Responsible for moving files from one storage adapter to another.
+    class CopyGenerator < BaseGenerator
+      self.output_extension = StorageLocations::SAME
+
+      include CopyFileConcern
+    end
+  end
+end

data/lib/derivative_rodeo/generators/hocr_generator.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module DerivativeRodeo
+  module Generators
+    ##
+    # Responsible for finding or creating a hocr file (or configured :output_suffix) using
+    # tesseract. Will create and store a monochrome derivative if one is not found.
+    #
+    # @see http://tesseract-ocr.github.io
+    #
+    # From `tesseract -h`
+    #
+    #   Usage:
+    #     tesseract --help | --help-extra | --version
+    #     tesseract --list-langs
+    #     tesseract imagename outputbase [options...] [configfile...]
+    class HocrGenerator < BaseGenerator
+      ##
+      # @!group Class Attributes
+      # @!attribute [rw]
+      # Command arena variables to for tesseract command; default `nil`.
+      # Should be a space seperated string of KEY=value pairs
+      #
+      # @example
+      #   # this works for space_stone aws lambda
+      #   Derivative::Rodeo::Step::HocrStep.command_environment_variables =
+      #     'OMP_THREAD_LIMIT=1 TESSDATA_PREFIX=/opt/share/tessdata LD_LIBRARY_PATH=/opt/lib PATH=/opt/bin:$PATH'
+      class_attribute :command_environment_variables, default: "OMP_THREAD_LIMIT=1"
+
+      ##
+      # @!attribute [rw]
+      # Additional options to send to tesseract command; default `nil`.
+      class_attribute :additional_tessearct_options, default: nil
+
+      # @!attribute [rw]
+      # The tesseract command's output base; default `:hocr`.
+      class_attribute :output_suffix, default: :hocr
+
+      self.output_extension = 'hocr'
+      # @!endgroup Class Attributes
+
+      ##
+      # Run tesseract on monocrhome file and store the resulting output in the configured
+      # {.output_extension} (default 'hocr')
+      #
+      # @param output_location [StorageLocations::BaseLocation]
+      # @param input_tmp_file_path [String]
+      #
+      # @return [StorageLocations::BaseLocation]
+      #
+      # @see #requisite_files
+      def build_step(output_location:, input_tmp_file_path:, **)
+        tesseractify(input_tmp_file_path, output_location)
+      end
+
+      ##
+      # @param builder [Class, #generated_files]
+      #
+      # When generating a hocr file from an image, we've found the best results are when we're
+      # processing a monochrome image.  As such, this generator will auto-convert a given image to
+      # monochrome.
+      #
+      # @yieldparam file [StorageLocations::BaseLocation]
+      # @yieldparam tmp_path [String]
+      #
+      # @see BaseGenerator#with_each_requisite_location_and_tmp_file_path for further discussion
+      def with_each_requisite_location_and_tmp_file_path(builder: MonochromeGenerator)
+        mono_location_template = output_location_template.gsub(self.class.output_extension, builder.output_extension)
+        requisite_files ||= builder.new(input_uris: input_uris, output_location_template: mono_location_template).generated_files
+        requisite_files.each do |input_location|
+          input_location.with_existing_tmp_path do |tmp_file_path|
+            yield(input_location, tmp_file_path)
+          end
+        end
+      end
+
+      ##
+      # @api private
+      #
+      # Call `tesseract` on the monochrome file and store the resulting hocr
+      # in the tmp_path
+      #
+      # @param input_tmp_file_path [String].
+      # @param output_location [StorageLocations::BaseLocation]
+      def tesseractify(input_tmp_file_path, output_location)
+        output_location.with_new_tmp_path do |out_tmp_path|
+          run_tesseract(input_tmp_file_path, out_tmp_path)
+        end
+      end
+
+      ##
+      # @param in_path [String] the source of the file
+      # @param out_path [String]
+      def run_tesseract(in_path, out_path)
+        # we pull the extension off the output path, because tesseract will add it back
+        cmd = ""
+        cmd += command_environment_variables + " " if command_environment_variables.present?
+        # TODO: The line of code could mean we had a file with multiple periods and we'd just
+        # replace the first one.  Should we instead prefer the following:
+        #
+        # `out_path.split(".")[0..-2].join('.') + ".#{output_extension}"`
+        output_to_path = out_path.sub('.' + output_extension, '')
+        cmd += "tesseract #{in_path} #{output_to_path}"
+        cmd += " #{additional_tessearct_options}" if additional_tessearct_options.present?
+        cmd += " #{output_suffix}"
+
+        # TODO: capture output in case of exceptions; perhaps delegate that to the #run method.
+        run(cmd)
+      end
+    end
+  end
+end

data/lib/derivative_rodeo/generators/monochrome_generator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DerivativeRodeo
+  module Generators
+    ##
+    # Take images an ensures that we have a monochrome derivative of those images.
+    class MonochromeGenerator < BaseGenerator
+      # TODO: Can we assume a tiff?
+      self.output_extension = 'mono.tiff'
+
+      ##
+      # @param input_location [StorageLocations::BaseLocation]
+      # @param output_location [StorageLocations::BaseLocation]
+      # @return [StorageLocations::BaseLocation]
+      def build_step(input_location:, output_location:, input_tmp_file_path:)
+        image = DerivativeRodeo::Services::ImageService.new(input_tmp_file_path)
+        if image.monochrome?
+          # The input_location is already have a monochrome file, no need to run conversions.
+          input_location
+        else
+          # We need to write monochromify and the image.
+          monochromify(output_location, image)
+        end
+      end
+
+      ##
+      # Convert the above image to a file at the monochrome_path
+      #
+      # @param monochrome_file [StorageLocations::BaseLocation]
+      # @param image [Services::ImageService]
+      # @return [StorageLocations::BaseLocation]
+      def monochromify(monochrome_file, image)
+        monochrome_file.with_new_tmp_path do |monochrome_path|
+          image.convert(destination: monochrome_path, monochrome: true)
+        end
+      end
+    end
+  end
+end

data/lib/derivative_rodeo/generators/pdf_split_generator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require 'derivative_rodeo/generators/concerns/copy_file_concern'
+
+module DerivativeRodeo
+  module Generators
+    ##
+    # This class is responsible for splitting each given PDF (e.g. {#input_files}) into one image
+    # per page (e.g. {#with_each_requisite_location_and_tmp_file_path}).  We need to ensure that we
+    # have each of those image files in S3/file storage then enqueue those files for processing.
+    class PdfSplitGenerator < BaseGenerator
+      ##
+      # There is a duplication  of the splitter name.
+      #
+      # @see #pdf_splitter_name
+      self.output_extension = "tiff"
+
+      include CopyFileConcern
+
+      ##
+      # @param name [#to_s] Convert the given name into the resulting {Services::PdfSplitter::Base}.
+      #
+      # @return [#call, Services::PdfSplitter::Base]
+      def pdf_splitter(name: pdf_splitter_name)
+        @pdf_splitter ||= Services::PdfSplitter.for(name)
+      end
+
+      ##
+      # @return [Symbol]
+      #
+      # @see .output_extension
+      def pdf_splitter_name
+        output_extension.to_s.split(".").last.to_sym
+      end
+
+      ##
+      # @api public
+      #
+      # Take the given PDF(s) and into one image per page.  Remember that the URL should account for
+      # the page number.
+      #
+      # When we have two PDFs (10 pages and 20 pages respectively), we will have 30 requisite files;
+      # the files must have URLs that associate with their respective parent PDFs.
+      #
+      # @yieldparam image_location [StorageLocations::FileLocation] the file and adapter logic.
+      # @yieldparam image_path [String] where to find this file in the tmp space
+      #
+      # @see BaseGenerator#with_each_requisite_location_and_tmp_file_path for further discussion
+      def with_each_requisite_location_and_tmp_file_path
+        input_files.each do |input_location|
+          input_location.with_existing_tmp_path do |input_tmp_file_path|
+            image_paths = pdf_splitter.call(input_tmp_file_path, baseid: input_location.file_basename, tmpdir: File.dirname(input_tmp_file_path))
+            image_paths.each do |image_path|
+              image_location = StorageLocations::FileLocation.new("file://#{image_path}")
+              yield(image_location, image_path)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/derivative_rodeo/generators/thumbnail_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DerivativeRodeo
+  module Generators
+    ##
+    # This generator is responsible for converting a given binary into a thumbnail.  As of
+    # <2023-05-22 Mon>, we're needing to generate thumbnails for PDFs and images.
+    class ThumbnailGenerator < BaseGenerator
+      ##
+      # We want to mirror the same file "last" extension as described in Hyrax.
+      #
+      # @see https://github.com/samvera/hyrax/blob/426575a9065a5dd3b30f458f5589a0a705ad7be2/app/services/hyrax/file_set_derivatives_service.rb
+      self.output_extension = 'thumbnail.jpeg'
+
+      ##
+      # @param output_location [StorageLocations::BaseLocation]
+      # @param input_tmp_file_path [String] the location of the file that we can use for processing.
+      #
+      # @return [StorageLocations::BaseLocation]
+      def build_step(output_location:, input_tmp_file_path:, **)
+        output_location.with_new_tmp_path do |out_tmp_path|
+          thumbnify(path_of_file_to_create_thumbnail_from: input_tmp_file_path, path_for_thumbnail_output: out_tmp_path)
+        end
+      end
+
+      ##
+      # Convert the file found at :path_to_input into a thumbnail, writing it to the
+      # :path_for_thumbnail_output
+      #
+      # @param path_of_file_to_create_thumbnail_from [String]
+      # @param path_for_thumbnail_output [String]
+      def thumbnify(path_of_file_to_create_thumbnail_from:, path_for_thumbnail_output:)
+        # @todo the dimensions might not be always 200x150, figure out a way to make it dynamic
+        `convert #{path_of_file_to_create_thumbnail_from} -thumbnail '200x150>' -flatten #{path_for_thumbnail_output}`
+      end
+    end
+  end
+end

data/lib/derivative_rodeo/generators/word_coordinates_generator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DerivativeRodeo
+  module Generators
+    ##
+    # Generate the word coordinates (as JSON) from the given input_uris.
+    #
+    # @note Assumes that we're receiving a HOCR file (generated via {HocrGenerator}).
+    class WordCoordinatesGenerator < BaseGenerator
+      self.output_extension = "coordinates.json"
+
+      ##
+      # @param output_location [StorageLocations::BaseLocation]
+      # @param input_tmp_file_path [String] the location of the file that we can use for processing.
+      #
+      # @return [StorageLocations::BaseLocation]
+      #
+      # @see #requisite_files
+      def build_step(output_location:, input_tmp_file_path:, **)
+        output_location.with_new_tmp_path do |output_tmp_file_path|
+          convert_to_coordinates(path_to_hocr: input_tmp_file_path, path_to_coordinate: output_tmp_file_path)
+        end
+      end
+
+      private
+
+      ##
+      # @param path_to_hocr [String]
+      # @param path_to_coordinate [String]
+      # @param service [#call, Services::ExtractWordCoordinatesFromHocrSgmlService]
+      def convert_to_coordinates(path_to_hocr:, path_to_coordinate:, service: Services::ExtractWordCoordinatesFromHocrSgmlService)
+        hocr_html = File.read(path_to_hocr)
+        File.open(path_to_coordinate, "w+") do |file|
+          file.puts service.call(hocr_html)
+        end
+      end
+    end
+  end
+end

data/lib/derivative_rodeo/services/base_service.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DerivativeRodeo
+  module Services
+    ##
+    # @api private
+    #
+    class BaseService
+    end
+  end
+end
+
+Dir.glob(File.join(__dir__, '**/*')).sort.each do |file|
+  require file unless File.directory?(file) || file.match?(/base_service/)
+end

data/lib/derivative_rodeo/services/convert_uri_via_template_service.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module DerivativeRodeo
+  module Services
+    ##
+    #
+    # A service to convert an array of :from_uris to :to_uris via a :template.
+    #
+    # @see .call
+    class ConvertUriViaTemplateService
+      DIR_PARTS_REPLACEMENT_REGEXP = %r{\{\{\s*dir_parts\[(?<left>\-?\d+)\.\.(?<right>\-?\d+)\]\s*\}\}}.freeze
+      FILENAME_REPLACEMENT_REGEXP = %r{\{\{\s*filename\s*\}\}}.freeze
+      BASENAME_REPLACEMENT_REGEXP = %r{\{\{\s*basename\s*\}\}}.freeze
+      EXTENSION_REPLACEMENT_REGEXP = %r{\{\{\s*extension\s*\}\}}.freeze
+      SCHEME_REPLACEMENT_REGEXP = %r{\{\{\s*scheme* \}\}}.freeze
+      SCHEME_FOR_URI_REGEXP = %r{^(?<from_scheme>[^:]+)://}.freeze
+      attr_accessor :from_uri, :template, :adapter, :separator, :uri, :from_scheme, :path, :parts, :dir_parts, :filename, :basename, :extension, :template_without_query, :template_query
+
+      ##
+      # Convert the given :from_uris to a different list of uris based on the given :template.
+      #
+      # Components of the template:
+      #
+      # - basename :: the file's basename without extension
+      # - extension :: the file's extension with the period
+      # - dir_parts :: the directory parts in which the file exists; excludes the scheme
+      # - filename :: a convenience that could be represented as `basename.extension`
+      # - scheme :: a convenience that could be represented as `basename.extension`
+      #
+      # The specs demonstrate the use cases.
+      #
+      # @param from_uri [String] Of the form "scheme://dir/parts/basename.extension"
+      # @param template [String] Another URI that may contain path_parts or scheme template values.
+      # @param adapter [StorageLocations::Location]
+      # @param separator [String]
+      #
+      # @return [String]
+      #
+      # @example
+      #   DerivativeRodeo::Services::ConvertUriViaTemplateService.call(
+      #     from_uris: ["file:///path1/A/file.pdf", "file:///path2/B/file.pdf"],
+      #     template: "file:///dest1/{{dir_parts[-2..-1]}}/{{filename}}")
+      #   => ["file:///dest1/path2/A/file.pdf", "file:///dest1/path2/B/file.pdf"]
+      #
+      #   DerivativeRodeo::Services::ConvertUriViaTemplateService.call(
+      #     from_uris: ["file:///path1/A/file.pdf", "aws:///path2/B/file.pdf"],
+      #     template: "file:///dest1/{{dir_parts[-1..-1]}}/{{ filename }}")
+      #   => ["file:///dest1/A/file.pdf", "aws:///dest1/B/file.pdf"]
+      def self.call(from_uri:, template:, adapter: nil, separator: "/")
+        new(from_uri: from_uri, template: template, adapter: adapter, separator: separator).call
+      end
+
+      def initialize(from_uri:, template:, adapter: nil, separator: "/")
+        @from_uri = from_uri
+        @template = template
+        @adapter = adapter
+        @separator = separator
+
+        @uri, _query = from_uri.split("?")
+        @from_scheme, @path = uri.split("://")
+        @parts = @path.split(separator)
+        @dir_parts = @parts[0..-2]
+        @filename = @parts[-1]
+        @basename = File.basename(@filename, ".*")
+        @extension = File.extname(@filename)
+
+        @template_without_query, @template_query = template.split("?")
+      end
+
+      def call
+        to_uri = template_without_query.gsub(DIR_PARTS_REPLACEMENT_REGEXP) do |text|
+          # The yielded value does not include capture regions.  So I'm re-matching things.
+          # capture region to handle this specific thing.
+          match = DIR_PARTS_REPLACEMENT_REGEXP.match(text)
+          dir_parts[(match[:left].to_i)..(match[:right].to_i)].join(separator)
+        end
+
+        to_uri = to_uri.gsub(SCHEME_REPLACEMENT_REGEXP, (adapter&.scheme || from_scheme))
+        to_uri = to_uri.gsub(EXTENSION_REPLACEMENT_REGEXP, extension)
+        to_uri = to_uri.gsub(BASENAME_REPLACEMENT_REGEXP, basename)
+        to_uri.gsub!(FILENAME_REPLACEMENT_REGEXP, filename)
+        to_uri = "#{to_uri}?#{template_query}" if template_query
+        to_uri
+      end
+    end
+  end
+end