app_archetype 1.2.3

data/lib/app_archetype/template/manifest.rb

@@ -0,0 +1,193 @@
+require 'json-schema'
+require 'ostruct'
+require 'jsonnet'
+
+module AppArchetype
+  module Template
+    # Manifest is a description of an archetype
+    class Manifest
+      ##
+      # Minimum supported archetype version
+      #
+      MIN_ARCHETYPE_VERSION = '1.0.0'.freeze
+
+      ##
+      # Manifest JSON schema
+      #
+      SCHEMA = {
+        type: 'object',
+        required: %w[name version metadata variables],
+
+        properties: {
+          name: {
+            type: 'string'
+          },
+          version: {
+            type: 'string'
+          },
+          metadata: {
+            type: 'object',
+            required: %w[app_archetype],
+
+            properties: {
+              app_archetype: {
+                type: 'object',
+                required: %w[version]
+              }
+            }
+          },
+          variables: {
+            type: 'object'
+          }
+        }
+      }.freeze
+
+      class <<self
+        ##
+        # Creates a [AppArchetype::Template] from a manifest json so long as the
+        # manifest is compatible with this version of AppArchetype.
+        #
+        # @param [String] file_path
+        #
+        def new_from_file(file_path)
+          manifest = Jsonnet.evaluate(
+            File.read(file_path)
+          )
+
+          if incompatible?(manifest)
+            raise 'provided manifest is invalid or incompatible with '\
+            'this version of app archetype'
+          end
+
+          new(
+            file_path,
+            manifest
+          )
+        end
+
+        ##
+        # Incompatible returns true if the current manifest is not compatible
+        # with this version of AppArchetype.
+        #
+        # A manifest is not compatible if it was created with a version greater
+        # than this the installed version.
+        #
+        # @param [Hash] manifest
+        #
+        # @return [Boolean]
+        #
+        def incompatible?(manifest)
+          manifest_version = manifest['metadata']['app_archetype']['version']
+          return true if manifest_version < MIN_ARCHETYPE_VERSION
+          return true if manifest_version > AppArchetype::VERSION
+        rescue NoMethodError
+          true
+        end
+      end
+
+      attr_reader :path, :data, :variables
+
+      ##
+      # Creates a manifest and memoizes the manifest data hash as a Hashe::Map
+      #
+      # On initialize the manifest variables are retrieved and memoized for use
+      # in rendering the templates.
+      #
+      # @param [String] path
+      # @param [Hash] data
+      #
+      def initialize(path, data)
+        @path = path
+        @data = OpenStruct.new(data)
+        @variables = AppArchetype::Template::VariableManager
+                     .new(@data.variables)
+      end
+
+      ##
+      # Manifest name getter
+      #
+      # @return [String]
+      #
+      def name
+        @data.name
+      end
+
+      ##
+      # Manifest version getter
+      #
+      # @return [String]
+      #
+      def version
+        @data.version
+      end
+
+      ##
+      # Manifest metadata getter
+      #
+      # @return [String]
+      #
+      def metadata
+        @data.metadata
+      end
+
+      ##
+      # Parent path of the manifest (working directory)
+      #
+      # @return [String]
+      def parent_path
+        File.dirname(@path)
+      end
+
+      ##
+      # Template files path
+      #
+      # @return [String]
+      #
+      def template_path
+        File.join(parent_path, 'template')
+      end
+
+      ##
+      # Loads the template that is adjacent to the manifest.json or
+      # manifest.jsonnet file.
+      #
+      # If the template cannot be found, a RuntimeError explaining that
+      # the template cannot
+      # be found is raised.
+      #
+      # Loaded template is memoized for the current session.
+      #
+      # @return [AppArchetype::Template::Source]
+      def template
+        unless File.exist?(template_path)
+          raise "cannot find template for manifest #{name}"
+        end
+
+        @template ||= AppArchetype::Template::Source.new(template_path)
+        @template
+      end
+
+      ##
+      # Runs a schema validation on the given manifest to determine whether
+      # the schema is valid. Returns an array of validation messages.
+      #
+      # @return [Array]
+      def validate
+        JSON::Validator.fully_validate(
+          SCHEMA,
+          @data.to_h.to_json,
+          strict: true
+        )
+      end
+
+      ##
+      # Returns true if manifest is valid
+      #
+      # @return [Boolean]
+      #
+      def valid?
+        validate.empty?
+      end
+    end
+  end
+end

data/lib/app_archetype/template/plan.rb

@@ -0,0 +1,172 @@
+require 'ruby-handlebars'
+require_relative '../../core_ext/string'
+
+module AppArchetype
+  module Template
+    # Plan builds an in memory representation of template output
+    class Plan
+      attr_reader :template, :destination_path, :files, :variables
+
+      ##
+      # Creates a new plan from given source and variables.
+      #
+      # @param [AppArchetype::Template::Source] template
+      # @param [AppArchetype::Template::VariableManager] variables
+      # @param [String] destination_path
+      # @param [Boolean] overwrite
+      #
+      def initialize(
+        template,
+        variables,
+        destination_path: nil,
+        overwrite: false
+      )
+        @template = template
+        @destination_path = destination_path
+        @files = []
+        @variables = variables
+        @overwrite = overwrite
+      end
+
+      ##
+      # Devise builds an in memory representation of what needs to be done to
+      # render the template.
+      #
+      # When the destination path does not exist - a RuntimeError is raised -
+      # however at this stage we should always have a destination path to
+      # render to.
+      #
+      def devise
+        raise 'destination path does not exist' unless destination_exist?
+
+        @template.files.each do |file|
+          @files << OutputFile.new(
+            file,
+            render_dest_file_path(file)
+          )
+        end
+      end
+
+      ##
+      # Execute will render the plan to disk
+      #
+      def execute
+        renderer = Renderer.new(
+          self,
+          @overwrite
+        )
+
+        renderer.render
+      end
+
+      ##
+      # Check for whether the destination exists
+      #
+      # @return [Boolean]
+      def destination_exist?
+        return false unless @destination_path
+
+        File.exist?(
+          File.dirname(@destination_path)
+        )
+      end
+
+      ##
+      # Determines what the destination file path is going to be by taking
+      # the source path, subbing the template path and then joining it
+      # with the specified destination path.
+      #
+      # Calls render path to handle any handlebars moustaches included within
+      # the file name.
+      #
+      # @param [String] source_path
+      #
+      # @return [String]
+      def render_dest_file_path(source_path)
+        rel_path = render_path(
+          source_path.gsub(@template.path, '')
+        )
+
+        File.join(@destination_path, rel_path)
+      end
+
+      ##
+      # Renders template variables into any moustaches included in the filename
+      #
+      # This permits us to have variable file names as well as variable file
+      # content.
+      #
+      # @param [String] path
+      #
+      # @return [String]
+      #
+      def render_path(path)
+        hbs = Handlebars::Handlebars.new
+        hbs.compile(path).call(@variables.to_h)
+      end
+    end
+
+    # OutputFile represents a plan action, in other words holds a reference
+    # to a source file, and what the output is likely to be
+    class OutputFile
+      attr_reader :source_file_path, :path
+
+      ##
+      # Creates an output file
+      #
+      # @param [String] source_file_path
+      # @param [String] path
+      #
+      def initialize(source_file_path, path)
+        @source_file_path = source_file_path
+        @path = path
+      end
+
+      ##
+      # Evaluates whether the source file is a directory
+      #
+      # @return [Boolean]
+      #
+      def source_directory?
+        File.directory?(@source_file_path)
+      end
+
+      ##
+      # Evaluates whether the source file is a erb template
+      #
+      # @return [Boolean]
+      #
+      def source_erb?
+        File.extname(@source_file_path) == '.erb'
+      end
+
+      ##
+      # Evaluates whether the source file is a handlebars template
+      #
+      # @return [Boolean]
+      #
+      def source_hbs?
+        File.extname(@source_file_path) == '.hbs'
+      end
+
+      ##
+      # Evaluates whether the source file is a file as opposed to
+      # being a directory.
+      #
+      # @return [Boolean]
+      #
+      def source_file?
+        File.file?(@source_file_path)
+      end
+
+      ##
+      # Evaluates whether the source file actually exists
+      #
+      # @return [Boolean]
+      #
+      def exist?
+        File.exist?(@path)
+      end
+    end
+  end
+end

data/lib/app_archetype/template/source.rb

@@ -0,0 +1,39 @@
+module AppArchetype
+  module Template
+    # Source is an in memory representation of a template source
+    class Source
+      attr_reader :path, :files
+
+      ##
+      # Creates a templatte source from path and initializes file array.
+      #
+      # @param [String] path
+      #
+      def initialize(path)
+        @path = path
+        @files = []
+      end
+
+      ##
+      # Loads template files into memory. Will raise a RuntimeError if
+      # by the time we're loading the source no longer exists.
+      #
+      def load
+        raise 'template source does not exist' unless exist?
+
+        Dir.glob(File.join(@path, '**', '*')).each do |file|
+          @files << file
+        end
+      end
+
+      ##
+      # Evaluates whether template source still exists.
+      #
+      # @return [Boolean]
+      #
+      def exist?
+        File.exist?(@path)
+      end
+    end
+  end
+end

data/lib/app_archetype/template/variable.rb

@@ -0,0 +1,237 @@
+require 'ostruct'
+require 'json'
+
+module AppArchetype
+  module Template
+    # Variable is a class representing a single variable
+    class Variable
+      ##
+      # Default variable type (String)
+      #
+      DEFAULT_TYPE = 'string'.freeze
+
+      ##
+      # Default value map
+      #
+      DEFAULT_VALUES = {
+        'string' => '',
+        'boolean' => false,
+        'integer' => 0
+      }.freeze
+
+      ##
+      # String validation function. Ensures given input
+      # is indeed a string.
+      #
+      # @param [Object] input
+      #
+      # @return [Boolean]
+      #
+      STRING_VALIDATOR = lambda do |input|
+        input.is_a?(String)
+      end
+
+      ##
+      # Boolean validation function. Ensures given input
+      # is a boolean.
+      #
+      # @param [Object] input
+      #
+      # @return [Boolean]
+      #
+      BOOLEAN_VALIDATOR = lambda do |input|
+        [true, false, 'true', 'false'].include?(input)
+      end
+
+      ##
+      # Integer validation function. Ensures given input is
+      # an integer.
+      #
+      # @param [Object] input
+      #
+      # @return [Boolean]
+      #
+      INTEGER_VALIDATOR = lambda do |input|
+        input != '0' && input.to_i != 0
+      end
+
+      ##
+      # Maps type to validation function
+      #
+      VALIDATORS = {
+        'string' => STRING_VALIDATOR,
+        'boolean' => BOOLEAN_VALIDATOR,
+        'integer' => INTEGER_VALIDATOR
+      }.freeze
+
+      ##
+      # Default validation function (string validator)
+      #
+      DEFAULT_VALIDATOR = STRING_VALIDATOR
+
+      attr_reader :name
+
+      def initialize(name, spec)
+        @name = name
+        @spec = OpenStruct.new(spec)
+        @value = @spec.value
+      end
+
+      ##
+      # Sets value of variable so long as it's valid.
+      #
+      # A runtime error will be raised if the valdiation
+      # fails for the given value.
+      #
+      # Has a side effect of setting @value instance variable
+      #
+      # @param [Object] value
+      def set!(value)
+        raise 'invalid value' unless valid?(value)
+
+        @value = value
+      end
+
+      ##
+      # Returns default value for the variable.
+      #
+      # In the event the manifest does not specify a default
+      # one will be picked from the DEFAULT_VALUES map based on
+      # the variable's type.
+      #
+      # @return [Object]
+      #
+      def default
+        return DEFAULT_VALUES[type] unless @spec.default
+
+        @spec.default
+      end
+
+      ##
+      # Returns variable description.
+      #
+      # In the event the manifest does not specify a description
+      # an empty string will be returned.
+      #
+      # @return [String]
+      #
+      def description
+        return '' unless @spec.description
+
+        @spec.description
+      end
+
+      ##
+      # Returns variable type.
+      #
+      # In the event the manifest does not specify a type, the
+      # default type of String will be returned.
+      #
+      # @return [String]
+      #
+      def type
+        return DEFAULT_TYPE unless @spec.type
+
+        @spec.type
+      end
+
+      ##
+      # Returns variable value.
+      #
+      # If the value has not been set (i.e. overridden) then the
+      # default value will be returned.
+      #
+      # Values set beginning with `#` are passed into the helpers
+      # class and evaluated as functions. That permits the manifest
+      # to use string helpers as values from the manifest.
+      #
+      # Function calls must be in the format `#method_name,arg1,arg2`
+      # for example to call the join function `#join,.,biggerconcept,com`
+      # will result in `biggerconcept.com` becoming the value.
+      #
+      # @return [String]
+      #
+      def value
+        return default if @value.nil?
+        return call_helper if method?
+
+        @value
+      end
+
+      ##
+      # Returns true if value has been set
+      #
+      # @return [Boolean]
+      def value?
+        !@value.nil?
+      end
+
+      ##
+      # Retrieves the appropriate validator function basedd on the
+      # specified type.
+      #
+      # If a type is not set then a string validator function is
+      # returned by default
+      #
+      # @return [Proc]
+      #
+      def validator
+        validator = VALIDATORS[@spec.type]
+        validator ||= DEFAULT_VALIDATOR
+
+        validator
+      end
+
+      ##
+      # Returns true if the value input is valid.
+      #
+      # @param [String] input
+      #
+      # @return [Boolean]
+      #
+      def valid?(input)
+        validator.call(input)
+      end
+
+      private
+
+      # Returns an object which extends helpers module.
+      #
+      # This is used for calling helper functions
+      def helpers
+        Object
+          .new
+          .extend(AppArchetype::Template::Helpers)
+      end
+
+      # Returns true if variable value begins with `#` this
+      # indicates the variable value has been set to a function
+      def method?
+        return false unless @value.is_a?(String)
+
+        @value[0, 1] == '#'
+      end
+
+      # Calls a helper function to generate a value
+      def call_helper
+        method = deserialize_method(@value)
+        helpers.send(method.name, *method.args)
+      end
+
+      # Creates a struct representing a method call to be made
+      # to resolve a variable value
+      def deserialize_method(method)
+        method = method.delete('#')
+        parts = method.split(',')
+        name = parts.shift
+
+        args = parts || []
+
+        OpenStruct.new(
+          name: name.to_sym,
+          args: args
+        )
+      end
+    end
+  end
+end