lono 8.0.0.pre.rc2 → 8.0.0.pre.rc5

data/lib/lono/cli/build.rb

@@ -1,91 +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
-      template_builder.run # 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 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

data/lib/lono/cli/code.rb

@@ -1,22 +0,0 @@
-class Lono::CLI
-  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 template 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/cli/help/blueprint/new.md

@@ -1,56 +0,0 @@
-## Examples
-
-    lono blueprint new demo # skeleton blueprint with barebones structure
-
-## Example Output
-
-    $ lono blueprint new demo
-    => Creating new blueprint called demo.
-          create  blueprints/demo
-          create  blueprints/demo/demo.gemspec
-          create  blueprints/demo/.gitignore
-          create  blueprints/demo/CHANGELOG.md
-          create  blueprints/demo/Gemfile
-          create  blueprints/demo/README.md
-          create  blueprints/demo/Rakefile
-          create  blueprints/demo/seed/configs.rb
-           exist  blueprints/demo
-          create  blueprints/demo/app/templates/demo.rb
-          create  blueprints/demo/app/user_data/bootstrap.sh
-           exist  blueprints/demo/app/templates
-           exist
-          create  config/demo/params/development.txt
-          create  config/demo/params/production.txt
-          create  config/demo/variables/development.rb
-          create  config/demo/variables/production.rb
-    => Installing dependencies with: bundle install
-    Fetching gem metadata from https://rubygems.org/..........
-    ...
-    Bundle complete! 4 Gemfile dependencies, 9 gems now installed.
-    Use `bundle info [gemname]` to see where a bundled gem is installed.
-    ================================================================
-    Congrats  You have successfully created a lono blueprint.
-
-    Cd into your blueprint and check things out.
-
-        cd demo
-
-    More info: https://lono.cloud/docs/core/blueprints
-
-    Here is the structure of your blueprint:
-
-    .
-    ├── app
-    │   ├── templates
-    │   │   └── demo.rb
-    │   └── user_data
-    │       └── bootstrap.sh
-    ├── CHANGELOG.md
-    ├── demo.gemspec
-    ├── Gemfile
-    ├── Gemfile.lock
-    ├── Rakefile
-    ├── README.md
-    └── seed
-        └── configs.rb
-    $

data/lib/lono/cli/new/extension.rb

@@ -1,57 +0,0 @@
-class Lono::CLI::New
-  class Extension < Sequence
-    argument :extension_name
-
-    def self.source_root
-      templates = File.expand_path("../../templates", File.dirname(__FILE__))
-      "#{templates}/extension"
-    end
-
-    def self.cli_options
-      [
-        [: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/extensions"
-    end
-
-    def create_project
-      puts "=> Creating new extension called #{extension_name}."
-      directory ".", "#{@cwd}/#{extension_name}", options
-    end
-
-    def create_license
-      return unless ENV['LONO_LICENSE_FILE']
-      copy_file ENV['LONO_LICENSE_FILE'], "#{@cwd}/#{extension_name}/LICENSE.txt"
-    end
-
-    # After this commands are executed with the newly created project
-    def set_destination_root
-      destination_root = "#{@cwd}/#{extension_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 extension.
-
-        Cd into your extension and check things out.
-
-            cd #{extension_name}
-
-        More info: https://lono.cloud/docs/extensions
-
-      EOL
-    end
-  end
-end

data/lib/lono/configset/builder.rb

@@ -1,59 +0,0 @@
-module Lono::Configset
-  class Builder
-    include Lono::Utils::Logging
-
-    def initialize(options)
-      @options = options
-      @configset = options[:configset]
-      @type = options[:type] || "project"
-    end
-
-    def run
-      check_configset_exist!
-      structure = build
-      logger.info YAML.dump(structure)
-    end
-
-    def check_configset_exist!
-      exist = !!Lono::Finder::Configset.find(@configset)
-      unless exist
-        logger.info "configset #{@configset.color(:green)} not found."
-        exit 1
-      end
-    end
-
-    def build
-      # Examples:
-      #   Erb.new(options).build
-      #   Dsl.new(options).build
-      builder_class = "Lono::Configset::Strategy::#{strategy.camelize}"
-      builder_class = Object.const_get(builder_class)
-      full = builder_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/combiner.rb

@@ -1,164 +0,0 @@
-require "yaml"
-
-module Lono::Configset
-  class Combiner
-    include Lono::Utils::Logging
-
-    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 build for all templates
-      Register::Project.clear! # in case of lono build 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")
-
-      logger.info "ERROR: The #{name} configset does not appear to have a AWS::CloudFormation::Init key".color(:red)
-      logger.info "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
-          logger.info message.color(:red)
-          exit 1
-        end
-      end
-    end
-  end
-end

data/lib/lono/configset/evaluate_file.rb

@@ -1,8 +0,0 @@
-module 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/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 @@
-module 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/s3_file/build.rb

@@ -1,34 +0,0 @@
-module Lono::Configset::S3File
-  class Build < Lono::CLI::Base
-    include Lono::Utils::Item::Zip
-    include Lono::Utils::Logging
-    include Lono::Utils::Rsync
-
-    def run
-      Lono::Configset::S3File::Registry.items.each do |item|
-        build(item)
-      end
-    end
-
-    def build(item)
-      copy_to_output(item)
-      compress_output
-    end
-
-    def copy_to_output(item)
-      src = "#{item.root}/lib/files/#{item.name}"
-      dest = "#{Lono.root}/output/#{@blueprint.name}/configsets/#{item.configset}/files/#{item.name}"
-      rsync(src, dest)
-    end
-
-    def compress_output
-      Registry.items.each do |item|
-        if 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
-  end
-end

data/lib/lono/configset/s3_file/item.rb

@@ -1,38 +0,0 @@
-module Lono::Configset::S3File
-  # Holds metadata about the item in the regsitry.
-  class Item
-    include Lono::Utils::Item::FileMethods
-
-    attr_reader :name, :configset, :root
-    def initialize(name, options={})
-      @name, @options = name, options
-      @blueprint = options[:blueprint]
-      @configset = options[:configset]
-      @root = options[:root]
-      @type = options[:type] || 'file'
-    end
-
-    def src_path
-      "#{@root}/lib/files"
-    end
-
-    def output_path
-      "#{Lono.root}/output/#{@blueprint.name}/configsets/#{@configset}/files/#{@name}"
-    end
-
-    def replacement_value
-      aws_data = AwsData.new
-      #
-      #   "https://s3.amazonaws.com/#{Lono::S3::Bucket.name}/#{s3_path}"
-      #   "https://lono-bucket-12di8xz5sy72z.s3-us-west-2.amazonaws.com/stuff/s3-antivirus.tgz"
-      #
-      # us-east-1 is special case:
-      #
-      #   "https://lono-bucket-12di8xz5sy72z.s3.amazonaws.com/stuff/s3-antivirus.tgz"
-      #
-      region = ""
-      region = "-#{aws_data.region}" unless aws_data.region == "us-east-1"
-      "https://#{Lono::S3::Bucket.name}.s3#{region}.amazonaws.com/#{s3_path}"
-    end
-  end
-end

data/lib/lono/configset/s3_file/registry.rb

@@ -1,12 +0,0 @@
-module Lono::Configset::S3File
-  class Registry
-    cattr_reader :items
-    @@items = []
-
-    class << self
-      def register(name, options)
-        @@items << Item.new(name, options) unless @@items.detect { |i| i.name == name }
-      end
-    end
-  end
-end

data/lib/lono/configset/s3_file/upload.rb

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

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

@@ -1,83 +0,0 @@
-# Subclasses must implement:
-#
-#   find_evaluation_path - use to set @evaluation_path
-#   load
-#
-# Notable instance variables:
-#
-#   @evaluation_path - IE: lib/configset.rb or lib/configset.yml
-#   @root - IE: /path/to/root/of/configset
-#
-module Lono::Configset::Strategy
-  class Base
-    extend Memoist
-    include Lono::Configset::EvaluateFile
-
-    # All Lono DSL Helpers and Fn - so configsets have access to instrinic functions like ref
-    # Not including the Lono::Builder::Template::Strategy::Dsl::Evaluator::Syntax since dont need those methods
-    #
-    # Interesting note: must include these modules here so load_project_predefined_variables works.
-    # Since load_project_predefined_variables calls evaluate_file / instance eval which seems to only be
-    # able to access methods from the direct class, not inherited classes like Dsl.
-    #
-    # This allows methods like ref and sub to work in variables files.
-    #
-    include Lono::Builder::Template::Strategy::Dsl::Evaluator::Helpers
-    include Lono::Builder::Template::Strategy::Dsl::Evaluator::Fn
-
-    def initialize(options={})
-      @options = options
-      @configset = options[:configset]
-      @root = options[:root]
-      @resource = options[:resource] || "FakeResource"
-      @blueprin = options[:blueprint]
-    end
-
-    def build
-      @evaluation_path = find_evaluation_path # implemented by subclass
-      copy_instance_variables
-      load_configset_helpers
-      init = load # implemented by subclass
-      finish_full_structure(init)
-    end
-    memoize :build
-
-    def finish_full_structure(init)
-      full = {"Metadata" => {}}
-      full["Metadata"]["AWS::CloudFormation::Init"] = init["AWS::CloudFormation::Init"]
-      full["Metadata"]["AWS::CloudFormation::Authentication"] = authentication if authentication # only on dsl
-      full.deep_stringify_keys!
-    end
-
-    def copy_instance_variables
-      load_blueprint_predefined_variables
-      load_project_predefined_variables
-    end
-
-    def load_blueprint_predefined_variables
-      evaluate_file("#{@root}/lib/variables.rb")
-    end
-
-    def load_project_predefined_variables
-      paths = [
-        "#{Lono.root}/config/#{@blueprint.name}/configsets/variables.rb", # global
-        "#{Lono.root}/config/#{@blueprint.name}/configsets/variables/#{@configset}.rb", # configset specific
-      ]
-      paths.each do |path|
-        evaluate_file(path)
-      end
-    end
-
-    def load_configset_helpers
-      paths = Dir.glob("#{@root}/lib/helpers/**/*.rb")
-      paths.sort_by! { |p| p.size } # load possible namespaces first
-      paths.each do |path|
-        filename = path.sub(%r{.*/lib/helpers/},'').sub('.rb','')
-        module_name = filename.camelize
-
-        require path
-        self.class.send :include, module_name.constantize
-      end
-    end
-  end
-end