lono 7.5.1 → 8.0.0.pre.rc2

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/dsl.rb

@@ -1,11 +0,0 @@
-class Lono::Extensions
-  module Dsl
-    def extend_with(*args, **options)
-      register_extension_helper(args, options)
-    end
-
-    def register_extension_helper(args, options={})
-      Lono::Jade::Registry.register_extension(args, options)
-    end
-  end
-end

data/lib/lono/extensions/loader.rb

@@ -1,30 +0,0 @@
-class Lono::Extensions
-  module Loader
-    include Lono::Template::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
-
-    #
-    #     1. vendor/extensions
-    #     2. normal gem
-    #     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/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/extensions.rb

@@ -1,18 +0,0 @@
-module Lono
-  class Extensions
-    include Dsl
-    include Lono::Template::Evaluate
-
-    def initialize(template_path)
-      @template_path = template_path
-    end
-
-    def evaluate
-      evaluate_template_path(@template_path) # handle extend_with
-    end
-
-    # The extend_with methods are used in file as the normal DSL evaluation.
-    # We use method_missing so we dont have to redefine all the normal methods of the DSL.
-    def method_missing(name, *args, &block); 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,107 +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 @options[:generate_only]
-      pre_generate
-      generate_templates # generates with some placeholders for build_files IE: file://app/files/my.rb
-      post_generate
-      upload unless @options[:generate_only]
-
-      @@parameters = param_generator.generate  # Writes the json file in CamelCase keys format
-      check_for_errors
-      @@parameters
-    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