handlebars-helpers 0.0.5 → 0.0.73

data/lib/handlebars/helpers/code_ruby/deconstantize.rb

@@ -0,0 +1,48 @@
+# 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
+    # Ruby code handling routines
+    module CodeRuby
+      # Deconstantize: Removes the rightmost segment from the constant expression in the string.
+      class Deconstantize < Handlebars::Helpers::BaseHelper
+        # Parse will deconstantize, remove the rightmost segment from the constant expression in the string.
+        #
+        # @example
+        #
+        #   puts Deconstantize.new.parse('Net::HTTP')
+        #
+        #   Net
+        #
+        #   puts Deconstantize.new.parse('::Net::HTTP')
+        #
+        #   ::Net
+        #
+        #   puts Deconstantize.new.parse('String')
+        #
+        #   ""
+        #
+        #   puts Deconstantize.new.parse('::String')
+        #
+        #   ""
+        #
+        # @param [String] value - name of the ruby constant expression
+        # @return [String] return constant without rightmost segment
+        def parse(value)
+          return '' if value.nil?
+
+          value.deconstantize
+        end
+
+        def handlebars_helper
+          proc { |_context, value| wrapper(parse(value)) }
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/code_ruby/demodulize.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_helper'
+
+module Handlebars
+  module Helpers
+    # Ruby code handling routines
+    module CodeRuby
+      # Demodulize: Removes the module part from the expression in the string.
+      class Demodulize < Handlebars::Helpers::BaseHelper
+        # Parse will demodulize, aka remove the module part from the expression in the string.
+        #
+        # @example
+        #
+        #   puts Demodulize.new.parse('ActiveSupport::Inflector::Inflections')
+        #
+        #   Inflections
+        #
+        # @example
+        #   demodulize('ActiveSupport::Inflector::Inflections') # => "Inflections"
+        #   demodulize('Inflections')                           # => "Inflections"
+        #   demodulize('::Inflections')                         # => "Inflections"
+        #   demodulize('')                                      # => ""
+        #
+        #   puts Demodulize.new.parse('Inflections')
+        #
+        #   Inflections
+        #
+        # @example
+        #
+        #   puts Demodulize.new.parse('::Inflections')
+        #
+        #   Inflections
+        #
+        # @example
+        #
+        #   puts Demodulize.new.parse('')
+        #
+        #   ""
+        #
+        # @param [String] value - name of the ruby module and class name separated by ::
+        # @return [String] value demodulize, aka class name without module
+        def parse(value)
+          return '' if value.nil?
+
+          value.demodulize
+        end
+
+        def handlebars_helper
+          proc { |_context, value| wrapper(parse(value)) }
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/code_ruby/foreign_key.rb

@@ -0,0 +1,49 @@
+# 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
+    # Ruby code handling routines
+    module CodeRuby
+      # Foreign Key: Creates a foreign key name from a class name
+      # +separate_class_name_and_id_with_underscore+ sets whether
+      # the method should put '_' between the name and 'id'.
+      class ForeignKey < Handlebars::Helpers::BaseHelper
+        # Parse will Creates a foreign key name from a class name
+        #
+        # @example
+        #
+        #   puts ForeignKey.new.parse('Message')
+        #
+        #   message_id
+        #
+        # @example
+        #
+        #   puts ForeignKey.new.parse('Message', class_id_underscored: false)
+        #
+        #   messageid
+        #
+        # @example
+        #
+        #   puts ForeignKey.new.parse('Admin::Post')
+        #
+        #   post_id
+        #
+        # @param [String] class_name - name of class
+        # @param [Boolean] class_id_underscored: - optional named value (defaults to true) - is the class and ID to be separated by underscore?
+        # @return [String] value converted to separate_class_name_and_id_with_underscore
+        def parse(class_name, class_id_underscored: true)
+          class_name.foreign_key(class_id_underscored)
+        end
+
+        def handlebars_helper
+          proc { |_context, class_name, class_id_underscored| wrapper(parse(class_name, class_id_underscored: class_id_underscored)) }
+        end
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/code_ruby/tableize.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
+    # Ruby code handling routines
+    module CodeRuby
+      # Tableize: Creates the name of a table like Rails does when converting models to table names
+      class Tableize < Handlebars::Helpers::BaseHelper
+        # Parse will creates the name of a table like Rails does when converting models to table names
+        #
+        # @example
+        #
+        #   puts Tableize.new.parse('product category')
+        #
+        #   product_categories
+        #
+        # @param [String] value - name of the table
+        # @return [String] value converted to table case with pluralization
+        def parse(value)
+          # tokenizer.parse(value, separator: '_', forced_separator: true).classify
+          tokenizer.parse(value).tableize
+        end
+
+        def handlebars_helper
+          proc { |_context, value| wrapper(parse(value)) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# 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
+      # And: Block helper that renders a block if **all of** the given values are truthy. If an inverse block is specified it will be rendered when falsy.
+      class And < Handlebars::Helpers::BaseHelper
+        # Parse will And: Block helper that renders a block if **all of** the given values are truthy. If an inverse block is specified it will be rendered when falsy.
+        #
+        # @example
+        #
+        # {{#if (and p1 p2 p3 p4 p5)}}
+        #   found
+        # {{/if}}
+        #
+        # @example
+        #
+        # @example
+        # {{#if (and name age)}}
+        #   {{name}}-{{age}}
+        # {{else}}
+        #   no name or age
+        # {{/if}}
+        #
+        # @param values list of values (via *splat) to be checked via AND condition
+        # @return [String] return block when every value is truthy
+        def parse(values)
+          values.all? { |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/comparison/default.rb

@@ -0,0 +1,66 @@
+# 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
+    # Comparison helpers, eg. or, and, equal, not equal, less than, greater than etc.
+    module Comparison
+      # Default: Returns the first value that is not nil or undefined, otherwise the 'default' value is returned.
+      class Default < Handlebars::Helpers::BaseSafeStringHelper
+        # Parse will Default: Returns the first value that is not nil or undefined, otherwise the 'default' value is returned.
+        #
+        # @example
+        #
+        #   emotion = nil
+        #   puts Default.new.parse(emotion, 'happy')
+        #
+        #   happy
+        #
+        # @example
+        #
+        #   emotion = 'sad'
+        #   puts Default.new.parse(emotion, 'happy')
+        #
+        #   sad
+        #
+        # @example
+        #
+        #   david = nil
+        #   lisa = nil
+        #   ben = nil
+        #   puts Default.new.parse(david, lisa, ben, 'happy')
+        #
+        #   happy
+        #
+        # @example
+        #
+        #   david = nil
+        #   lisa = sad
+        #   ben = mad
+        #   puts Default.new.parse(david, lisa, ben, 'happy')
+        #
+        #   sad
+        #
+        # @param [Object] *values - one or more paramaters that may or may not contain nil
+        # @param [String] default_value - the last paramater will be the default value
+        # @return [String] value or default value
+        def parse(values)
+          default_value = values[-1]
+
+          find_value = values[0..-2].find { |value| !value.nil? }
+
+          find_value || default_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/comparison/eq.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
+      # Eq: Block helper that renders a block if `a` is **equal to** `b`. If an inverse block is specified it will be rendered when falsy.
+      class Eq < Handlebars::Helpers::BaseHelper
+        # Parse will Eq: Block helper that renders a block if `a` is **equal to** `b`. If an inverse block is specified it will be rendered when falsy.
+        #
+        # @example
+        #
+        #   puts Eq.new.parse('aaa', 'aaa')
+        #
+        #   Truthy
+        #
+        # @param [String] lhs - left hand side value
+        # @param [String] rhs - right hand side value
+        # @return [String] truthy value if left hand side equals 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/gt.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
+      # Gt: (greater than) Block helper that renders a block if `a` is **greater than** `b`. If an inverse block is specified it will be rendered when falsy.
+      class Gt < Handlebars::Helpers::BaseHelper
+        # Parse will Gt: (greater than) Block helper that renders a block if `a` is **greater than** `b`. If an inverse block is specified it will be rendered when falsy.
+        #
+        # @example
+        #
+        #   puts Gt.new.parse(2, 1)
+        #
+        #   Truthy
+        #
+        # @param [String] lhs - left hand side value
+        # @param [String] rhs - right hand side value
+        # @return [String] truthy value if left hand side GREATER THAN 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/gte.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
+      # Gte: (greater than or equal to) Block helper that renders a block if `a` is **greater than** `b`. If an inverse block is specified it will be rendered when falsy.
+      class Gte < Handlebars::Helpers::BaseHelper
+        # Parse will Gte: (greater than or equal to) Block helper that renders a block if `a` is **greater than** `b`. If an inverse block is specified it will be rendered when falsy.
+        #
+        # @example
+        #
+        #   puts Gte.new.parse(1, 2)
+        #
+        #   Falsey
+        #
+        #   puts Gte.new.parse(1, 1)
+        #
+        #   Truthy
+        #
+        #   puts Gte.new.parse(2, 1)
+        #
+        #   Truthy
+        #
+        # @param [String] lhs - left hand side value
+        # @param [String] rhs - right hand side value
+        # @return [String] truthy value if left hand side GREATER 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/lt.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
+      # Lt: (less than) Block helper that renders a block if `a` is **less than** `b`. If an inverse block is specified it will be rendered when falsy.
+      class Lt < Handlebars::Helpers::BaseHelper
+        # Parse will Lt: (less than) Block helper that renders a block if `a` is **less than** `b`. If an inverse block is specified it will be rendered when falsy.
+        #
+        # @example
+        #
+        #   puts Lt.new.parse(1, 2)
+        #
+        #   Truthy
+        #
+        # @param [String] lhs - left hand side value
+        # @param [String] rhs - right hand side value
+        # @return [String] truthy value if left hand side LESS THAN 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