handlebars-helpers 0.0.5 → 0.0.73

data/lib/handlebars/helpers/misc/noop.rb

@@ -0,0 +1,36 @@
+# 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
+    # Miscellaneous handling routines
+    module Misc
+      # NoOp is a wrapper for blocks, it does no additional processing.
+      # It is useful for embedding blocks into the output when using raw operators {{{{noop}}}}
+      class Noop < Handlebars::Helpers::BaseHelper
+        # # Parse will do nothing and return.
+        # # It is useful for embedding blocks into the output when using raw operators {{{{noop}}}}
+        # #
+        # # @example
+        # #
+        # #   puts Noop.new.parse()
+        # #
+        # # @return does nothing, but will allow inner blocks to be processed
+        # def parse()
+        # end
+
+        def handlebars_helper
+          proc do |context, block|
+            # Handlebars::SafeString.new('<div class="bold">' + block.fn(context) + "</div>");
+
+            block.fn(context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/misc/safe.rb

@@ -0,0 +1,37 @@
+# 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
+    # Miscellaneous handling routines
+    module Misc
+      # Safe will return the value with <> and single and double quotes left as is
+      class Safe < Handlebars::Helpers::BaseSafeStringHelper
+        # Parse will return the value with <> and single and double quotes left as is
+        #
+        # @example
+        #
+        #   puts Safe.new.parse('<hello>')
+        #
+        #   <hello>
+        #
+        # @param [String] value that is considered a safe string
+        # @return [String] value in safe string format
+        def parse(value)
+          value = '' if value.nil?
+          value
+        end
+
+        def handlebars_helper
+          proc do |_context, value|
+            wrapper(parse(value))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/register_helpers.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'handlebars'
+require 'handlebars/helpers/configuration'
+
+module Handlebars
+  module Helpers
+    # Register helpers against handlebars context
+    class RegisterHelpers
+      attr_accessor :handlebars
+      attr_reader :helpers
+
+      # def initialize(handlebars = Handlebars::Context.new, &block)
+      def initialize(&block)
+        @handlebars = Handlebars::Context.new
+
+        if block_given?
+          block.call(self) # , handlebars)
+        else
+          register_from_config
+        end
+      end
+
+      def helper(*names, &helper)
+        names.each do |name|
+          handlebars.register_helper(name, &helper)
+        end
+      end
+
+      # Register from configuration file
+      #
+      # Sample configuration
+      # "groups": [
+      #   {
+      #     "name": "string_formatting",
+      #     "base_require": "handlebars/helpers/string_formatting",
+      #     "base_namespace": "Handlebars::Helpers::StringFormatting",
+      #     "description": "Case modification string manipulation methods",
+      #     "helpers": [
+      #       {
+      #         "name": "camel",
+      #         "description": "convert to camel case with first word uppercase and following words uppercase",
+      #         "aliases": ["camel", "camelUpper", "camelU"],
+      #         "require_path": "handlebars/helpers/string_formatting/camel",
+      #         "class_namespace": "Handlebars::Helpers::StringFormatting::Camel"
+      #       }
+      #     ]
+      #   }
+      # ]
+      def register_from_config
+        file = File.read Handlebars::Helpers.configuration.helper_config_file
+        config = JSON.parse(file)
+
+        config['groups'].each do |group|
+          group['helpers'].each do |helper_config|
+            register_config_item(helper_config)
+          end
+        end
+      end
+
+      private
+
+      def register_config_item(config)
+        require config['require_path']
+
+        helper_instance = Object.const_get(config['class_namespace']).new
+
+        helper(*config['aliases'].map(&:to_sym), &helper_instance.handlebars_helper)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# 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/string_formatting/format_as'
+
+module Handlebars
+  module Helpers
+    # String manipulation methods for case formatting
+    module StringFormatting
+      # Append If will append suffix to value, if value is not empty
+      class AppendIf < Handlebars::Helpers::BaseSafeStringHelper
+        # Parse will Append If will append suffix to value, if value is not empty
+        #
+        # @example
+        #
+        #   puts AppendIf.new.parse('the quick brown', 'fox', 'dashify')
+        #
+        #   the-quick-brown-fox
+        #
+        # @param [String] value - value to add suffix too
+        # @param [String] suffix - suffix to add to value
+        # @param [String] formats - list of formats to apply to value, defaults to none
+        # @return [String] value + suffix when value exists, otherwise ''
+        def parse(value, suffix, formats)
+          format_as = Handlebars::Helpers::StringFormatting::FormatAs.new
+          value.present? ? "#{format_as.parse(value, formats)}#{suffix}" : ''
+        end
+
+        def handlebars_helper
+          proc do |_context, value, suffix, formats|
+            # Handle optional: formats
+            formats = nil if formats.is_a?(V8::Object)
+            wrapper(parse(value, suffix, formats))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/string_formatting/back_slash.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 back slash notation
+      class BackSlash < Handlebars::Helpers::BaseHelper
+        # Parse will convert to back slash notation
+        #
+        # @side effects
+        #
+        #   Text casing is preserved.
+        #
+        # @example
+        #
+        #   puts BackSlash.new.parse('the Quick brown Fox 99')
+        #
+        #   the\quick\brown\fox99
+        #
+        # @return [String] value converted to back_slash case
+        def parse(value)
+          tokenizer.parse(value, preserve_case: true, separator: '\\')
+        end
+      end
+    end
+  end
+end

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