lono 8.0.0.pre.rc2 → 8.0.0.pre.rc5

data/lib/lono/cli/new/helper.rb

@@ -1,10 +1,12 @@
 class Lono::CLI::New
-  class Helper < Sequence
+  class Helper < Lono::CLI::New::Sequence
     def self.cli_options
+      # required for name => underscore_name => app/blueprints/demo/helpers/%underscore_name%_helper.rb.tt
+      argument :name, default: "custom", desc: "Helper name"
+
       [
         [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
-        [:blueprint, required: true, desc: "Blueprint name"],
-        [:name, default: "custom", desc: "Helper name"],
+        [:blueprint, aliases: :b, desc: "Blueprint name. Only use you want a blueprint helper. Otherwise a project helper is generated"],
       ]
     end
     cli_options.each do |args|
@@ -15,18 +17,24 @@ class Lono::CLI::New
       set_template_source "helper"
     end
 
-    def set_vars
-      @blueprint = @options[:blueprint]
-      @name = @options[:name]
+    def create_helper
+      if @options[:blueprint]
+        create_blueprint_helper
+      else
+        create_project_helper
+      end
     end
 
-    def create_blueprint
-      puts "underscore_name #{underscore_name}"
-      logger.info "=> Generating helper: #{@name}"
+  private
+    def create_blueprint_helper
+      @blueprint = @options[:blueprint] # allows %underscore_name%_helper.rb.tt to access @blueprint
+      logger.info "=> Generating #{underscore_name}_helper.rb"
       directory ".", "app/blueprints/#{@blueprint}/helpers"
     end
 
-  private
-    attr_reader :name # required for templates/helper/%name%_helper.rb.tt
+    def create_project_helper
+      logger.info "=> Generating #{underscore_name}_helper.rb"
+      directory ".", "app/helpers/#{underscore_name}"
+    end
   end
 end

data/lib/lono/cli/new/hook.rb

@@ -0,0 +1,32 @@
+class Lono::CLI::New
+  class Hook < Lono::CLI::New::Sequence
+    def self.cli_options
+      [
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
+        [:blueprint, aliases: :b, desc: "Blueprint name. Only use you want a blueprint helper. Otherwise a project helper is generated"],
+      ]
+    end
+    cli_options.each do |args|
+      class_option(*args)
+    end
+
+    def set_source
+      set_template_source "hook"
+    end
+
+    def create_hook
+      logger.info "=> Generating hook"
+      if blueprint
+        directory ".", "app/blueprints/#{blueprint}"
+      else
+        directory ".", "."
+      end
+    end
+
+  private
+    # So templates/hooks/config/hooks.rb.tt has access to blueprint
+    def blueprint
+      @options[:blueprint]
+    end
+  end
+end

data/lib/lono/cli/new/sequence.rb

@@ -12,7 +12,8 @@ class Lono::CLI::New
 
   private
     def self.set_template_source(folder)
-      source_root File.expand_path("../../../templates/#{folder}", __dir__)
+      path = File.expand_path("../../../templates/#{folder}", __dir__)
+      source_root path
     end
 
     def set_template_source(*paths)
@@ -47,5 +48,9 @@ class Lono::CLI::New
       puts "=> Initialize git repo"
       run("git init")
     end
+
+    def env
+      Lono.env # allows for seed/vars/%env%.rb.tt
+    end
   end
 end

data/lib/lono/cli/new.rb

@@ -2,27 +2,27 @@ class Lono::CLI
   class New < Lono::Command
     long_desc Help.text("new/blueprint")
     Blueprint.cli_options.each { |args| option(*args) }
-    register(Blueprint, "blueprint", "blueprint NAME", "Generates new blueprint.")
+    register(Blueprint, "blueprint", "blueprint NAME", "Generate new blueprint")
 
     long_desc Help.text("new/configset")
     Configset.cli_options.each { |args| option(*args) }
-    register(Configset, "configset", "configset NAME", "Generates new configset.")
-
-    long_desc Help.text("new/extension")
-    Extension.cli_options.each { |args| option(*args) }
-    register(Extension, "extension", "extension NAME", "Generates new extension.")
+    register(Configset, "configset", "configset NAME", "Generate new configset")
 
     long_desc Help.text("new/helper")
     Helper.cli_options.each { |args| option(*args) }
-    register(Helper, "helper", "helper NAME", "Generates new helper.")
+    register(Helper, "helper", "helper NAME", "Generate new helper")
+
+    long_desc Help.text("new/hook")
+    Hook.cli_options.each { |args| option(*args) }
+    register(Hook, "hook", "hook NAME", "Generate new hook")
 
     long_desc Help.text("new/project")
     Project.cli_options.each { |args| option(*args) }
-    register(Project, "project", "project NAME", "Generates new project.")
+    register(Project, "project", "project NAME", "Generate new project")
 
     long_desc Help.text("new/shim")
     Shim.cli_options.each { |args| option(*args) }
-    register(Shim, "shim", "shim NAME", "Generates new shim.")
+    register(Shim, "shim", "shim NAME", "Generate new shim")
 
     desc "test SUBCOMMAND", "test subcommands"
     long_desc Help.text(:test)

data/lib/lono/cli/script/build.rb

@@ -63,10 +63,5 @@ class Lono::CLI::Script
       @md5sum ||= Digest::MD5.file("#{@blueprint.root}/scripts.tgz").to_s[0..7]
     end
 
-    def sh(command)
-      puts "=> #{command}"
-      system command
-    end
-
   end
 end

data/lib/lono/cli/status.rb

@@ -0,0 +1,18 @@
+class Lono::CLI
+  class Status < Lono::CLI::Base
+    include Lono::AwsServices
+
+    def run
+      names = Lono::Names.new(@options)
+      stack = find_stack(@stack)
+      if stack
+        status = Lono::Cfn::Status.new(@stack, @options)
+        success = status.run
+        exit 1 unless success
+      else
+        logger.error "ERROR: stack #{@stack} not found".color(:red)
+        exit 1
+      end
+    end
+  end
+end

data/lib/lono/{inspector → cli}/summary.rb

@@ -1,32 +1,27 @@
-module Lono::Inspector
+class Lono::CLI
   class Summary < Base
+    include Lono::Cfn::Concerns::Build
     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
-
-      logger.info "=> CloudFormation Template Summary for template #{@template.color(:sienna)}:"
-      return if ENV['LONO_NOOP']
-
+    def run
+      build.all
       print_parameters_summary
-      logger.info "# Resources:"
       print_resource_types
     end
 
     def print_parameters_summary
       parameters = template_output.parameters
+      logger.info "Parameters (#{parameters.size})".color(:green)
       parameter_groups = template_output.parameter_groups
 
       if parameters.empty?
-        logger.info "There are no parameters in this template."
+        logger.info "No parameters"
         return
       end
 
       shown = []
-      logger.info "# Parameters Total (#{parameters.size})"
-      parameter_groups.each do |label, parameters|
-        logger.info "# Parameter Group (#{parameters.size}): #{label}".color(:sienna)
+      parameter_groups.each do |parameter_group_label, parameters|
+        logger.info parameter_group_label
         parameters.each do |name|
           logger.info parameter_line(name)
           shown << name
@@ -40,13 +35,11 @@ module Lono::Inspector
 
     def parameter_line(name)
       data = template_output.parameters[name]
-      example = description_example(data["Description"])
       if data["Default"].nil?
-        line = "#{name}=#{example} # (required)"
+        line = "    #{name} (required)"
       else
         default = data["Default"]
-        line = "# #{name}=#{default}"
-        line = "#{line} # #{example}" if example
+        line = default.blank? ? "    #{name}" : "    #{name}=#{default}"
       end
       line
     end
@@ -59,18 +52,9 @@ module Lono::Inspector
       md[2]
     end
 
-    def resource_types
-      resources = template_output.data["Resources"]
-      return unless resources
-
-      types = Hash.new(0)
-      resources.each do |logical_id, resource|
-        types[resource["Type"]] += 1
-      end
-      types
-    end
-
     def print_resource_types
+      total = template_output.data["Resources"].size
+      logger.info "Resources (#{total})".color(:green)
       unless resource_types
         logger.info "No resources found."
         return
@@ -79,15 +63,21 @@ module Lono::Inspector
       types = resource_types.sort_by {|r| r[1] * -1} # Hash -> 2D Array
       types.each do |a|
         type, count = a
-        printf "%3s %s\n", count, type
+        printf "%5s %s\n", count, type
       end
       total = types.inject(0) { |sum,(type,count)| sum += count }
-      printf "%3s %s\n", total, "Total"
+      printf "%5s %s\n", total, "Total"
     end
 
-    def template_output
-      Lono::Builder::Template::Output.new(@blueprint)
+    def resource_types
+      resources = template_output.data["Resources"]
+      return unless resources
+
+      types = Hash.new(0)
+      resources.each do |logical_id, resource|
+        types[resource["Type"]] += 1
+      end
+      types
     end
-    memoize :template_output
   end
 end

data/lib/lono/cli.rb

@@ -5,12 +5,12 @@ module Lono
     opts = Opts.new(self)
     cfn_opts = Lono::CLI::Cfn::Opts.new(self)
 
-    desc "build BLUEPRINT", "Build both CloudFormation template and parameters files"
+    desc "build BLUEPRINT", "Build template"
     long_desc Help.text(:build)
     option :quiet, type: :boolean, desc: "silence the output"
     opts.clean
     def build(blueprint)
-      Build.new(options.merge(blueprint: blueprint, build_only: true)).all
+      Lono::Builder.new(options.merge(blueprint: blueprint, build_only: true)).all
     end
 
     desc "bundle", "Bundle with Lonofile."
@@ -25,14 +25,20 @@ module Lono
       Clean.new(options).run
     end
 
-    desc "down BLUEPRINT", "Delete CloudFormation blueprint"
+    desc "down BLUEPRINT", "Delete stack"
     long_desc Help.text(:down)
     cfn_opts.delete
     def down(blueprint)
       Lono::Cfn::Delete.new(options.merge(blueprint: blueprint)).run
     end
 
-    desc "list", "List blueprints, configsets, extensions, etc"
+    desc "iam BLUEPRINT", "Generate IAM policy"
+    long_desc Help.text(:down)
+    def iam(blueprint)
+      Iam.new(options.merge(blueprint: blueprint)).run
+    end
+
+    desc "list", "List blueprints"
     long_desc Help.text(:list)
     option :type, aliases: :t, desc: "Type: IE: blueprint, configset, extension. Defaults to all"
     def list
@@ -41,12 +47,12 @@ module Lono
 
     desc "output BLUEPRINT", "output or preview of the deploy"
     long_desc Help.text(:output)
-    option :format, desc: "Output formats: #{CliFormat.formats.join(', ')}"
+    option :format, aliases: :f, desc: "Output formats: #{CliFormat.formats.join(', ')}"
     def output(blueprint)
       Lono::Cfn::Output.new(options.merge(blueprint: blueprint)).run
     end
 
-    desc "plan BLUEPRINT", "Plan or preview of the deploy"
+    desc "plan BLUEPRINT", "Preview deploy"
     long_desc Help.text(:plan)
     option :out, aliases: :o, desc: "Write Change Set info to path"
     def plan(blueprint)
@@ -71,16 +77,13 @@ module Lono
     desc "status BLUEPRINT", "Shows current status of blueprint."
     long_desc Help.text(:status)
     def status(blueprint)
-      names = Lono::Names.new(blueprint: blueprint)
-      status = Lono::Cfn::Status.new(names.stack, options)
-      success = status.run
-      exit 3 unless success
+      Status.new(options.merge(blueprint: blueprint)).run
     end
 
     desc "summary BLUEPRINT", "Prints summary of CloudFormation template"
     long_desc Help.text("summary")
     def summary(blueprint)
-      Lono::Inspector::Summary.new(options.merge(blueprint: blueprint)).run
+      Summary.new(options.merge(blueprint: blueprint)).run
     end
 
     desc "test", "Run test."
@@ -89,7 +92,7 @@ module Lono
       Test.new(options).run
     end
 
-    desc "up BLUEPRINT", "Deploy CloudFormation stack"
+    desc "up BLUEPRINT", "Deploy stack"
     long_desc Help.text(:up)
     cfn_opts.deploy
     def up(blueprint)
@@ -125,10 +128,6 @@ module Lono
     long_desc Help.text(:cfn)
     subcommand "cfn", Cfn
 
-    desc "code SUBCOMMAND", "code subcommands"
-    long_desc Help.text(:code)
-    subcommand "code", Code
-
     desc "new SUBCOMMAND", "new subcommands"
     long_desc Help.text(:new)
     subcommand "new", New

data/lib/lono/command.rb

@@ -37,6 +37,7 @@ module Lono
         # Lono.argv provides consistency when lono is being called by rspec-lono test harness
         Lono.argv = args.clone # important to clone since Thor removes the first argv
 
+        check_version_structure!
         check_project!(args.first)
 
         # Allow calling for help via:
@@ -48,7 +49,6 @@ module Lono
         # as well thor's normal way:
         #
         #   lono help command
-        help_flags = Thor::HELP_MAPPINGS + ["help"]
         if args.length > 1 && !(args & help_flags).empty?
           args -= help_flags
           args.insert(-2, "help")
@@ -69,13 +69,39 @@ module Lono
         return if subcommand?
         return if command_name.nil?
         return if help_flags.include?(Lono.argv.last) # IE: -h help
-        return if %w[-h -v --version completion completion_script help new test version].include?(command_name)
+        return if non_project_command?
         return if File.exist?("#{Lono.root}/config/app.rb")
         return unless Lono.check_project
         logger.error "ERROR: It doesnt look like this is a lono project. Are you sure you are in a lono project?".color(:red)
         ENV['LONO_TEST'] ? raise : exit(1)
       end
 
+      # Also, using ARGV instead of args because args is called by thor in multiple passes
+      # For `lono new project`:
+      # * 1st pass: "new"
+      # * 2nd pass: "project"
+      def non_project_command?
+        commands = %w[-h -v --version completion completion_script help new test version]
+        commands.include?(ARGV[0])
+      end
+
+      def check_version_structure!
+        return if non_project_command?
+        return unless File.exist?('configs')
+        puts "ERROR: Old lono project structure detected".color(:red)
+        puts <<~EOL
+          It looks like this Lono project with an old structure.
+          The old structure does not work with this version of Lono.
+
+          Current Installed Lono Version: #{Lono::VERSION}
+
+          Please upgrade the lono project structure.
+
+          See: https://lono.com/docs/upgrading/version8/
+        EOL
+        exit 1
+      end
+
       def help_flags
         Thor::HELP_MAPPINGS + ["help"]
       end

data/lib/lono/component.rb

@@ -0,0 +1,29 @@
+module Lono
+  class Component
+    attr_reader :name
+    def initialize(options={})
+      @options = options
+      @name = options[:name]
+    end
+
+    def type
+      self.class.name.to_s.split('::').last.underscore # IE: blueprint
+    end
+
+    def exist?
+      !root.nil?
+    end
+
+    def type_dir
+      type.pluralize # IE: blueprints
+    end
+
+    def root
+      paths = Dir.glob("#{Lono.root}/{app,vendor}/#{type_dir}/*")
+      paths.find do |path|
+        found = path.sub(%r{.*/(app|vendor)/}, '')
+        found == "#{type_dir}/#{@name}" # exact match
+      end
+    end
+  end
+end

data/lib/lono/concerns/aws_info.rb

@@ -0,0 +1,14 @@
+# Dont name AwsData. Think prefer AwsInfo vs AwsConcern
+module Lono::Concerns
+  module AwsInfo
+    extend Memoist
+    delegate :region, to: :aws_data
+    alias_method :aws_region, :region
+    alias_method :current_region, :region
+
+    def aws_data
+      AwsData.new
+    end
+    memoize :aws_data
+  end
+end

data/lib/lono/concerns/names.rb

@@ -0,0 +1,9 @@
+module Lono::Concerns
+  module Names
+    extend Memoist
+    def names
+      Lono::Names.new(@options)
+    end
+    memoize :names
+  end
+end

data/lib/lono/configset.rb

@@ -0,0 +1,17 @@
+module Lono
+  class Configset < Component
+    attr_reader :resource
+    attr_accessor :metadata
+    def initialize(options={})
+      super
+      @resource = options[:resource]
+    end
+
+    def path
+      return unless root
+      exts = %w[rb yml json] # rb highest precedence
+      paths = exts.map { |ext| "#{root}/configset.#{ext}" }
+      paths.find { |p| File.exist?(p) }
+    end
+  end
+end

data/lib/lono/core.rb

@@ -19,11 +19,21 @@ module Lono
     end
     memoize :app
 
+    def role
+      ENV['LONO_ROLE']
+    end
+    memoize :role
+
     def env
       ENV['LONO_ENV'] || 'dev'
     end
     memoize :env
 
+    def extra
+      ENV['LONO_EXTRA']
+    end
+    memoize :extra
+
     def tmp_root
       ENV['LONO_TMP_ROOT'] || "/tmp/lono"
     end
@@ -37,7 +47,7 @@ module Lono
       App.instance.configure(&block)
     end
 
-    # Generally, use the Terraspace.config instead of App.instance.config since it guarantees the load_project_config call
+    # Generally, use the Lono.config instead of App.instance.config since it guarantees the load_project_config call
     def config
       App.instance.load_project_config
       App.instance.config

data/lib/lono/ext/bundler.rb

@@ -0,0 +1,7 @@
+# Bundler 2.0 does yet not have with_unbundled_env
+# Bundler 2.1 deprecates with_clean_env for with_unbundled_env
+
+require "bundler"
+def Bundler.with_unbundled_env(&block)
+  with_clean_env(&block)
+end unless Bundler.respond_to?(:with_unbundled_env)

data/lib/lono/ext/core/module.rb

@@ -0,0 +1,31 @@
+class Module
+  # Include all modules within the relative folder. IE: for dsl/syntax/mod/*
+  #
+  #    include Common
+  #    include Provider
+  #    # etc
+  #
+  # Caller lines are different for OSes:
+  #
+  #   windows: "C:/Ruby31-x64/lib/ruby/gems/3.1.0/gems/lono-1.1.1/lib/lono/builder.rb:34:in `build'"
+  #   linux: "/home/ec2-user/.rvm/gems/ruby-3.0.3/gems/lono-1.1.1/lib/lono/compiler/dsl/syntax/mod.rb:4:in `<module:Mod>'"
+  #
+  def include_modules(dir)
+    caller_line = caller[0]
+    parts = caller_line.split(':')
+    calling_file = caller_line.match(/^[a-zA-Z]:/) ? parts[1] : parts[0]
+    parent_dir = File.dirname(calling_file)
+
+    full_dir = "#{parent_dir}/#{dir}"
+    paths = Dir.glob("#{full_dir}/**/*.rb")
+    if paths.empty?
+      raise "Empty include_modules full_dir: #{full_dir}"
+    end
+    paths.each do |path|
+      regexp = Regexp.new(".*/lib/")
+      mod = path.sub(regexp, '').sub('.rb','').camelize
+      c = mod.constantize
+      include c if c.class == Module
+    end
+  end
+end

data/lib/lono/ext/core/object.rb

@@ -0,0 +1,32 @@
+class Object
+  # Load custom helper methods from project
+  def load_helper_files(dir, type: :blueprint)
+    paths = Dir.glob("#{dir}/**/*.rb")
+    paths.sort_by! { |p| p.size } # so namespaces are loaded first
+    paths.each do |path|
+      next unless File.file?(path)
+
+      filename = if type == :project
+                   path.sub(%r{.*/helpers/[a-zA-Z\-_]+/},'').sub('.rb','')
+                 else # blueprint, configset
+                   path.sub(%r{.*/helpers/},'').sub('.rb','')
+                 end
+      module_name = filename.camelize
+
+      # Prepend a period so require works when LONO_ROOT is set to a relative path without a period.
+      #   Example: LONO_ROOT=tmp/lono_project
+      first_char = path[0..0]
+      path = "./#{path}" unless %w[. /].include?(first_char)
+
+      # Examples:
+      #   project:
+      #     path:        app/helpers/custom/custom_helper.rb
+      #     module_name: CustomHelper
+      #   blueprint:
+      #     path:        app/blueprints/demo/helpers/outputs.rb
+      #     module_name: Outputs
+      require path
+      self.class.send :include, module_name.constantize
+    end
+  end
+end

data/lib/lono/ext/core/string.rb

@@ -0,0 +1,9 @@
+module Lono
+  refine String do
+    def camelcase
+      self.underscore.camelize
+    end
+  end
+end
+
+using Lono

data/lib/lono/ext.rb

@@ -0,0 +1,4 @@
+require_relative "ext/bundler"
+require_relative "ext/core/module"
+require_relative "ext/core/object"
+require_relative "ext/core/string"

data/lib/lono/files/base.rb

@@ -0,0 +1,12 @@
+class Lono::Files
+  class Base < Lono::CLI::Base
+    delegate :full_path, :output_path, :zip_name, :zip_path, to: :files
+    attr_reader :files
+    def initialize(options={})
+      super
+      # @files is reference to Lono::Files self instance
+      # IE: Lono::Files instance is the caller
+      @files = options[:files]
+    end
+  end
+end

data/lib/lono/{utils → files/builder/lambda_layer}/rsync.rb

@@ -1,13 +1,11 @@
 require 'shellwords'
 
-module Lono::Utils
+class Lono::Files::Builder::LambdaLayer
   module Rsync
-    include Lono::Utils::Logging
-
     def sh(command)
-      logger.info "=> #{command}"
+      logger.debug "=> #{command}"
       out = `#{command}`
-      logger.info out if ENV['LONO_DEBUG_SH']
+      logger.debug out
       success = $?.success?
       raise("ERROR: running command #{command}").color(:red) unless success
       success