lono 7.5.2 → 8.0.0.pre.rc1

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

@@ -1,13 +0,0 @@
-module Lono::Configset::Register
-  class Project < Base
-    self.configsets = []
-    self.validations = []
-
-    def evaluate
-      layering = Lono::Layering.new("configsets", @options, Lono.env)
-      layering.locations.each do |path|
-        evaluate_file(path)
-      end
-    end
-  end
-end

data/lib/lono/configset/resolver.rb

@@ -1,47 +0,0 @@
-class Lono::Configset
-  class Resolver
-    extend Memoist
-
-    @@dependencies = [] # save to later regsiter configsets
-
-    @@resolving_message_shown = false
-    def resolve(*unresolved)
-      unresolved.flatten! # initially only top-level
-      unresolved.uniq! { |jade| jade.name }
-      puts "Resolving dependencies..." if !@@resolving_message_shown && !unresolved.empty?
-      puts "Resolving #{unresolved.map(&:name)}" if ENV['LONO_DEBUG_CONFIGSET']
-
-      @@resolving_message_shown = true
-
-      unresolved.each do |jade|
-        jade.check_for_circular_dependency!
-        jade.materialize
-        jade.dependencies.each do |j|
-          @@dependencies << j # store for later registration
-          unless j.resolved? or unresolved.include?(j)
-            resolve(j)
-          end
-        end
-        jade.resolved! # resolve after depth-first tranversal. So all dependencies have also been resolved at this point.
-      end
-    end
-
-    def register
-      @@dependencies.each do |jade|
-        # dependency jades have minimal registry info. For additional info is pulled from stored reference data in
-        # jade like jade.resource_from_parent.
-        registry = jade.registry
-        registry.resource = jade.resource_from_parent
-
-        # Always prepend to Register::Blueprint.configsets to ensure they are run before any other configset.
-        # Leaving old code in place for now. Possibly revisit this approach.
-        Register::Blueprint.prepend(registry)
-        # if jade.type == "blueprint/configset"
-        #   Register::Blueprint.prepend(registry)
-        # elsif jade.type == "configset"
-        #   Register::Project.prepend(registry)
-        # end
-      end
-    end
-  end
-end

data/lib/lono/configset.rb

@@ -1,16 +0,0 @@
-module Lono
-  class Configset < Command
-    long_desc Help.text("configset/new")
-    New.cli_options.each do |args|
-      option(*args)
-    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
-    end
-  end
-end

data/lib/lono/conventions.rb

@@ -1,23 +0,0 @@
-module Lono
-  class Conventions
-    attr_reader :stack, :blueprint, :template, :param
-    def initialize(options)
-      @options = options
-      @stack, @blueprint, @template, @param = naming_conventions(options)
-    end
-
-    def naming_conventions(options)
-      o = options.deep_symbolize_keys
-      stack = o[:stack]
-      blueprint = o[:blueprint] || o[:stack]
-      template = o[:template] || blueprint
-      param = o[:param] || template || blueprint
-      stack ||= blueprint # fallback for commands that dont take stack name. IE: lono generate
-      [stack, blueprint, template, param]
-    end
-
-    def values
-      [@stack, @blueprint, @template, @param]
-    end
-  end
-end

data/lib/lono/core/config.rb

@@ -1,22 +0,0 @@
-module Lono::Core
-  class Config
-    PATHS = {
-      definitions_path: "app/definitions",
-      helpers_path: "app/helpers",
-      content_path: "app/content",
-      partials_path: "app/partials",
-      scripts_path: "app/scripts",
-      templates_path: "app/templates",
-      user_data_path: "app/user_data",
-    }
-    PATHS.each do |meth, path|
-      define_method meth do
-        "#{Lono.blueprint_root}/#{path}"
-      end
-    end
-
-    def output_path
-      "#{Lono.root}/output"
-    end
-  end
-end

data/lib/lono/default/settings.yml

@@ -1,21 +0,0 @@
-# More info: https://lono.cloud/docs/settings/
-# The base config is specially treated. It gets included the other environments automatically.
-# Yaml also directly supports merging with & and <<* syntax but doing it automatically
-# for a cleaner syntax.
-base:
-  # https://lono.cloud/docs/app-scripts/
-  # extract_scripts:
-  #   to: "/opt"
-  #   as: "ec2-user"
-
-development:
-  # When you have AWS_PROFILE set to one of these values, lono will switch to the desired
-  # environment. This prevents you from switching AWS_PROFILE, forgetting to
-  # also switch LONO_ENV, and accidentally deploying to production vs development.
-  # aws_profiles:
-  #   - dev_profile1
-  #   - dev_profile2
-
-production:
-  # aws_profiles:
-  #   - prod_profile

data/lib/lono/ext/bundler.rb

@@ -1,7 +0,0 @@
-# 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/extension/helper.rb

@@ -1,13 +0,0 @@
-class Lono::Extension
-  module Helper
-    extend Memoist
-
-    def extension_class_name
-      extension_underscore_name.camelize
-    end
-
-    def extension_underscore_name
-      extension_name.underscore
-    end
-  end
-end

data/lib/lono/extension/list.rb

@@ -1,40 +0,0 @@
-require 'cli-format'
-
-class Lono::Extension
-  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 blueprint_configsets
-      Lono::Extensions::Preparer.new(@options).run # register and materialize gems
-      tracked_extension_names = Lono::Jade::Registry.tracked_extensions.map(&:name)
-
-      finder = Lono::Finder::Extension.new
-      jadespecs = finder.find_all
-
-      presenter = CliFormat::Presenter.new(@options)
-      presenter.header = %w[Name Path Type]
-      jadespecs.each do |j|
-        if tracked_extension_names.include?(j.name)
-          pretty_path = j.root.sub("#{Lono.root}/",'').sub(ENV["HOME"], "~")
-          presenter.rows << [j.name, pretty_path, j.source_type]
-        end
-      end
-      presenter.show
-    end
-
-    def project_configsets
-      Lono::Finder::Extension.list(filter_materialized: true, message: "Project extensions:")
-    end
-  end
-end

data/lib/lono/extension.rb

@@ -1,9 +0,0 @@
-module Lono
-  class Extension < Command
-    long_desc Help.text("extension/new")
-    New.cli_options.each do |args|
-      option(*args)
-    end
-    register(New, "new", "new NAME", "Generates new lono extension.")
-  end
-end

data/lib/lono/extensions/preparer.rb

@@ -1,26 +0,0 @@
-class Lono::Extensions
-  class Preparer < Lono::AbstractBase
-    def initialize(options={})
-      super
-      @register = Register.new(options)
-    end
-
-    def run
-      @register.run
-      download
-      final_materialize
-    end
-
-    def download
-      Lono::Jade::Registry.tracked_extensions.each do |registry|
-        jade = Lono::Jade.new(registry.name, "extension", registry)
-        jade.materialize # adds to Lono::Jade::Registry.downloaded_extensions
-      end
-    end
-
-    def final_materialize
-      jades = Lono::Jade::Registry.downloaded_extensions
-      Lono::Jade::Materializer::Final.new.build(jades)
-    end
-  end
-end

data/lib/lono/extensions/register.rb

@@ -1,15 +0,0 @@
-class Lono::Extensions
-  class Register < Lono::AbstractBase
-    include Lono::Configset::EvaluateFile
-
-    def run
-      register_extensions # evaluates extend_with
-    end
-
-    # register_extensions and evaluate extend_with methods earlier than load_context so project helpers can override extensions
-    def register_extensions
-      template_path = "#{Lono.config.templates_path}/#{@template}.rb"
-      Lono::Extensions.new(template_path).evaluate # registers extensions
-    end
-  end
-end

data/lib/lono/file_uploader.rb

@@ -1,21 +0,0 @@
-module Lono
-  class FileUploader < AbstractBase
-    extend Memoist
-
-    def initialize(options={})
-      super
-      @checksums = {}
-      @prefix = "#{Lono.env}/#{blueprint}/files" # s3://s3-bucket/folder/development/files
-    end
-
-    def upload_all
-      puts "Uploading app/files.."
-      load_checksums!
-
-      Dir.glob(pattern).each do |path|
-        next if ::File.directory?(path)
-        Lono::S3::Uploader.new(path).upload
-      end
-    end
-  end
-end

data/lib/lono/finder/base.rb

@@ -1,152 +0,0 @@
-require "bundler"
-require "text-table"
-
-module Lono::Finder
-  class Base
-    extend Memoist
-
-    def initialize(lono_root: nil, blueprint_root: nil)
-      @lono_root = lono_root || Lono.root
-      @blueprint_root = blueprint_root || Lono.blueprint_root
-    end
-
-    # Returns root path of component: blueprint or configset
-    def find(name, local_only: false)
-      all = find_all(local_only: local_only)
-      all.find { |jadespec| jadespec.name == name }
-    end
-
-    def find_all(local_only: false)
-      if local_only
-        local
-      else
-        local + materialized
-      end
-    end
-
-    def local
-      project + vendor + gems
-    end
-
-    def project
-      roots = path_roots("#{@lono_root}/app/#{type.pluralize}")
-      components(roots, "project")
-    end
-
-    def vendor
-      roots = path_roots("#{@lono_root}/vendor/#{type.pluralize}")
-      components(roots, "vendor")
-    end
-
-    def gems
-      components(gem_roots, "gem")
-    end
-
-    # Folders that each materialized gems to tmp/jades
-    def materialized
-      components(materialized_gem_roots, "materialized")
-    end
-
-    # Components: blueprints or configsets
-    # Returns array of config Hashes. Example structure:
-    #
-    #     [{
-    #       name: "cfn-hup",
-    #       root: "/path/to/gem/root",
-    #       source_type: "project",
-    #     },...]
-    #
-    def components(roots, source_type)
-      components = []
-      roots.each do |root|
-        next unless detect?(root)
-        jadespec = Lono::Jadespec.new(root, source_type)
-        components << jadespec
-      end
-      components
-    end
-    memoize :components
-
-    def detect?(root)
-      expr = "#{root}/#{detection_path}"
-      Dir.glob(expr).size > 0
-    end
-
-    # Used for blueprints, configsets, and blueprint/configsets
-    def list(options={})
-      table = Text::Table.new
-      table.head = ["Name", "Path", "Type"]
-
-      components = find_all.sort_by { |jadespec| jadespec.name }
-      components.each do |jadespec|
-        pretty_path = jadespec.root.sub("#{Lono.root}/", "").sub(ENV['HOME'], "~")
-        unless options[:filter_materialized] && jadespec.source_type == "materialized"
-          table.rows << [jadespec.name, pretty_path, jadespec.source_type]
-        end
-      end
-
-      if table.rows.empty?
-        puts "No #{type.pluralize} found."
-      else
-        puts(options[:message] || "Available #{type.pluralize}:")
-        puts table
-      end
-    end
-
-  private
-    def path_roots(path)
-      Dir.glob("#{path}/*").to_a
-    end
-
-    # Example return:
-    #
-    #     [
-    #       "/home/ec2-user/.rbenv/versions/2.5.6/lib/ruby/gems/2.5.0/gems/rake-13.0.1",
-    #       "/home/ec2-user/.rbenv/versions/2.5.6/lib/ruby/gems/2.5.0/gems/thor-0.20.3"
-    #     ]
-    #
-    def gem_roots
-      Bundler.load.specs.map do |spec|
-        spec.full_gem_path
-      end
-    end
-    memoize :gem_roots
-
-    def materialized_gem_roots
-      gemfile_lock = "#{Lono.root}/tmp/jades/Gemfile.lock"
-      return [] unless File.exist?(gemfile_lock)
-
-      parser = Bundler::LockfileParser.new(Bundler.read_file(gemfile_lock))
-      specs = parser.specs
-      # __materialize__ only exists in Gem::LazySpecification and not in Gem::Specification
-      specs.each { |spec| spec.__materialize__ }
-      begin
-        specs.map do |spec|
-          spec.full_gem_path
-        end
-      rescue RuntimeError => e
-        if e.message.include?("LazySpecification has not been materialized yet")
-          # Thinking quiet behavior is preferred. Leaving comment here for now.
-          # puts "WARN: The Finder class is having trouble using the cached tmp/jades/Gemfile.lock to search for materialized gems."
-          # puts "This can happen when materialized gems are updated. It is generally safe to ignore."
-          # puts "To remove this warning you can remove the cached Gemfile.lock"
-          return []
-        else
-          raise(e)
-        end
-      end
-    end
-    memoize :materialized_gem_roots
-
-  public
-    class << self
-      def find(name)
-        new.find(name)
-      end
-
-      def list(options={})
-        new.list(options)
-      end
-    end
-  end
-end

data/lib/lono/finder/blueprint/configset.rb

@@ -1,17 +0,0 @@
-class Lono::Finder::Blueprint
-  class Configset < Lono::Finder::Configset
-    def initialize(options={})
-      super(**options) # **options to remove: warning: Using the last argument as keyword parameters is deprecated; maybe ** should be added to the call
-      @blueprint_root = options[:blueprint_root] || Lono.blueprint_root
-    end
-
-    def local
-      project + vendor + blueprint_app + gems
-    end
-
-    def blueprint_app
-      roots = path_roots("#{@blueprint_root}/app/#{type.pluralize}")
-      components(roots, "blueprint")
-    end
-  end
-end

data/lib/lono/finder/blueprint.rb

@@ -1,11 +0,0 @@
-module Lono::Finder
-  class Blueprint < Base
-    def type
-      "blueprint"
-    end
-
-    def detection_path
-      "app/templates"
-    end
-  end
-end

data/lib/lono/finder/configset.rb

@@ -1,11 +0,0 @@
-module Lono::Finder
-  class Configset < Base
-    def type
-      "configset"
-    end
-
-    def detection_path
-      "lib/configset.*"
-    end
-  end
-end

data/lib/lono/finder/extension.rb

@@ -1,11 +0,0 @@
-module Lono::Finder
-  class Extension < Base
-    def type
-      "extension"
-    end
-
-    def detection_path
-      "lib/*/helpers"
-    end
-  end
-end

data/lib/lono/generate.rb

@@ -1,111 +0,0 @@
-module Lono
-  class Generate < AbstractBase
-    # Use class variable to cache this only runs once across all classes. base.rb, diff.rb, preview.rb
-    @@parameters = nil
-    def all
-      return @@parameters if @@parameters
-
-      ensure_s3_bucket_exist unless generate_only?
-      pre_generate
-      generate_templates # generates with some placeholders for build_files IE: file://app/files/my.rb
-      post_generate
-      upload unless generate_only?
-
-      @@parameters = param_generator.generate  # Writes the json file in CamelCase keys format
-      check_for_errors
-      @@parameters
-    end
-
-    def generate_only?
-      ENV['LONO_GENERATE_ONLY'] || @options[:generate_only]
-    end
-
-    def pre_generate
-      build_scripts
-    end
-
-    def post_generate
-      return if @options[:noop]
-      return if @options[:source]
-
-      build_files # builds app/files to output/BLUEPRINT/files
-      post_process_template
-    end
-
-    def param_generator
-      o = {
-        regenerate: true,
-        allow_not_exists: true,
-      }.merge(@options)
-      o = HashWithIndifferentAccess.new(o)
-      Lono::Param::Generator.new(o)
-    end
-    memoize :param_generator
-
-    def ensure_s3_bucket_exist
-      bucket = Lono::S3::Bucket.new
-      return if bucket.exist?
-      bucket.deploy
-    end
-
-    def build_scripts
-      Lono::Script::Build.new(@options).run
-    end
-
-    def build_files
-      Lono::AppFile::Build.new(@options).run
-      Lono::Configset::S3File::Build.new(@options).run # copies files to the output folder
-    end
-
-    def generate_templates
-      Lono::Template::Generator.new(@options).run # write templates to disk
-      inject_configsets
-    end
-
-    def inject_configsets
-      # The inject_configsets reads it back from disk. Leaving as-is instead of reading all in memory in case there's a reason.
-      Lono::Configset::Preparer.new(@options).run # register and materialize gems
-      Lono::Template::ConfigsetInjector.new(@options).run
-    end
-
-    def post_process_template
-      Lono::Template::PostProcessor.new(@options).run
-    end
-
-    def upload
-      upload_files
-      upload_scripts
-      upload_templates
-    end
-
-    def upload_templates
-      Lono::Template::Upload.new(@options).run
-    end
-
-    def upload_scripts
-      Lono::Script::Upload.new(@options).run
-    end
-
-    def upload_files
-      Lono::AppFile::Upload.new(@options).upload
-      Lono::Configset::S3File::Upload.new(@options).upload
-    end
-
-    def check_for_errors
-      errors = check_files
-      unless errors.empty?
-        puts "Please double check the command you ran.  There were some errors."
-        puts "ERROR: #{errors.join("\n")}".color(:red)
-        exit
-      end
-    end
-
-    def check_files
-      errors = []
-      unless File.exist?(template_path)
-        errors << "Template file missing: could not find #{template_path}"
-      end
-      errors
-    end
-  end
-end

data/lib/lono/help/cfn/create.md

@@ -1,26 +0,0 @@
-## Examples
-
-Provided that you are in a lono project and have a `demo` lono blueprint that contains a `demo` template.  To create a stack you can run:
-
-    lono cfn create demo
-
-The above command will generate:
-
-* template:   output/demo/templates/demo.yml
-* parameters: output/demo/params/development.json
-
-By [convention]({% link _docs/conventions/cli.md %}), the blueprint name is the same as the stack name. In turn, template name is the same as the blueprint name. Lastly, the param name will default to the template name.
-
-Here are examples of overriding the template and params name conventions.
-
-    lono cfn create demo --template different1
-
-The template used is `app/templates/different1.rb` and the parameters used is `configs/demo/params/development/demo/different1.txt`.
-
-    lono cfn create demo --param different2
-
-The template used is `app/templates/demo.rb` and the parameters used is `configs/demo/params/development/demo/different2.json`.
-
-    lono cfn create demo --template different3 --param different4
-
-The template used is `app/templates/different3.rb` and the parameters used is `configs/demo/params/different3/different4.json`.

data/lib/lono/help/cfn/delete.md

@@ -1,13 +0,0 @@
-## Examples
-
-    $ lono cfn delete ec2
-    Are you sure you want to delete the stack? (y/N)
-    y
-    Deleted example stack.
-    $
-
-Lono prompts you with an "Are you sure?" message before the stack gets deleted.  If you would like to bypass the prompt, you can use the `--sure` flag.
-
-    $ lono cfn delete example --sure
-    Deleted example stack.
-    $

data/lib/lono/help/cfn/deploy.md

@@ -1,21 +0,0 @@
-The `cfn deploy` command figures out whether or not it should perform a stack create or update. It delegates to `cfn create` or `cfn update`.  This saves you from thinking about it
-
-## Examples
-
-Provided that you are in a lono project and have a `demo` lono blueprint that contains a `demo` template.  To create a stack you can run:
-
-    lono cfn deploy demo
-
-The above command will generate:
-
-* template:   output/demo/templates/demo.yml
-* parameters: output/demo/params/development.json
-
-
-## Conventions
-
-By [convention]({% link _docs/conventions/cli.md %}), the blueprint name is the same as the stack name. In turn, template name is the same as the blueprint name. Lastly, the param name will match the stack name unless it's explicitly specified with `--config` or `--param`.
-
-Often you want to create a stack name that is different from the blueprint name. Here’s an example of overriding the blueprint name.
-
-    lono cfn deploy my-stack --blueprint demo

data/lib/lono/help/cfn/download.md

@@ -1,3 +0,0 @@
-## Examples
-
-  lono cfn download my-stack