giter8 0.1.1

data/lib/giter8/ast.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Giter8
+  # AST represents a set of nodes of a template file
+  class AST
+    extend Forwardable
+
+    LEADING_LINEBREAK_REGEXP = /^\r?\n/.freeze
+
+    def initialize
+      @nodes = []
+    end
+
+    def_delegators :@nodes, :push, :<<, :each, :each_with_index, :empty?,
+                   :length, :[], :last, :first, :map!, :map, :find, :shift,
+                   :unshift
+
+    # Returns whether this AST node is composed exclusively by Literals
+    def pure_literal?
+      all? { |v| v.is_a? Literal }
+    end
+
+    # Cleans up this AST's nodes in-place.
+    def clean!
+      @nodes = clean.instance_variable_get(:@nodes)
+    end
+
+    # Cleans leading linebreaks from the provided node
+    def clean_conditional_ast(node)
+      return node if node.empty? || !node.first.is_a?(Literal)
+
+      cond = node.first
+      cond.value.sub!(LEADING_LINEBREAK_REGEXP, "")
+      node.shift
+      node.unshift(cond) unless cond.value.empty?
+      node
+    end
+
+    # clean_node attempts to sanitise a provide node under a given index
+    # in this AST
+    def clean_node(node, idx)
+      if node.is_a?(Conditional)
+        # Remove leading linebreak from ASTs inside conditionals
+        node.cond_then = clean_conditional_ast(node.cond_then.clean)
+        node.cond_else = clean_conditional_ast(node.cond_else.clean)
+
+        # cond_else_if contains a list of Condition objects, which
+        # need special handling.
+        node.cond_else_if.clean!
+      end
+
+      if node.is_a?(Literal) && idx.positive? && self[idx - 1].is_a?(Conditional)
+        # Remove leading linebreak from Literals following conditionals
+        node.value.sub!(LEADING_LINEBREAK_REGEXP, "")
+        return if node.value.empty?
+      end
+      node
+    end
+
+    # Returns a new AST node containing this node's after cleaning them.
+    def clean
+      ast = AST.new
+      ast.push(*each_with_index.map(&method(:clean_node)).reject(&:nil?))
+      ast
+    end
+  end
+end

data/lib/giter8/conditional.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Giter8
+  # Represents a conditional structure in an AST
+  class Conditional
+    attr_accessor :source, :line, :column, :property, :helper, :cond_then,
+                  :cond_else_if, :cond_else, :parent
+
+    TRUTHY_VALUES = %w[yes y true].freeze
+
+    # Returns whether a provided value is considered as "truthy". Giter8
+    # assumes the values "yes", "y", and "true" as true. Any other value
+    # is assumed to be false.
+    def self.truthy?(value)
+      if value.nil?
+        nil
+      elsif value.is_a? Literal
+        truthy?(value.value)
+      elsif value.is_a? String
+        TRUTHY_VALUES.any? { |e| e.casecmp(value).zero? }
+      end
+    end
+
+    def initialize(property, helper, parent, source, line, column)
+      @source = source
+      @line = line
+      @column = column
+      @property = property
+      @helper = helper
+      @parent = parent
+
+      @cond_then = AST.new
+      @cond_else_if = AST.new
+      @cond_else = AST.new
+    end
+
+    # Cleans this Conditional's branches by calling AST#clean, and returns a
+    # copy of this instance.
+    def clean
+      cond = Conditional.new(@property, @helper, @parent, @source, @line, @column)
+
+      cond.cond_then = @cond_then.clean
+      cond.cond_else = @cond_else.clean
+      cond.cond_else_if = @cond_else_if.clean
+
+      cond
+    end
+
+    # clean! executes the same operation as #clean, but updates this instance
+    # instead of returning a copy.
+    def clean!
+      @cond_then = @cond_then.clean
+      @cond_else = @cond_else.clean
+      @cond_else_if = @cond_else_if.clean
+    end
+  end
+end

data/lib/giter8/error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Giter8
+  class Error < StandardError; end
+
+  # PropertyNotFoundError indicates that a template referenced a variable not
+  # defined by the property pairs provided to the renderer.
+  class PropertyNotFoundError < Error
+    def initialize(prop_name, source, line, column)
+      super("Property `#{prop_name}' is not defined at #{source}:#{line}:#{column}")
+    end
+  end
+
+  # FormatterNotFoundError indicates that a template variable referenced a
+  # formatter not known by the renderer.
+  class FormatterNotFoundError < Error
+    def initialize(name, source, line, column)
+      super("Formatter `#{name}' is not defined at #{source}:#{line}:#{column}")
+    end
+  end
+end

data/lib/giter8/fs/fs.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Giter8
+  # FS implements filesystem-related methods for handling template directories
+  class FS
+    # Returns whether the provided path must be copied verbatim by the renderer
+    # instead of being handled by parsers.
+    def self.verbatim?(path, ignore_patterns)
+      return false if ignore_patterns.empty?
+
+      ignore_patterns.any? do |pattern|
+        File.fnmatch? pattern, path
+      end
+    end
+
+    # Returns whether a given path contains a binary file.
+    def self.binary?(path)
+      File.binary?(path)
+    end
+
+    # Recursively enumerate paths inside a given path and returns a list
+    # of files, except "default.properties".
+    def self.enumerate(path)
+      original_path = path
+      path = "#{path}/**/*" unless path.match?(%r{/\*})
+      Dir.glob(path)
+         .select { |e| File.stat(e).file? }
+         .reject { |e| File.basename(e) == "default.properties" }
+         .collect { |e| e[original_path.length + 1..] }
+    end
+
+    def self.handle_file_copy(from, to)
+      FileUtils.cp(from, to)
+    end
+
+    def self.handle_file_render(props, source, destination)
+      f = File.open(source)
+      rendered = Giter8.render_template(f, props)
+      f.close
+
+      File.write(destination, rendered, 0, mode: "w")
+    end
+
+    # Optimistically attempt to render a file name. Returns the name verbatim
+    # in case parsing or rendering fails.
+    def self.render_file_name(name, props)
+      ast = Giter8.parse_template(name)
+      Giter8.render_template(ast, props)
+    rescue Giter8::Error
+      name
+    end
+
+    # Renders the contents of a given input directory into a destination,
+    # creating directories as required, using provided opts to render templates.
+    def self.render(props, input, output)
+      FileUtils.mkdir_p output
+      props = Giter8.parse_props(props)
+
+      verbatim = []
+      verbatim = props.fetch(:verbatim).split if props.key? :verbatim
+
+      enumerate(input).each do |file|
+        source = File.absolute_path(File.join(input, file))
+        output_file_name = render_file_name(file, props)
+        destination = File.absolute_path(File.join(output, output_file_name))
+        FileUtils.mkdir_p File.dirname(destination)
+        if verbatim?(source, verbatim)
+          handle_file_copy(source, destination)
+        else
+          handle_file_render(props, source, destination)
+        end
+      end
+    end
+  end
+end

data/lib/giter8/literal.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Giter8
+  # Literal represents a sequence of one or more characters not separated by
+  # either a Template or Condition node.
+  class Literal
+    extend Forwardable
+    attr_accessor :source, :line, :column, :value, :parent
+
+    def initialize(value, parent, source, line, column)
+      @source = source
+      @line = line
+      @column = column
+      @value = value
+      @parent = parent
+    end
+
+    def_delegators :@value, :empty?
+    def_delegators :@value, :start_with?
+
+    # Returns whether this node's value is comprised solely of a linebreak
+    def linebreak?
+      ["\r\n", "\n"].include? @value
+    end
+
+    def inspect
+      parent = @parent
+      parent = if parent.nil?
+                 "nil"
+               else
+                 "#<#{@parent.class.name}:#{format("%08x", (@parent.object_id * 2))}>"
+               end
+      "#<#{self.class.name}:#{format("%08x", (object_id * 2))} line=#{@line} value=#{@value.inspect} parent=#{parent}>"
+    end
+  end
+end

data/lib/giter8/pair.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Giter8
+  # Pair represent a key-value property pair
+  class Pair
+    PLAIN_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/.freeze
+
+    attr_accessor :key, :value
+
+    def initialize(key, value)
+      key = key.to_sym if !key.is_a?(Symbol) && PLAIN_KEY.match?(key)
+
+      @key = key
+      @value = value
+    end
+
+    # Determines whether the Pair's value contains a truthy value.
+    # See Conditional.truthy?
+    def truthy?
+      Conditional.truthy? @value
+    end
+
+    def ==(other)
+      same_pair = other.is_a?(Pair) && other.key == @key && other.value == @value
+      same_hash = other.is_a?(Hash) && other == { @key => @value }
+      same_hash || same_pair
+    end
+  end
+end

data/lib/giter8/pairs.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Giter8
+  # Pairs represents a set of property pairs
+  class Pairs
+    # Creates a new Pairs instance, optionally with a given map.
+    def initialize(map = {})
+      @pairs = map.map do |e|
+        if e.is_a? Pair
+          e
+        else
+          Pair.new(*e)
+        end
+      end
+    end
+
+    # Attempts to find a Pair instance with a given name among all propertines
+    # in the current set.
+    # Returns a Pair object, or nil, if the provided name does not match any
+    # Pair.
+    def find(name)
+      v = find_pair(name.to_sym)
+      return nil if v.nil?
+
+      v.value
+    end
+
+    # Returns the value associated with a given name, or an optional default
+    # argument. In case no default is provided, nil is returned.
+    def fetch(name, default = nil)
+      find(name) || default
+    end
+
+    # When a block is provided, invokes the block once for each Pair included in
+    # this set. Otherwise, returns an Enumerator for this instance.
+    def each(&block)
+      @pairs.each(&block)
+    end
+
+    # Invokes a given block once for each element in this set, providing the
+    # element's key and value as arguments, respectively.
+    def each_pair
+      each do |p|
+        yield p.key, p.value
+      end
+    end
+
+    # Returns a Pair value with a given name, or nil, in case no Pair matches
+    # the provided name.
+    def find_pair(name)
+      @pairs.find { |e| e.key == name.to_sym }
+    end
+
+    # Returns the current props represented as a Hash
+    def to_h
+      @pairs.map { |e| [e.key, e.value] }.to_h
+    end
+
+    # Returns whether a Pair with the provided name exists in the set
+    def key?(name)
+      !find(name).nil?
+    end
+
+    # Merges a provided Hash or Pairs instance into the current set
+    def merge(pairs)
+      pairs = Pairs.new(pairs) if pairs.is_a? Hash
+
+      pairs.each_pair do |k, v|
+        pair = find_pair(k)
+        if pair.nil?
+          @pairs << Pair.new(k, v)
+        else
+          idx = @pairs.index(pair)
+          pair.value = v
+          @pairs[idx] = pair
+        end
+      end
+    end
+  end
+end

data/lib/giter8/parsers/pairs_parser.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Giter8
+  module Parsers
+    # PairsParser implements an FSM for parsing a key-value string containing
+    # property pairs for rendering.
+    class PairsParser
+      STATE_KEY     = 0
+      STATE_VALUE   = 1
+      STATE_COMMENT = 2
+
+      CHR_SPACE           = " "
+      CHR_TAB             = "\t"
+      CHR_CARRIAGE_RETURN = "\r"
+      CHR_NEWLINE         = "\n"
+      CHR_HASH            = "#"
+      CHR_EQUAL           = "="
+      WHITE_CHARS = [CHR_SPACE, CHR_TAB, CHR_CARRIAGE_RETURN, CHR_NEWLINE].freeze
+      ALPHA_REGEXP = /[[:alpha:]]/.freeze
+
+      # Parses a given key-value pair list within a string with provided options.
+      # Options is a hash that currently only supports the :source key, which
+      # must be the name of the file being parsed. This key is used to identify
+      # any errors whilst parsing the contents and will be provided on any
+      # raised errors.
+      # Returns an Pairs object with the read properties.
+      def self.parse(input, opts = {})
+        new(opts).parse(input)
+      end
+
+      # Initialises a new PairsParser instance.
+      # See also: PairsParser.parse
+      def initialize(opts = {})
+        @pairs = []
+        @state = STATE_KEY
+        @tmp_key = []
+        @tmp_val = []
+        @source = opts[:source] || "unknown"
+        @column = 0
+        @line = 1
+      end
+
+      # Parses a given input string into key-value Pair objects.
+      # Returns an Pairs object of identified keys and values.
+      def parse(input)
+        input.chars.each do |chr|
+          chr = chr.chr
+          case @state
+          when STATE_KEY
+            parse_key(chr)
+
+          when STATE_COMMENT
+            @state = STATE_KEY if chr == CHR_NEWLINE
+
+          when STATE_VALUE
+            parse_value(chr)
+          end
+
+          @column += 1
+          if chr == CHR_NEWLINE
+            @line += 1
+            @column = 0
+          end
+        end
+
+        finish_parse
+      end
+
+      private
+
+      # Returns the current FSM's location as a string representation in the
+      # format SOURCE_FILE_NAME:LINE:COLUMN
+      def location
+        "#{@source}:#{line}:#{column}"
+      end
+
+      # Parses a given character into the current key's key property.
+      # Raises an error in case the character is not accepted as a valid
+      # candidate for a key identifier.
+      def parse_key(chr)
+        if @tmp_key.empty? && WHITE_CHARS.include?(chr)
+          nil
+        elsif @tmp_key.empty? && chr == CHR_HASH
+          @state = STATE_COMMENT
+        elsif @tmp_key.empty? && !ALPHA_REGEXP.match?(chr)
+          raise Giter8::Error, "unexpected char #{chr} at #{location}"
+        elsif chr == CHR_EQUAL
+          @state = STATE_VALUE
+        else
+          @tmp_key << chr
+        end
+      end
+
+      # Consumes provided characters until a newline is reached.
+      def parse_value(chr)
+        if chr != CHR_NEWLINE
+          @tmp_val << chr
+          return
+        end
+
+        push_result
+        @state = STATE_KEY
+      end
+
+      def reset_tmp
+        @tmp_key = []
+        @tmp_val = []
+      end
+
+      def push_result
+        @pairs << Pair.new(@tmp_key.join.strip, @tmp_val.join.strip)
+        reset_tmp
+      end
+
+      def finish_parse
+        raise Giter8::Error, "unexpected end of input at #{location}" if @state == STATE_KEY && !@tmp_key.empty?
+
+        push_result if @state == STATE_VALUE
+
+        result = Pairs.new(@pairs)
+        reset_tmp
+        @state = STATE_KEY
+        @pairs = []
+        result
+      end
+    end
+  end
+end