curly_bracket_parser 0.9.9 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c287b3fc82c91116b7c0ca2f982b81bac5c37e4ca286cd1ea8606de75e0c214f
-  data.tar.gz: 04f59765b1f59ea540d1e152bbc88c0294ca5adc681f30bf1efed3a117cb3afa
+  metadata.gz: 40d43493980369bc381be05ab5ba6b68051555646e5d04c6baaaf0fb90e947a1
+  data.tar.gz: f51aaa5658b30890774a4aa8027e702ada49cabdf575192cdfb4913b9bd1c63e
 SHA512:
-  metadata.gz: 685345c3a8551e0749742550f2dae6784501fefa07318b8e76b2b30fd743c96d1571d2550bee0731a1c1609d82055ec39ff943a6aebf3c39db435d4686d8e01c
-  data.tar.gz: a19c4ffb4fe23ce4945023604aeb34ee28a88bd6f89cf2df08f5eab63151fbb0f1ec6b7ec337f6cc8c0b8d2b57c8dacbfec19cbec7b70b22d68cc8b4caf965c6
+  metadata.gz: 9ca8945a471c2404407c0c19fbbdcc7b19f5a65631f0c8b55d617c24713193c93ebd2a07b57b81e0ae517cd5e4a5ea3483c4006ab0dc64b157f8a88144c5595a
+  data.tar.gz: 14251164b9fcce7ce7f0721c5275655135387a7fd8688ad2f1651cc9b3e52a4f98d8ed411591d505fbefa63f64018bd58daf0dbedb99945522d6b8b94701dbb5

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Matthäus J. N. Beyrle
+Copyright (c) 2020-2021 Matthäus J. N. Beyrle
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,6 +1,9 @@
 # curly_bracket_parser
+![Gem](https://img.shields.io/gem/v/curly_bracket_parser?color=default&style=plastic&logo=ruby&logoColor=red)
+![Gem](https://img.shields.io/gem/dt/curly_bracket_parser?color=blue&style=plastic)
+[![License: MIT](https://img.shields.io/badge/License-MIT-gold.svg?style=plastic&logo=mit)](LICENSE)
 
-Ruby gem providing a simple parser to replace curly brackets `{{like_this}}` inside strings like URLs, texts or even files easily.
+> Ruby gem providing a simple parser to replace curly brackets `{{like_this}}` inside strings like URLs, texts or even files easily.
 
 Additional support for build-in filters and custom filters make them more powerful. `{{example|my_filter}}`
 
@@ -47,15 +50,25 @@ You can either parse variables inside strings or even directly in files.
 
 ```ruby
     url = "https://my-domain.com/items/{{item_id}}"
-    final_url = CurlyBracketParser.parse url, item_id: 123
+    final_url = CurlyBracketParser.parse url, { item_id: 123 }
     # => "https://my-domain.com/items/123"
 ```
 
+Nested variables are supported as well:
+```ruby
+    tmpl = "This is my template with {{my_nested_variable}}";
+    my_nested_variable = "my {{nested}} variable"; 
+    parsed_tmpl = CurlyBracketParser.parse tmpl, { my_nested_variable: my_nested_variable, nested: 'pizza'}
+    # => "This is my template with my pizza variable"
+```
+
+
+
 ### Filters
 
 ```ruby
     url = "https://my-domain.com/catalog/{{item_name|snake_case}}"
-    final_url = CurlyBracketParser.parse url, item_name: 'MegaSuperItem'
+    final_url = CurlyBracketParser.parse url, { item_name: 'MegaSuperItem' }
     # => "https://my-domain.com/catalog/mega_super_item"
 ```
 
@@ -69,10 +82,26 @@ For a list of built-in filters visit [LuckyCase](https://github.com/magynhard/lu
     end
 
     text = "Paul went out and screamed: A{{scream|7times}}h"
-    final_text = CurlyBracketParser.parse text, scream: 'a'
+    final_text = CurlyBracketParser.parse text, { scream: 'a' }
     # => "Paul went out and screamed: Aaaaaaaah"
 ```
 
+
+### Value variables
+
+For special cases you can directly define or set variables inside the template - usually it does only make sense, if you combine them with custom filters.
+
+You can either use quotes to define a string or numbers (integer or floating point) directly.
+
+Empty values are possible as well. They are equal to a empty string.
+
+```ruby
+    tmpl = %Q(This is a {{'string'|pascal_case}} and today is {{"today"|date_filter}}. Peter is {{'1990-10-05'|iso_date_age}} years old. His girlfriends name is {{girl|pascal_case}} and she is {{16|double_number}} years old. This article has been written at {{|date_now_formatted}}`)
+    parsed = CurlyBracketParser.parse tmpl, { girl: "anna" }
+    # => "This is a String and today is 2022-06-27. Peter is 32 years old. His girlfriends name is Anna and she is 32 years old. This article has been written at 6/28/2022, 12:46:40 PM."
+```
+
+
 ### Files
 
 <ins>test.html</ins>
@@ -81,7 +110,7 @@ For a list of built-in filters visit [LuckyCase](https://github.com/magynhard/lu
 ```
 
 ```ruby
-    parsed_file = CurlyBracketParser.parse_file './test.html', title: 'WelcomeAtHome'
+    parsed_file = CurlyBracketParser.parse_file './test.html', { title: 'WelcomeAtHome' }
     # => "<h1>Welcome at home</h1>"
 ```
 
@@ -101,7 +130,7 @@ Because of providing blocks, your variables can dynamically depend on other stat
     text = "You are running version {{version}}"
     CurlyBracketParser.parse text
     # => "You are running version 1.0.2"
-    CurlyBracketParser.parse text, version: '0.7.0'
+    CurlyBracketParser.parse text, { version: '0.7.0' }
     # => "You are running version 0.7.0"
 ```
 

data/lib/curly_bracket_parser/version.rb

@@ -1,3 +1,3 @@
 module CurlyBracketParser
-  VERSION = '0.9.9'.freeze
+  VERSION = '1.1.6'.freeze
 end

data/lib/curly_bracket_parser.rb

@@ -18,8 +18,8 @@ require_relative 'custom_errors/variable_already_registered_error'
 module CurlyBracketParser
 
   # {{variable_name|optional_filter}}
-  VARIABLE_DECODER_REGEX = /{{([^{}\|]+)\|?([^{}\|]*)}}/
-  VARIABLE_REGEX = /{{[^{}]+}}/
+  VARIABLE_DECODER_REGEX = /{{([^{}\|]*)\|?([^{}\|]*)}}/
+  VARIABLE_REGEX = /{{[^{}]*}}/
 
   VALID_DEFAULT_FILTERS = [
     LuckyCase::CASES.keys.map(&:to_s)
@@ -31,40 +31,54 @@ module CurlyBracketParser
   #
   # @param [String] string to parse
   # @param [Hash<Symbol => String>] variables <key: 'value'>
-  # @param [Symbol] unresolved_vars :raise, :keep, :replace => define how to act when unresolved variables within the string are found.
-  # @param [String] replace_pattern pattern used when param unresolved_vars is set to :replace. You can include the var name \\1 and filter \\2. Empty string to remove unresolved variables.
+  # @param [Hash] options
+  # @param [Symbol] options.unresolved_vars :raise, :keep, :replace => define how to act when unresolved variables within the string are found.
+  # @param [String] options.replace_pattern pattern used when param unresolved_vars is set to :replace. You can include the var name \\1 and filter \\2. Empty string to remove unresolved variables.
   # @return [String, UnresolvedVariablesError] parsed string
-  def self.parse(string, variables, unresolved_vars: :raise, replace_pattern: "##\\1##")
+  def self.parse(string, variables = {}, options = { unresolved_vars: :raise, replace_pattern: "##\\1##" })
     variables ||= {}
+    options ||= {}
+    options[:unresolved_vars] = :raise unless options[:unresolved_vars]
+    options[:replace_pattern] = "##\\1##" unless options[:replace_pattern]
     result_string = string.clone
+    # symbolize keys
+    variables = variables.map { |key, value| [key.to_sym, value] }.to_h
     if CurlyBracketParser.any_variable_included? string
       loop do
-        variables(string).each do |string_var|
+        variables(result_string).each do |string_var|
           dec = decode_variable(string_var)
-          name = dec[:name]
+          name = !dec[:name] || dec[:name] == '' ? "''" : dec[:name]
           filter = dec[:filter]
-          if variables[name.to_sym]
-            value = if filter
-                      process_filter(filter, variables[name.to_sym])
-                    else
-                      variables[name.to_sym]
-                    end
-            result_string.gsub!(string_var, value)
+          value = nil
+          is_single_quoted = name.start_with?("'") && name.end_with?("'")
+          is_double_quoted = name.start_with?('"') && name.end_with?('"')
+          # When the name itself is quoted as string or is a number, we use it as a value itself
+          if is_single_quoted || is_double_quoted
+            value = name[1...-1]
+          elsif CurlyBracketParser.number_string? name
+            value = eval(name)
+          elsif variables[name.to_sym]
+            value = variables[name.to_sym]
           elsif registered_default_var?(name.to_s)
             value = process_default_var(name)
-            result_string.gsub!(string_var, value)
+          end
+          if value
+            value = process_filter(filter, value) if filter
+            result_string.gsub!(string_var, value.to_s)
           end
         end
         # break if no more given variable is available
-        break unless any_variable_included?(string) && includes_one_variable_of(variables, string)
+        unless any_variable_included?(result_string) && includes_one_variable_of(variables.keys, result_string)
+          break
+        end
       end
-      case unresolved_vars
+      case options[:unresolved_vars]
       when :raise
         if any_variable_included? result_string
           raise UnresolvedVariablesError, "There are unresolved variables in the given string: #{variables(result_string)}"
         end
       when :replace
-        result_string.gsub!(VARIABLE_DECODER_REGEX, replace_pattern)
+        result_string.gsub!(VARIABLE_DECODER_REGEX, options[:replace_pattern])
       end
     end
     result_string
@@ -303,11 +317,39 @@ module CurlyBracketParser
   # @return [Boolean] true if one given variable name is included in given the string, otherwise false
   def self.includes_one_variable_of(variable_names, string)
     decoded_variables(string).each do |dvar|
-      return true if variable_names.include?(dvar[:name])
+      return true if variable_names.map(&:to_sym).include?(dvar[:name].to_sym)
     end
     false
   end
 
   #----------------------------------------------------------------------------------------------------
 
+  #
+  # Check if given variable is a valid number inside a string that evaluates to a number in Ruby.
+  #
+  # @example
+  #     # valid number strings
+  #     '200'
+  #     '25.75'
+  #     '500_000'
+  #     '0x1fF'
+  #
+  # @param [String] name
+  # @return [Boolean]
+  def self.number_string?(name)
+    number_regex = /(^[0-9]+[0-9_]*([.][0-9_]*[0-9]+)?$|^0[xX][0-9A-Fa-f]+$)/
+    if (name =~ number_regex) != nil
+      begin
+        eval name
+        true
+      rescue StandardError, SyntaxError => e
+        false
+      end
+    else
+      false
+    end
+  end
+
+  #----------------------------------------------------------------------------------------------------
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curly_bracket_parser
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 1.1.6
 platform: ruby
 authors:
 - Matthäus Beyrle
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-10 00:00:00.000000000 Z
+date: 2022-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lucky_case
@@ -110,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: Simple parser to replace variables inside templates/strings and files