lono 6.0.1 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffc3d416a358f6676a11c46731c18dff4c2eb1220ec68dce304e4e570e19dca0
-  data.tar.gz: 03a5e764bb8f66582d909fef1f5c32274e1a1105d4c3627a0834bb1316f0b2f4
+  metadata.gz: 00b82bf7f6fe03723b4819ebe0852b507d141654905d9fab6be7755d5bda22d2
+  data.tar.gz: 20552ff66d7d729e114c1539f1f5e8df2956b746c444a3bc3ce699021b46ce28
 SHA512:
-  metadata.gz: 2cf2ee72d6d80f0be84171139b45855d167012e28c54a262c5f7954941d577958d7cb600aecffc9fc446c8b5b4f1f873750ff8511eafc84197b875e9758952af
-  data.tar.gz: fdb40125279f0e67eea4e5abda5e445febfd3ce26ae427070f850955b794206c83f58e311778a6febb60ebba20ff6472afd3fae77609f7339402a15d4fb96bd9
+  metadata.gz: e408ef09601c5472db878a329968fa4da5bca6f14980cc7adf56fee36895ae5a7312ebe4ebf8bbb969b12dcdeac8ef01b9bf9f542149b4c230ed6e271678a804
+  data.tar.gz: 437bb6232f2ab9b605c7653cf3da3fba70ab93d8a4e6bc201598a2917eac4a365612a2fb66a1359a71fbc38c3fc30a32b4f25b4ebc9f65793f8ad1d4ffd2297c

data/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 This project *tries* to adhere to [Semantic Versioning](http://semver.org/), even before v1.0.
 
+## [6.1.0]
+- #17 big improvements to how the configs lookup logic happens: simpler and easier to understand
+- variables lookup strategy is same as params
+- `--config` option sets both `--param` and `--variable`
+- also account for stack name as part of conventional lookup - big win to help provide consistent and organized configs files.
+- #18 parameter(name, Conditional: true)
+- ref(name, Conditional: true)
+- deprecated `conditional_parameter`, `optional_ref`
+- deprecated `tags` helper, use `tag_list` instead
+- cleanup: organize CoreHelper
+
 ## [6.0.1]
 - #14 restructure dsl methods are available in variables definition
 - #15 fix Type camelize bug

data/README.md

@@ -54,7 +54,7 @@ resource("Instance", "AWS::EC2::Instance",
   UserData: base64(user_data("bootstrap.sh"))
 )
 resource("SecurityGroup", "AWS::EC2::SecurityGroup",
-  group_description: "demo security group",
+  GroupDescription: "demo security group",
 )
 
 output("Instance")

data/lib/lono/cfn.rb

@@ -5,15 +5,16 @@ module Lono
 
     base_options = Proc.new do
       # common to create, update and deploy
+      option :config, aliases: "c", desc: "override convention and specify both the param and variable file to use"
       option :blueprint, desc: "override convention and specify the template file to use"
       option :capabilities, type: :array, desc: "iam capabilities. Ex: CAPABILITY_IAM, CAPABILITY_NAMED_IAM"
       option :iam, type: :boolean, desc: "Shortcut for common IAM capabilities: CAPABILITY_IAM, CAPABILITY_NAMED_IAM"
       option :lono, type: :boolean, desc: "invoke lono to generate CloudFormation templates", default: true
-      option :param, desc: "override convention and specify the param file to use"
+      option :param, aliases: "p", desc: "override convention and specify the param file to use"
       option :rollback, type: :boolean, desc: "rollback", default: true
       option :tags, type: :hash, desc: "Tags for the stack. IE: name:api-web owner:bob"
       option :template, desc: "override convention and specify the template file to use"
-      option :variable, desc: "override convention and specify the variable file to use"
+      option :variable, aliases: "v", desc: "override convention and specify the variable file to use"
     end
     wait_option = Proc.new do
       option :wait, type: :boolean, desc: "Wait for stack operation to complete.", default: true

data/lib/lono/cfn/base.rb

@@ -19,9 +19,6 @@ class Lono::Cfn
       @blueprint = options[:blueprint] || remove_suffix(@stack_name)
       @template, @param = template_param_convention(options)
 
-      # Add template and param to options because used later for Lono::Param::Generator
-      @options[:blueprint], @options[:template], @options[:param] = @blueprint, @template, @param
-
       set_blueprint_root(@blueprint)
 
       @template_path = "#{Lono.config.output_path}/#{@blueprint}/templates/#{@template}.yml"
@@ -149,27 +146,10 @@ class Lono::Cfn
       param_generator.generate  # Writes the json file in CamelCase keys format
       @@generate_all = param_generator.params    # Returns Array in underscore keys format
 
-      # At this point we have the info about params path used so we can display it.
-      # We display other useful info here too so it's together logically.
-      unless @options[:mute_using]
-        puts "Using template: #{pretty_path(@template_path)}"
-        param_generator.puts_param_message(:base)
-        param_generator.puts_param_message(:env)
-      end
-
       check_for_errors
       @@generate_all
     end
 
-    def param_generator
-      generator_options = {
-        regenerate: false,
-        allow_not_exists: true
-      }.merge(@options)
-      Lono::Param::Generator.new(@blueprint, generator_options)
-    end
-    memoize :param_generator
-
     def ensure_s3_bucket_exist
       bucket = Lono::S3::Bucket.new
       return if bucket.exist?
@@ -185,8 +165,18 @@ class Lono::Cfn
     end
 
     def generate_templates
-      Lono::Template::Generator.new(@blueprint, @options).run
+      Lono::Template::Generator.new(@blueprint, @options.merge(stack: @stack_name)).run
+    end
+
+    def param_generator
+      generator_options = {
+        regenerate: true,
+        allow_not_exists: true,
+      }.merge(@options)
+      generator_options[:stack] ||= @stack_name || @blueprint
+      Lono::Param::Generator.new(@blueprint, generator_options)
     end
+    memoize :param_generator
 
     def post_process_templates
       Lono::Template::PostProcessor.new(@blueprint, @options).run

data/lib/lono/cli.rb

@@ -18,6 +18,7 @@ module Lono
     long_desc Help.text(:generate)
     option :clean, type: :boolean, default: false, desc: "remove all output files before generating"
     option :quiet, type: :boolean, desc: "silence the output"
+    option :stack, desc: "stack name. defaults to blueprint name."
     def generate(blueprint=nil)
       Blueprint::Find.one_or_all(blueprint).each do |b|
         Script::Build.new(b, options).run

data/lib/lono/config_location.rb

@@ -0,0 +1,93 @@
+module Lono
+  class ConfigLocation
+    extend Memoist
+    include Lono::Conventions
+
+    def initialize(config, options={}, env=Lono.env, root=Lono.root)
+      # config can be params or variables
+      @config, @options, @root, @env = config, options, root, env
+
+      @stack = options[:stack]
+      @blueprint = options[:blueprint] || @stack
+      @template, @param = template_param_convention(options)
+
+      @requested = determine_requested
+    end
+
+    def lookup
+      levels = []
+      levels += direct_levels
+      # Standard lookup paths
+      template_level = "#{@root}/configs/#{@blueprint}/#{@config}/#{@env}/#{@template}/#{@requested}"
+      env_level = "#{@root}/configs/#{@blueprint}/#{@config}/#{@env}/#{@requested}"
+      config_level = "#{@root}/configs/#{@blueprint}/#{@config}/#{@requested}"
+      generic_env = "#{@root}/configs/#{@blueprint}/#{@config}/#{@env}"
+      levels += [template_level, env_level, config_level, generic_env]
+
+      print_levels(levels)
+
+      found = levels.find do |level|
+        requested_file(level)
+      end
+      if found
+        file = requested_file(found)
+        using_message(file, @env)
+        file
+      end
+    end
+
+    def direct_levels
+      [
+        @requested, # IE: absolute full path
+        "#{@root}/#{@requested}", # IE : relative path within lono project
+      ]
+    end
+
+    def lookup_base
+      base = "#{@root}/configs/#{@blueprint}/#{@config}/base"
+      file = requested_file(base)
+      if file
+        using_message(file, "base")
+        file
+      end
+    end
+
+    def print_levels(levels)
+      return unless ENV["LONO_DEBUG_CONFIG"]
+      puts "levels:"
+      pp levels
+    end
+
+    @@using_message_displayed = {}
+    def using_message(file, type)
+      return if @@using_message_displayed[file]
+
+      pretty_file = file.sub("#{Lono.root}/", "")
+      puts "Using #{@config} for #{type}: #{pretty_file}"
+
+      @@using_message_displayed[file] = true
+    end
+
+    # Some switching logic between variable and param below
+
+    def determine_requested
+      # param is usually set from the convention. when set from convention stack name takes higher precedence
+      config_key = @config.singularize.to_sym # param or variable
+      from_convention = !@options[config_key] && !@options[:config]
+      if from_convention
+        @options[:stack]
+      else
+        @options[config_key] || @options[:config] || @options[:stack]
+      end
+    end
+
+    def requested_file(path)
+      # List of paths to consider from initial path provided
+      paths = @config == "params" ?
+                [path, "#{path}.txt", "#{path}.sh"] :
+                [path, "#{path}.rb"]
+      paths.find { |p| File.file?(p) }
+    end
+    memoize :requested_file
+  end
+end

data/lib/lono/param.rb

@@ -6,6 +6,7 @@ module Lono
 
     desc "generate", "Generate parameter output files to `output/params`."
     long_desc Lono::Help.text("param/generate")
+    option :stack, desc: "stack name. defaults to blueprint name."
     def generate(blueprint=nil)
       Blueprint::Find.one_or_all(blueprint).each do |b|
         Generator.new(b, options).generate

data/lib/lono/param/generator.rb

@@ -5,107 +5,25 @@ class Lono::Param
 
     attr_reader :env_path, :base_path # set when generate is called
     def initialize(blueprint, options={})
-      @blueprint, @options = blueprint, options
+      # dup because we're modifying the Thor frozen hash
+      # HashWithIndifferentAccess.new again because .dup changes it to a normal Hash
+      @blueprint, @options = blueprint, ActiveSupport::HashWithIndifferentAccess.new(options.dup)
+      @options[:stack] ||= @blueprint
       set_blueprint_root(@blueprint)
       @template, @param = template_param_convention(options)
     end
 
-    def puts_param_message(type)
-      path = send("#{type}_path")
-      return unless path
-      if param_file?(path)
-        pretty_path = path.sub("#{Lono.root}/",'')
-        puts "Using param for #{type}: #{pretty_path}".color(:yellow)
-      end
-    end
-
-    # Lookup precedence:
-    #
-    #   configs/BLUEPRINT/params/development/TEMPLATE/PARAM.txt
-    #   configs/BLUEPRINT/params/development/PARAM.txt
-    #   configs/BLUEPRINT/params/development.txt
-    #
-    def lookup_param_file(root: Lono.root, env: Lono.env)
-      # The docs conver direct_absolute_form and direct_relative_form as the "Direct Form"
-      unless env == "base"
-        direct_absolute_form = @param # user provided the absolute full path
-        direct_relative_form = "#{root}/#{@param}" # user provided the full path within the lono project
-        direct_env_form = "#{root}/configs/#{@blueprint}/params/#{env}/#{@param}" # direct lookup is simple
-        direct_simple_form = "#{root}/configs/#{@blueprint}/params/#{@param}" # direct lookup is simple
-      end
-      long_form = "#{root}/configs/#{@blueprint}/params/#{env}/#{@template}/#{@param}"
-      medium_form = "#{root}/configs/#{@blueprint}/params/#{env}/#{@param}"
-      short_form = "#{root}/configs/#{@blueprint}/params/#{env}"
-
-      if ENV['LONO_DEBUG_PARAM']
-        puts "Lono.blueprint_root #{Lono.blueprint_root}"
-        puts "direct_absolute_form #{direct_absolute_form}"
-        puts "direct_relative_form #{direct_relative_form}"
-        puts "direct_env_form #{direct_env_form}"
-        puts "direct_simple_form #{direct_simple_form}"
-        puts "long_form #{long_form}"
-        puts "medium_form #{medium_form}"
-        puts "short_form #{short_form}"
-      end
-
-      unless env == "base"
-        return param_file(direct_absolute_form) if param_file?(direct_absolute_form)
-        return param_file(direct_relative_form) if param_file?(direct_relative_form)
-        return param_file(direct_env_form) if param_file?(direct_env_form) # consider this first its simple and direct but is scope to env so it's more specific
-        return param_file(direct_simple_form) if param_file?(direct_simple_form) # consider this first its simple and direct but is scope to env so it's more specific
-      end
-      return param_file(long_form) if param_file?(long_form) # consider this first because its more explicit
-
-      # All 3 are the same
-      # Also, blueprint and template the same and explicitly specified param
-      if @blueprint == @template
-        return param_file(medium_form) if param_file?(medium_form) # higher precedence between longer but short form should be encouraged
-        return param_file(short_form) if param_file?(short_form)
-        return # cannot find a param file
-      end
-
-      # Only template and param are the same
-      if @template == @param
-        return param_file(medium_form) if param_file?(medium_form) # only consider medium form
-        return # cannot find a param file
-      end
-    end
-
-    # Allows user to specify the .txt extension or not to.
-    # Also allows user to use other extensions like .sh if they are explicit about it.
-    def param_file?(path)
-      File.file?(path) || File.file?("#{path}.txt") || File.file?("#{path}.sh")
-    end
-
-    def param_file(path)
-      return path if File.file?(path)
-      return "#{path}.txt" if File.file?("#{path}.txt")
-      return "#{path}.sh" if File.file?("#{path}.sh")
-    end
-
-    def lookup_paths
-      @base_path = lookup_param_file(env: "base")
-      @env_path = lookup_param_file(env: Lono.env)
-
-      if ENV['LONO_DEBUG_PARAM']
-        puts "  @base_path #{@base_path.inspect}"
-        puts "  @env_path #{@env_path.inspect}"
-      end
-
-      [@base_path, @env_path]
-    end
-
     def generate
       puts "Generating parameter files for blueprint #{@blueprint.color(:green)}:"
 
-      @base_path, @env_path = lookup_paths
+      @base_path, @env_path = config_locations
 
       return unless @base_path || @env_path
 
       # useful option for lono cfn, since some templates dont require params
-      return if @options[:allow_not_exists] && !source_exist?
+      return if @options[:allow_not_exists] && !params_exist?
 
-      if source_exist?
+      if params_exist?
         contents = process_erb
         data = convert_to_cfn_format(contents)
         json = JSON.pretty_generate(data)
@@ -121,21 +39,51 @@ class Lono::Param
       json
     end
 
+    def config_locations
+      @base_path = lookup_config_location("base")
+      @env_path = lookup_config_location(Lono.env)
+
+      if ENV['LONO_DEBUG_PARAM']
+        puts "LONO_DEBUG_PARAM enabled"
+        puts "  @base_path #{@base_path.inspect}"
+        puts "  @env_path #{@env_path.inspect}"
+      end
+
+      [@base_path, @env_path]
+    end
+
+    def lookup_config_location(env)
+      options = @options.clone
+      options[:blueprint] = @blueprint
+      options[:stack] ||= @blueprint
+      location = Lono::ConfigLocation.new("params", options, env)
+      env == "base" ? location.lookup_base : location.lookup
+    end
+
+    def puts_param_message(type)
+      path = send("#{type}_path")
+      return unless path
+      if param_file?(path)
+        pretty_path = path.sub("#{Lono.root}/",'')
+        puts "Using param for #{type}: #{pretty_path}".color(:yellow)
+      end
+    end
+
     # Checks both base and source path for existing of the param file.
     # Example:
     #   params/base/mystack.txt - base path
     #   params/production/mystack.txt - source path
-    def source_exist?
+    def params_exist?
       @base_path && File.exist?(@base_path) ||
       @env_path && File.exist?(@env_path)
     end
 
     # useful for when calling CloudFormation via the aws-sdk gem
     def params(casing = :underscore)
-      @base_path, @env_path = lookup_paths
+      @base_path, @env_path = config_locations
 
       # useful option for lono cfn
-      return {} if @options[:allow_not_exists] && !source_exist?
+      return {} if @options[:allow_not_exists] && !params_exist?
 
       contents = process_erb
       convert_to_cfn_format(contents, casing)
@@ -206,7 +154,7 @@ class Lono::Param
       # Now build up the aws json format for parameters
       params = []
       data.each do |key,value|
-        param = if value == "use_previous_value"
+        param = if value == "use_previous_value" || value == "UsePreviousValue"
                   {
                     "ParameterKey": key,
                     "UsePreviousValue": true

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

@@ -8,36 +8,12 @@ class Lono::Template::Context
     #   config/variables/development.rb - will override any variables in base.rb
     #
     def load_variables
-      load_variables_file(project_path("base"))
-
-      direct_absolute_form = @options[:variable] # user provided the absolute full path
-      direct_relative_form = "#{Lono.root}/configs/#{@blueprint}/variables/#{@options[:variable]}" # user provided the full path within the lono project
-      conventional_form = project_path(Lono.env)
-
-      if ENV['LONO_DEBUG_VARIABLE']
-        puts "direct_absolute_form: #{direct_absolute_form.inspect}"
-        puts "direct_relative_form: #{direct_relative_form.inspect}"
-        puts "conventional_form: #{conventional_form.inspect}"
-      end
-
-      load_variables_file(variable_file(direct_absolute_form)) if variable_file?(direct_absolute_form)
-      load_variables_file(variable_file(direct_relative_form)) if variable_file?(direct_relative_form)
-      load_variables_file(conventional_form) if variable_file?(conventional_form)
-    end
-
-    def variable_file?(path)
-      return if path.nil?
-      return path if File.file?(path) # direct lookup with .rb extension
-      return "#{path}.rb" if File.file?("#{path}.rb") # direct lookup without .rb extension
-    end
-
-    def variable_file(path)
-      return path if File.file?(path)
-      return "#{path}.rb" if File.file?("#{path}.rb")
-    end
-
-    def project_path(name)
-      "#{Lono.root}/configs/#{@blueprint}/variables/#{name}.rb"
+      options = @options.clone
+      options[:blueprint] = @blueprint
+      options[:stack] ||= @blueprint
+      location = Lono::ConfigLocation.new("variables", options, Lono.env)
+      evaluate_variables_file(location.lookup_base) if location.lookup_base
+      evaluate_variables_file(location.lookup) if location.lookup # config file
     end
 
     # Load the variables defined in config/variables/* to make available in the
@@ -56,15 +32,8 @@ class Lono::Template::Context
     #
     # NOTE: Only able to make instance variables avaialble with instance_eval,
     #   wasnt able to make local variables available.
-    def load_variables_file(path)
-      # if File.exist?(path)
-      #   puts "context.rb loading #{path}"
-      # else
-      #   puts "context.rb file doesnt exist #{path}"
-      # end
-
+    def evaluate_variables_file(path)
       return unless File.exist?(path)
-
       instance_eval(IO.read(path), path)
     end
 

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

@@ -67,9 +67,13 @@ class Lono::Template::Dsl::Builder
     end
 
     # special cases
-    def ref(name)
+    def ref(name, options={})
       name = name.to_s.camelize
-      { "Ref" => name }
+      if options[:Conditional] || options[:conditional]
+        if!("Has#{name}", ref(name), ref("AWS::NoValue"))
+      else
+        { "Ref" => name }
+      end
     end
 
     # Examples:
@@ -78,7 +82,7 @@ class Lono::Template::Dsl::Builder
     #   get_attr(["logical_id", "attribute"])
     def get_att(*item)
       item = item.flatten
-      options = item.last.is_a?(Hash) ? item.pop : {}
+      item.last.is_a?(Hash) ? item.pop : {}
 
       # list is an Array
       list = if item.size == 1

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

@@ -2,72 +2,7 @@
 class Lono::Template::Dsl::Builder
   module Helpers
     extend Memoist
+    include CoreHelper
     include ParamHelper
-
-    def tags(hash, casing: :camelize)
-      hash.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)
-      tags(hash, casing: casing).map { |h|
-        h[:Name] = h.delete(:Key) || h.delete(:key)
-        h
-      }
-    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 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/core_helper.rb

@@ -0,0 +1,76 @@
+module Lono::Template::Dsl::Builder::Helpers
+  module CoreHelper
+    extend Memoist
+
+    def tags(hash, casing: :camelize)
+      puts "DEPRECATED: tags helper will be removed. Use tag_list instead."
+      tag_list(hash, casing: casing)
+    end
+
+    def tag_list(hash, casing: :camelize)
+      hash.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)
+      tags(hash, casing: casing).map { |h|
+        h[:Name] = h.delete(:Key) || h.delete(:key)
+        h
+      }
+    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 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,15 +1,22 @@
 # Note: These are experimental helpers. Their interface may change or removed entirely.
 module Lono::Template::Dsl::Builder::Helpers
   module ParamHelper
-    # Creates:
-    #
-    #    1. parameter
-    #    2. condition - used to make it optional
-    #
-    def conditional_parameter(name, options={})
-      options = normalize_conditional_parameter_options(options)
-      parameter(name, options)
-      condition("Has#{name}", not!(equals(ref(name), "")))
+    # Decorate the parameter method to make smarter.
+    def parameter(*definition)
+      name, second, _ = definition
+      # 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)
+        condition("Has#{name}", not!(equals(ref(name), "")))
+      else
+        super
+      end
     end
 
     # use long name to minimize method name collision
@@ -26,7 +33,20 @@ module Lono::Template::Dsl::Builder::Helpers
       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

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

@@ -2,8 +2,8 @@
 class Lono::Template::Dsl::Builder
   module Syntax
     include Fn
-    include Helpers # built-in helpers
     include Lono::Template::Evaluate
     include SectionMethods
+    include Helpers # built-in helpers
   end
 end

data/lib/lono/template/generator.rb

@@ -5,7 +5,7 @@ class Lono::Template
     include Lono::Blueprint::Root
 
     def initialize(blueprint, options={})
-      @blueprint, @options = blueprint, options
+      @blueprint, @options = blueprint, ActiveSupport::HashWithIndifferentAccess.new(options.dup)
       @template = @options[:template] || @blueprint
       Lono::ProjectChecker.check
       set_blueprint_root(@blueprint)
@@ -13,11 +13,11 @@ class Lono::Template
 
     def run
       # Examples:
-      #   Erb.new(b, options.clone).run
-      #   Dsl.new(b, options.clone).run
+      #   Erb.new(b, options.dup).run
+      #   Dsl.new(b, options.dup).run
       generator_class = "Lono::Template::#{template_type.classify}"
       generator_class = Object.const_get(generator_class)
-      generator_class.new(@blueprint, @options.clone).run
+      generator_class.new(@blueprint, @options).run
     end
 
     def template_type

data/lib/lono/version.rb

@@ -1,3 +1,3 @@
 module Lono
-  VERSION = "6.0.1"
+  VERSION = "6.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lono
 version: !ruby/object:Gem::Version
-  version: 6.0.1
+  version: 6.1.0
 platform: ruby
 authors:
 - Tung Nguyen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-02 00:00:00.000000000 Z
+date: 2019-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -486,6 +486,7 @@ files:
 - lib/lono/completer/script.rb
 - lib/lono/completer/script.sh
 - lib/lono/completion.rb
+- lib/lono/config_location.rb
 - lib/lono/conventions.rb
 - lib/lono/core.rb
 - lib/lono/core/config.rb
@@ -555,6 +556,7 @@ files:
 - lib/lono/template/dsl/builder/condition.rb
 - lib/lono/template/dsl/builder/fn.rb
 - lib/lono/template/dsl/builder/helpers.rb
+- lib/lono/template/dsl/builder/helpers/core_helper.rb
 - lib/lono/template/dsl/builder/helpers/param_helper.rb
 - lib/lono/template/dsl/builder/mapping.rb
 - lib/lono/template/dsl/builder/output.rb