handlebars-helpers 0.0.5 → 0.0.65

data/lib/handlebars/helpers/string_formatting/camel.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # camel case the characters in the given 'string'.
+      class Camel < Handlebars::Helpers::BaseHelper
+        # Parse will camel case the characters in the given 'string'.
+        #
+        # @example
+        #
+        #   puts Camel.new.parse('the quick brown fox 99')
+        #
+        #   TheQuickBrownFox99
+        #
+        # @return [String] value converted to camel case
+        def parse(value)
+          tokenizer.parse(value).underscore.camelize
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/constantize.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # CONSTANT case the characters in the given 'string'.
+      class Constantize < Handlebars::Helpers::BaseHelper
+        # Parse will CONSTANT case the characters in the given 'string'.
+        #
+        # @example
+        #
+        #   puts Constantize.new.parse('the quick brown fox 99')
+        #
+        #   THE_QUICK_BROWN_FOX99
+        #
+        # @return [String] value converted to constant case
+        def parse(value)
+          tokenizer.parse(value, separator: '_').upcase
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/dasherize.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # convert to dash notation
+      class Dasherize < Handlebars::Helpers::BaseHelper
+        # Parse will convert to dash notation
+        #
+        # @side effects
+        #
+        #   All text is in lower case
+        #
+        # @example
+        #
+        #   puts Dasherize.new.parse('the quick brown fox 99')
+        #
+        #   the-quick-brown-fox99
+        #
+        # @return [String] value converted to dash notation
+        def parse(value)
+          tokenizer.parse(value)
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/dotirize.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # convert to dot notation
+      class Dotirize < Handlebars::Helpers::BaseHelper
+        # Parse will convert to dot notation
+        #
+        # @side effects
+        #
+        #   All text is in lower case
+        #
+        # @example
+        #
+        #   puts Dotirize.new.parse('the quick brown fox 99')
+        #
+        #   the.quick.brown.fox99
+        #
+        # @return [String] value converted to dot notation
+        def parse(value)
+          tokenizer.parse(value, separator: '.')
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/double_colon.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # double_colon notation for the characters in the given 'string'. aka ruby namespace
+      class DoubleColon < Handlebars::Helpers::BaseHelper
+        # Parse will double_colon notation for the characters in the given 'string'. aka ruby namespace
+        #
+        # @side effects
+        #
+        #   Text casing is preserved.
+        #
+        # @example
+        #
+        #   puts DoubleColon.new.parse('the quick brown fox 99')
+        #
+        #   The::Quick::Brown::Fox99
+        #
+        # @return [String] value converted to double_colon notation
+        def parse(value)
+          tokenizer.parse(value, preserve_case: true, separator: '::')
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/downcase.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # Downcase/Lowercase all of the characters in the given string.
+      class Downcase < Handlebars::Helpers::BaseHelper
+        # Parse will Downcase/Lowercase all of the characters in the given string.
+        #
+        # @example
+        #
+        #   puts Downcase.new.parse('The Quick Brown Fox 99')
+        #
+        #   the quick brown fox 99
+        #
+        # @return [String] value in lowercase
+        def parse(value)
+          return '' if value.nil?
+
+          value.downcase
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/format_as.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # Format As: Chain a list of string formatters to run sequentially
+      class FormatAs < Handlebars::Helpers::BaseHelper
+        # Parse will execute a chain of string formatters and run them sequentially
+        #
+        # @example
+        #
+        #   puts FormatAs.new.parse('the quick brown fox', 'pluralize,dashify')
+        #
+        #   the-quick-brown-foxes
+        #
+        # @param [String] value - value to format
+        # @param [String] formats - comma delimited list of formats
+        # @return [String] returns a value that has been processed by multiple formatters
+        def parse(value, formats)
+          return '' if value.nil?
+          return value if formats.nil? || formats.empty?
+
+          formats = formats.split(',') if formats.is_a?(String)
+          formats = formats.map(&:to_sym)
+          formats.each do |format|
+            value = format_value(value, format)
+          end
+          value
+        end
+
+        def handlebars_helper
+          proc { |_context, value, formats| wrapper(parse(value, formats)) }
+        end
+
+        private
+
+        def format_value(value, format)
+          return value if format == :none
+
+          formatter = Handlebars::Helpers.configuration.string_formatter_config[format]
+          unless formatter
+            puts 'Logger not found: format'
+            return value
+          end
+
+          formatter.parse(value)
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/humanize.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # humanize wil convert text to human case, aka capitalize
+      class Humanize < Handlebars::Helpers::BaseHelper
+        # Parse will humanize wil convert text to human case, aka capitalize
+        #
+        # @side effects
+        #
+        #   Text casing set to upper case for first letter only.
+        #   Numbers will maintain their spacing
+        #
+        # @example
+        #
+        #   puts Humanize.new.parse('the quick brown fox 99')
+        #
+        #   The quick brown fox 99
+        #
+        # @return [String] value converted to sentence case
+        def parse(value)
+          tokenizer.parse(value,
+                          separator: ' ',
+                          preserve_case: true,
+                          compress_prefix_numerals: false,
+                          compress_suffix_numerals: false)
+                   .humanize
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/lamel.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # lamel case is the same as camel case except with the first character as lower case
+      class Lamel < Handlebars::Helpers::BaseHelper
+        # Parse will lamel case is the same as camel case except with the first character as lower case
+        #
+        # @example
+        #
+        #   puts Lamel.new.parse('the quick brown fox 99')
+        #
+        #   theQuickBrownFox99
+        #
+        # @return [String] value converted to lamel case
+        def parse(value)
+          tokenizer.parse(value, separator: '_').camelize(:lower)
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/padl.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_safe_string_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # Add padding to the left of the value.
+      class Padl < Handlebars::Helpers::BaseSafeStringHelper
+        # Parse will Add padding to the left of the value.
+        #
+        # @example
+        #
+        #   puts "[#{Padl.new.parse('aaa', 10)}]"
+        #
+        #   [       aaa]
+        #
+        # @example
+        #
+        #   puts "[#{Padl.new.parse('aaa')}]"
+        #
+        #   [                           aaa]
+        #
+        # @example
+        #
+        #   puts Padl.new.parse('aaa', '10', '-')
+        #
+        #   -------aaa
+        #
+        # @param [String] value - value to apply padding to
+        # @param [Integer] count - how much padding to apply. defaults to configuration.padl_count
+        # @param [String] char - character to pad with. defaults to configuration.padl_char
+        # @return [String] value with padding to left
+        def parse(value, count, char)
+          value = '' if value.nil?
+          count = Handlebars::Helpers.configuration.padl_count if count.nil?
+          count = count.to_i if count.is_a?(String)
+          char = Handlebars::Helpers.configuration.padl_char if char.nil?
+          value.rjust(count, char)
+        end
+
+        def handlebars_helper
+          proc do |_context, value, count, char|
+            # Handle optional: value, count and char
+            value = nil if value.is_a?(V8::Object)
+            count = nil if count.is_a?(V8::Object)
+            char = nil if char.is_a?(V8::Object)
+            wrapper(parse(value, count, char))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/padr.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_safe_string_helper'
+require 'handlebars/helpers/configuration'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # Add padding to the right of the value.
+      class Padr < Handlebars::Helpers::BaseSafeStringHelper
+        # Parse will Add padding to the right of the value.
+        #
+        # @example
+        #
+        #   puts "[#{Padr.new.parse('aaa', 10)}]"
+        #
+        #   [aaa       ]
+        #
+        # @example
+        #
+        #   puts "[#{Padr.new.parse('aaa')}]"
+        #
+        #   [aaa                           ]
+        #
+        # @example
+        #
+        #   puts Padr.new.parse('aaa', '10', '-')
+        #
+        #   aaa-------
+        #
+        # @param [String] value - value to apply padding to
+        # @param [Integer] count - how much padding to apply. defaults to configuration.padr_count
+        # @param [String] char - character to pad with. defaults to configuration.padr_char
+        # @return [String] value with padding to right
+        def parse(value, count = nil, char = nil)
+          value = '' if value.nil?
+          count = Handlebars::Helpers.configuration.padr_count if count.nil?
+          count = count.to_i if count.is_a?(String)
+          char = Handlebars::Helpers.configuration.padr_char if char.nil?
+          value.ljust(count, char)
+        end
+
+        def handlebars_helper
+          proc do |_context, value, count, char|
+            # Handle optional: value, count and char
+            value = nil if value.is_a?(V8::Object)
+            count = nil if count.is_a?(V8::Object)
+            char = nil if char.is_a?(V8::Object)
+            wrapper(parse(value, count, char))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/pluserize.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# reference: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+require 'active_support/core_ext/string'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # convert to plus notation
+      class Pluserize < Handlebars::Helpers::BaseHelper
+        # Parse will convert to plus notation
+        #
+        # @example
+        #
+        #   puts Pluserize.new.parse('the quick brown fox 99')
+        #
+        #   the+quick+brown+fox99
+        #
+        # @return [String] value converted to plus notation
+        def parse(value)
+          tokenizer.parse(value, separator: '+')
+        end
+      end
+    end
+  end
+end