handlebars-helpers 0.0.5 → 0.0.73

data/lib/handlebars/helpers/comparison/lte.rb

@@ -0,0 +1,43 @@
+# 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
+    # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+    module Comparison
+      # Lte: (less than or equal to) Block helper that renders a block if `a` is **less than or equal to** `b`. If an inverse block is specified it will be rendered when falsy.
+      class Lte < Handlebars::Helpers::BaseHelper
+        # Parse will Lte: (less than or equal to) Block helper that renders a block if `a` is **less than or equal to** `b`. If an inverse block is specified it will be rendered when falsy.
+        #
+        # @example
+        #
+        #   puts Lte.new.parse(1, 2)
+        #
+        #   Truthy
+        #
+        #   puts Lte.new.parse(1, 1)
+        #
+        #   Truthy
+        #
+        #   puts Lte.new.parse(2, 1)
+        #
+        #   Falsey
+        #
+        # @param [String] lhs - left hand side value
+        # @param [String] rhs - right hand side value
+        # @return [String] truthy value if left hand side LESS THAN or EQUAL to right hand side
+        def parse(lhs, rhs)
+          lhs <= rhs
+        end
+
+        def handlebars_helper
+          proc { |_context, lhs, rhs| wrapper(parse(lhs, rhs)) }
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/comparison/ne.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
+    # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+    module Comparison
+      # Ne: (not equal) Block helper that renders a block if `a` is **not equal to** `b`. If an inverse block is specified it will be rendered when falsy.
+      class Ne < Handlebars::Helpers::BaseHelper
+        # Parse will Ne: (not equal) Block helper that renders a block if `a` is **not equal to** `b`. If an inverse block is specified it will be rendered when falsy.
+        #
+        # @example
+        #
+        #   puts Ne.new.parse('aaa', 'bbb')
+        #
+        #   Truthy
+        #
+        # @param [String] lhs - left hand side value
+        # @param [String] rhs - right hand side value
+        # @return [String] truthy value if left hand side is NOT equal to right hand side
+        def parse(lhs, rhs)
+          lhs != rhs
+        end
+
+        def handlebars_helper
+          proc { |_context, lhs, rhs| wrapper(parse(lhs, rhs)) }
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/comparison/or.rb

@@ -0,0 +1,56 @@
+# 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
+    # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+    module Comparison
+      # Or: Block helper that renders a block if **any of** the given values is truthy. If an inverse block is specified it will be rendered when falsy.
+      #
+      # @example
+      #
+      # {{#if (or p1 p2 p3 p4 p5)}}
+      #   found
+      # {{/if}}
+      #
+      # @example
+      #
+      # {{#if (or
+      #     (eq section1 "foo")
+      #     (ne section2 "bar"))}}
+      # .. content
+      # {{/if}}
+      #
+      # @example
+      # {{#if (or name age)}}
+      #   {{name}}-{{age}}
+      # {{else}}
+      #   no name or age
+      # {{/if}}
+      class Or < Handlebars::Helpers::BaseHelper
+        # Parse will Or: Block helper that renders a block if **any of** the given values is truthy. If an inverse block is specified it will be rendered when falsy.
+        #
+        # @example
+        #
+        #   puts Or.new.parse(var1, var2)
+        #
+        #   truthy block
+        #
+        # @param values list of values (via *splat) to be checked via OR condition
+        # @return [String] return block when first value is truthy
+        def parse(values)
+          values.any? { |value| value }
+        end
+
+        def handlebars_helper
+          # Exclude last paramater which is the context V8::Object
+          proc { |_context, *values| wrapper(parse(values[0..-2])) }
+        end
+      end
+    end
+  end
+end

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