lono 4.2.7 → 5.0.1

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

@@ -0,0 +1,60 @@
+class Lono::Template::Dsl
+  class Builder
+    include Lono::Template::Util
+    include Lono::Template::Context::Loader
+
+    include Fn
+    include Helper # built-in helpers
+    include Lono::Template::Evaluate
+    include Syntax
+
+    def initialize(path, blueprint, options={})
+      @path, @blueprint, @options = path, blueprint, options
+      @template = @path.sub("#{Lono.config.templates_path}/",'').sub(/\.rb$/,'')
+      @cfn = {}
+    end
+
+    def build
+      load_context
+      evaluate_template_path(@path)
+      build_template
+      write_output
+    end
+
+    def build_template
+      @results = YAML.dump(camelize(@cfn))
+    end
+
+    def write_output
+      output_path = "#{Lono.config.output_path}/#{@blueprint}/templates"
+      FileUtils.mkdir_p(output_path)
+
+      path = "#{output_path}/#{@template}.yml"
+      ensure_parent_dir(path)
+      IO.write(path, @results)
+
+      validate_yaml(path)
+
+      unless @options[:quiet]
+        pretty_path = path.sub("#{Lono.root}/",'')
+        puts "  #{pretty_path}"
+      end
+    end
+
+    def camelize(data)
+      CfnCamelizer.transform(data)
+    end
+
+    # Not using Lono::Template::Context because that works differently.
+    # That is used to load a context object that is passed to RenderMePretty's context.
+    # So that we can load context for params files and erb templates.
+    #
+    # In this case builder is actually the dsl context.
+    # We want to load variables and helpers into this builder context directly.
+    # This loads additional context. It looks very similar to Lono::Template::Context
+    def load_context
+      load_variables
+      load_project_helpers
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+class Lono::Template::Dsl::Builder
+  class Base
+    include Fn
+    include Helper
+
+    def initialize(*definition)
+      @definition = definition.flatten
+    end
+
+    def camelize(attributes)
+      CfnCamelizer.transform(attributes)
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# Implements:
+#
+#   template - uses @definition to build a CloudFormation template section
+#
+class Lono::Template::Dsl::Builder
+  class Condition < Base
+    def template
+      camelize(standarize(@definition))
+    end
+
+    # There are only 2 forms for condition: long and medium
+    #
+    # 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 }
+      else # I dont know what form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+class Lono::Template::Dsl::Builder
+  module Fn
+    # Also act as documentation on the method signatures
+    # Also used in Coder crafting so should always list all the functions here
+    # even if they are overriden with specific implementations below
+    FUNCTIONS = {
+      base64: :simple,
+      cidr: :array,
+      find_in_map: :array,
+      get_att: :array, # special case
+      # get_azs: :simple, # special map to GetAZs, and default region=''
+      import_value: :simple,
+      # join: :array, # special case
+      select: :array,
+      split: :array,
+      # sub: :array, # special case
+      transform: :simple,
+      # Conditional methods
+      # Most of the condition methods need to be accessed via the modulde
+      # since they are Ruby keywords. So Fn::if , also builder has an fn method
+      # so they can also be called via fn::if
+      and: :array,
+      equals: :array,
+      if: :array, # special case, if is a Ruby keyword , we'll use fn_if instead
+      not: :array,
+      or: :array,
+      ref: :simple,
+    }
+    # These are also Ruby keywords
+    # keywords: and if not or
+
+    # Note, for if function, do not flatten the args. Its arguments can be Arrays.  Example:
+    #
+    #   SecurityGroups:
+    #     Fn::If:
+    #     - ExistingSecurityGroupIsBlank
+    #     - - GroupId:
+    #           Ref: SecurityGroup
+    #     - - GroupId:
+    #           Ref: SecurityGroup
+    #       - GroupId:
+    #           Ref: ExistingSecurityGroup
+    FUNCTIONS.each do |name, type|
+      if type == :simple
+        define_method(name) do |arg|
+          id = fn_id(name)
+          arg = arg.is_a?(Symbol) ? CfnCamelizer.camelize(arg) : arg
+          { id => arg }
+        end
+      else # array
+        define_method(name) do |*args|
+          id = fn_id(name)
+          # Note, do not flatten args for if statement as it can have Array as arguments.
+          args = args.flatten unless name == :if
+          args = args.map do |arg|
+            arg.is_a?(Symbol) ? CfnCamelizer.camelize(arg) : arg
+          end
+          { id => args }
+        end
+      end
+    end
+
+    def fn_id(name)
+      "Fn::#{CfnCamelizer.camelize(name)}"
+    end
+
+    # special cases
+    def ref(name)
+      name = CfnCamelizer.camelize(name)
+      { "Ref" => name }
+    end
+
+    # Examples:
+    #   get_attr("logical_id.attribute")
+    #   get_attr("logical_id", "attribute")
+    #   get_attr(["logical_id", "attribute"])
+    def get_att(*item)
+      item = item.flatten
+      options = item.last.is_a?(Hash) ? item.pop : {}
+
+      # list is an Array
+      list = if item.size == 1
+                item.first.split('.')
+              else
+                item
+              end
+      list.map!(&:camelize) unless options[:autoformat] == false
+      { "Fn::GetAtt" => list }
+    end
+
+    def join(delimiter, *list)
+      list = list.flatten
+      { "Fn::Join" => [delimiter, list] }
+    end
+
+    def get_azs(region='')
+      { "Fn::GetAZs" => region }
+    end
+
+    def sub(str, vals={})
+      { "Fn::Sub" => [str, vals] }
+    end
+
+    # for fn::if and fn.if to work
+    def fn
+      Fn
+    end
+    extend self # for Fn::if and Fn.if
+
+    def self.included(base)
+      base.extend(Fn)
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# Built-in helpers for the DSL form
+class Lono::Template::Dsl::Builder
+  module Helper
+    extend Memoist
+
+    def tags(hash, casing: :camelize)
+      hash.map do |k,v|
+        k = k.to_s
+        k = case casing
+        when :camelize
+          CfnCamelizer.camelize(k)
+        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
+      }
+    end
+
+    def user_data(path)
+      path = "#{Lono.config.user_data_path}/#{path}"
+      if File.exist?(path)
+        render_path(path)
+      else
+        message = "WARNING: user-data path #{path} not found"
+        puts message.color(:yellow)
+        puts "Called from:"
+        puts caller[1]
+        message
+      end
+    end
+    memoize :user_data
+
+    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/mapping.rb

@@ -0,0 +1,24 @@
+# Implements:
+#
+#   template - uses @definition to build a CloudFormation template section
+#
+class Lono::Template::Dsl::Builder
+  class Mapping < Base
+    def template
+      camelize(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, maps = first, second
+        { logical_id => maps }
+      else # I dont know what form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# Implements:
+#
+#   template - uses @definition to build a CloudFormation template section
+#
+class Lono::Template::Dsl::Builder
+  class Output < Base
+    def template
+      camelize(standarize(@definition))
+    end
+
+    # Value is the only required property: https://amzn.to/2xbhmk3
+    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
+        if second.key?(:value)
+          logical_id, properties = first, second
+        else
+          logical_id = first
+          properties = {value: second}
+        end
+        { logical_id => properties }
+      elsif definition.size == 2 && second.is_a?(String) # short form
+        logical_id = first
+        properties = second.is_a?(String) ? { value: second } : {}
+        { logical_id => properties }
+      elsif definition.size == 1
+        logical_id = first.to_s
+        properties = {value: ref(logical_id) }
+        { logical_id => properties }
+      else # I dont know what form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# 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 && num_or_str?(second)) || # short form
+            definition.size == 1
+        logical_id = first
+        properties = num_or_str?(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 num_or_str?(o)
+      o.is_a?(Float) || o.is_a?(Integer) || o.is_a?(String)
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# Implements:
+#
+#   template - uses @definition to build a CloudFormation template section
+#
+class Lono::Template::Dsl::Builder
+  class Resource < Base
+    def template
+      camelize(standarize(@definition))
+    end
+
+    # Type is the only required property: https://amzn.to/2x8W5aD
+    def standarize(definition)
+      first, second, third, _ = 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, attributes = first, second
+        attributes.delete(:properties) if attributes[:properties].nil? || attributes[:properties].empty?
+        { logical_id => attributes }
+      elsif definition.size == 2 && second.is_a?(String) # short form
+        logical_id, type = first, second
+        { logical_id => {
+            type: type
+        }}
+      elsif definition.size == 3 && (second.is_a?(String) || second.is_a?(NilClass))# short form
+        logical_id, type, properties = first, second, third
+        template = { logical_id => {
+                       type: type
+                    }}
+        attributes = template.values.first
+        attributes[:properties] = properties unless properties.empty?
+        template
+      else # Dont understand this form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# Implements:
+#
+#   template - uses @definition to build a CloudFormation template section
+#
+class Lono::Template::Dsl::Builder
+  class Section < Base
+    def template
+      hash, _ = @definition
+      camelize(hash)
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# Organize core syntax here
+class Lono::Template::Dsl::Builder
+  module Syntax
+    def aws_template_format_version(version_date)
+      @cfn["AWSTemplateFormatVersion"] = version_date
+    end
+
+    def description(text)
+      @cfn["Description"] = text
+    end
+
+    def metadata(data)
+      @cfn["Metadata"] = data
+    end
+
+    def transform(*definition)
+      definition = definition.flatten
+      definition.map! { |x| CfnCamelizer.camelize(x) }
+      @cfn["Transform"] = definition.size == 1 ? definition.first : definition
+    end
+
+    def parameter(*definition)
+      @cfn["Parameters"] ||= {}
+      param = Parameter.new(definition)
+      @cfn["Parameters"].merge!(param.template)
+    end
+
+    def mapping(*definition)
+      @cfn["Mappings"] ||= {}
+      mapping = Mapping.new(definition)
+      @cfn["Mappings"].merge!(mapping.template)
+    end
+
+    def resource(*definition)
+      @cfn["Resources"] ||= {}
+      resource = Resource.new(definition)
+      @cfn["Resources"].merge!(resource.template)
+    end
+
+    def condition(*definition)
+      @cfn["Conditions"] ||= {}
+      condition = Condition.new(definition)
+      @cfn["Conditions"].merge!(condition.template)
+    end
+
+    def output(*definition)
+      @cfn["Outputs"] ||= {}
+      output = Output.new(definition)
+      @cfn["Outputs"].merge!(output.template)
+    end
+
+    # Generic section method in case CloudFormation adds a new future section.
+    # The generic section method adds a new top-level key
+    def section(key, definition)
+      @cfn[key] = Section.new(definition).template
+    end
+  end
+end