handlebars-helpers 0.0.5 → 0.0.65

data/lib/handlebars/helpers/configuration.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'handlebars/helpers/string_tokenizer'
+
+module Handlebars
+  # Configuration access for Handlebars/Helpers
+  module Helpers
+    # Configuration access for handlebars/helpers
+    class << self
+      attr_writer :configuration
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.reset
+      @configuration = Configuration.new
+    end
+
+    def self.configure
+      yield(configuration)
+    end
+
+    # Configuration class
+    class Configuration
+      attr_accessor :tokenizer,
+                    :helper_config_file,
+                    :padl_count,
+                    :padl_char,
+                    :padr_count,
+                    :padr_char
+      attr_reader :string_formatter_config_file
+      attr_writer :string_formatter_config
+
+      def initialize
+        @tokenizer = Handlebars::Helpers::StringTokenizer.new
+        @helper_config_file = '.handlebars_helpers.json'
+        @string_formatter_config_file = '.handlebars_string_formatters.json'
+        @padr_count = 30
+        @padr_char = ' '
+        @padl_count = 30
+        @padl_char = ' '
+      end
+
+      def string_formatter_config_file=(value)
+        @string_formatter_config_file = value
+        # updating the file will clear the config object,
+        # which will be reloaded on next call to string_formatter_config
+        self.string_formatter_config = nil
+      end
+
+      def string_formatter_config
+        @string_formatter_config ||= build_string_formatter_config
+      end
+
+      def build_string_formatter_config
+        config_content = File.read(string_formatter_config_file)
+        config = JSON.parse(config_content)
+        configured_formatters = config['formatters']
+        configured_formatters.each_with_object({}) do |formatter, result|
+          require formatter['require_path']
+          helper_instance = Object.const_get(formatter['class_namespace']).new
+
+          formatter['aliases'].each do |name|
+            result[name.to_sym] = helper_instance
+          end
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/inflection/ordinal.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/integer/inflections'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # Inflection handling routines, eg. pluralize, singular, ordinalize
+    module Inflection
+      # Ordinal: The suffix that should be added to a number to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th
+      class Ordinal < Handlebars::Helpers::BaseHelper
+        # Parse will Ordinal: The suffix that should be added to a number to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th
+        #
+        # @example
+        #
+        #   puts Ordinal.new.parse('1')
+        #
+        #   st
+        #
+        # @example
+        #
+        #   puts Ordinal.new.parse('2')
+        #
+        #   nd
+        #
+        # @example
+        #
+        #   puts Ordinal.new.parse('3')
+        #
+        #   rd
+        #
+        # @example
+        #
+        #   puts Ordinal.new.parse('4')
+        #
+        #   th
+        #
+        # @param [String] value - numeric value
+        # @return [String] ordinal suffix that would be required for a number
+        def parse(value)
+          return '' if value.nil?
+
+          value = value.to_i if value.is_a? String
+
+          value.ordinal
+        end
+
+        def handlebars_helper
+          proc do |_context, value|
+            wrapper(parse(value))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/inflection/ordinalize.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/inflector/inflections'
+require 'active_support/core_ext/integer/inflections'
+
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # Inflection handling routines, eg. pluralize, singular, ordinalize
+    module Inflection
+      # Ordinalize: Turns a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+      class Ordinalize < Handlebars::Helpers::BaseHelper
+        # Parse will Ordinalize: Turns a number into an ordinal string used to denote the position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
+        #
+        # @example
+        #
+        #   puts Ordinalize.new.parse('1')
+        #
+        #   1st
+        #
+        # @example
+        #
+        #   puts Ordinalize.new.parse('2')
+        #
+        #   2nd
+        #
+        # @example
+        #
+        #   puts Ordinalize.new.parse('3')
+        #
+        #   3rd
+        #
+        # @example
+        #
+        #   puts Ordinalize.new.parse('4')
+        #
+        #   4th
+        #
+        # @param [String] value - numeric value
+        # @return [String] number value turned to 1st, 2nd, 3rd, 4th etc.
+        def parse(value)
+          return '' if value.nil?
+
+          value = value.to_i if value.is_a? String
+
+          value.ordinalize
+        end
+
+        def handlebars_helper
+          proc do |_context, value|
+            wrapper(parse(value))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/inflection/pluralize.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
+    # Inflection handling routines, eg. pluralize, singular, ordinalize
+    module Inflection
+      # Returns the plural form of the word in the string
+      class Pluralize < Handlebars::Helpers::BaseHelper
+        # Parse will Returns the plural form of the word in the string
+        #
+        # @example
+        #
+        #   puts Pluralize.new.parse('name')
+        #
+        #   names
+        #
+        #   puts Pluralize.new.parse('octopus')
+        #
+        #   octopi
+        #
+        #
+        # @return [String] value in plural form
+        def parse(value)
+          return '' if value.nil?
+
+          value.pluralize
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/inflection/pluralize_by_number.rb

@@ -0,0 +1,60 @@
+# 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
+    # Inflection handling routines, eg. pluralize, singular, ordinalize
+    module Inflection
+      # Pluralize By Number: uses both a word and number to decide if the plural or singular form should be used.
+      class PluralizeByNumber < Handlebars::Helpers::BaseHelper
+        # Parse will Pluralize By Number: uses both a word and number to decide if the plural or singular form should be used.
+        #
+        # @example
+        #
+        #   puts PluralizeByNumber.new.parse('category', '3', 'number_word')
+        #
+        #   3 categories
+        #
+        # @example
+        #
+        #   puts PluralizeByNumber.new.parse('category', '3', 'word' )
+        #
+        #   categories
+        #
+        #   puts PluralizeByNumber.new.parse('category', '1' )
+        #
+        #   category
+        #
+        # @param [String] value - value to pluralize
+        # @param [Integer] count - count used to determine pluralization
+        # @param [String] format - (Optional) what format should output be. :word, :number_word
+        # @return [String] value and number are used to calculate plural/singular form
+        def parse(value, count, format)
+          return '' if value.nil?
+
+          count = count.to_i if count.is_a? String
+          format = :word if format.nil?
+
+          case format.to_sym
+          when :number_word, :number_and_word
+            "#{count} #{value.pluralize(count)}"
+          else # aka :word
+            value.pluralize(count)
+          end
+        end
+
+        def handlebars_helper
+          proc do |_context, value, count, format|
+            # Handle optional: format
+            format = nil if value.is_a?(V8::Object)
+            wrapper(parse(value, count, format))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/inflection/singularize.rb

@@ -0,0 +1,35 @@
+# 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
+    # Inflection handling routines, eg. pluralize, singular, ordinalize
+    module Inflection
+      # The reverse of #pluralize, returns the singular form of a word in a string
+      class Singularize < Handlebars::Helpers::BaseHelper
+        # Parse will reverse of #pluralize, returns the singular form of a word in a string
+        #
+        # @example
+        #
+        #   puts Singularize.new.parse('names')
+        #
+        #   name
+        #
+        #   puts Singularize.new.parse('octopi')
+        #
+        #   octopus
+        #
+        # @return [String] plural value turned to singular value
+        def parse(value)
+          return '' if value.nil?
+
+          value.singularize
+        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