app_archetype 1.2.3

data/lib/app_archetype/generators.rb

@@ -0,0 +1,95 @@
+module AppArchetype
+  # Generators create empty projects for the app_archetype gem
+  module Generators
+    # Default variables provided to new projects
+    DEFAULT_VARS = {
+      'example_string' => {
+        'type' => 'string',
+        'description' => 'This is an example string variable',
+        'default' => 'default value'
+      },
+      'example_random_string' => {
+        'type' => 'string',
+        'description' => 'Example call to helper to generate 25 char string',
+        'value' => '#random_string,25'
+      }
+    }.freeze
+
+    # Function that creates a named, empty manifest for new templates
+    TEMPLATE_MANIFEST = lambda do |name|
+      {
+        'name' => name,
+        'version' => '1.0.0',
+        'metadata' => {
+          'app_archetype' => {
+            'version' => AppArchetype::VERSION
+          }
+        },
+        'variables' => DEFAULT_VARS
+      }
+    end
+
+    # Function that creates a readme for a new blank template
+    TEMPLATE_README = lambda do |name|
+      <<~MD
+        # #{name} Template
+
+        ## Installation
+
+        To generate:
+
+        ```bash
+          cd $HOME/Code
+          mkdir my_#{name}
+          cd $HOME/Code/my_#{name}
+
+          archetype render #{name}
+        ```
+      MD
+    end
+
+    class <<self
+      ##
+      # Render empty template renders a manifest and template folder at
+      # the given path.
+      #
+      # The name param will be rendered into the template manifest at
+      # runtime
+      #
+      # @param [String] name
+      # @param [String] path
+      #
+      def render_empty_template(name, path)
+        template_path = File.join(path, name)
+        manifest_path = File.join(path, 'manifest.json')
+        readme_path = File.join(path, 'README.md')
+
+        make_template_dir(template_path)
+        render_manifest(manifest_path, name)
+        render_readme(readme_path, name)
+      end
+
+      private
+
+      def make_template_dir(path)
+        FileUtils.mkdir_p(path)
+      end
+
+      def render_manifest(path, name)
+        File.open(path, 'w') do |f|
+          f.write(
+            TEMPLATE_MANIFEST.call(name).to_json
+          )
+        end
+      end
+
+      def render_readme(path, name)
+        File.open(path, 'w') do |f|
+          f.write(
+            TEMPLATE_README.call(name)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/app_archetype/logger.rb

@@ -0,0 +1,69 @@
+module AppArchetype
+  # CLI Logging methods
+  module Logger
+    ##
+    # Creates logger for printing messages
+    #
+    # Sets the formatter to output only the provided message to the
+    # specified IO
+    #
+    # @param [IO] out - default: STDOUT
+    #
+    # @return [::Logger]
+    #
+    def logger(out = STDOUT)
+      @logger ||= ::Logger.new(out)
+      @logger.formatter = proc do |_sev, _time, _prog, msg|
+        "#{msg}\n"
+      end
+
+      @logger
+    end
+
+    ##
+    # Prints command line message to STDOUT
+    #
+    # For use when printing info messages for a user to STDOUT
+    #
+    # @param [String] message - message to be printed
+    #
+    def print_message(message)
+      logger.info(message)
+    end
+
+    ##
+    # Prints warning to STDOUT
+    #
+    # For use when printing warn messages to STDOUT
+    #
+    # @param [String] message - message to be printed
+    #
+    def print_warning(message)
+      logger.warn(message)
+    end
+
+    ##
+    # Prints error to STDERR
+    #
+    # For indicating fatal message to user
+    #
+    # @param [String] message - message to be printed
+    #
+    def print_error(message)
+      logger(STDERR).error(message)
+    end
+
+    ##
+    # Prints a message and then exits with given status code
+    #
+    # This will terminate the program with the given status code
+    #
+    # @param [String] message - message to be printed
+    # @param [Integer] exit_code - exit status (default: 1)
+    #
+    def print_message_and_exit(message, exit_code = 1)
+      print_message(message)
+      exit(exit_code)
+    end
+  end
+end

data/lib/app_archetype/renderer.rb

@@ -0,0 +1,116 @@
+require 'fileutils'
+require 'erb'
+require 'ruby-handlebars'
+
+module AppArchetype
+  # Renderer renders a plan
+  class Renderer
+    include AppArchetype::Logger
+
+    ##
+    # Creates a renderer instance
+    #
+    # @param [AppArchetype::Template::Plan] plan
+    # @param [Boolean] overwrite
+    #
+    def initialize(plan, overwrite = false)
+      @plan = plan
+      @overwrite = overwrite
+    end
+
+    ##
+    # Renders plan to disk. The renderer is capable of:
+    # - creating directories
+    # - Rendering ERB templates with plan variables
+    # - Rendering Handlebars templates with plan variables
+    # - Copying static files
+    #
+    # When a template requests a varaible that does not exist within
+    # the plan - then the rendering process stops and a RuntimeError
+    # is raised
+    #
+    # Similarly when a template cannot be parsed a Runtime Error will
+    # be raised.
+    #
+    def render
+      write_dir(File.new(@plan.destination_path))
+
+      @last_file = ''
+      @plan.files.each do |file|
+        @last_file = file
+        if file.source_directory?
+          write_dir(file)
+        elsif file.source_erb?
+          render_erb_file(file)
+        elsif file.source_hbs?
+          render_hbs_file(file)
+        elsif file.source_file?
+          copy_file(file)
+        end
+      end
+    rescue NoMethodError => e
+      raise "error rendering #{@last_file.path} "\
+            "cannot find variable `#{e.name}` in template"
+    rescue SyntaxError
+      raise "error parsing #{@last_file.path} template is invalid"
+    end
+
+    ##
+    # Creates a directory at the specified location
+    #
+    # @param [AppArchetype::Template::OutputFile] file
+    #
+    def write_dir(file)
+      print_message("CREATE dir -> #{file.path}")
+
+      FileUtils.mkdir_p(file.path)
+    end
+
+    ##
+    # Renders erb template to output location
+    #
+    # @param [AppArchetype::Template::OutputFile] file
+    #
+    def render_erb_file(file)
+      raise 'cannot overwrite file' if file.exist? && !@overwrite
+
+      print_message("RENDER erb ->: #{file.path}")
+      input = File.read(file.source_file_path)
+      out = ERB.new(input).result(@plan.variables.instance_eval { binding })
+
+      File.open(file.path.gsub('.erb', ''), 'w+') { |f| f.write(out) }
+    end
+
+    ##
+    # Renders handlebars template to output location
+    #
+    # @param [AppArchetype::Template::OutputFile] file
+    #
+    def render_hbs_file(file)
+      raise 'cannot overwrite file' if file.exist? && !@overwrite
+
+      print_message("RENDER hbs ->: #{file.path}")
+
+      input = File.read(file.source_file_path)
+
+      hbs = Handlebars::Handlebars.new
+      out = hbs.compile(input).call(@plan.variables.to_h)
+
+      File.open(file.path.gsub('.hbs', ''), 'w+') { |f| f.write(out) }
+    end
+
+    ##
+    # Copies source file to planned path only ovewriting if permitted by the
+    # renderer.
+    #
+    # @param [AppArchetype::Template::OutputFile] file
+    #
+    def copy_file(file)
+      raise 'cannot overwrite file' if file.exist? && !@overwrite
+
+      print_message("COPY file ->: #{file.path}")
+
+      FileUtils.cp(file.source_file_path, file.path)
+    end
+  end
+end

data/lib/app_archetype/template.rb

@@ -0,0 +1,12 @@
+require 'app_archetype/template/helpers'
+require 'app_archetype/template/source'
+require 'app_archetype/template/variable_manager'
+require 'app_archetype/template/variable'
+require 'app_archetype/template/manifest'
+require 'app_archetype/template/plan'
+
+module AppArchetype
+  # Template is a namespace for template components
+  module Template
+  end
+end

data/lib/app_archetype/template/helpers.rb

@@ -0,0 +1,216 @@
+require 'securerandom'
+
+module AppArchetype
+  module Template
+    # Template rendering helpers
+    module Helpers
+      # dot provides a convenient way for a noop render at the
+      # beginning of dotfiles
+      def dot
+        ''
+      end
+
+      ##
+      # Returns this year as YYYY
+      #
+      # @return [String]
+      #
+      def this_year
+        Time.now.strftime('%Y')
+      end
+
+      ##
+      # Returns timestamp at current time
+      #
+      # @return [String]
+      #
+      def timestamp_now
+        Time.now.strftime('%Y%m%d%H%M%S%L')
+      end
+
+      ##
+      # Returns timestamp at utc current time
+      #
+      # @return [String]
+      #
+      def timestamp_utc_now
+        Time.now.utc.strftime('%Y%m%d%H%M%S%L')
+      end
+
+      ##
+      # Generates a random string at specified length
+      #
+      # @param [String] length
+      def random_string(length = '256')
+        length = length.to_i
+        key_set = ('a'..'z').to_a + ('A'..'Z').to_a + (0..9).to_a
+        (0...length).map { key_set[Random.rand(0..key_set.length)] }.join
+      end
+
+      ##
+      # Randomizes a given string by addding a slice of a hex
+      # to the end of it at the specified size.
+      #
+      # The template will pass through a string as arguments for this
+      # function, thus it must accept a string as an argument.
+      #
+      # @param [String] string
+      # @param [String] size
+      #
+      # @return [String]
+      def randomize(string, size = '5')
+        size = size.to_i
+        raise 'size must be an integer' unless size.is_a?(Integer) && size != 0
+        raise 'randomize supports up to 32 characters' if size > 32
+
+        hex = SecureRandom.hex
+        suffix = hex[hex.length - size..hex.length]
+
+        "#{string}_#{suffix}"
+      end
+
+      ##
+      # Converts a string to upper case
+      #
+      # @param [String] string
+      #
+      # @return [String]
+      #
+      def upcase(string)
+        string.upcase
+      end
+
+      ##
+      # Converts a string to lower case
+      #
+      # @param [String] string
+      #
+      # @return [String]
+      def downcase(string)
+        string.downcase
+      end
+
+      ##
+      # Joins a string with specified delimiter
+      #
+      # @param [String] delim
+      # @param [Array] strings
+      #
+      # @return [String]
+      def join(delim, *strings)
+        strings.join(delim)
+      end
+
+      ##
+      # Changes a string into snake case. Useful for
+      # converting class names to function or file names.
+      #
+      # @example
+      #   str = 'AGreatExample'
+      #   puts snake_case(str) # => outputs 'a_great_example'
+      #
+      # @param [String] string
+      #
+      # @return [String]
+      #
+      def snake_case(string)
+        return string.downcase if string =~ /\A[A-Z]+\z/
+
+        string
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z])([A-Z])/, '\1_\2')
+          .gsub(/\s/, '_')
+          .tr('-', '_')
+          .downcase
+      end
+
+      ##
+      # Downcase and converts a string into dashcase string
+      #
+      # @example
+      #   str = 'AGreatExample'
+      #   puts = dash_case(str) # => outputs 'a-great-example'
+
+      def dash_case(string)
+        return string.downcase if string =~ /\A[A-Z]+\z/
+
+        string
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1-\2')
+          .gsub(/([a-z])([A-Z])/, '\1-\2')
+          .tr(' ', '-')
+          .tr('_', '-')
+          .downcase
+      end
+
+      ##
+      # Camelcases a given string
+      #
+      # Usage:
+      # in_string = "an example"
+      # out_string = camel_case(in_string) => AnExample
+      #
+      # @param [String] string
+      # @return [String]
+      def camel_case(string)
+        str = snake_case(string)
+        snake_to_camel(str)
+      end
+
+      ##
+      # Converts snake case string to camelcase
+      #
+      # Usage:
+      # in_string = "an_example"
+      # out_string = snake_to_camel(in_string) => AnExample
+      #
+      # @param [String] string
+      # @return [String]
+      def snake_to_camel(string)
+        str = snake_case(string)
+        str.to_s.split('_').map(&:capitalize).join('')
+      end
+
+      ##
+      # Attempts to pluralize a word
+      #
+      # Usage:
+      # in_string = "Thing"
+      # out_string = pluralize(in_string) => "Things"
+      #
+      # @param [String] string
+      # @return [String]
+      #
+      def pluralize(string)
+        str = string.to_s
+
+        if str.match(/([^aeiouy]|qu)y$/i)
+          str = str.gsub(/y\Z/, 'ies')
+        else
+          str << 's'
+        end
+
+        str
+      end
+
+      ##
+      # Singularizes plural words
+      #
+      # Usage:
+      # in_string = "Things"
+      # out_string = singularize(in_string) => "Thing"
+      #
+      # @param [String] string
+      # @return [String]
+      #
+      def singularize(string)
+        str = string.to_s
+
+        if str.end_with?('ies')
+          str.gsub(/ies\Z/, 'y')
+        else
+          str.gsub(/s\Z/, '')
+        end
+      end
+    end
+  end
+end