lono 1.1.3 → 2.0.0

data/lib/lono/command.rb

@@ -0,0 +1,25 @@
+require 'thor'
+
+module Lono
+  class Command < Thor
+    class << self
+      def dispatch(m, args, options, config)
+        # Allow calling for help via:
+        #   lono generate help
+        #   lono generate -h
+        #   lono generate --help
+        #   lono generate -D
+        #
+        # as well thor's nomral setting as
+        #
+        #   lono help generate
+        help_flags = Thor::HELP_MAPPINGS + ["help"]
+        if args.length > 1 && !(args & help_flags).empty?
+          args -= help_flags
+          args.insert(-2, "help")
+        end
+        super
+      end
+    end
+  end
+end

data/lib/lono/help.rb

@@ -0,0 +1,59 @@
+module Lono::Help
+  def new_long_desc
+<<-EOL
+Examples:
+
+$ lono new project
+
+$ lono new lono
+EOL
+  end
+
+  def generate
+<<-EOL
+Examples:
+
+$ lono generate
+
+$ lono g -c # shortcut
+
+Builds both CloudFormation template and parameter files based on lono project and writes them to the output folder on the filesystem.
+EOL
+
+  end
+
+  def template
+<<-EOL
+Examples:
+
+$ lono template generate --help
+
+$ lono template bashify --help
+EOL
+
+  end
+
+  def cfn
+<<-EOL
+Examples:
+
+$ lono cfn create my-stack
+
+$ lono cfn preview my-stack
+
+$ lono cfn update my-stack
+
+$ lono cfn delete my-stack
+EOL
+  end
+
+  def param
+<<-EOL
+Examples:
+
+$ lono param generate
+EOL
+  end
+
+  extend self
+end

data/lib/lono/new.rb

@@ -9,11 +9,12 @@ module Lono
 
     def run
       puts "Setting up lono project" unless options[:quiet]
-      source_root = File.expand_path("../../starter_project_#{@format}", __FILE__)
+      source_root = File.expand_path("../../starter_projects/#{@format}_project", __FILE__)
       paths = Dir.glob("#{source_root}/**/*").
                 select {|p| File.file?(p) }
       paths.each do |src|
-        regexp = Regexp.new(".*starter_project_#{@format}/")
+        # starter_projects/yaml_project/ ->
+        regexp = Regexp.new(".*starter_projects/#{@format}_project/")
         dest = src.gsub(regexp,'')
         dest = "#{@project_root}/#{dest}"
 

data/lib/lono/param.rb

@@ -0,0 +1,20 @@
+require "thor"
+
+module Lono
+  class Param < Command
+    autoload :Help, 'lono/param/help'
+    autoload :Generator, 'lono/param/generator'
+
+    class_option :verbose, type: :boolean
+    class_option :noop, type: :boolean
+    class_option :mute, type: :boolean
+    class_option :project_root, desc: "project root to use", default: '.'
+
+    desc "generate NAME", "generate parameter json file for NAME"
+    long_desc Help.generate
+    option :path, desc: "Name of the source that maps to the params txt file.  name -> params/NAME.txt.  Use this to override the params/NAME.txt convention"
+    def generate
+      Generator.generate_all(options)
+    end
+  end
+end

data/lib/lono/param/generator.rb

@@ -0,0 +1,90 @@
+class Lono::Param::Generator
+  def self.generate_all(options)
+    puts "Generating params files"
+    project_root = options[:project_root] || '.'
+    Dir.glob("#{project_root}/params/**/*.txt").each do |path|
+      next if File.directory?(path)
+      name = path.sub(/.*params\//, '').sub('.txt', '')
+      param = Lono::Param::Generator.new(name, options)
+      param.generate
+    end
+  end
+
+  def initialize(name, options)
+    @name = name
+    @options = options
+    @project_root = options[:project_root] || '.'
+    @source_path = options[:path] || "#{@project_root}/params/#{@name}.txt"
+  end
+
+  def generate
+    # useful option for lono cfn
+    return if @options[:allow_no_file] && !File.exist?(@source_path)
+
+    if File.exist?(@source_path)
+      contents = IO.read(@source_path)
+      data = convert_to_cfn_format(contents)
+      json = JSON.pretty_generate(data)
+      write_output(json)
+      puts "Params file generated for #{@name} at #{output_path}" unless @options[:mute]
+    else
+      puts "#{@source_path} could not be found?  Are you sure it exist?"
+      exit 1
+    end
+  end
+
+  # useful for when calling CloudFormation via the aws-sdk gem
+  def params
+    # useful option for lono cfn
+    return {} if @options[:allow_no_file] && !File.exist?(@source_path)
+
+    contents = IO.read(@source_path)
+    convert_to_cfn_format(contents, :underscore)
+  end
+
+  def parse_contents(contents)
+    lines = contents.split("\n")
+    # remove comment at the end of the line
+    lines.map! { |l| l.sub(/#.*/,'').strip }
+    # filter out commented lines
+    lines = lines.reject { |l| l =~ /(^|\s)#/i }
+    # filter out empty lines
+    lines = lines.reject { |l| l.strip.empty? }
+    lines
+  end
+
+  def convert_to_cfn_format(contents, casing=:camel)
+    lines = parse_contents(contents)
+    params = []
+    lines.each do |line|
+      key,value = line.strip.split("=").map {|x| x.strip}
+      param = if value == "use_previous_value"
+                {
+                  ParameterKey: key,
+                  UsePreviousValue: true
+                }
+              elsif value
+                {
+                  ParameterKey: key,
+                  ParameterValue: value
+                }
+              end
+      if param
+        param = param.to_snake_keys if casing == :underscore
+        params << param
+      end
+    end
+    params
+  end
+
+  def output_path
+    "#{@project_root}/output/params/#{@name}.json".sub(/\.\//,'')
+  end
+
+  def write_output(json)
+    dir = File.dirname(output_path)
+    FileUtils.mkdir_p(dir) unless File.exist?(dir)
+    IO.write(output_path, json)
+  end
+
+end

data/lib/lono/param/help.rb

@@ -0,0 +1,15 @@
+class Lono::Param::Help
+  class << self
+    def generate
+<<-EOL
+Example:
+
+To generate a CloudFormation json parameter files in the params folder to the output/params folder.
+
+$ lono-params generate
+
+If you have params/my-stack.txt. It will generate a CloudFormation json file in output/params/my-stack.json.
+EOL
+    end
+  end
+end

data/lib/lono/project_checker.rb

@@ -0,0 +1,44 @@
+module Lono
+  class ProjectChecker
+    # Checks to see command is running in a lono project.
+    # If not, provide a friendly message and exit.
+    def self.check(project_root)
+      new(project_root).check
+    end
+
+    def initialize(project_root)
+      @project_root = project_root
+    end
+
+    def check
+      config_folder_exist
+      templates_folder_exist
+      empty_folders
+    end
+
+    def config_folder_exist
+      unless File.exist?("#{@project_root}/config")
+        puts "The config folder does not exist in this project.  Are you sure this is a lono project?"
+        exit 1
+      end
+    end
+
+    def templates_folder_exist
+      unless File.exist?("#{@project_root}/templates")
+        puts "The templates folder does not exist in this project.  Are you sure this is a lono project?"
+        exit 1
+      end
+    end
+
+    def empty_folders
+      if Dir["#{@project_root}/config/**/*.rb"].empty?
+        puts "The config folder does not contain any lono template definitions."
+        exit 1
+      end
+      if Dir["#{@project_root}/templates/**/*"].empty?
+        puts "The templates folder does not contain any lono template definitions."
+        exit 1
+      end
+    end
+  end
+end

data/lib/lono/template.rb

@@ -1,253 +1,27 @@
-require 'erb'
-require 'json'
-require 'base64'
+require "thor"
+require_relative "command"
 
 module Lono
-  class Template
-    include ERB::Util
-
-    attr_reader :name
-    def initialize(name, block, options={})
-      @name = name
-      @block = block
-      @options = options
-    end
-
-    def build
-      instance_eval(&@block)
-      template = IO.read(@source)
-      erb_result(@source, template)
-    end
-
-    def source(path)
-      @source = path[0..0] == '/' ? path : "#{@options[:project_root]}/templates/#{path}"
-    end
-
-    def variables(vars={})
-      vars.each do |var,value|
-        instance_variable_set("@#{var}", value)
-      end
-    end
-
-    def partial(path,vars={}, options={})
-      path = "#{@options[:project_root]}/templates/partial/#{path}"
-      template = IO.read(path)
-      variables(vars)
-      result = erb_result(path, template)
-      result = indent(result, options[:indent]) if options[:indent]
-      result
-    end
-
-    # add indentation
-    def indent(result, indentation_amount)
-      result.split("\n").map do |line|
-        " " * indentation_amount + line
-      end.join("\n")
-    end
-
-    def erb_result(path, template)
-      begin
-        ERB.new(template, nil, "-").result(binding)
-      rescue Exception => e
-        puts e
-
-        # how to know where ERB stopped? - https://www.ruby-forum.com/topic/182051
-        # syntax errors have the (erb):xxx info in e.message
-        # undefined variables have (erb):xxx info in e.backtrac
-        error_info = e.message.split("\n").grep(/\(erb\)/)[0]
-        error_info ||= e.backtrace.grep(/\(erb\)/)[0]
-        raise unless error_info # unable to find the (erb):xxx: error line
-        line = error_info.split(':')[1].to_i
-        puts "Error evaluating ERB template on line #{line.to_s.colorize(:red)} of: #{path.sub(/^\.\//, '')}"
-
-        template_lines = template.split("\n")
-        context = 5 # lines of context
-        top, bottom = [line-context-1, 0].max, line+context-1
-        spacing = template_lines.size.to_s.size
-        template_lines[top..bottom].each_with_index do |line_content, index|
-          line_number = top+index+1
-          if line_number == line
-            printf("%#{spacing}d %s\n".colorize(:red), line_number, line_content)
-          else
-            printf("%#{spacing}d %s\n", line_number, line_content)
-          end
-        end
-        exit 1 unless ENV['TEST']
-      end
-    end
-
-    def user_data(path, vars={})
-      path = "#{@options[:project_root]}/templates/user_data/#{path}"
-      template = IO.read(path)
-      variables(vars)
-      result = erb_result(path, template)
-      output = []
-      result.split("\n").each do |line|
-        output += transform(line)
-      end
-      json = output.to_json
-      json[0] = '' # remove first char: [
-      json.chop!   # remove last char:  ]
-    end
-
-    def ref(name)
-      %Q|{"Ref"=>"#{name}"}|
-    end
-
-    def find_in_map(*args)
-      %Q|{"Fn::FindInMap" => [ #{transform_array(args)} ]}|
-    end
-
-    def base64(value)
-      %Q|{"Fn::Base64"=>"#{value}"}|
-    end
-
-    def get_att(*args)
-      %Q|{"Fn::GetAtt" => [ #{transform_array(args)} ]}|
-    end
-
-    def get_azs(region="AWS::Region")
-      %Q|{"Fn::GetAZs"=>"#{region}"}|
-    end
-
-    def join(delimiter, values)
-      %Q|{"Fn::Join" => ["#{delimiter}", [ #{transform_array(values)} ]]}|
-    end
-
-    def select(index, list)
-      %Q|{"Fn::Select" => ["#{index}", [ #{transform_array(list)} ]]}|
-    end
-
-    def transform_array(arr)
-      arr.map! {|x| x =~ /=>/ ? x : x.inspect }
-      arr.join(',')
-    end
-
-    # transform each line of bash script to array with cloudformation template objects
-    def transform(data)
-      data = evaluate(data)
-      if data[-1].is_a?(String)
-        data[0..-2] + ["#{data[-1]}\n"]
-      else
-        data + ["\n"]
-      end
-    end
-
-    # Input:
-    #   String
-    # Output:
-    #   Array of parse positions
-    #
-    # The positions of tokens taking into account when brackets start and close,
-    # handles nested brackets.
-    def bracket_positions(line)
-      positions,pair,count = [],[],0
-
-      line.split('').each_with_index do |char,i|
-        pair << i if pair.empty?
-
-        first_pair_char = line[pair[0]]
-        if first_pair_char == '{' # object logic
-          if char == '{'
-            count += 1
-          end
-
-          if char == '}'
-            count -= 1
-            if count == 0
-              pair << i
-              positions << pair
-              pair = []
-            end
-          end
-        else # string logic
-          lookahead = line[i+1]
-          if lookahead == '{'
-            pair << i
-            positions << pair
-            pair = []
-          end
-        end
-      end # end of loop
-
-      # for string logic when lookahead does not contain a object token
-      # need to clear out what's left to match the final pair
-      if !pair.empty?
-        pair << line.size - 1
-        positions << pair
-      end
-
-      positions
-    end
-
-    # Input:
-    #   Array - bracket_positions
-    # Ouput:
-    #   Array - positions that can be use to determine what to parse
-    def parse_positions(line)
-      positions = bracket_positions(line)
-      positions.flatten
-    end
-
-    # Input
-    #   String line of code to decompose into chunks, some can be transformed into objects
-    # Output
-    #   Array of strings, some can be transformed into objects
-    #
-    # Example:
-    # line = 'a{b}c{d{d}d}e' # nested brackets
-    # template.decompose(line).should == ['a','{b}','c','{d{d}d}','e']
-    def decompose(line)
-      positions = parse_positions(line)
-      return [line] if positions.empty?
-
-      result = []
-      str = ''
-      until positions.empty?
-        left = positions.shift
-        right = positions.shift
-        token = line[left..right]
-        # if cfn object, add to the result set but after clearing out
-        # the temp str that is being built up when the token is just a string
-        if cfn_object?(token)
-          unless str.empty? # first token might be a object
-            result << str
-            str = ''
-          end
-          result << token
-        else
-          str << token # keeps building up the string
-        end
-      end
-
-      # at the of the loop there's a leftover string, unless the last token
-      # is an object
-      result << str unless str.empty?
-
-      result
-    end
-
-    def cfn_object?(s)
-      exact = %w[Ref]
-      pattern = %w[Fn::]
-      exact_match = !!exact.detect {|word| s.include?(word)}
-      pattern_match = !!pattern.detect {|p| s =~ Regexp.new(p)}
-      (exact_match || pattern_match) && s =~ /^{/ && s =~ /=>/
-    end
-
-    def recompose(decomposition)
-      decomposition.map { |s| cfn_object?(s) ? eval(s) : s }
-    end
-
-    def evaluate(line)
-      recompose(decompose(line))
-    end
-
-    # For simple just parameters files that can also be generated with lono, the CFN
-    # Fn::Base64 function is not available and as lono is not being used in the context
-    # of CloudFormation.  So this can be used in it's place.
-    def encode_base64(text)
-      Base64.strict_encode64(text).strip
+  class Template < Command
+    autoload :Help, 'lono/template/help'
+    autoload :Bashify, 'lono/template/bashify'
+    autoload :DSL, 'lono/template/dsl'
+    autoload :Template, 'lono/template/template'
+
+    desc "generate", "Generate the CloudFormation templates"
+    Help.generate
+    option :clean, type: :boolean, aliases: "-c", desc: "remove all output files before generating"
+    option :project_root, default: ".", aliases: "-r", desc: "project root"
+    option :quiet, type: :boolean, aliases: "-q", desc: "silence the output"
+    option :pretty, type: :boolean, default: true, desc: "json pretty the output.  only applies with json format"
+    def generate
+     DSL.new(options.clone).run
+    end
+
+    desc "bashify [URL-OR-PATH]", "Convert the UserData section of an existing CloudFormation Template to a starter bash script that is compatiable with lono"
+    Help.bashify
+    def bashify(path)
+      Bashify.new(path: path).run
     end
   end
 end