giter8 0.1.1

data/lib/giter8/renderer/executor.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Giter8
+  # Module Renderer implements all mechanisms related to template rendering
+  module Renderer
+    # Executor implements methods for rendering remplates
+    class Executor
+      # Initializes the executor with a given Pairs set
+      def initialize(props)
+        @props = props
+      end
+
+      # Returns a string after rendering the provided AST tree with the Pairs
+      # provided upon initialisation
+      def exec(tree)
+        result = StringIO.new
+        exec_tree(tree, result)
+        result.string
+      end
+
+      private
+
+      # Returns a string array containing all formatting options present in the
+      # template's format options.
+      def extract_format_options(template)
+        unless template.is_a? Giter8::Template
+          raise Giter8::Error, "Can't call extract_format_options on non-template value"
+        end
+        return nil if template.options.empty?
+
+        all_forms = template.options.fetch(:format)
+        return nil if all_forms.nil?
+
+        all_forms.split(",").map(&:strip)
+      end
+
+      # Execute all formatting helpers (if any) for a given Template instance,
+      # returning the expanded variable value with all formatting applied.
+      def run_methods(template)
+        unless template.is_a? Giter8::Template
+          raise(Giter8::Error,
+                "Can't call run_methods on non-template value")
+        end
+
+        val = @props.fetch(template.name)
+        if val.nil?
+          raise Giter8::PropertyNotFoundError.new(template.name, template.source, template.line,
+                                                  template.column)
+        end
+
+        opts = extract_format_options(template)
+        unless opts.nil?
+          return opts.inject(val) do |value, method_name|
+            fn = HELPERS.fetch(method_name, nil)
+            if fn.nil?
+              raise Giter8::FormatterNotFoundError.new(method_name, template.source, template.line,
+                                                       template.column)
+            end
+
+            fn.call(value)
+          end
+        end
+
+        val
+      end
+
+      # Evaluates and returns a boolean value for a given Conditional instance
+      # of an AST.
+      def evaluate_conditional_expression(cond)
+        val = @props.find_pair(cond.property)
+        helper = cond.helper
+        helper = helper.downcase
+
+        return nil if %w[truthy present].include?(helper) && val.nil?
+
+        raise Giter8::PropertyNotFoundError.new(cond.property, cond.source, cond.line, cond.column) if val.nil?
+
+        case helper
+        when "truthy"
+          val.truthy?
+        when "present"
+          return nil if val.value.nil?
+
+          !val.value.strip.empty?
+        else
+          raise "BUG: helper #{helper} allowed by parser, but not implemented by renderer"
+        end
+      end
+
+      # Evaluates a given Conditional instance and writes a matching branch to
+      # the provided Writer. Returns whether a branch was matched.
+      def evaluate_conditional(cond, writer)
+        unless cond.is_a? Giter8::Conditional
+          raise Giter8::Error,
+                "Can't call evaluate_conditional on non-conditional type"
+        end
+
+        ok = evaluate_conditional_expression(cond)
+        if ok
+          exec_tree(cond.cond_then, writer)
+          return true
+        end
+
+        cond.cond_else_if.each do |inner_cond|
+          return true if evaluate_conditional(inner_cond, writer)
+        end
+
+        unless cond.cond_else.nil?
+          exec_tree(cond.cond_else, writer)
+          return true
+        end
+
+        false
+      end
+
+      # Recursively iterate a provided AST tree and writes its results to the
+      # provided writer.
+      def exec_tree(tree, writer)
+        tree.each do |node|
+          case node
+          when Giter8::Literal
+            writer << node.value
+          when Giter8::Template
+            writer << run_methods(node)
+          when Giter8::Conditional
+            evaluate_conditional(node, writer)
+          else
+            raise Giter8::Error, "BUG: Unexpected node type #{node.class.name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/giter8/renderer/utils.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Giter8
+  # nodoc
+  module Renderer
+    WORD_ONLY_REGEXP = /[^a-zA-Z0-9_]/.freeze
+    WORD_SPACE_REGEXP = /[^a-zA-Z0-9]/.freeze
+    SNAKE_CASE_REGEXP = /[\s.]/.freeze
+    ALPHABET = ((65..90).to_a + (97..122).to_a).map(&:chr).freeze
+
+    def self.uppercase(val)
+      val.upcase
+    end
+
+    def self.lowercase(val)
+      val.downcase
+    end
+
+    def self.capitalize(val)
+      val.capitalize
+    end
+
+    def self.decapitalize(val)
+      lowercase(val)
+    end
+
+    def self.start_case(val)
+      val.split.map(&:capitalize)
+    end
+
+    def self.word_only(val)
+      val.gsub(WORD_ONLY_REGEXP, "")
+    end
+
+    def self.word_space(val)
+      val.gsub(WORD_SPACE_REGEXP, " ")
+    end
+
+    def self.upper_camel(val)
+      word_only(start_case(val))
+    end
+
+    def self.lower_camel(val)
+      decapitalize(word_only(start_case(val)))
+    end
+
+    def self.hyphenate(val)
+      val.gsub(/\s/, "-")
+    end
+
+    def self.normalize(val)
+      lowercase(hyphenate(val))
+    end
+
+    def self.snake_case(val)
+      val.gsub(SNAKE_CASE_REGEXP, "_")
+    end
+
+    def self.package_naming(val)
+      val.gsub(/\s/, ".")
+    end
+
+    def self.package_dir(val)
+      val.gsub(/\./, "/")
+    end
+
+    def self.random
+      ALPHABET.sample(40).join
+    end
+
+    HELPERS = {
+      "upper" => method(:uppercase),
+      "uppercase" => method(:uppercase),
+      "lower" => method(:lowercase),
+      "lowercase" => method(:lowercase),
+      "cap" => method(:capitalize),
+      "capitalize" => method(:capitalize),
+      "decap" => method(:decapitalize),
+      "decapitalize" => method(:decapitalize),
+      "start" => method(:start_case),
+      "start-case" => method(:start_case),
+      "word" => method(:word_only),
+      "word-only" => method(:word_only),
+      "space" => method(:word_space),
+      "word-space" => method(:word_space),
+      "Camel" => method(:upper_camel),
+      "upper-camel" => method(:upper_camel),
+      "camel" => method(:lower_camel),
+      "lower-camel" => method(:lower_camel),
+      "hyphen" => method(:hyphenate),
+      "hyphenate" => method(:hyphenate),
+      "norm" => method(:normalize),
+      "normalize" => method(:normalize),
+      "snake" => method(:snake_case),
+      "snake-case" => method(:snake_case),
+      "package" => method(:package_naming),
+      "package-naming" => method(:package_naming),
+      "packaged" => method(:package_dir),
+      "package-dir" => method(:package_dir),
+      "random" => method(:random),
+      "generate-random" => method(:random)
+    }.freeze
+  end
+end

data/lib/giter8/template.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Giter8
+  # Template represents a Template variable in an AST. Contains a source file,
+  # the line and column where the template begins, the variable name to be
+  # looked up, a set of options, and the parent to which the node belongs to.
+  class Template
+    attr_accessor :source, :line, :column, :name, :options, :parent
+
+    def initialize(name, options, parent, source, line, column)
+      @source = source
+      @line = line
+      @column = column
+      @name = name
+      @options = options
+      @parent = parent
+    end
+  end
+end

data/lib/giter8/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Giter8
+  VERSION = "0.1.1"
+end

data/lib/giter8.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "stringio"
+require "fileutils"
+
+require_relative "giter8/version"
+require_relative "giter8/error"
+require_relative "giter8/pair"
+require_relative "giter8/pairs"
+require_relative "giter8/literal"
+require_relative "giter8/template"
+require_relative "giter8/conditional"
+require_relative "giter8/ast"
+
+require_relative "giter8/parsers/pairs_parser"
+require_relative "giter8/parsers/template_parser"
+
+require_relative "giter8/renderer/utils"
+require_relative "giter8/renderer/executor"
+
+require_relative "giter8/fs/fs"
+
+require "ptools"
+
+# Giter8 implements a parser and renderer for Giter8 templates
+module Giter8
+  # Parses a given String, Hash or File into a Pairs set. When parsing from a
+  # File object, file metadata is used on error messages. The parser ignores
+  # any content beginning with a hash (#) until the end of the line. Properties
+  # are composed of a key comprised of a-z characters, numbers (0-9), unerscores
+  # and dashes. When a file is passed, the caller is responsible for closing it.
+  def self.parse_props(props)
+    return props if props.is_a? Pairs
+
+    if [String, Hash, File].none? { |type| props.is_a? type }
+      raise Giter8::Error, "parse_props can only be used with strings, hashes, and files. Got #{props.class.name}"
+    end
+
+    opts = {}
+    if props.is_a? File
+      opts[:source] = props.path
+      props = props.read
+    end
+    return Parsers::PairsParser.parse(props, opts) if props.is_a? String
+
+    Pairs.new(props)
+  end
+
+  # Parses a provided Giter8 template from a String or File. When a File is
+  # provided, its name will be used in error metadata. Also, when using a File
+  # object, the caller is responsible for closing it.
+  # Returns an AST object containing the file's contents.
+  def self.parse_template(template)
+    if [String, File, AST].none? { |type| template.is_a? type }
+      raise Giter8::Error, "parse_template can only be used with strings and files. Got #{template.class.name}"
+    end
+
+    return template if template.is_a? AST
+
+    opts = {}
+    if template.is_a? File
+      opts[:source] = template.path
+      template = template.read
+    end
+
+    Parsers::TemplateParser.parse(template, opts)
+  end
+
+  # Renders a given template using a set of props. Template may be a
+  # String or File, while props can be a Hash, String, or File. When providing
+  # a File to either parameter, the caller is responsible for closing it.
+  # Returns a string containing the rendered contents.
+  def self.render_template(template, props)
+    template = parse_template template
+    props = parse_props props
+
+    executor = Renderer::Executor.new(props)
+    executor.exec(template)
+  end
+
+  # Renders a provided input directory into an output directory using a provided
+  # props set.
+  def self.render_directory(props, input, output)
+    raise Giter8::Error, "Input directory #{input} does not exist" unless File.exist?(input)
+    raise Giter8::Error, "Input path #{input} is not a directory" unless File.stat(input).directory?
+    raise Giter8::Error, "Destination path #{output} already exists" if File.exist?(output)
+
+    FS.render(props, input, output)
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: giter8
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Victor Gama
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ptools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+description: giter8 implements giter8 rendering mechanisms
+email:
+- hey@vito.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- giter8.gemspec
+- lib/giter8.rb
+- lib/giter8/ast.rb
+- lib/giter8/conditional.rb
+- lib/giter8/error.rb
+- lib/giter8/fs/fs.rb
+- lib/giter8/literal.rb
+- lib/giter8/pair.rb
+- lib/giter8/pairs.rb
+- lib/giter8/parsers/pairs_parser.rb
+- lib/giter8/parsers/template_parser.rb
+- lib/giter8/renderer/executor.rb
+- lib/giter8/renderer/utils.rb
+- lib/giter8/template.rb
+- lib/giter8/version.rb
+homepage: https://github.com/heyvito/giter8.rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/heyvito/giter8.rb
+  source_code_uri: https://github.com/heyvito/giter8.rb
+  changelog_uri: https://github.com/heyvito/giter8.rb
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: giter8 implements giter8 rendering mechanisms
+test_files: []