lono 6.1.11 → 7.0.0

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

@@ -1,8 +0,0 @@
-# Built-in helpers for the DSL form
-class Lono::Template::Dsl::Builder
-  module Helpers
-    extend Memoist
-    include CoreHelper
-    include ParamHelper
-  end
-end

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

@@ -1,107 +0,0 @@
-module Lono::Template::Dsl::Builder::Helpers
-  module CoreHelper
-    extend Memoist
-
-    def tags(list={})
-      casing = list.delete(:casing) || :camelize
-      if list.empty?
-        tag_list(@tags) if @tags # when list is empty, use @tags variable. If not set then return nil
-      else
-        tag_list(list, casing: casing)
-      end
-    end
-
-    def tag_list(list, casing: :camelize)
-      raise "tags list cannot be empty" if list == nil
-
-      if list.is_a?(Array)
-        hash = list.inject({}) do |h,i|
-          i.symbolize_keys!
-          h[i[:Key]] = i[:Value]
-          h
-        end
-        return tag_list(hash) # recursive call tag_list to normalized the argument with a Hash
-      end
-
-      list.map do |k,v|
-        k = k.to_s
-        k = case casing
-        when :camelize
-          k.camelize
-        when :underscore
-          k.underscore
-        when :dasherize
-          k.dasherize
-        else # leave alone
-          k
-        end
-
-        {Key: k, Value: v}
-      end
-    end
-
-    def dimensions(hash, casing: :camelize)
-      tag_list(hash, casing: casing).map { |h|
-        h[:Name] = h.delete(:Key) || h.delete(:key)
-        h
-      }
-    end
-
-    def stack_name
-      @options[:stack]
-    end
-
-    def content(path)
-      render_file(Lono.config.content_path, path)
-    end
-
-    def user_data(path)
-      render_file(Lono.config.user_data_path, path)
-    end
-
-    def user_data_script
-      return "# @user_data variable not set" unless @user_data
-
-      if File.exist?(@user_data)
-        IO.read(@user_data)
-      else
-        message = "WARN: #{@user_data} not found"
-        puts 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"
-        puts message.color(:yellow)
-        puts "Called from:"
-        puts caller[2]
-        message
-      end
-    end
-    memoize :render_file
-
-    def render_path(path)
-      RenderMePretty.result(path, context: self)
-    end
-
-    def s3_bucket
-      Lono::S3::Bucket.name
-    end
-
-    def file_s3_key(name, options={})
-      Lono::AppFile::Registry.register(name, @blueprint, options)
-      "file://app/files/#{name}" # placeholder for post processing
-    end
-    alias_method :s3_key, :file_s3_key
-
-    def setting
-      Lono::Setting.new
-    end
-    memoize :setting
-  end
-end

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

@@ -1,61 +0,0 @@
-# Note: These are experimental helpers. Their interface may change or removed entirely.
-module Lono::Template::Dsl::Builder::Helpers
-  module ParamHelper
-    # Decorate the parameter method to make smarter.
-    def parameter(*definition)
-      name, second, third = definition
-      create_condition = true
-      # medium form
-      if definition.size == 2 && second.is_a?(Hash) && second[:Conditional]
-        # Creates:
-        #
-        #    1. parameter
-        #    2. condition - used to make it optional
-        #
-        options = normalize_conditional_parameter_options(second)
-        super(name, options)
-      elsif definition.size == 3 && !second.is_a?(Hash) && third.is_a?(Hash)
-        options = normalize_conditional_parameter_options(third)
-        options[:Default] = second # probably a String, Integer, or Float
-        super(name, options)
-      else
-        super
-        create_condition = false
-      end
-
-      condition("Has#{name}", not!(equals(ref(name), ""))) if create_condition
-    end
-
-    # use long name to minimize method name collision
-    def normalize_conditional_parameter_options(options)
-      if options.is_a?(Hash)
-        options.delete(:Conditional)
-        options = if options.empty?
-          { Default: "" }
-        else
-          defaults = { Default: "" }
-          options.reverse_merge(defaults)
-        end
-      end
-
-      options
-    end
-
-    # Creates:
-    #
-    #    1. parameter
-    #    2. condition - used to make it optional
-    #
-    def conditional_parameter(name, options={})
-      puts "DEPRECATED: Will be removed. Instead use: parameter(name, Conditional: true)"
-      options = normalize_conditional_parameter_options(options)
-      parameter(name, options)
-      condition("Has#{name}", not!(equals(ref(name), "")))
-    end
-
-    def optional_ref(name)
-      puts "DEPRECATED: Will be removed. Instead use: ref(name, Conditional: true)"
-      if!("Has#{name}", ref(name), ref("AWS::NoValue"))
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# Implements:
-#
-#   template - uses @definition to build a CloudFormation template section
-#
-class Lono::Template::Dsl::Builder
-  class Parameter < Base
-    def template
-      camelize(add_required(standarize(@definition)))
-    end
-
-    # Type is the only required property: https://amzn.to/2x8W5aD
-    def standarize(definition)
-      first, second, _ = definition
-      if definition.size == 1 && first.is_a?(Hash) # long form
-        first # pass through
-      elsif definition.size == 2 && second.is_a?(Hash) # medium form
-        logical_id, properties = first, second
-        { logical_id => properties }
-      elsif (definition.size == 2 && valid_value?(second)) || # short form
-            definition.size == 1
-        logical_id = first
-        properties = valid_value?(second) ? { Default: second } : {}
-        { logical_id => properties }
-      else # I dont know what form
-        raise "Invalid form provided. definition #{definition.inspect}"
-      end
-    end
-
-    def add_required(attributes)
-      properties = attributes.values.first
-      properties["Type"] ||= 'String'
-      attributes
-    end
-
-    def valid_value?(o)
-      o.is_a?(Float) || o.is_a?(Integer) || o.is_a?(String) || o.is_a?(TrueClass) || o.is_a?(FalseClass)
-    end
-  end
-end

data/lib/lono/upgrade/upgrade4.rb

@@ -1,175 +0,0 @@
-require 'fileutils'
-require 'yaml'
-
-class Lono::Upgrade
-  class Upgrade4
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      checks
-      puts "Upgrading structure of your current project to the new lono version 4 project structure"
-
-      upgrade_settings("config/settings.yml")
-      upgrade_settings("#{ENV['HOME']}/.lono/settings.yml")
-      add_mandantory_settings
-
-      FileUtils.mkdir_p("app")
-      mv("helpers", "app/helpers")
-      mv("params", "config/params")
-      mv("config/templates", "app/definitions")
-      mv("templates", "app/templates")
-      mv("app/templates/partial", "app/partials")
-      mv("app/partials/user_data", "app/user_data")
-      update_variables
-      update_stacks
-      update_params
-
-      puts "Upgrade to lono version 4 complete!"
-    end
-
-    def update_stacks
-      update_structure("app/definitions")
-    end
-
-    def update_variables
-      update_structure("config/variables")
-    end
-
-    # Takes variable files in the subfolder like config/variables/production/*
-    # and combines the into a single file like config/variables/production.rb.
-    #
-    #   config/variables/base/* -> config/variables/base.rb
-    #   config/variables/development/* -> config/variables/development.rb
-    #   config/variables/production/* -> config/variables/production.rb
-    #   app/definitions/base/* -> app/definitions/base.rb
-    #   app/definitions/development/* -> app/definitions/development.rb
-    #   app/definitions/production/* -> app/definitions/production.rb
-    def update_structure(component_path)
-      puts "Updating structure of #{component_path}"
-      Dir.glob("#{component_path}/*").each do |path|
-        next unless File.directory?(path)
-        folder = File.basename(path)
-        update_structure_for(component_path, folder)
-      end
-
-      # remove the old folders
-      Dir.glob("#{component_path}/*").each do |path|
-        next unless File.directory?(path)
-        FileUtils.rm_rf(path)
-      end
-    end
-
-    # combines the files in the lono_env subfolder into one file
-    def update_structure_for(component_path, lono_env)
-      code = ""
-      Dir.glob("#{component_path}/#{lono_env}/*.rb").each do |path|
-        code << IO.read(path)
-        code << "\n"
-      end
-      IO.write("#{component_path}/#{env_map(lono_env)}.rb", code)
-    end
-
-    def update_params
-      Dir.glob("config/params/*").each do |path|
-        next unless File.directory?(path)
-        lono_env = File.basename(path)
-        mapped_env = env_map(lono_env)
-        if mapped_env != lono_env
-          mv("config/params/#{lono_env}", "config/params/#{mapped_env}")
-        end
-      end
-    end
-
-    # make to the longer full environment names
-    def env_map(lono_env)
-      map = {
-        "prod" => "production",
-        "stag" => "staging",
-        "dev" => "development",
-      }
-      map[lono_env] || lono_env
-    end
-
-    def checks
-      if File.exist?(Lono.config.definitions_path)
-        puts "It looks like you already have a #{Lono.config.definitions_path} folder in your project. This is the new project structure so exiting without updating anything."
-        exit
-      end
-
-      old_templates_path = "#{Lono.root}/config/templates"
-      if !File.exist?(old_templates_path)
-        puts "Could not find a #{old_templates_path} folder in your project. Maybe you want to run lono new to initialize a new lono project instead?"
-        exit
-      end
-    end
-
-    def upgrade_settings(path)
-      return unless File.exist?(path)
-
-      data = YAML.load_file(path)
-      return if data.key?("base") # already in new format
-
-      new_structure = {}
-
-      (data["aws_profile_lono_env_map"] || {}).each do |aws_profile, lono_env|
-        new_structure[env_map(lono_env)] ||= {}
-        new_structure[env_map(lono_env)]["aws_profiles"] ||= []
-        new_structure[env_map(lono_env)]["aws_profiles"] << aws_profile
-      end
-      data.delete("aws_profile_lono_env_map")
-
-      data = update_s3_setting(data)
-
-      new_structure["base"] = data
-      text = YAML.dump(new_structure)
-      IO.write(path, text)
-      puts "Upgraded settings: #{path}"
-      if path.include?(ENV['HOME'])
-        puts "NOTE: Your ~/.lono/settings.yml file was also upgraded to the new format. If you are using lono in other projects those will have to be upgraded also."
-      end
-    end
-
-    # accounts for most cases
-    def update_s3_setting(data)
-      return data unless data["s3"] && data["s3"]["path"]
-
-      options = data["s3"]["path"]
-      if options.is_a?(String)
-        data.delete("s3")
-        data["s3_folder"] = options
-        return data # return early if String
-      end
-
-      # Reach here: dealing with a Hash
-      if options.size == 1 and options["default"]
-        data["s3_folder"] = options["default"]
-      end
-
-      if options.size > 1
-        data["s3_folder"] = {}
-        options.each do |key, value|
-          data["s3_folder"][key] = value
-        end
-      end
-
-      data.delete("s3")
-      data
-    end
-
-    # If config/settings.yml does not exist, use the default one.
-    def add_mandantory_settings
-      return if File.exists?("config/settings.yml")
-
-      default_settings = File.expand_path("default/settings.yml", File.dirname(__FILE__))
-      FileUtils.cp(default_settings, "config/settings.yml")
-    end
-
-    def mv(src, dest)
-      return unless File.exist?(src)
-      puts "mv #{src} #{dest}"
-      FileUtils.mv(src, dest)
-    end
-  end
-end

data/lib/lono/upgrade/upgrade42.rb

@@ -1,36 +0,0 @@
-require 'fileutils'
-require 'yaml'
-
-class Lono::Upgrade
-  class Upgrade42 < Lono::Sequence
-    def upsert_gitignore
-      text =<<-EOL
-.lono/current
-EOL
-      if File.exist?(".gitignore")
-        append_to_file ".gitignore", text
-      else
-        create_file ".gitignore", text
-      end
-    end
-
-    def update_settings_yaml
-      path = "config/settings.yml"
-      puts "Updating #{path}."
-      data = YAML.load_file(path)
-
-      if data["base"].has_key?("randomize_stack_name")
-        randomize = data["base"]["randomize_stack_name"]
-        if randomize
-          data["base"]["stack_name_suffix"] = "random"
-        end
-
-        data["base"].delete("randomize_stack_name")
-        puts "Updated randomize_stack_name with stack_name_suffix."
-      end
-
-      text = YAML.dump(data)
-      IO.write(path, text)
-    end
-  end
-end

data/lib/lono/upgrade/upgrade5.rb

@@ -1,55 +0,0 @@
-require 'fileutils'
-require 'yaml'
-
-class Lono::Upgrade
-  class Upgrade5 < Lono::Sequence
-    def sanity_check
-      if File.exist?("blueprints")
-        puts "The blueprints folder already exist. The project already seems to have the lono v5 structure."
-        exit
-      end
-
-      unless File.exist?("config/settings.yml")
-        puts "ERROR: The config/settings.yml file does not exist. Are you sure you're within a lono project?".color(:red)
-        exit 1
-      end
-    end
-
-    def create_blueprints_folder
-      puts "Creating: blueprints folder"
-      FileUtils.mkdir_p("blueprints/main")
-    end
-
-    def move_to_main_blueprint
-      puts "Moving files to blueprints folder"
-      # Dir.entries includes hidden files
-      Dir.entries('.').each do |p|
-        next if %w[blueprints .git .. .].include?(p)
-        FileUtils.mv(p, "blueprints/main/#{p}")
-      end
-    end
-
-    def move_configs
-      puts "Setting up the new configs structure"
-      FileUtils.mkdir_p("configs/main")
-      FileUtils.mv("blueprints/main/config/params", "configs/main/params")
-      FileUtils.mv("blueprints/main/config/variables", "configs/main/variables")
-      FileUtils.mv("blueprints/main/config/settings.yml", "configs/settings.yml")
-
-      FileUtils.rmdir("blueprints/main/config") if Dir.empty?("blueprints/main/config")
-    end
-
-    def starter_files
-      puts "Creating remaining starter lono project files"
-      files = %w[
-        .gitignore
-        Gemfile
-        Guardfile
-        README.md
-      ]
-      files.each { |f | template(f) }
-
-      template("../upgrade5/blueprints/main/.meta/config.yml", "blueprints/main/.meta/config.yml")
-    end
-  end
-end