lono 7.5.2 → 8.0.0.pre.rc3

data/lib/lono/cli.rb

@@ -1,115 +1,116 @@
 module Lono
   class CLI < Command
+    include Help
     include Thor::Actions # for add_runtime_options
     opts = Opts.new(self)
+    cfn_opts = Lono::CLI::Cfn::Opts.new(self)
 
-    long_desc Help.text(:new)
-    New.cli_options.each do |args|
-      option(*args)
+    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
     end
-    register(New, "new", "new NAME", "Generates new lono project.")
 
-    desc "blueprints", "Lists blueprints"
-    long_desc Help.text(:blueprints)
-    def blueprints
-      Finder::Blueprint.list
+    desc "bundle", "Bundle with Lonofile."
+    long_desc Help.text(:bundle)
+    def bundle(*args)
+      Bundle.new(options.merge(args: args)).run
     end
 
-    desc "configsets [BLUEPRINT]", "Lists configsets"
-    long_desc Help.text(:configsets)
-    opts.source
-    opts.stack
-    def configsets(blueprint=nil)
-      Configset::List.new(options.merge(blueprint: blueprint)).run
+    desc "clean", "Removes `output` folder."
+    opts.yes
+    def clean
+      Clean.new(options).run
     end
 
-    desc "extensions [BLUEPRINT]", "Lists extensions"
-    long_desc Help.text(:extensions)
-    opts.source
-    opts.stack
-    def extensions(blueprint=nil)
-      Extension::List.new(options.merge(blueprint: blueprint)).run
+    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 "generate BLUEPRINT", "Generate both CloudFormation templates and parameters files."
-    long_desc Help.text(:generate)
-    option :quiet, type: :boolean, desc: "silence the output"
-    opts.clean
-    opts.source
-    opts.stack
-    opts.template
-    def generate(blueprint)
-      o = options.merge(
-        blueprint: blueprint,
-        generate_only: true,
-      )
-      Lono::Generate.new(o).all
-    end
-
-    desc "user_data NAME", "Generates user_data script for debugging."
-    long_desc Help.text(:user_data)
-    opts.clean
-    def user_data(blueprint, name)
-      Script::Build.new(blueprint, options).run
-      UserData.new(blueprint, options.merge(name: name)).generate
+    desc "list", "List blueprints"
+    long_desc Help.text(:list)
+    option :type, aliases: :t, desc: "Type: IE: blueprint, configset, extension. Defaults to all"
+    def list
+      List.new(options).run
     end
 
-    desc "summary BLUEPRINT", "Prints summary of CloudFormation templates."
-    long_desc Help.text("summary")
-    opts.source
-    opts.template
-    def summary(blueprint)
-      Lono::Inspector::Summary.new(options.merge(blueprint: blueprint)).run
+    desc "output BLUEPRINT", "output or preview of the deploy"
+    long_desc Help.text(:output)
+    option :format, desc: "Output formats: #{CliFormat.formats.join(', ')}"
+    def output(blueprint)
+      Lono::Cfn::Output.new(options.merge(blueprint: blueprint)).run
     end
 
-    desc "xgraph STACK", "Graphs dependencies tree of CloudFormation template resources."
-    long_desc Help.text("xgraph")
-    option :display, type: :string, desc: "graph or text", default: "graph"
-    option :noop, type: :boolean, desc: "noop mode"
-    opts.source
-    opts.template
-    def xgraph(blueprint)
-      Lono::Inspector::Graph.new(options.merge(blueprint: blueprint)).run
+    desc "plan BLUEPRINT", "Preview deploy"
+    long_desc Help.text(:plan)
+    option :out, aliases: :o, desc: "Write Change Set info to path"
+    def plan(blueprint)
+      Lono::Cfn::Plan.new(options.merge(blueprint: blueprint)).run
     end
 
-    desc "seed BLUEPRINT", "Generates starter configs for a blueprint."
+    desc "seed BLUEPRINT", "Builds starter configs for a blueprint."
     long_desc Help.text("seed")
     option :param, desc: "override convention and specify the param file to use"
-    opts.source
-    opts.template
-    add_runtime_options! # Thor::Action options like --force
+    opts.runtime_options
+    option :where, desc: "Where to create file, you specify the top-level folder. Possible values: app, config, vendor. Defaults to config"
     def seed(blueprint)
       Seed.new(options.merge(blueprint: blueprint)).create
     end
 
-    desc "app_files BLUEPRINT", "Builds app files", hide: true
-    long_desc Help.text("app_files")
-    add_runtime_options! # Thor::Action options like --force
-    def app_files(blueprint)
-      Lono::AppFile::Build.new(blueprint, options).run
+    desc "show BLUEPRINT", "Deploy CloudFormation stack"
+    long_desc Help.text(:show)
+    def show(blueprint)
+      Lono::Cfn::Show.new(options.merge(blueprint: blueprint)).run
     end
 
-    desc "clean", "Removes `output` folder."
-    def clean
-      Clean.new(options).run
+    desc "status BLUEPRINT", "Shows current status of blueprint."
+    long_desc Help.text(:status)
+    def status(blueprint)
+      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
+    end
+
+    desc "test", "Run test."
+    long_desc Help.text(:test)
+    def test
+      Test.new(options).run
     end
 
-    desc "upgrade", "Upgrade lono"
-    long_desc Help.text("upgrade")
-    def upgrade
-      Upgrade.new(options).run
+    desc "up BLUEPRINT", "Deploy stack"
+    long_desc Help.text(:up)
+    cfn_opts.deploy
+    def up(blueprint)
+      Lono::Cfn::Deploy.new(options.merge(blueprint: blueprint)).run
+    end
+
+    desc "user_data BLUEPRINT NAME", "Generates user_data script for debugging."
+    long_desc Help.text(:user_data)
+    opts.clean
+    def user_data(blueprint, name)
+      Script::Build.new(options.merge(blueprint: blueprint)).run
+      UserData.new(options.merge(blueprint: blueprint, name: name)).generate
     end
 
-    desc "completion *PARAMS", "Prints words for auto-completion."
+    desc "completion *PARAMS", "Prints words for auto-completion"
     long_desc Help.text("completion")
     def completion(*params)
       Completer.new(CLI, *params).run
     end
 
-    desc "completion_script", "Generates a script that can be eval to setup auto-completion."
+    desc "completion_script", "Builds a script that can be eval to setup auto-completion"
     long_desc Help.text("completion_script")
     def completion_script
-      Completer::Script.generate
+      Completer::Script.build
     end
 
     desc "version", "Prints version"
@@ -117,10 +118,6 @@ module Lono
       puts "Lono: #{VERSION}"
     end
 
-    desc "blueprint SUBCOMMAND", "blueprint subcommands"
-    long_desc Help.text(:blueprint)
-    subcommand "blueprint", Blueprint
-
     desc "cfn SUBCOMMAND", "cfn subcommands"
     long_desc Help.text(:cfn)
     subcommand "cfn", Cfn
@@ -129,25 +126,9 @@ module Lono
     long_desc Help.text(:code)
     subcommand "code", Code
 
-    desc "configset SUBCOMMAND", "configset subcommands"
-    long_desc Help.text(:configset)
-    subcommand "configset", Configset
-
-    desc "extension SUBCOMMAND", "extension subcommands"
-    long_desc Help.text(:extension)
-    subcommand "extension", Extension
-
-    desc "param SUBCOMMAND", "param subcommands"
-    long_desc Help.text(:param)
-    subcommand "param", Param
-
-    desc "pro SUBCOMMAND", "pro subcommands"
-    long_desc Help.text(:pro)
-    subcommand "pro", Pro
-
-    desc "registration SUBCOMMAND", "registration subcommands"
-    long_desc Help.text(:registration)
-    subcommand "registration", Registration
+    desc "new SUBCOMMAND", "new subcommands"
+    long_desc Help.text(:new)
+    subcommand "new", New
 
     desc "s3 SUBCOMMAND", "s3 subcommands"
     long_desc Help.text(:s3)
@@ -156,17 +137,5 @@ module Lono
     desc "script SUBCOMMAND", "script subcommands"
     long_desc Help.text(:script)
     subcommand "script", Script
-
-    desc "sets SUBCOMMAND", "sets subcommands"
-    long_desc Help.text(:sets)
-    subcommand "sets", Sets
-
-    desc "set_instances SUBCOMMAND", "set_instances subcommands"
-    long_desc Help.text(:set_instances)
-    subcommand "set_instances", SetInstances
-
-    desc "template SUBCOMMAND", "template subcommands"
-    long_desc Help.text(:template)
-    subcommand "template", Template
   end
 end

data/lib/lono/command.rb

@@ -31,7 +31,14 @@ end
 module Lono
   class Command < Thor
     class << self
+      include Lono::Utils::Logging
+
       def dispatch(m, args, options, config)
+        # 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_project!(args.first)
+
         # Allow calling for help via:
         #   lono command help
         #   lono command -h
@@ -41,7 +48,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")
@@ -58,6 +64,26 @@ module Lono
         super
       end
 
+      def check_project!(command_name)
+        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 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
+
+      def help_flags
+        Thor::HELP_MAPPINGS + ["help"]
+      end
+      private :help_flags
+
+      def subcommand?
+        !!caller.detect { |l| l.include?('in subcommand') }
+      end
+
       # Override command_help to include the description at the top of the
       # long_description.
       def command_help(shell, command_name)

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

@@ -1,16 +1,17 @@
 module Lono
-  class Configset < Command
-    long_desc Help.text("configset/new")
-    New.cli_options.each do |args|
-      option(*args)
+  class Configset < Component
+    attr_reader :resource
+    attr_accessor :metadata
+    def initialize(options={})
+      super
+      @resource = options[:resource]
     end
-    register(New, "new", "new NAME", "Generates new lono configset.")
 
-    desc "generate", "Generate configset from DSL"
-    long_desc Help.text(:generate)
-    option :resource, default: "PretendResource", desc: "Set the @resource instance variable availalbe in the configset"
-    def generate(configset)
-      Generator.new(options.merge(configset: configset, cli: true)).run
+    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

@@ -4,79 +4,50 @@ module Lono
   module Core
     extend Memoist
 
-    def config
-      Config.new
-    end
-    memoize :config
+    cattr_accessor :argv
+    cattr_accessor :check_project, default: true
 
-    @@root = nil
+    # allow testing frameworks to switch root
+    cattr_writer :root
     def root
       path = @@root || ENV['LONO_ROOT'] || Dir.pwd
       Pathname.new(path)
     end
-    memoize :root
 
-    @@blueprint_root = nil
-    def blueprint_root; @@blueprint_root ; end
-    def blueprint_root=(v) ; @@blueprint_root = v ; end
+    def app
+      ENV['LONO_APP']
+    end
+    memoize :app
 
     def env
-      # 2-way binding
-      env = env_from_profile(ENV['AWS_PROFILE']) || 'development'
-      env = ENV['LONO_ENV'] if ENV['LONO_ENV'] # highest precedence
-      env
+      ENV['LONO_ENV'] || 'dev'
     end
     memoize :env
 
-    # Overrides AWS_PROFILE based on the Lono.env if set in configs/settings.yml
-    # 2-way binding.
-    def set_aws_profile!
-      return unless settings # Only load if within lono project and there's a settings.yml
-      data = settings[Lono.env] || {}
-      if data["aws_profile"]
-        # puts "Using AWS_PROFILE=#{data["aws_profile"]} from LONO_ENV=#{Lono.env} in configs/settings.yml"
-        ENV['AWS_PROFILE'] = data["aws_profile"]
-      end
+    def tmp_root
+      ENV['LONO_TMP_ROOT'] || "/tmp/lono"
     end
+    memoize :tmp_root
 
-    # Do not use the Setting#data to load the profile because it can cause an
-    # infinite loop then if we decide to use Lono.env from within settings class.
-    def settings
-      setting = Setting.new(false) # check_lono_project to account for `lono new`
-      settings_path = setting.lookup_project_settings_path
-      return unless settings_path # in case outside of lono project
-
-      YAML.load_file(settings_path)
+    def log_root
+      "#{root}/log"
     end
-    memoize :settings
 
-    def lono_pro_removal_check!
-      if lono_pro_installed?
-        puts "ERROR: A lono-pro gem installation has been detected.".color(:red)
-        puts <<~EOL
-          The lono-pro gem is now a part of lono itself. The lono-pro gem has been deprecated.
-          Please uninstall the lono-pro gem and remove it from your Gemfile to continue.
-        EOL
-        exit 1
-      end
+    def configure(&block)
+      App.instance.configure(&block)
     end
 
-    def lono_pro_installed?
-      Lono::Pro::VERSION
-      true
-    rescue NameError
-      false
+    # 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
     end
+    memoize :config
 
-  private
-    def env_from_profile(aws_profile)
-      return unless settings
-      env = settings.find do |_env, settings|
-        settings ||= {}
-        profiles = settings['aws_profile']
-        profiles && profiles == aws_profile
-      end
-      env.first if env
+    # allow different logger when running up all or rspec-lono
+    cattr_writer :logger
+    def logger
+      @@logger ||= config.logger
     end
   end
 end

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/files/builder.rb

@@ -0,0 +1,37 @@
+class Lono::Files
+  class Builder < Base
+    extend Memoist
+    include Lono::Builder::Context
+    include Lono::Builder::Dsl::Syntax
+    # Tricky must define files again to avoid conflict with files from loading the Dsl::Syntax
+    attr_reader :files
+
+    def run
+      load_context
+      if File.directory?(full_path)
+        directory(@files)
+      else
+        template(@files)
+      end
+    end
+
+    def template(files)
+      sequence.send(:set_template_paths, @blueprint.root)
+      src = files.path
+      dest = files.output_path
+      sequence.template(src, dest)
+    end
+
+    def directory(files)
+      src = files.full_path
+      sequence.send(:set_template_paths, src)
+      sequence.destination_root = @files.output_path
+      sequence.directory(".", verbose: false, force: true, context: binding) # Thor::Action
+    end
+
+    def sequence
+      Lono::CLI::New::Sequence.new(@options)
+    end
+    memoize :sequence
+  end
+end

data/lib/lono/files/compressor.rb

@@ -0,0 +1,53 @@
+require 'fileutils'
+
+class Lono::Files
+  class Compressor < Base
+    def run
+      if File.directory?(output_path)
+        zip_directory
+      else
+        zip_file
+      end
+    end
+
+    def zip_file
+      logger.debug "Zipping file to #{pretty_path(zip_path)}"
+      # create zipfile at same level of file
+      command = "cd #{File.dirname(output_path)} && zip -q #{zip_name} #{File.basename(output_path)}"
+      execute_zip(command)
+    end
+
+    def zip_directory
+      logger.debug "Zipping folder to #{zip_path}"
+      command = "cd #{output_path} && zip --symlinks -rq #{zip_name} ." # create zipfile witih directory
+      execute_zip(command)
+      FileUtils.mv("#{output_path}/#{zip_name}", "#{File.dirname(output_path)}/#{zip_name}") # move zip back to the parent directory
+    end
+
+  private
+    def execute_zip(command)
+      check_zip_installed!
+      logger.debug "=> #{command}".color(:green)
+      `#{command}`
+      return if $?.success?
+      logger.info "ERROR: Fail trying to zip files".color(:red)
+      logger.info "Command: #{command}".color(:red)
+      exit 1
+    end
+
+    @@zip_installed = false
+    def check_zip_installed!
+      @@zip_installed = system("type zip > /dev/null 2>&1")
+      if @@zip_installed
+        @@zip_installed = true
+        return
+      end
+      logger.error "ERROR: The command 'zip' is not installed.".color(:red)
+      logger.error <<~EOL
+        The file helper requires the zip command.
+        Please install the zip command on this system.
+      EOL
+      exit 1
+    end
+  end
+end