handlebars-helpers 0.0.5 → 0.0.65

data/.handlebars_string_formatters.json

@@ -0,0 +1,137 @@
+{
+  "formatters": [
+    {
+      "name": "ordinalize",
+      "description": "number value turned to 1st, 2nd, 3rd, 4th etc.",
+      "aliases": ["ordinalize"],
+      "class_namespace": "Handlebars::Helpers::Inflection::Ordinalize",
+      "require_path": "handlebars/helpers/inflection/ordinalize"
+    },
+    {
+      "name": "ordinal",
+      "description": "ordinal suffix that would be required for a number, eg. st, nd, rd, th",
+      "aliases": ["ordinal"],
+      "class_namespace": "Handlebars::Helpers::Inflection::Ordinal",
+      "require_path": "handlebars/helpers/inflection/ordinal"
+    },
+    {
+      "name": "pluralize",
+      "description": "singular value is converted to plural form",
+      "aliases": ["pluralize", "plural"],
+      "class_namespace": "Handlebars::Helpers::Inflection::Pluralize",
+      "require_path": "handlebars/helpers/inflection/pluralize"
+    },
+    {
+      "name": "singularize",
+      "description": "plural value is converted to singular from",
+      "aliases": ["singularize", "singular"],
+      "class_namespace": "Handlebars::Helpers::Inflection::Singularize",
+      "require_path": "handlebars/helpers/inflection/singularize"
+    },
+    {
+      "name": "tableize",
+      "description": "creates the name of a table like Rails does when converting models to table names",
+      "aliases": ["tableize"],
+      "class_namespace": "Handlebars::Helpers::CodeRuby::Tableize",
+      "require_path": "handlebars/helpers/code_ruby/tableize"
+    },
+    {
+      "name": "back_slash",
+      "description": "convert to back slash notation",
+      "aliases": ["back_slash", "backward_slash", "slash_backward"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::BackSlash",
+      "require_path": "handlebars/helpers/string_formatting/back_slash"
+    },
+    {
+      "name": "camel",
+      "description": "convert to camel case with first word uppercase and following words uppercase",
+      "aliases": ["camel", "camel_upper", "camelUpper", "camelU", "pascalcase"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Camel",
+      "require_path": "handlebars/helpers/string_formatting/camel"
+    },
+    {
+      "name": "constantize",
+      "description": "convert to constant case",
+      "aliases": ["constantize", "constant"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Constantize",
+      "require_path": "handlebars/helpers/string_formatting/constantize"
+    },
+    {
+      "name": "dasherize",
+      "description": "convert to dash notation",
+      "aliases": ["dasherize", "dashify", "dashcase", "hyphenate"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Dasherize",
+      "require_path": "handlebars/helpers/string_formatting/dasherize"
+    },
+    {
+      "name": "dotirize",
+      "description": "convert to dash notation",
+      "aliases": ["dotirize", "dotify", "dotcase"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Dotirize",
+      "require_path": "handlebars/helpers/string_formatting/dotirize"
+    },
+    {
+      "name": "double_colon",
+      "description": "double_colon notation, similar to ruby namespace",
+      "aliases": ["double_colon"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::DoubleColon",
+      "require_path": "handlebars/helpers/string_formatting/double_colon"
+    },
+    {
+      "name": "downcase",
+      "description": "convert all characters to lower case",
+      "aliases": ["downcase", "lowercase"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Downcase",
+      "require_path": "handlebars/helpers/string_formatting/downcase"
+    },
+    {
+      "name": "humanize",
+      "description": "convert text to human case, aka capitalize",
+      "aliases": ["humanize", "capitalize"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Humanize",
+      "require_path": "handlebars/helpers/string_formatting/humanize"
+    },
+    {
+      "name": "lamel",
+      "description": "convert to lamel case with first word lowercase and following words uppercase",
+      "aliases": ["lamel", "camel_lower", "camelLower", "camelL"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Lamel",
+      "require_path": "handlebars/helpers/string_formatting/lamel"
+    },
+    {
+      "name": "pluserize",
+      "description": "convert to plus notation",
+      "aliases": ["pluserize", "plusify", "pluscase"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Pluserize",
+      "require_path": "handlebars/helpers/string_formatting/pluserize"
+    },
+    {
+      "name": "slash",
+      "description": "convert to slash notation, aka forward slash",
+      "aliases": ["slash", "forward_slash", "slash_forward"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Slash",
+      "require_path": "handlebars/helpers/string_formatting/slash"
+    },
+    {
+      "name": "snake",
+      "description": "convert to snake notation",
+      "aliases": ["snake"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Snake",
+      "require_path": "handlebars/helpers/string_formatting/snake"
+    },
+    {
+      "name": "titleize",
+      "description": "value converted to titleize case, aka heading case",
+      "aliases": ["titleize", "heading", "capitalize_all"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Titleize",
+      "require_path": "handlebars/helpers/string_formatting/titleize"
+    },
+    {
+      "name": "upcase",
+      "description": "convert all characters to lower case",
+      "aliases": ["upcase", "uppercase"],
+      "class_namespace": "Handlebars::Helpers::StringFormatting::Upcase",
+      "require_path": "handlebars/helpers/string_formatting/upcase"
+    }
+  ]
+}

data/.rubocop.yml

@@ -1,3 +1,4 @@
+require: rubocop-rake
 inherit_from: .rubocop_todo.yml
 
 AllCops:
@@ -10,9 +11,9 @@ AllCops:
 
 Metrics/BlockLength:
   Exclude:
-    - "**/spec/*"
+    - "**/spec/**/*"
     - "*.gemspec"
-  ExcludedMethods:
+  IgnoredMethods:
     - configure
     - context
     - define
@@ -77,3 +78,4 @@ Style/AccessorGrouping:
 Layout/SpaceBeforeComma:
   Enabled: false
 # My Preferences - End
+

data/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "cSpell.words": [
+    "dashcase",
+    "dotcase"
+  ]
+}

data/Gemfile

@@ -17,8 +17,11 @@ group :development, :test do
   gem 'guard-rspec'
   gem 'guard-rubocop'
   gem 'rake', '~> 12.0'
+  gem 'rake-compiler', require: false
   gem 'rspec', '~> 3.0'
   gem 'rubocop'
+  gem 'rubocop-rake', require: false
+  gem 'rubocop-rspec', require: false
 end
 
 # # Temporary path:

data/Rakefile

@@ -7,6 +7,7 @@ RSpec::Core::RakeTask.new(:spec)
 
 require 'rake/extensiontask'
 
+desc 'Compile all the extensions'
 task build: :compile
 
 Rake::ExtensionTask.new('handlebars_helpers') do |ext|

data/STORIES.md

@@ -8,10 +8,41 @@ As a Ruby Developer, I want to use HandlebarsJS with useful helpers, so that I h
 
 ### Stories next on list
 
+As a Documentor, I can create usage examples for this GEM, so that I can document the project
+
+- setup rspec-usage for the project
+- create templates for generating slide decks
+- record videos on how to use
+
+As a Developer, I can release a new version of the GEM, so that the updated Gem appears on rubygems and rubydoc
+
+- research automated solution, eg. rake
+- implement the solution
+
+As a Developer, I have flexible and modular formatters, so that I can format data into a new format
+
+- Define formatter categories, https://github.com/helpers/handlebars-helpers has 20 categories
+- Create modular formatters with tests
+
+### Tasks next on list
+
+add support for misc helper category
+
+- add noop/raw helper
+- add safe helper
+
+add support for category count, helper count and formatter count to readme.md
+
+## Stories and tasks
+
+### Stories - completed
+
 As a Developer, I can easily render Handlebar Templates, so that I am more efficient
 
 - Build simplified API for rendering templates
 
+As a Developer, I can have string case formatting helpers, so that I can generate code and documentation using handlebars
+
 As a Developer, I can alias existing helpers, so that I have helper names that make sense to me
 
 - Provide a flexible mechanism for template aliases
@@ -20,16 +51,23 @@ As a Developer, I can load specific groups of helpers, so that memory consumptio
 
 - Lazy load ruby helpers on an as needed basis
 
-### Tasks next on list
+### Tasks - completed
 
-Setup RubyGems and RubyDoc
+refactor inflections namespace
 
-- Build and deploy gem to rubygems.org
-- Attach documentation to [rubydoc.info](https://rubydoc.info/github/klueless-io/handlebars-helpers/master)
+- Move pluralize and singularize to inflections
+- Add support for ordinalize case, eg. 1st, 2nd, 3rd, 4th
+- Add support for ordinal case, eg. st, nd, rd, th
 
-## Stories and tasks
+String tokenizer that formats input strings in a consistent fashion
 
-### Tasks - completed
+- Setup a single opinionated string tokenizer
+- Make the string tokenizer configurable so it can be replaced with a different opinionated tokenizer
+
+Setup RubyGems and RubyDoc
+
+- Build and deploy gem to [rubygems.org](https://rubygems.org/gems/handlebars-helpers)
+- Attach documentation to [rubydoc.info](https://rubydoc.info/github/klueless-io/handlebars-helpers/master)
 
 Setup GitHub Action (test and lint)
 

data/handlebars-helpers.gemspec

@@ -39,4 +39,6 @@ Gem::Specification.new do |spec|
   # spec.extensions    = ['ext/handlebars_helpers/extconf.rb']
 
   # spec.add_dependency 'tty-box',         '~> 0.5.0'
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'handlebars'
 end

data/lib/handlebars/helpers.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'handlebars/helpers/version'
+require 'handlebars/helpers/template'
+require 'handlebars/helpers/register_helpers'
 
 module Handlebars
   module Helpers

data/lib/handlebars/helpers/base_helper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'handlebars/helpers/configuration'
+
+module Handlebars
+  module Helpers
+    # base helper provides an interface to wrap your parsing logic
+    # in a Handlebars aware context
+    class BaseHelper
+      # Wrap the parse method in a handlebars context
+      # aware block that is used during registration
+      def handlebars_helper
+        proc { |_context, value| wrapper(parse(value)) }
+      end
+
+      # All child classes will generally implement this method
+      def parse(value)
+        value
+      end
+
+      # If you need to wrap the return value in a specific
+      # Handlebars Type, eg. SafeString, then you can override
+      # this method
+      def wrapper(value)
+        value
+      end
+
+      # String tokenizer will clean up a string so that
+      # all sorts of case formatted strings can be
+      # represented in a consistent fashion
+      def tokenizer
+        @_tokenizer ||= Handlebars::Helpers.configuration.tokenizer
+      end
+    end
+  end
+end

data/lib/handlebars/helpers/base_safe_string_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'handlebars/safe_string'
+require 'handlebars/helpers/configuration'
+require 'handlebars/helpers/base_helper'
+
+module Handlebars
+  module Helpers
+    # base safe string helper provides will return a Handlebars::SafeString
+    # which allows characters like < > " to be rendered as is
+    class BaseSafeStringHelper < BaseHelper
+      def wrapper(value)
+        Handlebars::SafeString.new(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# 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
+      # Classify: Creates a class name from a plural table name like Rails does for table names to models.
+      class Classify < Handlebars::Helpers::BaseHelper
+        # Parse will create a class name from a plural table name like Rails does for table names to models.
+        #
+        # @example
+        #
+        #   puts Classify.new.parse('product_categories')
+        #
+        #   ProductCategory
+        #
+        # @example
+        #
+        #   puts Classify.new.parse('product_category')
+        #
+        #   ProductCategory
+        #
+        # @param [String] value - name of the ruby class in plural or singular notation
+        # @return [String] value converted to ruby class notation
+        def parse(value)
+          tokenizer.parse(value, separator: '_', forced_separator: true).classify
+        end
+
+        def handlebars_helper
+          proc { |_context, value| wrapper(parse(value)) }
+        end
+      end
+    end
+  end
+end

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