lono 7.5.2 → 8.0.0.pre.rc3

data/lib/lono/cfn.rb

@@ -1,75 +0,0 @@
-module Lono
-  class Cfn < Command
-    opts = Opts.new(self)
-
-    class_option :verbose, type: :boolean
-    class_option :noop, type: :boolean
-
-    desc "create STACK", "Create a CloudFormation stack using the generated template.", hide: true
-    opts.create
-    long_desc Lono::Help.text("cfn/create")
-    def create(stack)
-      Create.new(options.merge(stack: stack)).run
-    end
-
-    desc "update STACK", "Update a CloudFormation stack using the generated template.", hide: true
-    long_desc Lono::Help.text("cfn/update")
-    opts.update
-    def update(stack)
-      Update.new(options.merge(stack: stack)).run
-    end
-
-    desc "deploy STACK", "Create or update a CloudFormation stack using the generated template."
-    long_desc Lono::Help.text("cfn/deploy")
-    opts.deploy
-    def deploy(stack)
-      Deploy.new(options.merge(stack: stack)).run
-    end
-
-    desc "delete STACK", "Delete CloudFormation stack."
-    long_desc Lono::Help.text("cfn/delete")
-    opts.delete
-    def delete(stack)
-      Delete.new(options.merge(stack: stack)).run
-    end
-
-    desc "cancel STACK", "Cancel a CloudFormation stack."
-    long_desc Lono::Help.text("cfn/cancel")
-    opts.cancel
-    def cancel(stack)
-      Cancel.new(options.merge(stack: stack)).run
-    end
-
-    desc "preview STACK", "Preview a CloudFormation stack update.  This is similar to terraform's plan or puppet's dry-run mode."
-    long_desc Lono::Help.text("cfn/preview")
-    opts.preview
-    def preview(stack)
-      Preview::Param.new(options.merge(stack: stack)).run if options[:param_preview]
-      Preview::Codediff.new(options.merge(stack: stack)).run if options[:codediff_preview]
-      Preview::Changeset.new(options.merge(stack: stack)).run if options[:changeset_preview]
-    end
-
-    desc "download STACK", "Download CloudFormation template from existing stack."
-    long_desc Lono::Help.text("cfn/download")
-    opts.download
-    def download(stack)
-      Download.new(options.merge(stack: stack)).run
-    end
-
-    desc "current", "Current stack that you're working with."
-    long_desc Lono::Help.text("cfn/current")
-    option :rm, type: :boolean, desc: "Remove all current settings. Removes `.lono/current`"
-    option :name, desc: "Current stack name."
-    def current
-      Current.new(options).run
-    end
-
-    desc "status", "Shows current status of stack."
-    long_desc Lono::Help.text("cfn/status")
-    def status(stack)
-      status = Lono::Cfn::Status.new(stack, options)
-      success = status.run
-      exit 3 unless success
-    end
-  end
-end

data/lib/lono/clean.rb

@@ -1,14 +0,0 @@
-require "fileutils"
-
-class Lono::Clean
-  attr_reader :options
-  def initialize(options={})
-    @options = options
-  end
-
-  def run
-    puts "Clean: removing output/ and tmp/ folder"
-    FileUtils.rm_rf("#{Lono.config.output_path}")
-    FileUtils.rm_rf("#{Lono.root}/tmp")
-  end
-end

data/lib/lono/code.rb

@@ -1,22 +0,0 @@
-module Lono
-  class Code < Lono::Command
-    desc "import SOURCE", "Imports CloudFormation template and converts it to Ruby code."
-    long_desc Help.text("code/import")
-    option :blueprint, default: nil, desc: "final blueprint name"
-    option :casing, default: "as-is", desc: "Controls casing of logical ids. IE: as-is, camelcase or underscore"
-    option :summary, default: true, type: :boolean, desc: "provide template summary after import"
-    option :template, default: nil, desc: "final template name of downloaded template without extension"
-    option :template_name_casing, default: "dasherize", desc: "camelcase or dasherize the template name"
-    option :type, default: "dsl", desc: "import as a DSL or ERB template"
-    def import(source)
-      Importer.new(options.merge(source: source)).run
-    end
-
-    desc "convert SOURCE", "Converts snippet of JSON or YAML CloudFormation templates to Ruby code."
-    long_desc Help.text("code/convert")
-    option :casing, default: "as-is", desc: "Controls casing of logical ids. IE: as-is, camelcase or underscore"
-    def convert(source)
-      Importer::Converter.new(options.merge(source: source)).run
-    end
-  end
-end

data/lib/lono/configset/combiner.rb

@@ -1,162 +0,0 @@
-require "yaml"
-
-class Lono::Configset
-  class Combiner
-    def initialize(cfn, options={})
-      @cfn, @options = cfn, options
-
-      @sets = []
-      @map = {} # stores resource logical id => metadata cfn-init
-    end
-
-    def generator_options(registry, options={})
-      o = @options.merge(configset: registry.name, resource: registry.resource)
-      o.merge(options)
-    end
-
-    def metadata_map
-      return {} unless additional_configsets?
-
-      existing_configsets.each do |data|
-        add(data[:registry], data[:metdata_configset])
-      end
-
-      Register::Blueprint.configsets.each do |registry|
-        generator = Lono::Configset::Generator.new(generator_options(registry, type: "blueprint"))
-        cloudformation_init = generator.build
-        add(registry, cloudformation_init)
-      end
-      Register::Project.configsets.each do |registry|
-        generator = Lono::Configset::Generator.new(generator_options(registry, type: "project"))
-        cloudformation_init = generator.build
-        add(registry, cloudformation_init)
-      end
-
-      combine
-      Register::Blueprint.clear! # in case of lono generate for all templates
-      Register::Project.clear! # in case of lono generate for all templates
-      @map
-    end
-
-    def add(registry, metadata)
-      @sets << [registry, metadata.dup]
-    end
-
-    def additional_configsets?
-      !Register::Blueprint.configsets.empty? || !Register::Project.configsets.empty?
-    end
-
-    # Normalized/convert cfn template to mimic the registry format
-    def existing_configsets
-      configsets = []
-      @cfn["Resources"].each do |logical_id, attributes|
-        init = attributes.dig("Metadata", "AWS::CloudFormation::Init")
-
-        next unless init
-
-        data = {
-          registry: Lono::Jade::Registry.new(["#{logical_id}OriginalConfigset"], resource: logical_id),
-          metdata_configset: {"Metadata" => attributes["Metadata"]} #  # wrap metadata to create right structure
-        }
-        configsets << data
-      end
-      configsets
-    end
-
-    def combine
-      # Remove duplicate configsets. Can happen if same configset is in blueprint and project.
-      # Ugly because of the sets structure.
-      @sets.uniq! do |array|
-        registry, _ = array
-        registry.name
-      end
-
-      metadata_map = {}
-      configsets_map = {}
-
-      @sets.each_with_index do |array, i|
-        padded_i = "%03d" % i
-        registry, metadata = array
-
-        # metadata example (full structure):
-        #
-        #     {"Metadata"=>
-        #       {"AWS::CloudFormation::Init"=>
-        #         {"configSets"=>{"default"=>["aaa1", "aaa2"]},
-        #         "aaa1"=>{"commands"=>{"test"=>{"command"=>"echo from-aaa1 > test1.txt"}}},
-        #         "aaa2"=>
-        #           {"commands"=>{"test"=>{"command"=>"echo from-aaa2 > test1.txt"}}}}}}
-
-        name, resource = registry.name, registry.resource
-        configsets = configsets_map[resource] ||= {}
-
-        validate_structure!(name, metadata)
-
-        new_metadata = metadata["Metadata"].dup
-        init = new_metadata["AWS::CloudFormation::Init"] # important: adjust data by reference
-
-        if init.key?("configSets")
-          validate_simple!(registry, new_metadata["AWS::CloudFormation::Init"]["configSets"]) # validate original configset for only simple elements
-
-          # 1. expand each config as its own config, flattening to top-level
-          cs = init.delete("configSets") # Only support configSets with simple Array of Strings
-          new_config_set = {}
-          new_config_set[name] = cs["default"].map {|c| "#{padded_i}_#{c}" }
-          init.transform_keys! { |c| "#{padded_i}_#{c}" }
-
-          # Rebuild default configSet, append the new complex ConfigSet structure with each iteration
-          configsets["default"] ||= []
-          configsets["default"] << {"ConfigSet" => name}
-          configsets.merge!(new_config_set) # add each config from #1 to the top-level
-
-          init["configSets"] = configsets # replace new configset
-        else # simple config
-          init["configSets"] = configsets # adjust data by reference
-          configsets["default"] ||= []
-          configsets["default"] << {"ConfigSet" => name}
-
-          # build new config
-          config_key = "#{padded_i}_single_generated"
-          configsets[name] = [config_key]
-          new_config = {config_key => init["config"]}
-          # replace old config with new one
-          init.delete("config") # delete original simple config
-          init.merge!(new_config)
-        end
-
-        metadata_map[resource] ||= {"Metadata" => {}}
-        metadata_map[resource]["Metadata"].deep_merge!(new_metadata)
-        @map[resource] = metadata_map[resource]
-      end
-      @map
-    end
-
-    def validate_structure!(name, metadata)
-      return if metadata.is_a?(Hash) && metadata.dig("Metadata", "AWS::CloudFormation::Init")
-
-      puts "ERROR: The #{name} configset does not appear to have a AWS::CloudFormation::Init key".color(:red)
-      puts "Please double check the #{name} configset.yml structure"
-      exit 1
-    end
-
-    def validate_simple!(registry, cs)
-      has_complex_type = cs["default"].detect { |s| !s.is_a?(String) }
-      if has_complex_type
-        message =<<~EOL
-          ERROR: The configset #{registry.name} has a configSets property with a complex type.
-          configSets:
-
-              #{cs}
-
-          lono configsets only supports combining configSets with an Array of Strings.
-        EOL
-        if ENV['LONO_TEST']
-          raise message
-        else
-          puts message.color(:red)
-          exit 1
-        end
-      end
-    end
-  end
-end

data/lib/lono/configset/evaluate_file.rb

@@ -1,8 +0,0 @@
-class Lono::Configset
-  module EvaluateFile
-    def evaluate_file(path)
-      return unless path && File.exist?(path)
-      instance_eval(IO.read(path), path)
-    end
-  end
-end

data/lib/lono/configset/generator.rb

@@ -1,57 +0,0 @@
-class Lono::Configset
-  class Generator
-    def initialize(options)
-      @options = options
-      @configset = options[:configset]
-      @type = options[:type] || "project"
-    end
-
-    def run
-      check_configset_exist!
-      structure = build
-      puts YAML.dump(structure)
-    end
-
-    def check_configset_exist!
-      exist = !!Lono::Finder::Configset.find(@configset)
-      unless exist
-        puts "configset #{@configset.color(:green)} not found."
-        exit 1
-      end
-    end
-
-    def build
-      # Examples:
-      #   Erb.new(options).build
-      #   Dsl.new(options).build
-      generator_class = "Lono::Configset::Strategy::#{strategy.camelize}"
-      generator_class = Object.const_get(generator_class)
-      full = generator_class.new(@options.merge(root: configset_root)).build
-      if @options[:cli]
-        full["Metadata"] # contains AWS::CloudFormation::Init and optional AWS::CloudFormation::Authentication
-      else
-        full # Combiner uses full metadata structure
-      end
-    end
-
-    def strategy
-      jadespec = Lono::Jadespec.new(configset_root, "unknown") # abusing Jadespec to get strategy
-      jadespec.lono_strategy
-    end
-
-    def configset_root
-      finder = finder_class.new
-      found = finder.find(@configset, local_only: false)
-      found.root if found
-    end
-
-    def finder_class
-      case @type
-      when "project"
-        Lono::Finder::Configset
-      when "blueprint"
-        Lono::Finder::Blueprint::Configset
-      end
-    end
-  end
-end

data/lib/lono/configset/list.rb

@@ -1,67 +0,0 @@
-require "text-table"
-
-class Lono::Configset
-  class List
-    def initialize(options={})
-      @options = options
-      @stack, @blueprint, @template, @param = Lono::Conventions.new(options).values
-    end
-
-    def run
-      if @blueprint
-        blueprint_configsets
-      else
-        project_configsets
-      end
-    end
-
-    def project_configsets
-      Lono::Finder::Configset.list(filter_materialized: true, message: "Project configsets:")
-    end
-
-    def blueprint_configsets
-      Lono::Configset::Preparer.new(@options).run # register and materialize gems
-
-      @final ||= []
-
-      project = Lono::Configset::Register::Project.new(@options)
-      project.register
-      finder = Lono::Finder::Configset.new
-      finder.list("Configsets available to project and can used with configs:") if @options[:verbose]
-      puts "Configsets project is using for the #{@blueprint} blueprint:" if @options[:verbose]
-      show(project.configsets, finder.find_all, "project")
-
-      blueprint = Lono::Configset::Register::Blueprint.new(@options)
-      blueprint.register
-      finder = Lono::Finder::Blueprint::Configset.new
-      finder.list("Configsets available to #{@blueprint} blueprint:") if @options[:verbose]
-      puts "Configsets built into the blueprint:" if @options[:verbose]
-      show(blueprint.configsets, finder.find_all, "blueprint")
-
-      table = Text::Table.new
-      table.head = ["Name", "Path", "Type", "From"]
-      @final.each do |spec|
-        pretty_root = spec.root.sub("#{Lono.root}/",'').sub(ENV["HOME"], "~")
-        table.rows << [spec.name, pretty_root, spec.source_type, spec.from]
-      end
-
-      if table.rows.empty?
-        puts "No configsets being used."
-      else
-        puts "Configsets used by #{@blueprint.color(:green)} blueprint:"
-        puts table
-      end
-    end
-
-    def show(configsets, all, from)
-      configsets.each do |c|
-        puts "    #{c.name}" if @options[:verbose]
-        spec = all.find { |jadespec| jadespec.name == c.name }
-        next unless spec
-        spec.from = from
-        @final << spec
-      end
-      puts "" if @options[:verbose]
-    end
-  end
-end

data/lib/lono/configset/meta/dsl.rb

@@ -1,12 +0,0 @@
-class Lono::Configset::Meta
-  module Dsl
-    def depends_on(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      registry = Lono::Jade::Registry.new(args, options)
-      registry.depends_on = args.first
-      registry.parent = @jade
-      already_has = @jade.depends_ons.detect { |d| d.name == registry.name && d.args == registry.args }
-      @jade.depends_ons << registry unless already_has
-    end
-  end
-end

data/lib/lono/configset/meta.rb

@@ -1,19 +0,0 @@
-class Lono::Configset
-  class Meta
-    extend Memoist
-    include EvaluateFile
-    include Dsl
-
-    class_attribute :registries
-    self.registries = []
-
-    def initialize(jade)
-      @jade = jade
-    end
-
-    def evaluate
-      path = "#{@jade.root}/lib/meta.rb"
-      evaluate_file(path) # DSL depends_on sets @jade.depends_on decorated options
-    end
-  end
-end

data/lib/lono/configset/new.rb

@@ -1,77 +0,0 @@
-class Lono::Configset
-  class New < Lono::Sequence
-    include Lono::Blueprint::Helper
-    include Lono::Utils::Generators::Tree
-
-    argument :configset_name
-
-    def self.source_root
-      templates = File.expand_path("../../templates", File.dirname(__FILE__))
-      "#{templates}/configset"
-    end
-
-    def self.cli_options
-      [
-        [:demo, type: :boolean, default: true, desc: "Include demo template"],
-        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files."],
-      ]
-    end
-
-    cli_options.each do |args|
-      class_option(*args)
-    end
-
-    # for specs
-    def set_cwd
-      @cwd = ENV['LONO_TEST'] ? File.dirname(Lono.root) : "#{Dir.pwd}/app/configsets"
-    end
-
-    def set_variables
-      @demo = @options[:demo]
-      @demo = false if ENV["LONO_ORG"] # overrides --demo CLI option
-    end
-
-    def create_project
-      puts "=> Creating new configset called #{configset_name}."
-      if @demo
-        options = {}
-      else
-        create_file "#{@cwd}/#{configset_name}/lib/configset.rb"
-        options = {exclude_pattern: %r{configset\.rb}}
-      end
-
-      directory ".", "#{@cwd}/#{configset_name}", options
-    end
-
-    def create_license
-      return unless ENV['LONO_LICENSE_FILE']
-      copy_file ENV['LONO_LICENSE_FILE'], "#{@cwd}/#{configset_name}/LICENSE.txt"
-    end
-
-    # After this commands are executed with the newly created project
-    def set_destination_root
-      destination_root = "#{@cwd}/#{configset_name}"
-      self.destination_root = destination_root
-      @old_dir = Dir.pwd # for reset_current_dir
-      FileUtils.cd(self.destination_root)
-    end
-
-    def welcome_message
-      puts <<~EOL
-        #{"="*64}
-        Congrats 🎉 You have successfully created a lono configset.
-
-        Cd into your configset and check things out.
-
-            cd #{configset_name}
-
-        More info: https://lono.cloud/docs/core/configsets
-
-      EOL
-    end
-
-    def tree
-      tree_structure("configset")
-    end
-  end
-end

data/lib/lono/configset/preparer.rb

@@ -1,44 +0,0 @@
-class Lono::Configset
-  class Preparer < Lono::AbstractBase
-    def initialize(options={})
-      super
-      @blueprint = Register::Blueprint.new(options)
-      @project   = Register::Project.new(options)
-      @meta      = Meta.new(options)
-      @resolver  = Resolver.new
-    end
-
-    def run
-      register
-      resolve_dependencies # also calls jade.materialize
-      register_dependencies
-      materialize
-      validate_all! # run after final materializer
-    end
-
-    # Stores configsets registry items
-    def register
-      @project.register   # IE: evaluates configs/BLUEPRINT/configsets/base.rb
-      @blueprint.register # IE: evaluates BLUEPRINT/config/configsets.rb
-    end
-
-    def resolve_dependencies
-      jades = Lono::Jade::Registry.tracked_configsets  # at this point only top-level
-      @resolver.resolve(jades) # also calls jade.materialize
-    end
-
-    def register_dependencies
-      @resolver.register
-    end
-
-    def materialize
-      jades = Lono::Jade::Registry.downloaded_configsets
-      Lono::Jade::Materializer::Final.new.build(jades)
-    end
-
-    def validate_all!
-      @blueprint.validate!
-      @project.validate!
-    end
-  end
-end

data/lib/lono/configset/register/base.rb

@@ -1,122 +0,0 @@
-# Subclasses must implement:
-#
-#    evaluate
-#
-module Lono::Configset::Register
-  class Base < Lono::AbstractBase
-    class_attribute :configsets
-    class_attribute :validations
-    class_attribute :source
-
-    include Dsl
-    include Lono::Configset::EvaluateFile
-
-    def register
-      evaluate
-      jadify
-    end
-
-    def jadify
-      self.class.configsets.each do |registry|
-        jade = Lono::Jade.new(registry.name, jade_type, registry)
-        Lono::Jade::Registry.tracked_configsets << jade
-      end
-    end
-
-    def jade_type
-      finder_class.to_s.sub('Lono::Finder::','').underscore
-    end
-
-    # Used in Base#validate!
-    def finder_class
-      case self
-      when Lono::Configset::Register::Blueprint
-        Lono::Finder::Blueprint::Configset
-      when Lono::Configset::Register::Project
-        Lono::Finder::Configset
-      end
-    end
-
-    # Store to be able to provide the validation errors altogether later.
-    def store_for_validation(registry)
-      # save caller line to use later for pointing to exactly line
-      caller_line = caller.grep(/evaluate_file/).first
-      registry.caller_line = caller_line
-      # huge performance improvement by only validating the first configset registration of duplicate gems
-      names = self.class.validations.map {|r| r.name }
-      self.class.validations << registry unless names.include?(registry.name)
-    end
-
-    # Validate the configset before building templates. So user finds out about errors early.
-    def validate!
-      errors = []
-      self.class.validations.each do |registry|
-        config = finder_class.find(registry.name) # finder_class implemented in subclass
-        errors << [:finder_missing, registry] unless config
-
-        if registry.depends_on.nil? && registry.resource.nil?
-          errors << [:resource_missing, registry]
-        end
-      end
-
-      return if errors.empty? # all good
-      show_errors_and_exit!(errors)
-    end
-
-    def show_errors_and_exit!(errors)
-      errors.each do |error_type, registry|
-        name, caller_line = registry.name, registry.caller_line
-        case error_type
-        when :finder_missing
-          puts "ERROR: Configset with name #{name} not found. Please double check Gemfile and configs/#{@blueprint}/configsets files.".color(:red)
-          pretty_trace(caller_line)
-        when :resource_missing
-          puts "ERROR: Configset with name #{name} does not specify resource. The resource key is required.".color(:red)
-          pretty_trace(caller_line)
-          raise
-        end
-      end
-      exit 1
-    end
-
-    def pretty_trace(caller_line)
-      md = caller_line.match(/(.*\.rb):(\d+):/)
-      path, error_line_number = md[1], md[2].to_i
-
-      context = 5 # lines of context
-      top, bottom = [error_line_number-context-1, 0].max, error_line_number+context-1
-
-      puts "Showing file: #{path}"
-      lines = IO.read(path).split("\n")
-      spacing = lines.size.to_s.size
-      lines[top..bottom].each_with_index do |line_content, index|
-        current_line_number = top+index+1
-        if current_line_number == error_line_number
-          printf("%#{spacing}d %s\n".color(:red), current_line_number, line_content)
-        else
-          printf("%#{spacing}d %s\n", current_line_number, line_content)
-        end
-      end
-    end
-
-  public
-    class << self
-      def clear!
-        self.configsets = []
-        self.validations = []
-      end
-
-      def prepend(registry)
-        self.configsets.unshift(registry) unless has?(registry)
-      end
-
-      def append(registry)
-        self.configsets << registry unless has?(registry)
-      end
-
-      def has?(registry)
-        configsets.detect { |r| r.name == registry.name && r.args == registry.args }
-      end
-    end
-  end
-end