lono 7.5.2 → 8.0.0.pre.rc1

data/lib/lono/extensions/loader.rb

@@ -1,19 +1,11 @@
 class Lono::Extensions
   module Loader
-    include Lono::Template::Context::Loader::LoadFiles
+    include Lono::Builder::Context::Loader::LoadFiles
 
     def load_all_extension_helpers
-      Lono::Jade::Registry.tracked_extensions.each do |registry|
-        load_extension_helpers(registry)
-      end
     end
 
     def load_extension_helpers(registry)
-      root = find_extensions_root_path(registry)
-      extension_file = "#{root}/lib/#{registry.name}"
-      require extension_file
-      helpers_path = "#{root}/lib/#{registry.name}/helpers"
-      load_files(helpers_path)
     end
 
     #
@@ -22,9 +14,6 @@ class Lono::Extensions
     #     3. materialized gem
     #
     def find_extensions_root_path(registry)
-      @finder ||= Lono::Finder::Extension.new
-      jadespec = @finder.find(registry.name)
-      jadespec.root
     end
   end
 end

data/lib/lono/extensions.rb

@@ -1,14 +1,14 @@
 module Lono
   class Extensions
     include Dsl
-    include Lono::Template::Evaluate
+    include Lono::Builder::Template::Evaluate
 
     def initialize(template_path)
       @template_path = template_path
     end
 
     def evaluate
-      evaluate_template_path(@template_path) # handle extend_with
+      evaluate_template_paths(@template_path) # handle extend_with
     end
 
     # The extend_with methods are used in file as the normal DSL evaluation.

data/lib/lono/importer/base.rb

@@ -1,5 +1,5 @@
 class Lono::Importer
-  class Base < Lono::AbstractBase
+  class Base < Lono::CLI::Base
     include Download
     include Thor::Actions
     include Thor::Base
@@ -14,7 +14,7 @@ class Lono::Importer
   private
     def summarize
       return unless @options[:summary]
-      puts "Template Summary:"
+      logger.info "Template Summary:"
       Lono::Inspector::Summary.new(@options).run
     end
 
@@ -24,10 +24,10 @@ class Lono::Importer
     end
 
     def create_params_file(template_path, env)
-      params_path = if @blueprint != @template
-                      "configs/#{@blueprint}/params/#{env}/#{@template}.txt"
+      params_path = if @blueprint.name != @template
+                      "config/#{@blueprint.name}/params/#{env}/#{@template}.txt"
                     else
-                      "configs/#{@blueprint}/params/#{env}.txt"
+                      "config/#{@blueprint.name}/params/#{env}.txt"
                     end
       params = Params.new(template_path, params_path)
       params.create

data/lib/lono/importer/download.rb

@@ -23,16 +23,16 @@ class Lono::Importer
     def read_source(source)
       open(source).read
     rescue OpenURI::HTTPError, SocketError, Errno::ENOENT
-      puts "ERROR: Unable to read source template provided: #{source}".color(:red)
+      logger.info "ERROR: Unable to read source template provided: #{source}".color(:red)
       e = $!
-      puts "#{e.class}: #{e.message}"
-      puts "Please double check the source provided."
+      logger.info "#{e.class}: #{e.message}"
+      logger.info "Please double check the source provided."
       exit 1
     rescue Exception => e
-      puts "ERROR: Unable to read source template provided: #{source}".color(:red)
-      puts "General Exception Error:"
-      puts "#{e.class}: #{e.message}"
-      puts "Please double check the source provided."
+      logger.info "ERROR: Unable to read source template provided: #{source}".color(:red)
+      logger.info "General Exception Error:"
+      logger.info "#{e.class}: #{e.message}"
+      logger.info "Please double check the source provided."
       exit 1
     end
 

data/lib/lono/importer/dsl.rb

@@ -4,7 +4,7 @@ class Lono::Importer
       tmp_template_path = download_template(@source, @tmp_path)
       template = IO.read(tmp_template_path)
 
-      Lono::Blueprint::New.start([@blueprint, "--import", "--type", "dsl"])
+      Lono::Blueprint::New.start([@blueprint.name, "--import", "--type", "dsl"])
 
       translate_to_dsl(template)
       create_params(tmp_template_path)
@@ -19,13 +19,13 @@ class Lono::Importer
       coder = Service::Coder.new(template, @options)
       result = coder.translate
 
-      path = "#{Lono.config.templates_path}/#{@template}.rb"
+      path = "#{Lono.config.paths.templates}/#{@template}.rb"
       FileUtils.mkdir_p(File.dirname(path))
       create_file(path, result) # Thor::Action
     end
 
     def final_message
-      puts <<~EOL
+      logger.info <<~EOL
         #{"="*64}
         Congrats 🎉 You have successfully imported a lono blueprint.
 

data/lib/lono/importer/service/coder.rb

@@ -22,10 +22,10 @@ class Lono::Importer::Service::Coder
       ruby_code = print(data) # returns data["ruby_code"] / passthrough
       ruby_code
     else
-      puts "Error: Unable to convert template to Ruby code."
-      puts "The error has been reported."
-      puts "Non-successful http response status code: #{res.code}"
-      # puts "headers: #{res.each_header.to_h.inspect}"
+      logger.info "Error: Unable to convert template to Ruby code."
+      logger.info "The error has been reported."
+      logger.info "Non-successful http response status code: #{res.code}"
+      # logger.info "headers: #{res.each_header.to_h.inspect}"
       exit 1
     end
   end
@@ -36,26 +36,26 @@ private
 
     if data["error"]
       # Code was processed but there was this error with an HTTP 200 OK
-      $stderr.puts "ERROR: #{data["error"]}".color(:red)
+      $stderr.logger.info "ERROR: #{data["error"]}".color(:red)
       if data["message"]
-        $stderr.puts data["message"]
+        $stderr.logger.info data["message"]
       end
       return
     end
 
     validity = data["valid_ruby"] ? "valid" : "invalid"
     if validity == "valid"
-      $stderr.puts "INFO: The generated Ruby code is has #{validity} syntax."
+      $stderr.logger.info "INFO: The generated Ruby code is has #{validity} syntax."
     else
-      $stderr.puts "WARN: The generated Ruby code is has #{validity} syntax. Providing because it may be small errors.".color(:yellow) # note redirection disables color
+      $stderr.logger.info "WARN: The generated Ruby code is has #{validity} syntax. Providing because it may be small errors.".color(:yellow) # note redirection disables color
     end
 
-    $stderr.puts <<~EOL
+    $stderr.logger.info <<~EOL
       Translated ruby code below:
 
     EOL
     ruby_code = data["ruby_code"]
-    puts ruby_code
+    logger.info ruby_code
     ruby_code
   end
 

data/lib/lono/importer.rb

@@ -1,14 +1,5 @@
 module Lono
-  class Importer
-    def initialize(options)
-      @options = options
-
-      Lono::ProjectChecker.check
-      @blueprint = Lono::Conventions.new(options).blueprint
-      # Dont use set_blueprint_root because it doesnt exist yet. The import creates it
-      Lono.blueprint_root = "#{Lono.root}/app/blueprints/#{@blueprint}"
-    end
-
+  class Importer < Lono::CLI::Base
     def run
       # Examples:
       #   Lono::Importer::Erb.new(source, options.clone).run

data/lib/lono/inspector/base.rb

@@ -1,29 +1,29 @@
 module Lono::Inspector
-  class Base < Lono::AbstractBase
+  class Base < Lono::CLI::Base
     extend Memoist
 
     def run
-      generate
+      build
       templates = @template_name ? [@template_name] : all_templates
       templates.each do |template_name|
         perform(template_name)
       end
     end
 
-    def generate
+    def build
       if @options[:source]
         Lono::Cfn::Download.new(@options).run
       else
-        generate_templates
+        build_templates
       end
     end
 
-    def generate_templates
-      Lono::Template::Generator.new(@options.merge(quiet: false)).run
+    def build_templates
+      Lono::Builder::Template.new(@options.merge(quiet: false)).run
     end
 
     def all_templates
-      templates_path = "#{Lono.config.output_path}/#{@blueprint}/templates"
+      templates_path = "#{Lono.root}/output/#{@blueprint.name}/templates"
       Dir.glob("#{templates_path}/**").map do |path|
         path.sub("#{templates_path}/", '').sub('.yml','') # template_name
       end

data/lib/lono/inspector/summary.rb

@@ -1,43 +1,45 @@
 module Lono::Inspector
   class Summary < Base
-    delegate :required_parameters, :optional_parameters, :parameters, :parameter_groups, :data,
-             to: :output_template
+    include Lono::Cfn::Concerns::TemplateOutput
 
     def perform(template)
       # little dirty but @template is used in data method so we dont have to pass it to the data method
       @template = template
 
-      puts "=> CloudFormation Template Summary for template #{@template.color(:sienna)}:"
-      return if @options[:noop]
+      logger.info "=> CloudFormation Template Summary for template #{@template.color(:sienna)}:"
+      return if ENV['LONO_NOOP']
 
       print_parameters_summary
-      puts "# Resources:"
+      logger.info "# Resources:"
       print_resource_types
     end
 
     def print_parameters_summary
+      parameters = template_output.parameters
+      parameter_groups = template_output.parameter_groups
+
       if parameters.empty?
-        puts "There are no parameters in this template."
+        logger.info "There are no parameters in this template."
         return
       end
 
       shown = []
-      puts "# Parameters Total (#{parameters.size})"
+      logger.info "# Parameters Total (#{parameters.size})"
       parameter_groups.each do |label, parameters|
-        puts "# Parameter Group (#{parameters.size}): #{label}".color(:sienna)
+        logger.info "# Parameter Group (#{parameters.size}): #{label}".color(:sienna)
         parameters.each do |name|
-          puts parameter_line(name)
+          logger.info parameter_line(name)
           shown << name
         end
-      end if output_template.parameter_groups
+      end if parameter_groups
 
       parameters.each do |name, data|
-        puts parameter_line(name) unless shown.include?(name)
+        logger.info parameter_line(name) unless shown.include?(name)
       end
     end
 
     def parameter_line(name)
-      data = parameters[name]
+      data = template_output.parameters[name]
       example = description_example(data["Description"])
       if data["Default"].nil?
         line = "#{name}=#{example} # (required)"
@@ -58,7 +60,7 @@ module Lono::Inspector
     end
 
     def resource_types
-      resources = data["Resources"]
+      resources = template_output.data["Resources"]
       return unless resources
 
       types = Hash.new(0)
@@ -70,7 +72,7 @@ module Lono::Inspector
 
     def print_resource_types
       unless resource_types
-        puts "No resources found."
+        logger.info "No resources found."
         return
       end
 
@@ -83,9 +85,9 @@ module Lono::Inspector
       printf "%3s %s\n", total, "Total"
     end
 
-    def output_template
-      Lono::Output::Template.new(@blueprint, @template)
+    def template_output
+      Lono::Builder::Template::Output.new(@blueprint)
     end
-    memoize :output_template
+    memoize :template_output
   end
 end

data/lib/lono/layering/layer.rb

@@ -0,0 +1,126 @@
+require "aws_data"
+
+# Layers example
+#
+#     app/blueprints/demo/config/params/base.txt
+#     app/blueprints/demo/config/params/dev.txt
+#     app/blueprints/demo/config/params/prod.txt
+#     app/blueprints/demo/config/vars/base.rb
+#     app/blueprints/demo/config/vars/dev.rb
+#     app/blueprints/demo/config/vars/prod.rb
+#
+module Lono::Layering
+  class Layer
+    include Lono::Layering
+    include Lono::Utils::Logging
+    include Lono::Utils::Pretty
+    extend Memoist
+
+    delegate :region, to: :aws_data
+
+    def initialize(blueprint, type)
+      @blueprint, @type = blueprint, type
+    end
+
+    def paths
+      blueprint = full_layers("app/blueprints/#{@blueprint.name}/config")
+      project = full_layers("config/blueprints/#{@blueprint.name}")
+      paths = blueprint + project
+      add_ext!(paths)
+      paths.map! { |p| "#{Lono.root}/#{p}" }
+      show_layers(paths)
+      paths
+    end
+
+    def full_layering
+      # layers defined in Lono::Layering module
+      all = layers.map { |layer| layer.sub(/\/$/,'') } # strip trailing slash
+      all.inject([]) do |sum, layer|
+        sum += layer_levels(layer) unless layer.nil?
+        sum
+      end
+    end
+
+    # interface method
+    def main_layers
+      [
+        '',
+        region,
+        account,
+        "#{account}/#{region}",
+      ]
+    end
+
+    def account
+      name = aws_data.account
+      # friendly name mapping
+      names = Lono.config.layering.names.stringify_keys
+      names[name] || name
+    end
+
+    # adds prefix and to each layer pair that has base and Lono.env. IE:
+    #
+    #    "#{prefix}/base"
+    #    "#{prefix}/#{Lono.env}"
+    #
+    def layer_levels(prefix=nil)
+      levels = ["base", Lono.env]
+      levels.map! do |i|
+        # base layer has prefix of '', reject with blank so it doesnt produce '//'
+        [prefix, i].reject(&:blank?).join('/')
+      end
+      levels.unshift(prefix) # unless prefix.blank? # IE: params/us-west-2.txt
+      levels
+    end
+
+    def add_ext!(paths)
+      exts = {
+        params: "txt",
+        vars: "rb",
+      }
+      ext = exts[@type.to_sym]
+
+      paths.map! do |path|
+        if path.include?("teams")
+          puts "path: #{path}"
+        end
+
+        if path.ends_with?('/')
+          "#{path.sub(/\/$/,'')}.#{ext}"
+        else
+          "#{path}.#{ext}"
+        end
+      end
+    end
+
+    def full_layers(dir)
+      layers = full_layering.map do |layer|
+        "#{dir}/#{@type}/#{layer}"
+      end
+      if Lono.app
+        app_layers = full_layering.map do |layer|
+          "#{dir}/#{@type}/#{Lono.app}/#{layer}"
+        end
+        layers += app_layers
+      end
+      layers
+    end
+
+    @@shown_layers = {}
+    def show_layers(paths)
+      return if @@shown_layers[@type]
+      logger.debug "#{@type.capitalize} Layers:"
+      paths.each do |path|
+        logger.debug "    #{pretty_path(path)}" if File.exist?(path) || ENV['LONO_SHOW_ALL_LAYERS']
+      end
+      logger.debug ""
+      @@shown_layers[@type] = true
+    end
+
+  private
+    def aws_data
+      AwsData.new
+    end
+    memoize :aws_data
+  end
+end

data/lib/lono/layering.rb

@@ -1,65 +1,23 @@
-module Lono
-  class Layering < AbstractBase
-    extend Memoist
-
-    def initialize(config, options={}, env=Lono.env, root=Lono.root)
-      super(options)
-      # config can be params or variables
-      @config, @options, @env, @root = config, options, env, root
-      @requested = determine_requested
-    end
-
-    def locations
-      paths = always + requested
-      layers = paths.map do |path|
-        requested_file(path)
-      end.compact
-      print_layers(layers)
-      layers
-    end
-
-    def always
-      base = "#{@root}/configs/#{@blueprint}/#{@config}/base"
-      env = "#{@root}/configs/#{@blueprint}/#{@config}/#{@env}"
-      [base, env]
-    end
+require "active_support/lazy_load_hooks"
 
-    def requested
-      standard_layers + direct_layers
-    end
-
-    def standard_layers
-      config_level = "#{@root}/configs/#{@blueprint}/#{@config}/#{@requested}"
-      env_level = "#{@root}/configs/#{@blueprint}/#{@config}/#{@env}/#{@requested}"
-      template_level = "#{@root}/configs/#{@blueprint}/#{@config}/#{@env}/#{@template}/#{@requested}"
-      [config_level, env_level, template_level]
-    end
-
-    def direct_layers
-      if @requested.starts_with?('/')
-        [@requested] # IE: absolute full path
-      else
-        ["#{@root}/#{@requested}"] # IE : relative path within lono project]
-      end
+module Lono
+  module Layering
+    def layers
+      pre_layers + main_layers + post_layers
     end
 
-    def print_layers(layers)
-      return unless ENV["LONO_DEBUG_LAYERING"]
-      puts "layers #{@config}:"
-      pp layers
+    def main_layers
+      super
     end
 
-    def determine_requested
-      # param is usually set from the convention. when set from convention stack name takes higher precedence
-      config_key = @config.singularize.to_sym # param or variable
-      @options[config_key] || @options[:config] || @stack
+    def pre_layers
+      []
     end
 
-    def requested_file(path)
-      # List of paths to consider from initial path provided. Combine params and variables possible paths for simplicity.
-      paths = [path, "#{path}.txt", "#{path}.sh", "#{path}.rb"].compact
-      paths.find { |p| File.file?(p) }
+    def post_layers
+      []
     end
-    memoize :requested_file
   end
 end
+
+ActiveSupport.run_load_hooks(:lono_layering, Lono::Layering)

data/lib/lono/logger/formatter.rb

@@ -0,0 +1,13 @@
+class Lono::Logger
+  class Formatter < ::Logger::Formatter
+    def call(severity, time, progname, msg)
+      # careful changing the format. All::Summary uses a regexp on this format to remove the timestamp
+      "[#{format_datetime(time)} ##{Process.pid} #{progname}]: #{msg}"
+    end
+
+  private
+    def format_datetime(time)
+      time.strftime("%Y-%m-%dT%H:%M:%S")
+    end
+  end
+end

data/lib/lono/logger.rb

@@ -0,0 +1,33 @@
+require 'logger'
+
+module Lono
+  class Logger < ::Logger
+    def initialize(*args)
+      super
+      self.formatter = Formatter.new
+      self.level = ENV['LONO_LOG_LEVEL'] || :info # note: only respected when config.logger not set in config/app.rb
+    end
+
+    def format_message(severity, datetime, progname, msg)
+      line = if @logdev.dev == $stdout || @logdev.dev == $stderr || @logdev.dev.is_a?(StringIO)
+        msg # super simple format if stdout
+      else
+        super # use the configured formatter
+      end
+      line =~ /\n$/ ? line : "#{line}\n"
+    end
+
+    # Used to allow terraform output to always go to stdout
+    # Terraspace output goes to stderr by default
+    # See: terraspace/shell.rb
+    def stdout(msg, newline: true)
+      if newline
+        puts msg
+      else
+        print msg
+      end
+    end
+
+    public :print
+  end
+end

data/lib/lono/lookup.rb

@@ -0,0 +1,12 @@
+module Lono
+  class Lookup
+    include Lono::Utils::Logging
+    include Lono::Utils::Pretty
+
+    def list(type)
+      Dir.glob("#{Lono.root}/{app,vendor}/#{type}/*").each do |path|
+        logger.info pretty_path(path)
+      end
+    end
+  end
+end

data/lib/lono/names.rb

@@ -0,0 +1,50 @@
+module Lono
+  class Names
+    extend Memoist
+
+    attr_reader :blueprint
+    def initialize(options={})
+      @options = options
+      @blueprint = options[:blueprint]
+    end
+
+    def stack
+      expansion(Lono.config.names.stack)
+    end
+    memoize :stack
+
+    def expansion(string)
+      return string unless string.is_a?(String) # in case of nil
+
+      string = string.dup
+      vars = string.scan(/:\w+/) # => [":APP", ":BLUEPRINT", :ENV"]
+      vars.each do |var|
+        string.gsub!(var, var_value(var))
+      end
+      strip(string)
+    end
+
+    def var_value(unexpanded)
+      name = unexpanded.sub(':','').downcase
+      if respond_to?(name)
+        value = send(name).to_s
+      else
+        unexpanded
+      end
+    end
+
+    def strip(string)
+      string.sub(/^-+/,'').sub(/-+$/,'') # remove leading and trailing -
+            .gsub(%r{-+},'-') # remove double dashes are more. IE: -- => -
+            .gsub('_','-')    # underscores are not allowed in CloudFormation stack names
+    end
+
+    def app
+      Lono.app
+    end
+
+    def env
+      Lono.env
+    end
+  end
+end

data/lib/lono/plugin/meta.rb

@@ -0,0 +1,30 @@
+class Lono::Plugin
+  module Meta
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :meta, default: []
+    end
+
+    class_methods do
+      def register(o={})
+        found = meta.find { |m| m[:name] == o[:name] && m[:type] == o[:type] }
+        meta << o unless found
+      end
+
+      def find(o={})
+        found = meta.find { |m| m[:name] == o[:name] && m[:type] == o[:type] }
+        Lono::Plugin.new(found) if found
+      end
+
+      def delegate_to_meta(*attrs)
+        attrs.each do |attr|
+          attr = attr.to_sym
+          define_method attr do
+            @options[attr]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lono/plugin/tester.rb

@@ -0,0 +1,13 @@
+class Lono::Plugin
+  class Tester
+    class << self
+      def register(name, options={})
+        Lono::Plugin.register(
+          name: name,
+          type: "test_framework",
+          root: options[:root],
+        )
+      end
+    end
+  end
+end