lono 1.1.3 → 2.0.0

data/lib/lono/bashify.rb

@@ -1,41 +0,0 @@
-require 'open-uri'
-
-module Lono
-  class Bashify
-    def initialize(options={})
-      @options = options
-      @path = options[:path]
-    end
-
-    def user_data_paths(data,path="")
-      paths = []
-      paths << path
-      data.each do |key,value|
-        if value.is_a?(Hash)
-          paths += user_data_paths(value,"#{path}/#{key}")
-        else
-          paths += ["#{path}/#{key}"]
-        end
-      end
-      paths.select {|p| p =~ /UserData/ && p =~ /Fn::Join/ }
-    end
-
-    def run
-      raw = open(@path).read
-      json = JSON.load(raw)
-      paths = user_data_paths(json)
-      if paths.empty?
-        puts "No UserData script found"
-        return
-      end
-      paths.each do |path|
-        puts "UserData script for #{path}:"
-        key = path.sub('/','').split("/").map {|x| "['#{x}']"}.join('')
-        user_data = eval("json#{key}")
-        delimiter = user_data[0]
-        script = user_data[1]
-        puts script.join(delimiter)
-      end
-    end
-  end
-end

data/lib/lono/cli/help.rb

@@ -1,37 +0,0 @@
-module Lono
-  module 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 the cloudformation templates files based on lono project and writes them to the output folder on the filesystem.
-EOL
-    end
-
-    def bashify
-<<-EOL
-Examples:
-
-$ lono bashify /path/to/cloudformation-template.json
-
-$ lono bashify https://s3.amazonaws.com/cloudformation-templates-us-east-1/EC2WebSiteSample.template
-EOL
-    end
-
-    extend self
-  end
-end

data/lib/lono/dsl.rb

@@ -1,132 +0,0 @@
-module Lono
-  class DSL
-    def initialize(options={})
-      @options = options
-      @options[:project_root] ||= '.'
-      @path = "#{@options[:project_root]}/config/lono.rb"
-      @templates = []
-      @results = {}
-      @detected_format = nil
-    end
-
-    def run(options={})
-      evaluate
-      build
-      output
-    end
-
-    def evaluate
-      instance_eval(File.read(@path), @path)
-      load_subfolder
-      @detected_format = detect_format
-    end
-
-    # Detects the format of the templates.  Simply checks the extension of all the
-    # templates files.
-    # All the templates must be of the same format, either all json or all yaml.
-    def detect_format
-      # @templates contains Array of Hashes. Example:
-      # [{name: ""blog-web-prod.json", block: ...},
-      #  {name: ""api-web-prod.json", block: ...}]
-      formats = @templates.map{ |t| File.extname(t[:name]) }.uniq
-      if formats.size > 1
-        puts "ERROR: Detected multiple formats: #{formats.join(", ")}".colorize(:red)
-        puts "All the source values in the template blocks in the config folder must have the same format extension."
-        exit 1
-      else
-        found_format = formats.first
-        if found_format
-          detected_format = found_format.sub(/^\./,'')
-          detected_format = "yaml" if detected_format == "yml"
-        else # empty templates, no templates defined yet
-          detected_format = "yaml" # defaults to yaml
-        end
-      end
-      detected_format
-    end
-
-    # load any templates defined in project/config/lono/*
-    def load_subfolder
-      Dir.glob("#{File.dirname(@path)}/lono/**/*").select{ |e| File.file? e }.each do |path|
-        instance_eval(File.read(path), path)
-      end
-    end
-
-    def template(name, &block)
-      @templates << {name: name, block: block}
-    end
-
-    def build
-      @templates.each do |t|
-        @results[t[:name]] = Template.new(t[:name], t[:block], @options).build
-      end
-    end
-
-    def output
-      output_path = "#{@options[:project_root]}/output"
-      FileUtils.rm_rf(output_path) if @options[:clean]
-      FileUtils.mkdir(output_path) unless File.exist?(output_path)
-      puts "Generating CloudFormation templates:" unless @options[:quiet]
-      @results.each do |name,text|
-        path = "#{output_path}/#{name}".sub(/^\.\//,'')
-        puts "  #{path}" unless @options[:quiet]
-        ensure_parent_dir(path)
-        validate(text, path)
-        File.open(path, 'w') do |f|
-          f.write(output_format(text))
-        end
-      end
-    end
-
-    # TODO: set @detected_format upon DSL.new
-    def validate(text, path)
-      if @detected_format == "json"
-        validate_json(text, path)
-      else
-        validate_yaml(text, path)
-      end
-    end
-
-    def validate_yaml(yaml, path)
-      begin
-        YAML.load(yaml)
-      rescue Psych::SyntaxError => e
-        puts "Invalid yaml.  Output written to #{path} for debugging".colorize(:red)
-        puts "ERROR: #{e.message}".colorize(:red)
-        File.open(path, 'w') {|f| f.write(yaml) }
-        exit 1
-      end
-    end
-
-    def validate_json(json, path)
-      begin
-        JSON.parse(json)
-      rescue JSON::ParserError => e
-        puts "Invalid json.  Output written to #{path} for debugging".colorize(:red)
-        puts "ERROR: #{e.message}".colorize(:red)
-        File.open(path, 'w') {|f| f.write(json) }
-        exit 1
-      end
-    end
-
-    def output_format(text)
-      @options[:pretty] ? prettify(text) : text
-    end
-
-    # Input text is either yaml or json.
-    # Do not prettify yaml format because it removes the !Ref like CloudFormation notation
-    def prettify(text)
-      @detected_format == "json" ? JSON.pretty_generate(JSON.parse(text)) : remove_blank_lines(text)
-    end
-
-    # ERB templates leaves blank lines around, remove those lines
-    def remove_blank_lines(text)
-      text.split("\n").reject { |l| l.strip == '' }.join("\n") + "\n"
-    end
-
-    def ensure_parent_dir(path)
-      dir = File.dirname(path)
-      FileUtils.mkdir_p(dir) unless File.exist?(dir)
-    end
-  end
-end