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

data/lib/parameter_substitution/formatters/json_parse.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::JsonParse < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Attempts to parse strings as JSON. If valid, passes along the parsed object, if not valid json, or not a string, passes the json encoded value."
+  end
+
+  def self.has_parameters?
+    false
+  end
+
+  def self.encoding
+    :json
+  end
+
+  def self.format(value)
+    if value.is_a?(String)
+      JSON.parse(value)
+      value
+    else
+      value.to_json
+    end
+  rescue JSON::ParserError
+    value.to_json
+  end
+end

data/lib/parameter_substitution/formatters/left.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::Left < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Takes a single n argument. Returns the left most n characters from the input."
+  end
+
+  def self.has_parameters?
+    true
+  end
+
+  def initialize(character_count)
+    @character_count = character_count
+  end
+
+  def format(value)
+    value.to_s[0, @character_count]
+  end
+end

data/lib/parameter_substitution/formatters/lookup.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::Lookup < ParameterSubstitution::Formatters::Base
+  def self.description
+    "This takes a table as a constructor parameter and performs a lookup from the value. If the value exists as a key in the lookup table, the key's value is returned."
+  end
+
+  def self.has_parameters?
+    true
+  end
+
+  def initialize(lookup_table)
+    @lookup_table = lookup_table
+  end
+
+  def format(value)
+    @lookup_table[value.to_s]
+  end
+end

data/lib/parameter_substitution/formatters/lower.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::Lower < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Converts to string and returns all characters lowercased, preserves nil."
+  end
+
+  def self.format(value)
+    value&.to_s&.downcase
+  end
+end

data/lib/parameter_substitution/formatters/manager.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution
+  module Formatters
+    class Manager
+      class << self
+        def find(key)
+          all_formats[key.to_s]
+        end
+
+        def all_formats
+          default_formats.merge(custom_formatters_if_any)
+        end
+
+        def default_formats
+          @default_formats ||= formatter_class_hash(__FILE__, ["ParameterSubstitution", "Formatters"])
+        end
+
+        private
+
+        def formatter_class_hash(manager_file, module_array)
+          Hash[Dir[Pathname.new(manager_file).dirname + '*.rb'].map do |filename|
+            class_key  = File.basename(filename).chomp(".rb")
+            class_name = (module_array + [class_key.camelize.to_s]).join('::').constantize
+            [class_key, class_name]
+          end].except("manager")
+        end
+
+        def custom_formatters_if_any
+          ParameterSubstitution.config&.custom_formatters || {}
+        end
+      end
+    end
+  end
+end

data/lib/parameter_substitution/formatters/md5.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::Md5 < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Generates an md5 hash of the value."
+  end
+
+  def self.format(value)
+    Digest::MD5.hexdigest(value.to_s)
+  end
+end

data/lib/parameter_substitution/formatters/mid.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::Mid < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Takes starting_position and character_count as arguments. Returns the character_count characters starting from starting_position from the input."
+  end
+
+  def self.has_parameters?
+    true
+  end
+
+  def initialize(starting_position, character_count)
+    @starting_position = starting_position
+    @character_count = character_count
+  end
+
+  def format(value)
+    value.to_s[@starting_position, @character_count]
+  end
+end

data/lib/parameter_substitution/formatters/parse_time.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::ParseTime < ParameterSubstitution::Formatters::DateTimeFormat
+  def self.description
+    "Takes format_string as a parameter and uses format_string to parse the input as a time. Does not change the input if the value is not a time."
+    end
+
+  def self.has_parameters?
+    true
+  end
+
+  def initialize(format_string)
+    @format_string = format_string
+  end
+
+  def format(value)
+    value && Time.strptime(value.to_s, @format_string).strftime('%Y-%m-%d %H:%M:%S')
+  rescue ArgumentError => ex
+    # strptime raises argument error if either argument is wrong.
+    ex.message =~ /invalid .*strptime format/ or raise
+    value
+  end
+end

data/lib/parameter_substitution/formatters/right.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::Right < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Takes a single n argument. Returns the right most n characters from the input."
+  end
+
+  def self.has_parameters?
+    true
+  end
+
+  def initialize(character_count)
+    @character_count = character_count
+  end
+
+  def format(value)
+    if (as_string = value.to_s).size > @character_count
+      as_string[-@character_count, @character_count]
+    else
+      as_string
+    end
+  end
+end

data/lib/parameter_substitution/formatters/sha256.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::Sha256 < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Generates a sha256 hash of the value."
+  end
+
+  def self.format(value)
+    Digest::SHA256.hexdigest(value.to_s)
+  end
+end

data/lib/parameter_substitution/formatters/split_after_colon.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::SplitAfterColon < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Returns the portion of a string after the first colon, or nil if there is no colon."
+  end
+
+  def self.format(value)
+    value && value.to_s.split(':', 2)[1]&.lstrip
+  end
+end

data/lib/parameter_substitution/formatters/split_and_find.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::SplitAndFind < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Takes delimiter and index as arguments. Splits the input on delimiters and returns the indexed element. Preserves nil."
+  end
+
+  def self.has_parameters?
+    true
+  end
+
+  def initialize(delimiter, index)
+    @delimiter = delimiter
+    @index = index
+  end
+
+  def format(value)
+    value && value.to_s.split(@delimiter)[@index]
+  end
+end

data/lib/parameter_substitution/formatters/split_before_colon.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::SplitBeforeColon < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Returns the portion of a string before the first colon, or the full string if there is no colon."
+  end
+
+  def self.format(value)
+    value && value.to_s.split(':')[0]
+  end
+end

data/lib/parameter_substitution/formatters/time_with_seconds.rb

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

data/lib/parameter_substitution/formatters/trim.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::Trim < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Returns the input as a string with leading and trailing whitespace removed."
+  end
+
+  def self.format(value)
+    value&.to_s&.strip
+  end
+end

data/lib/parameter_substitution/formatters/upper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution::Formatters::Upper < ParameterSubstitution::Formatters::Base
+  def self.description
+    "Converts to string and returns all characters uppercased, preserves nil."
+  end
+
+  def self.format(value)
+    value&.to_s&.upcase
+  end
+end

data/lib/parameter_substitution/method_call_expression.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution
+  class MethodCallExpression
+    attr_reader :name, :arguments
+
+    def initialize(name, arguments)
+      @name = name
+      @arguments = arguments || []
+    end
+
+    def validate
+      if format_class
+        expected_arguments = format_class&.has_parameters? ? format_class.instance_method(:initialize).arity : 0
+        if @arguments.size != expected_arguments
+          raise ParameterSubstitution::ParseError, "Wrong number of arguments for '#{@name}' expected #{expected_arguments}, received #{@arguments.size}"
+        end
+      else
+        raise ParameterSubstitution::ParseError, "Unknown method '#{@name}'"
+      end
+    end
+
+    def call_method(value)
+      column_formatter.format(value)
+    end
+
+    def encoding
+      format_class.encoding
+    end
+
+    private
+
+    def column_formatter
+      @column_formatter ||= begin
+        if format_class&.has_parameters?
+          format_class.new(*format_args)
+        else
+          format_class
+        end
+      end
+    end
+
+    def format_class
+      @format_class ||= ParameterSubstitution::Formatters::Manager.find(@name)
+    end
+
+    def format_args
+      @arguments.map do |arg|
+        case arg
+        when ParameterSubstitution::Expression
+          arg.evaluate
+        else
+          arg
+        end
+      end
+    end
+  end
+end

data/lib/parameter_substitution/parse_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class ParameterSubstitution
+  class ParseError < StandardError
+  end
+end

data/lib/parameter_substitution/parser.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'parslet'
+#
+# The parser describes the rules of the grammar, and when executed on a string it will
+# either fail with an exception or it will return a structure describing what it found.
+#
+# See the parslet documentation for more detail.
+#
+
+class ParameterSubstitution
+  class Parser < Parslet::Parser
+    def initialize(parameter_start: "<", parameter_end: ">", allow_unmatched_parameter_end: false)
+      @parameter_start = parameter_start
+      @parameter_end = parameter_end
+      @allow_unmatched_parameter_end = allow_unmatched_parameter_end
+      super()
+    end
+
+    root :text_with_substitution_parameters
+
+    rule(:double_quote)    { str("\"")             }
+    rule(:single_quote)    { str("\'")             }
+    rule(:escape)          { str("\\")             }
+    rule(:dot)             { str(".")              }
+    rule(:open_param)      { str(@parameter_start) }
+    rule(:close_param)     { str(@parameter_end)   }
+    rule(:digit)           { match["0-9"]          }
+    rule(:parameter_start) { str("(")              }
+    rule(:parameter_end)   { str(")")              }
+    rule(:space)           { str(" ")              }
+    rule(:space?)          { space.repeat          }
+    rule(:comma)           { space? >> str(",") >> space? }
+
+    rule :double_quoted_string_arg do
+      double_quote >> (escape >> any | double_quote.absent? >> any).repeat.as(:string_arg) >> double_quote
+    end
+
+    rule :single_quoted_string_arg do
+      single_quote >> (escape >> any | single_quote.absent? >> any).repeat.as(:string_arg) >> single_quote
+    end
+
+    rule :string_arg do
+      double_quoted_string_arg | single_quoted_string_arg
+    end
+
+    rule :float_arg do
+      (digit.repeat(1) >> dot >> digit.repeat(1)).as(:float_arg)
+    end
+
+    rule :int_arg do
+      digit.repeat(1).as(:int_arg)
+    end
+
+    rule :nil_arg do
+      str('nil').as(:nil_arg)
+    end
+
+    rule :substitution_parameter_arg do
+      open_param >> parameter.repeat.as(:raw_expression) >> close_param
+    end
+
+    rule :arg do
+      float_arg | string_arg | int_arg | nil_arg | substitution_parameter_arg
+    end
+
+    rule :argument_list do
+      parameter_start >> space? >> (arg >> (comma >> arg).repeat).repeat(0, 1).as(:arg_list) >> space? >> parameter_end
+    end
+
+    rule :method_name do
+      (parameter_start.absent? >> close_param.absent? >> dot.absent? >> any).repeat(1).as(:method_call)
+    end
+
+    rule :method_call do
+      method_name >> argument_list.maybe
+    end
+
+    rule :method_call_list do
+      (dot >> method_call).repeat(0)
+    end
+
+    rule :parameter_name do
+      ((escape >> any) | (open_param.absent? >> close_param.absent? >> dot.absent? >> any)).repeat(1)
+    end
+
+    rule :parameter do
+      parameter_name.as(:parameter_name) >> method_call_list.as(:method_calls)
+    end
+
+    rule :substitution_parameter_with_brackets do
+      open_param >> parameter >> close_param
+    end
+
+    rule :text do
+      text_char =
+        if @allow_unmatched_parameter_end
+          (open_param.absent? >> any)
+        else
+          (open_param.absent? >> close_param.absent? >> any)
+        end
+      text_char.repeat(1).as(:text)
+    end
+
+    rule :text_with_substitution_parameters do
+      (text | substitution_parameter_with_brackets).repeat.as(:expression)
+    end
+  end
+end