lono 8.0.0.pre.rc1 → 8.0.0.pre.rc4

data/lib/lono/app_file/build.rb

@@ -1,79 +0,0 @@
-require "thor"
-
-module Lono::AppFile
-  class Build < Base
-    include Lono::Utils::Item::Zip
-
-    def initialize_variables
-      @output_files_path = "#{Lono.root}/output/#{@blueprint.name}/files"
-    end
-
-    def run
-      return unless detect_files?
-      logger.info "Building app/files"
-      build_all
-    end
-
-    def build_all
-      clean_output
-      validate_files!
-      copy_to_output
-      build_layers
-      compress_output
-    end
-
-    def validate_files!
-      items = Registry.items + Registry.layers
-      missing = items.select do |item|
-        !File.exist?(item.src_path)
-      end
-      missing_paths = missing.map { |item| item.src_path }.uniq
-      unless missing_paths.empty?
-        logger.info "ERROR: These app/files are missing were used by the s3_key method but are missing".color(:red)
-        missing_paths.each do |path|
-          logger.info "    #{path}"
-        end
-        logger.info "Please double check that they exist."
-        exit 1
-      end
-    end
-
-    def build_layers
-      layer_items = Registry.layers
-      layer_items.each do |item|
-        LambdaLayer.new(@blueprint, item).build
-      end
-    end
-
-    def compress_output
-      Registry.items.each do |item|
-        # type can be lambda_layer or file
-        if item.type == "lambda_layer" || item.exist?
-          zip(item)
-        else
-          logger.info "WARN: #{item.src_path} does not exist. Double check that the path is correct in the s3_key call.".color(:yellow)
-        end
-      end
-    end
-
-    def copy_to_output
-      override_source_paths("#{@blueprint.root}/app/files")
-      self.destination_root = @output_files_path
-      directory(".", verbose: false, context: context.get_binding) # Thor::Action
-    end
-
-    def clean_output
-      FileUtils.rm_rf(@output_files_path)
-    end
-
-    def detect_files?
-      app_files = Dir["#{@blueprint.root}/app/files/*"]
-      if app_files.empty?
-        false
-      else
-        logger.info "Detected app/files"
-        true
-      end
-    end
-  end
-end

data/lib/lono/app_file/registry/item.rb

@@ -1,24 +0,0 @@
-class Lono::AppFile::Registry
-  # Holds metadata about the item in the regsitry.
-  class Item
-    include Lono::Utils::Item::FileMethods
-
-    attr_reader :name, :options, :type
-    def initialize(name, blueprint, options={})
-      @name, @blueprint.name, @options = name, blueprint, options
-      @type = options[:type] || "file"
-    end
-
-    def src_path
-      "#{@blueprint.root}/app/files/#{@name}"
-    end
-
-    def output_path
-      if @type == "file"
-        "#{Lono.root}/output/#{@blueprint.name}/files/#{@name}"
-      else
-        "#{Lono.root}/output/#{@blueprint.name}/lambda_layers/#{@name}/opt"
-      end
-    end
-  end
-end

data/lib/lono/app_file/registry.rb

@@ -1,16 +0,0 @@
-module Lono::AppFile
-  class Registry
-    cattr_reader :items
-    @@items = []
-
-    class << self
-      def register(name, blueprint, options={})
-        @@items << Item.new(name, blueprint, options) unless @@items.detect { |i| i.name == name && i.type == options[:type] }
-      end
-
-      def layers
-        @@items.select { |i| i.type == "lambda_layer" }
-      end
-    end
-  end
-end

data/lib/lono/app_file/upload.rb

@@ -1,12 +0,0 @@
-module Lono::AppFile
-  class Upload < Base
-    def upload
-      return unless Registry.items.size > 0
-      logger.info "Uploading app/files..."
-
-      Registry.items.each do |item|
-        Lono::S3::Uploader.new(item.zip_file_path).upload
-      end
-    end
-  end
-end

data/lib/lono/builder/context/loader/load_files.rb

@@ -1,23 +0,0 @@
-module Lono::Builder::Context::Loader
-  module LoadFiles
-    # Load custom helper methods from project
-    def load_files(dir)
-      paths = Dir.glob("#{dir}/**/*.rb")
-      paths.sort_by! { |p| p.size } # so namespaces are loaded first
-      paths.each do |path|
-        # helpers = blueprint or project extensions
-        filename = path.sub(%r{.*/helpers/},'').sub('.rb','')
-        module_name = filename.camelize
-
-        # Prepend a period so require works 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)
-
-        require path
-        self.class.send :include, module_name.constantize
-      end
-    end
-  end
-end

data/lib/lono/builder/context/loader.rb

@@ -1,35 +0,0 @@
-class Lono::Builder::Context
-  module Loader
-    include LoadFiles
-
-    # Variables in base.rb are overridden by their environment specific variables
-    # file.  Example, file LONO_ENV=dev:
-    #
-    #   config/vars/base.rb
-    #   config/vars/dev.rb - will override any variables in base.rb
-    #   config/vars/base.rb
-    #   config/vars/dev.rb - will override any variables in base.rb
-    #
-    def load_variables
-      layers = Lono::Layering::Layer.new(@blueprint, "vars").paths
-      layers.each do |layer|
-        evaluate_variables_file(layer)
-      end
-    end
-
-    # Load the variables defined in config/vars/* to make available in lono scope.
-    #
-    # NOTE: Was only able to make instance variables avaialble with instance_eval, wasnt able to make local variables
-    # available.
-    def evaluate_variables_file(path)
-      return unless File.exist?(path)
-      instance_eval(IO.read(path), path)
-    end
-
-    # Load blueprint helpers
-    # blueprint helpers override extension helpers
-    def load_blueprint_helpers
-      load_files("#{@blueprint.root}/#{Lono.config.paths.helpers}")
-    end
-  end
-end

data/lib/lono/builder/context/params.rb

@@ -1,7 +0,0 @@
-class Lono::Builder::Context
-  class Params < Lono::Builder::Context
-    # These helpers are only defined in the params context.
-    # Overriding output resource DSL method
-    alias_method :output, :stack_output
-  end
-end

data/lib/lono/builder/template/configset_injector.rb

@@ -1,52 +0,0 @@
-class Lono::Builder::Template
-  class ConfigsetInjector < Lono::CLI::Base
-    def initialize(options={})
-      super
-    end
-
-    def run
-      @cfn = load_template # initial
-      @cfn = inject # overwrite
-      write(@cfn)
-      @cfn
-    end
-
-    def inject
-      metadata_map.each do |logical_id, metadata_configset|
-        resource = @cfn["Resources"][logical_id]
-
-        unless resource
-          logger.info "WARN: Resources.#{logical_id} not found in the template. Are you sure you are specifying the correct resource id in your configsets configs?".color(:yellow)
-          next
-        end
-
-        resource["Metadata"] ||= metadata_configset["Metadata"]
-
-        # metdata = resource["Metadata"] ||= {}
-        # metdata["AWS::CloudFormation::Init"] ||= {}
-        # # The metadata_configset has been combined with the original AWS::CloudFormation::Init if it exists
-        # metdata["AWS::CloudFormation::Init"] = metadata_configset["AWS::CloudFormation::Init"]
-      end
-
-      @cfn
-    end
-
-    def metadata_map
-      combiner = Lono::Configset::Combiner.new(@cfn, @options)
-      combiner.metadata_map
-    end
-    memoize :metadata_map
-
-    def write(cfn)
-      IO.write(template_path, YAML.dump(cfn))
-    end
-
-    def load_template
-      YAML.load_file(template_path)
-    end
-
-    def template_path
-      "#{Lono.root}/output/#{@blueprint.name}/templates/#{@template}.yml"
-    end
-  end
-end

data/lib/lono/builder/template/dsl/evaluator/helpers/core_helper.rb

@@ -1,14 +0,0 @@
-module Lono::Builder::Template::Dsl::Evaluator::Helpers
-  module CoreHelper
-    extend Memoist
-
-    def stack_name
-      @options[:stack]
-    end
-
-    def setting
-      Lono::Setting.new
-    end
-    memoize :setting
-  end
-end

data/lib/lono/builder/template/dsl/evaluator/helpers/file_helper.rb

@@ -1,44 +0,0 @@
-module Lono::Builder::Template::Dsl::Evaluator::Helpers
-  module FileHelper
-    extend Memoist
-
-    def user_data(path)
-      render_file(Lono.config.paths.user_data, path)
-    end
-
-    def user_data_script
-      unless @user_data_script
-        return <<~EOL
-          # @user_data_script variable not set. IE: @user_data_script = "config/#{@blueprint.name}/user_data/boostrap.sh"
-          # Also, make sure that "config/#{@blueprint.name}/user_data/boostrap.sh" path you're using exists.
-        EOL
-      end
-
-      if File.exist?(@user_data_script)
-        render_path(@user_data_script)
-      else
-        message = "WARN: #{@user_data_script} not found"
-        logger.info message.color(:yellow)
-        "# #{message}"
-      end
-    end
-
-    def render_file(folder, path)
-      path = "#{folder}/#{path}"
-      if File.exist?(path)
-        render_path(path)
-      else
-        message = "WARNING: path #{path} not found"
-        logger.info message.color(:yellow)
-        logger.info "Called from:"
-        logger.info caller[2]
-        message
-      end
-    end
-    memoize :render_file
-
-    def render_path(path)
-      RenderMePretty.result(path, context: self)
-    end
-  end
-end

data/lib/lono/builder/template/dsl/evaluator/helpers/s3_helper.rb

@@ -1,16 +0,0 @@
-module Lono::Builder::Template::Dsl::Evaluator::Helpers
-  module S3Helper
-    def s3_bucket
-      Lono::S3::Bucket.name
-    end
-    alias_method :lono_bucket_name, :s3_bucket
-
-    def s3_key(name, options={})
-      default = {type: "file"}
-      options.reverse_merge!(default)
-      Lono::AppFile::Registry.register(name, @blueprint.name, options)
-      "file://app/files/#{options[:type]}/#{name}" # placeholder for post processing
-    end
-    alias_method :file_s3_key, :s3_key
-  end
-end

data/lib/lono/builder/template/dsl/evaluator/helpers.rb

@@ -1,16 +0,0 @@
-# Built-in helpers for the DSL form
-class Lono::Builder::Template::Dsl::Evaluator
-  module Helpers
-    extend Memoist
-
-    # Auto include all modules in helpers folder
-    helpers_dir = File.expand_path("helpers", __dir__)
-    Dir.glob("#{helpers_dir}/**/*").each do |path|
-      next unless File.file?(path)
-      klass = path.gsub(%r{.*/lib/},'').sub(".rb",'').camelize
-      include klass.constantize
-    end
-
-    include Lono::Builder::Template::Helpers
-  end
-end

data/lib/lono/builder/template/dsl/evaluator/squeezer.rb

@@ -1,24 +0,0 @@
-class Lono::Builder::Template::Dsl::Evaluator
-  class Squeezer
-    def initialize(data)
-      @data = data
-    end
-
-    def squeeze(new_data=nil)
-      data = new_data.nil? ? @data : new_data
-
-      case data
-      when Array
-        data.map! { |v| squeeze(v) }
-      when Hash
-        data.each_with_object({}) do |(k,v), squeezed|
-          # only remove nil and empty Array values within Hash structures
-          squeezed[k] = squeeze(v) unless v.nil? || v.is_a?(Array) && v.empty?
-          squeezed
-        end
-      else
-        data # do not transform
-      end
-    end
-  end
-end

data/lib/lono/builder/template/dsl/evaluator/syntax/extend_with.rb

@@ -1,9 +0,0 @@
-module Lono::Builder::Template::Dsl::Evaluator::Syntax
-  module ExtendWith
-    def extend_with(extension)
-      # Do nothing during the main DSL evaluation. The extend_with logical actual runs during during the
-      # pre_evalation stage before project helpers are loaded. This allows project helper to override extend helpers.
-      # Define the method here it does not error though.
-    end
-  end
-end

data/lib/lono/builder/template/dsl/evaluator/syntax.rb

@@ -1,11 +0,0 @@
-# Encapsulates syntax methods so they can be included in both the Evaluator and Context scope
-class Lono::Builder::Template::Dsl::Evaluator
-  module Syntax
-    include Fn
-    include Lono::Builder::Template::Evaluate
-    include Section::Methods
-    include ParameterGroup
-    include ExtendWith
-    include Helpers # built-in helpers
-  end
-end

data/lib/lono/builder/template/dsl/evaluator.rb

@@ -1,45 +0,0 @@
-class Lono::Builder::Template::Dsl
-  class Evaluator
-    include Lono::Extensions::Loader
-    include Lono::Utils::Context
-    include Lono::Builder::Context::Loader
-
-    include Syntax
-    extend Memoist
-
-    def initialize(options={})
-      @options = options
-      @blueprint = Lono::Blueprint.new(options)
-      @template_path = "#{@blueprint.root}/template.rb"
-      @parameters = [] # registry
-      @cfn = {}
-    end
-
-    def build
-      # TODO: load_all_extension_helpers # after Extensions::Preparer#run
-      load_variables unless seed? # both blueprint and project variables
-      load_blueprint_helpers
-      evaluate_template_paths(@template_path) # modifies @cfn
-      finalize
-      to_yaml
-      @cfn
-    end
-
-    def finalize
-      o = @options.merge(parameters: @parameters)
-      @cfn = Finalizer.new(@cfn, o).run
-    end
-
-    def to_yaml
-      # https://stackoverflow.com/questions/24508364/how-to-emit-yaml-in-ruby-expanding-aliases
-      # Trick to prevent YAML from emitting aliases
-      @cfn = YAML.load(@cfn.to_json)
-    end
-
-    # Dont want any existing files to prevent building the blueprint.
-    # This means that parameters cannot be based on vars. It's a trade-off.
-    def seed?
-      ARGV[0] == "seed"
-    end
-  end
-end

data/lib/lono/builder/template/dsl/finalizer.rb

@@ -1,12 +0,0 @@
-class Lono::Builder::Template::Dsl
-  class Finalizer
-    def initialize(cfn, options={})
-      @cfn, @options = cfn, options
-    end
-
-    def run
-      @cfn = ParameterGroups.new(@cfn, @options[:parameters]).run
-      @cfn
-    end
-  end
-end

data/lib/lono/builder/template/evaluate.rb

@@ -1,52 +0,0 @@
-class Lono::Builder::Template
-  module Evaluate
-    include Lono::Utils::Logging
-
-    # Example path: /full/path/to/project/app/blueprints/demo/template.rb
-    def evaluate_template_paths(path)
-      ext = File.extname(path)
-      folder = path.sub(ext, '')
-      expr = "#{folder}/**/*.rb"
-      evaluate_template_path(path) # process top-level template.rb first
-      Dir.glob(expr).each do |path|
-        evaluate_template_path(path)
-      end
-    end
-
-    def evaluate_template_path(path)
-      return unless File.exist?(path)
-      begin
-        instance_eval(File.read(path), path)
-      rescue Exception => e
-        template_evaluation_error(e)
-        logger.error "\nFull error:"
-        raise
-      end
-    end
-
-    # Prints out a user friendly task_definition error message
-    def template_evaluation_error(e)
-      lines = e.backtrace.reject { |l| l.include?("/lib/lono/") }
-      error_info = lines.first
-      path, line_no, _ = error_info.split(':')
-      line_no = line_no.to_i
-      logger.error "Error evaluating #{path}:".color(:red)
-      logger.error e.message
-      logger.error "Here's the line in #{path} with the error:\n\n"
-
-      contents = IO.read(path)
-      content_lines = contents.split("\n")
-      context = 5 # lines of context
-      top, bottom = [line_no-context-1, 0].max, line_no+context-1
-      spacing = content_lines.size.to_s.size
-      content_lines[top..bottom].each_with_index do |line_content, index|
-        line_number = top+index+1
-        if line_number == line_no
-          printf("%#{spacing}d %s\n".color(:red), line_number, line_content)
-        else
-          printf("%#{spacing}d %s\n", line_number, line_content)
-        end
-      end
-    end
-  end
-end

data/lib/lono/builder/template/post_processor.rb

@@ -1,67 +0,0 @@
-class Lono::Builder::Template
-  class PostProcessor < Lono::CLI::Base
-    def run
-      replacements.each do |placeholder, replacement|
-        update_template!(template)
-      end
-      write_template!
-    end
-
-    def write_template!
-      IO.write(template_path, YAML.dump(template)) # unless ENV['LONO_TEST'] # additional safeguard for testing
-    end
-
-    def replacements
-      map = {}
-
-      registry_items.each do |item|
-        if item.type == "lambda_layer"
-          placeholder = "file://app/files/lambda_layer/#{item.name}"
-        elsif item.directory? || item.file?
-          placeholder = "file://app/files/file/#{item.name}"
-        else
-          logger.info "WARN: PostProcessor replacements Cannot find file: #{item.output_path}"
-          next
-        end
-        map[placeholder] = item.s3_path
-      end
-
-      Lono::Configset::S3File::Registry.items.each do |item|
-        placeholder = "file://configset/#{item.configset}/#{item.name}"
-        # map[placeholder] = "https://s3.amazonaws.com/#{Lono::S3::Bucket.name}/#{item.s3_path}"
-        map[placeholder] = item.replacement_value
-      end
-
-      map
-    end
-
-    def update_template!(hash)
-      hash.each do |k, v|
-        if v.is_a?(String)
-          if v =~ %r{^file://}
-            v.replace(replacements[v]) # replace the placeholder
-          end
-        elsif v.is_a?(Hash)
-          update_template!(v) # recurse
-        elsif v.is_a?(Array)
-          v.each { |x| update_template!(x) if x.is_a?(Hash) }
-        end
-      end
-      hash
-    end
-
-    # Useful for specs
-    def registry_items
-      Lono::AppFile::Registry.items
-    end
-
-    def template
-      YAML.load_file(template_path)
-    end
-    memoize :template
-
-    def template_path
-      "#{Lono.root}/output/#{@blueprint.name}/templates/#{@template}.yml"
-    end
-  end
-end

data/lib/lono/cli/build.rb

@@ -1,101 +0,0 @@
-class Lono::CLI
-  class Build < Base
-    delegate :param_path, to: :param_builder
-
-    # Use class variable to cache this only runs once across all classes. base.rb, diff.rb, preview.rb
-    def all
-      ensure_s3_bucket_exist unless build_only?
-      pre_build
-      build_template # build with some placeholders for build_files IE: file://app/files/my.rb
-      post_build
-      upload unless build_only?
-
-      parameters = param_builder.build  # Writes the json file in CamelCase keys format
-      logger.info "" # newline
-      parameters
-    end
-    memoize :all
-
-    def parameters
-      all
-    end
-
-    def build_only?
-      ENV['LONO_BUILD_ONLY'] || @options[:build_only]
-    end
-
-    def pre_build
-      build_scripts
-    end
-
-    def post_build
-      return if @options[:source]
-      build_files # builds app/files to output/BLUEPRINT/files
-      post_process_template
-    end
-
-    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 build_template
-      template_builder.run
-      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.
-      # TODO Lono::Builder::Template::ConfigsetInjector.new(@options).run
-    end
-
-    def post_process_template
-      # support for file://app/files/lambda_layer replacement
-      # TODO: Lono::Builder::Template::PostProcessor.new(@options).run
-    end
-
-    def upload
-      upload_files
-      upload_scripts
-      upload_templates
-    end
-
-    def upload_templates
-      Lono::Builder::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 param_builder
-      o = {
-        regenerate: true,
-        allow_not_exists: true,
-      }.merge(@options)
-      o = HashWithIndifferentAccess.new(o)
-      Lono::Builder::Param.new(o)
-    end
-    memoize :param_builder
-
-    def template_builder
-      Lono::Builder::Template.new(@options) # write templates to disk
-    end
-    memoize :template_builder
-  end
-end