parameter_substitution 0.3.0.pre.1 → 0.3.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cc065caf5495a6eb293189475b549b2143a422f
-  data.tar.gz: cb4cc3f82eb1ecd6163ad7cbf432cc2454f0e497
+  metadata.gz: a4e76cde13e88dbac61ee723cb76916c588b362e
+  data.tar.gz: 487e1ee69d64390362c9886781d9a895c7e20b74
 SHA512:
-  metadata.gz: dead877cadef6706c2f0bfc833ce677c45c816e786a33b3ca9a32e4b9a3f12e9c473dfda8bef88c4dbb296b97b80d3811327eaa5ee61d1c6b65ffbc014840aa4
-  data.tar.gz: 713b75455392a1dcd45326d8a1d6143b4de25177e5036040e50e3404a29107f5058109c2bf04878bb29cb517358d5ea4774703654489542ecc9af9f94be30c83
+  metadata.gz: 5ff4a9eae3f8507c666baefc7605c15fefe01129f3852cd246dc1f987fabafb9d172641bbc3c71cfe381c5853d467529bbc6f381536154d942a4ea9720f135fb
+  data.tar.gz: 980e35f7f9987c1378ed90b5df055c3ea1858c42e526cebaa356ec88bf552293d39b707c11dd48d0ecdde1e7b0b48996fc67d732dc4152cfcb49a7985fba39cb

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 'hobo_support/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

data/lib/parameter_substitution/formatters/cgi_unescape.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::CgiUnescape < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Url-decodes the string, preserves nil."
+  end
+
+  def self.format(value)
+    value && CGI.unescape(value.to_s)
+  end
+end

data/lib/parameter_substitution/formatters/compare_string.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::CompareString < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.description
+    "Compares the field to a string and returns results based on the comparison"
+  end
+
+  def self.has_parameters?
+    true
+  end
+
+  def initialize(compare_value, true_value, false_value)
+    @compare_value = compare_value
+    @true_value = true_value
+    @false_value = false_value
+  end
+
+  def format(value)
+    value.to_s.casecmp(@compare_value) == 0 ? @true_value : @false_value
+  end
+end

data/lib/parameter_substitution/formatters/date_time_custom.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'hobo_support'
+
+class ParameterSubstitution::Formatters::DateTimeCustom < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.has_parameters?
+    true
+  end
+
+  def self.description
+    "Formats a Date String with the provided formatting, converts it's time zone, and then converts it to the desired formatting string."
+  end
+
+  def initialize(from_formatting_string, to_formatting_string, from_time_zone, to_time_zone)
+    @parse_options = { from_formatting: from_formatting_string, from_time_zone: from_time_zone }
+    @to_formatting = to_formatting_string
+    @to_time_zone  = to_time_zone
+  end
+
+  def format(value)
+    self.class.parse_to_time(value, @parse_options)._?
+        .in_time_zone(@to_time_zone)._?
+        .strftime(@to_formatting).to_s
+  end
+end

data/lib/parameter_substitution/formatters/date_time_format.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::DateTimeFormat < ParameterSubstitution::Formatters::Base
+  MINIMUM_INTEGER_TIME = Time.new(2000, 0o1, 0o1).to_i
+
+  class << self
+    def parse_to_time(value, parse_options = nil)
+      from_custom_time(value, parse_options) ||
+        from_yyyymmddhhmmssss(value) ||
+        from_unix_time_ms(value) ||
+        from_unix_time_sec(value) ||
+        from_parse(value)
+    rescue ArgumentError => ex
+      ex.message =~ /invalid date/ || ex.message =~ /argument out of range/ or raise
+      nil
+    end
+
+    def from_yyyymmddhhmmssss(value)
+      candidate = value.to_s.strip
+      candidate =~ /\d{14}/ && DateTime.strptime(candidate[0, 14], '%Y%m%d%H%M%S')
+    end
+
+    def from_unix_time_sec(value)
+      (value.to_f > MINIMUM_INTEGER_TIME) && Time.zone.at(value.to_f)
+    end
+
+    def from_unix_time_ms(value)
+      (value.to_i / 1000 > MINIMUM_INTEGER_TIME) && Time.zone.at(value.to_f / 1000)
+    end
+
+    def from_parse(value)
+      Time.zone.parse(value.to_s)
+    end
+
+    def from_custom_time(value, parse_options)
+      # parse_options = { from_formatting: "%m-%d-%Y %h %m %z", from_time_zone: "Pacific Time (US & Canada)" }
+      if parse_options && parse_options[:from_formatting]
+        from_time_zone_with_dst = parse_options[:from_time_zone].presence && parse_time_zone_offset(parse_options[:from_time_zone])
+        DateTime.strptime("#{value} #{from_time_zone_with_dst}", parse_options[:from_formatting])
+      end
+    end
+
+    private
+
+    def parse_time_zone_offset(from_time_zone)
+      if (time_zone = ActiveSupport::TimeZone.new(from_time_zone))
+        time_zone.now.formatted_offset
+      else
+        raise "Invalid from_time_zone argument #{from_time_zone} See ActiveSupport::TimeZone"
+      end
+    end
+  end
+end

data/lib/parameter_substitution/formatters/date_time_iso8601.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::DateTimeIso8601 < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.description
+    "iso8601 - 2017-04-11T15:55:10+00:00"
+  end
+
+  def self.format(value)
+    parse_to_time(value)&.iso8601
+  end
+end

data/lib/parameter_substitution/formatters/date_time_iso8601_zulu.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::DateTimeIso8601Zulu < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.description
+    "iso8601 - 2017-04-11T07:00Z"
+  end
+
+  def self.format(value)
+    parse_to_time(value)&.strftime("%Y-%m-%dT%TZ")
+  end
+end

data/lib/parameter_substitution/formatters/date_time_strftime.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::DateTimeStrftime < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.has_parameters?
+    true
+  end
+
+  def self.description
+    "Formats a DateTime with the provided format string."
+  end
+
+  def initialize(formatting_string)
+    @formatting_string = formatting_string
+  end
+
+  def format(value)
+    self.class.parse_to_time(value)&.strftime(@formatting_string).to_s
+  end
+end

data/lib/parameter_substitution/formatters/date_time_unix_timestamp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::DateTimeUnixTimestamp < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.description
+    "unix timestamp"
+  end
+
+  def self.format(value)
+    parse_to_time(value)&.to_i
+  end
+end

data/lib/parameter_substitution/formatters/date_time_us_all_slashes.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::DateTimeUsAllSlashes < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.description
+    "MM/DD/YYYY/hh/mm/ss"
+  end
+
+  def self.format(value)
+    parse_to_time(value)&.strftime("%m/%d/%Y/%H/%M/%S").to_s
+  end
+end

data/lib/parameter_substitution/formatters/date_time_us_normal.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::DateTimeUsNormal < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.description
+    "MM/DD/YYYY hh:mm"
+  end
+
+  def self.format(value)
+    parse_to_time(value)&.strftime("%m/%d/%Y %H:%M").to_s
+  end
+end

data/lib/parameter_substitution/formatters/date_time_us_seconds.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::DateTimeUsSeconds < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.description
+    "MM/DD/YYYY hh:mm:ss"
+  end
+
+  def self.format(value)
+    parse_to_time(value)&.strftime("%m/%d/%Y %H:%M:%S").to_s
+  end
+end

data/lib/parameter_substitution/formatters/date_time_us_short_am_pm.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::DateTimeUsShortAmPm < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.description
+    "MM/DD/YYYY hh:mm PM"
+  end
+
+  def self.format(value)
+    parse_to_time(value)&.strftime('%-m/%-d/%y %l:%M %p').to_s
+  end
+end

data/lib/parameter_substitution/formatters/date_time_us_short_year.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::DateTimeUsShortYear < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.description
+    "MM/DD/YY hh:mm"
+  end
+
+  def self.format(value)
+    parse_to_time(value)&.strftime("%m/%d/%y %H:%M").to_s
+  end
+end