parameter_substitution 0.3.0.pre.1 → 1.1.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6cc065caf5495a6eb293189475b549b2143a422f
-  data.tar.gz: cb4cc3f82eb1ecd6163ad7cbf432cc2454f0e497
+SHA256:
+  metadata.gz: 01e0aa08d4f8130fd493c54e5958aed36159746476fa168180407401584aaaf6
+  data.tar.gz: 4bc6bd8c7b94edc3690c474f8b7ece56d6e9aadf1d825e14bcc7413a2b1fe7a9
 SHA512:
-  metadata.gz: dead877cadef6706c2f0bfc833ce677c45c816e786a33b3ca9a32e4b9a3f12e9c473dfda8bef88c4dbb296b97b80d3811327eaa5ee61d1c6b65ffbc014840aa4
-  data.tar.gz: 713b75455392a1dcd45326d8a1d6143b4de25177e5036040e50e3404a29107f5058109c2bf04878bb29cb517358d5ea4774703654489542ecc9af9f94be30c83
+  metadata.gz: e8c2436cdce9ccaf16e02fe368aaa22337d43af01cdd1c35677a7fccf8af19db089c7ebfffbf859b52b3188b7323b884d8ed7cc57f63935afc7fb2d3f1075829
+  data.tar.gz: 1b1b2548aaa1a4e6ed4940c4589e65f3247d76ca9aa07089d0c7cde701acecb1704b12018b57b1661ce89d4b47416c337c9ee3aaab3a7b7c208b8f88263349ae

data/lib/parameter_substitution.rb

@@ -2,6 +2,7 @@
 
 # See lib/parameter_substitution/readme.md
 
+require 'active_support/all'
 require "parameter_substitution/context"
 require "parameter_substitution/parse_error"
 require "parameter_substitution/parser"
@@ -18,8 +19,6 @@ Dir[File.dirname(__FILE__) + '/parameter_substitution/formatters/*.rb'].each do
   require file
 end
 
-require 'active_support/all'
-
 class ParameterSubstitution
   class SubstitutionError < StandardError; end
 

data/lib/parameter_substitution/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution
+  class Configuration
+    attr_reader :custom_formatters
+
+    def custom_formatters=(custom_formatters)
+      check_that_classes_are_classes(custom_formatters)
+      check_for_correct_base_class(custom_formatters)
+
+      @custom_formatters = custom_formatters
+    end
+
+    private
+
+    def check_that_classes_are_classes(custom_formatters)
+      bad_formatters = custom_formatters.reject do |_formatter, klass|
+        klass.is_a?(Class)
+      end
+
+      raise_if_any(bad_formatters, "must be of type Class")
+    end
+
+    def check_for_correct_base_class(custom_formatters)
+      bad_formatters = custom_formatters.reject do |_formatter, klass|
+        klass.ancestors.include?(ParameterSubstitution::Formatters::Base)
+      end
+
+      raise_if_any(bad_formatters, "must inherit from ParameterSubstitution::Formatters::Base and did not")
+    end
+
+    def raise_if_any(formatters, failure_context)
+      if formatters.any?
+        log_context = formatters.map { |formatter, klass| [formatter, klass].join(": ") }.join(", ")
+        raise StandardError, "CONFIGURATION ERROR: custom_formatters (#{log_context}) #{failure_context}."
+      end
+    end
+  end
+end

data/lib/parameter_substitution/context.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'invoca/utils/enumerable'
+
+class ParameterSubstitution
+  class Context
+    attr_reader :input, :mapping, :required_parameters, :parameter_start, :parameter_end,
+                :destination_encoding, :allow_unknown_replacement_parameters, :allow_nil,
+                :allow_unmatched_parameter_end
+
+    def initialize(
+      input:,
+      mapping:,
+      required_parameters: [],
+      parameter_start: "<",
+      parameter_end: ">",
+      destination_encoding: :text,
+      allow_unknown_replacement_parameters: false,
+      allow_nil: false,
+      allow_unmatched_parameter_end: false
+    )
+
+      @input = input
+      @mapping = mapping
+      @required_parameters = required_parameters
+      @parameter_start = parameter_start
+      @parameter_end = parameter_end
+      @destination_encoding = destination_encoding
+      @allow_unknown_replacement_parameters = allow_unknown_replacement_parameters
+      @allow_nil = allow_nil
+      @allow_unmatched_parameter_end = allow_unmatched_parameter_end
+    end
+
+    def allow_unknown_params?(inside_quotes)
+      allow_unknown_replacement_parameters || (destination_encoding == :json && inside_quotes)
+    end
+
+    def mapping_has_key?(key)
+      downcased_mapping.key?(key.downcase)
+    end
+
+    def mapped_value(key)
+      downcased_mapping[key.downcase]
+    end
+
+    def mapping_keys
+      mapping.keys
+    end
+
+    def formatted_arg_list(arg_list)
+      arg_list.sort.map { |arg| "'#{arg}'" }.join(", ")
+    end
+
+    def duplicate_raw
+      ParameterSubstitution::Context.new(
+        input: @input,
+        mapping: @mapping,
+        required_parameters: @required_parameters,
+        parameter_start: @parameter_start,
+        parameter_end: @parameter_end,
+        destination_encoding: :raw,
+        allow_unknown_replacement_parameters: @allow_unknown_replacement_parameters,
+        allow_nil: @allow_nil,
+        allow_unmatched_parameter_end: @allow_unmatched_parameter_end
+      )
+    end
+
+    private
+
+    def downcased_mapping
+      @downcase_mapping ||= mapping.build_hash { |k, v| [k.downcase, v] }
+    end
+  end
+end

data/lib/parameter_substitution/encoder.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'active_support/core_ext/string/inflections'
+require 'builder'
+
+class ParameterSubstitution
+  class Encoder
+    ENCODINGS = {
+      cgi:            "CGI encode - for html parameters",
+      html:           "HTML encode - for html content",
+      xml:            "XML encode",
+      angle_brackets: "Content converted to a string and placed in angle brackets",
+      json:           "JSON encode",
+      raw:            "content is not changed",
+      text:           "content is converted to a string"
+    }.keys
+
+    class << self
+      def encode(value, destination_encoding, source_encoding, parameter_name, inside_quotes)
+        destination_encoding.in?(ENCODINGS) or raise "unknown encoding #{destination_encoding}"
+        source_encoding.in?(ENCODINGS) or raise "unknown encoding #{source_encoding}"
+
+        result =
+          if source_encoding == destination_encoding
+            if destination_encoding == :json && inside_quotes
+              value.to_json
+            else
+              value
+            end
+          else
+            case destination_encoding
+            when :cgi
+              CGI.escape(value.to_s)
+            when :html
+              CGI.escapeHTML(value.to_s)
+            when :xml
+              value_for_xml(parameter_name, value)
+            when :angle_brackets
+              "<#{value}>"
+            when :json
+              value.to_json
+            when :raw
+              value
+            when :text
+              value.to_s
+            else
+              raise "unexepected escaping #{destination_encoding}"
+            end
+          end
+
+        if destination_encoding == :json && inside_quotes
+          if value.is_a?(String)
+            result[1...-1]
+          else
+            result.to_json[1...-1]
+          end
+        else
+          result
+        end
+      end
+
+      private
+
+      def value_for_xml(key, value)
+        if value.is_a?(Array)
+          array_to_xml(key, value)
+        else
+          CGI.escapeHTML(value.to_s)
+        end
+      end
+
+      def array_to_xml(key, value)
+        tag_name = key_to_tag_name(key)
+        buffer = +""
+        builder = Builder::XmlMarkup.new(target: buffer)
+        value.each { |tag_value| builder.tag!(tag_name, tag_value) }
+        buffer
+      end
+
+      def key_to_tag_name(key)
+        key.gsub('ids_', 'id_').singularize
+      end
+    end
+  end
+end

data/lib/parameter_substitution/expression.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'invoca/utils'
+
+class ParameterSubstitution
+  class Expression
+    attr_reader :expression_list, :context
+
+    def initialize(expression_list, context)
+      @expression_list = expression_list
+      @context = context
+    end
+
+    def validate
+      validate_required_parameters
+      validate_unknown_parameters
+      validate_expressions
+    end
+
+    def evaluate
+      if context.destination_encoding == :raw && @expression_list.size == 1
+        # When using the destination encoding of raw, the output should preserve the type from the mapping if the substitution
+        # is the full expression.  So the input of '<id>' with the mapping { 'id' => 1 } should return 1 and not "1".
+        @expression_list.first.evaluate(:OutsideString, only_expression: true)
+      else
+        map_expressions_with_quote_tracking do |expression, inside_quotes|
+          expression.evaluate(inside_quotes).to_s
+        end.join("")
+      end
+    end
+
+    def warnings
+      unknown_parameters_message
+    end
+
+    def parameter_and_method_warnings
+      unknown_messages = unknown_parameter_messages + unknown_method_messages
+      unknown_messages.empty? ? nil : unknown_messages.uniq
+    end
+
+    def substitution_parameter_names
+      @expression_list.map_compact(&:parameter_name)
+    end
+
+    def method_names
+      @expression_list.reduce([]) do |all_method_names, expression|
+        all_method_names + methods_used_by_expression(expression)
+      end
+    end
+
+    def methods_used_by_expression(expression)
+      if (method_calls = expression.try(:method_calls))
+        method_calls.reduce([]) do |all_method_call_names, method_call|
+          all_method_call_names + [method_call.name.to_s] + method_call.arguments&.flat_map { |arg| arg.try(:method_names) }.compact # arg.try returns 'nil' when no methods are called; only method names needed
+        end
+      else
+        []
+      end
+    end
+
+    private
+
+    def validate_required_parameters
+      matched_parameters = substitution_parameter_names.uniq
+      required_parameters = @context.required_parameters
+      if !required_parameters.empty? && (missing_fields = required_parameters.reject { |rt| rt.in?(matched_parameters) }).any?
+        raise ParameterSubstitution::ParseError,
+              "The following #{pluralize_text("field", missing_fields.size)} must be included: #{@context.formatted_arg_list(missing_fields)}"
+      end
+    end
+
+    def validate_unknown_parameters
+      unless @context.allow_unknown_replacement_parameters
+        if (message = unknown_parameters_message)
+          raise ParameterSubstitution::ParseError, message
+        end
+      end
+    end
+
+    def validate_expressions
+      map_expressions_with_quote_tracking do |expression, inside_quotes|
+        expression.validate(inside_quotes)
+      end
+    end
+
+    def unknown_method_messages
+      unknown_parameter_methods.map_compact do |param, methods|
+        method_string = pluralize_text("method", methods.size)
+        unless methods.empty? || unknown_parameters.include?(param)
+          "Unknown #{method_string} #{@context.formatted_arg_list(methods)} used on parameter '#{param}'"
+        end
+      end
+    end
+
+    def unknown_parameter_messages
+      unknown_parameters.map do |param|
+        unknown_methods_for_param = unknown_parameter_methods[param]
+        method_string = pluralize_text("method", unknown_methods_for_param.size)
+        unknown_method_message = if unknown_methods_for_param.empty?
+                                   ''
+                                 else
+                                   " and #{method_string} #{@context.formatted_arg_list(unknown_methods_for_param)}"
+                                 end
+        "Unknown param '#{param}'#{unknown_method_message}"
+      end
+    end
+
+    def unknown_parameters_message
+      unless unknown_parameters.empty?
+        "Unknown replacement #{pluralize_text("parameter", unknown_parameters.size)} #{@context.formatted_arg_list(unknown_parameters)}"
+      end
+    end
+
+    def map_expressions_with_quote_tracking
+      inside_quotes = false
+      @expression_list.map do |expression|
+        result = yield expression, inside_quotes
+        inside_quotes = expression.ends_inside_quotes(started_inside_quotes: inside_quotes)
+        result
+      end
+    end
+
+    def unknown_parameters
+      @unknown_parameters ||=
+        map_expressions_with_quote_tracking do |expression, inside_quotes|
+          expression.unknown_parameters(inside_quotes)
+        end.compact
+    end
+
+    def unknown_parameter_methods
+      @expression_list.select(&:parameter_name).reduce({}) do |hash, expression|
+        hash[expression.parameter_name] ||= []
+        hash[expression.parameter_name].push(*missing_methods(expression))
+        hash
+      end
+    end
+
+    def missing_methods(expression)
+      (methods_used_by_expression(expression) - ParameterSubstitution::Formatters::Manager.all_formats.map { |k, _v| k.to_s })
+    end
+
+    def pluralize_text(text, amount)
+      text + (amount > 1 ? 's' : '')
+    end
+  end
+end

data/lib/parameter_substitution/formatters/add_prefix.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::AddPrefix < ParameterSubstitution::Formatters::Base
+  def self.description
+    "This takes a prefix as a constructor parameter and prepends it to the value. If the value is blank, nothing is shown."
+  end
+
+  def self.has_parameters?
+    true
+  end
+
+  def initialize(prefix)
+    @prefix = prefix
+  end
+
+  def format(value)
+    value.presence && (@prefix + value.to_s)
+  end
+end

data/lib/parameter_substitution/formatters/base.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution
+  module Formatters
+    class Base
+      class << self
+        def description
+          raise NotImplementedError, "Derived classes must implement"
+        end
+
+        def format(_value)
+          raise NotImplementedError, "Derived classes must implement"
+        end
+
+        def key
+          name.split('::').last.gsub(/Format/, '').underscore
+        end
+
+        # Formats that have parameters are constructed and format is called on the instance.
+        # Formats without parameters have format called on the class.
+        def has_parameters?
+          false
+        end
+
+        def encoding
+          :raw
+        end
+
+        # TODO: Move out of the base class.
+        def parse_duration(duration)
+          if duration.is_a?(String)
+            if duration =~ /([\d]{1,2})\:([\d]{1,2})\:([\d]{1,2})/
+              (Regexp.last_match(1).to_i.hours + Regexp.last_match(2).to_i.minutes + Regexp.last_match(3).to_i.seconds).to_i
+            elsif duration =~ /([\d]{1,2})\:([\d]{1,2})/
+              (Regexp.last_match(1).to_i.minutes + Regexp.last_match(2).to_i.seconds).to_i
+            else
+              duration.to_i
+            end
+          else
+            duration.to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/parameter_substitution/formatters/blank_if_nil.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::BlankIfNil < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Converts nil values to empty strings: ''"
+  end
+
+  def self.format(value)
+    value.nil? ? "" : value
+  end
+end