lono 7.5.2 → 8.0.0.pre.rc1

data/lib/lono/cli/help.rb

@@ -0,0 +1,56 @@
+class Lono::CLI
+  module Help
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def main_commands
+        %w[
+          build
+          down
+          list
+          new
+          plan
+          seed
+          show
+          up
+        ]
+      end
+
+      def help(shell, subcommand)
+        list = printable_commands(true, subcommand)
+        list.sort! { |a, b| a[0] <=> b[0] }
+        filter = Proc.new do |command, desc|
+          main_commands.detect { |name| command =~ Regexp.new("^lono #{name}") }
+        end
+        main = list.select(&filter)
+        other = list.reject(&filter)
+
+        shell.say <<~EOL
+          Usage: lono COMMAND [args]
+          The available commands are listed below.
+          The primary workflow commands are given first, followed by
+          less common or more advanced commands.
+        EOL
+        shell.say "\nMain Commands:\n\n"
+        shell.print_table(main, :indent => 2, :truncate => true)
+        shell.say "\nOther Commands:\n\n"
+        shell.print_table(other, :indent => 2, :truncate => true)
+        shell.say <<~EOL
+
+          For more help on each command, you can use the -h option. Example:
+
+              lono up -h
+
+          CLI Reference also available at: https://lono.cloud/reference/
+        EOL
+      end
+    end
+
+    def text(namespaced_command)
+      path = namespaced_command.to_s.gsub(':','/')
+      path = File.expand_path("../help/#{path}.md", __FILE__)
+      IO.read(path) if File.exist?(path)
+    end
+    extend self
+  end
+end

data/lib/lono/cli/list.rb

@@ -0,0 +1,28 @@
+class Lono::CLI
+  class List < Base
+    attr_reader :options
+    def initialize(options={})
+      @options = options
+    end
+
+    def run
+      list_type("blueprints") if show?("blueprint")
+      list_type("configsets") if show?("configset")
+      list_type("extensions") if show?("extension")
+    end
+
+  private
+    def list_type(type)
+      lookup.list(type)
+    end
+
+    def lookup
+      Lono::Lookup.new
+    end
+    memoize :lookup
+
+    def show?(type)
+      @options[:type] == type || @options[:type].nil? || @options[:type] == "all"
+    end
+  end
+end

data/lib/lono/cli/new/blueprint.rb

@@ -0,0 +1,33 @@
+class Lono::CLI::New
+  class Blueprint < Sequence
+    argument :name
+    def self.cli_options
+      [
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
+        [:examples, type: :boolean, desc: "Whether not to generate examples"],
+        [:project, desc: "Project name"],
+      ]
+    end
+    cli_options.each do |args|
+      class_option(*args)
+    end
+
+    def set_source
+      if @options[:examples]
+        set_template_source "examples/blueprint"
+      else
+        set_template_source "blueprint"
+      end
+    end
+
+    # for specs
+    def set_dest
+      @dest = [@options[:project], "app/blueprints"].compact.join('/')
+    end
+
+    def create_blueprint
+      logger.info "=> Creating new blueprint called #{name}."
+      directory ".", "#{@dest}/#{name}"
+    end
+  end
+end

data/lib/lono/cli/new/concerns.rb

@@ -0,0 +1,16 @@
+class Lono::CLI::New
+  module Concerns
+    extend ActiveSupport::Concern
+
+  private
+    def class_name
+      name.underscore.camelize
+    end
+
+    # Files should be named with underscores instead of dashes even though project name can contain a dash.
+    # This is because autoloading works with underscores in the filenames only.
+    def underscore_name
+      name.underscore
+    end
+  end
+end

data/lib/lono/{configset/new.rb → cli/new/configset.rb}

@@ -1,8 +1,5 @@
-class Lono::Configset
-  class New < Lono::Sequence
-    include Lono::Blueprint::Helper
-    include Lono::Utils::Generators::Tree
-
+class Lono::CLI::New
+  class Configset < Sequence
     argument :configset_name
 
     def self.source_root
@@ -69,9 +66,5 @@ class Lono::Configset
 
       EOL
     end
-
-    def tree
-      tree_structure("configset")
-    end
   end
 end

data/lib/lono/{extension/new.rb → cli/new/extension.rb}

@@ -1,9 +1,5 @@
-class Lono::Extension
-  class New < Lono::Sequence
-    include Lono::Blueprint::Helper # for user_info
-    include Lono::Extension::Helper
-    include Lono::Utils::Generators::Tree
-
+class Lono::CLI::New
+  class Extension < Sequence
     argument :extension_name
 
     def self.source_root
@@ -57,9 +53,5 @@ class Lono::Extension
 
       EOL
     end
-
-    def tree
-      tree_structure("extension")
-    end
   end
 end

data/lib/lono/cli/new/helper.rb

@@ -0,0 +1,32 @@
+class Lono::CLI::New
+  class Helper < Sequence
+    def self.cli_options
+      [
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
+        [:blueprint, required: true, desc: "Blueprint name"],
+        [:name, default: "custom", desc: "Helper name"],
+      ]
+    end
+    cli_options.each do |args|
+      class_option(*args)
+    end
+
+    def set_source
+      set_template_source "helper"
+    end
+
+    def set_vars
+      @blueprint = @options[:blueprint]
+      @name = @options[:name]
+    end
+
+    def create_blueprint
+      puts "underscore_name #{underscore_name}"
+      logger.info "=> Generating helper: #{@name}"
+      directory ".", "app/blueprints/#{@blueprint}/helpers"
+    end
+
+  private
+    attr_reader :name # required for templates/helper/%name%_helper.rb.tt
+  end
+end

data/lib/lono/cli/new/project.rb

@@ -0,0 +1,77 @@
+class Lono::CLI::New
+  class Project < Sequence
+    argument :name
+    set_template_source "project"
+
+    def self.cli_options
+      [
+        [:bundle, type: :boolean, default: true, desc: "Runs bundle install on the project"],
+        [:examples, type: :boolean, default: false, desc: "Also generate blueprint example"],
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
+        [:git, type: :boolean, default: true, desc: "Git initialize the project"],
+        [:quiet, type: :boolean, desc: "Quiet output."],
+      ]
+    end
+    cli_options.each { |args| class_option(*args) }
+
+    # for specs
+    def set_pwd
+      @pwd = Dir.pwd
+    end
+
+    def create_project
+      log "=> Creating new project called #{name}."
+      directory ".", "#{@pwd}/#{name}"
+    end
+
+    def create_example_blueprint
+      return unless @options[:examples]
+      # https://github.com/erikhuda/thor/wiki/Invocations
+      args = ["demo", "--project", name]
+      args += ["--examples"] if @options[:examples]
+      args += ["--force"] if @options[:force]
+      Blueprint.start(args)
+    end
+
+    def bundle_install
+      return unless options[:bundle]
+      log "=> Installing dependencies with: bundle install"
+      ::Bundler.with_unbundled_env do
+        bundle = "BUNDLE_IGNORE_CONFIG=1 bundle install"
+        bundle << " > /dev/null 2>&1" if @options[:quiet]
+        system(bundle, chdir: name)
+      end
+    end
+
+    def welcome_message
+      log <<~EOL
+        #{"="*64}
+        Congrats 🎉 You have successfully created a lono project.
+
+            cd #{name}
+
+      EOL
+      unless @options[:examples]
+        log <<~EOL
+          To generate a new blueprint:
+
+              lono new blueprint demo --examples
+
+        EOL
+      end
+      log <<~EOL
+        To deploy:
+
+            lono up demo
+
+        More info: https://lono.cloud/
+      EOL
+    end
+
+  private
+    def log(msg)
+      logger.info(msg) unless @options[:quiet]
+    end
+
+  end
+end

data/lib/lono/cli/new/sequence.rb

@@ -0,0 +1,51 @@
+require 'fileutils'
+require 'active_support'
+require 'active_support/core_ext/string'
+require 'thor'
+require 'bundler'
+
+class Lono::CLI::New
+  class Sequence < Thor::Group
+    include Concerns
+    include Lono::Utils::Logging
+    include Thor::Actions
+
+  private
+    def self.set_template_source(folder)
+      source_root File.expand_path("../../../templates/#{folder}", __dir__)
+    end
+
+    def set_template_source(*paths)
+      paths = paths.flatten.map do |path|
+        File.expand_path("../../../templates/#{path}", __dir__)
+      end
+      set_template_paths(paths)
+    end
+
+    def set_template_paths(*paths)
+      paths.flatten!
+      # https://github.com/erikhuda/thor/blob/34df888d721ecaa8cf0cea97d51dc6c388002742/lib/thor/actions.rb#L128
+      instance_variable_set(:@source_paths, nil) # unset instance variable cache
+      # Using string with instance_eval because block doesnt have access to path at runtime.
+      instance_eval %{
+        def self.source_paths
+          #{paths.flatten.inspect}
+        end
+      }
+    end
+
+    def git_installed?
+      system("type git > /dev/null 2>&1")
+    end
+
+    def run_git?
+      options[:git] && git_installed?
+    end
+
+    def run_git_init
+      return unless run_git?
+      puts "=> Initialize git repo"
+      run("git init")
+    end
+  end
+end

data/lib/lono/cli/new/shim.rb

@@ -0,0 +1,59 @@
+class Lono::CLI::New
+  class Shim < Thor::Group
+    include Thor::Actions
+
+    def self.cli_options
+      [
+        [:path, aliases: %w[p], default: "/usr/local/bin/lono", desc: "path to save the shim script"],
+      ]
+    end
+    cli_options.each { |args| class_option(*args) }
+
+    def self.source_root
+      File.expand_path("../../../templates/shim", __dir__)
+    end
+
+    def set_vars
+      @path = @options[:path]
+    end
+
+    def create
+      dest = @path
+      template "lono", dest
+      chmod dest, 0755
+    end
+
+    def message
+      dir = File.dirname(@path)
+      puts <<~EOL
+        A lono shim as been generated at #{@path}
+        Please make sure that it is found in the $PATH.
+
+        You can double check with:
+
+            which lono
+
+        You should see
+
+            $ which lono
+            #{@path}
+
+        If you do not, please add #{dir} to your PATH.
+        You can usually do so by adding this line to ~/.bash_profile and opening a new terminal to check.
+
+            export PATH=#{dir}:/$PATH
+
+        Also note, the shim wrapper contains starter code. Though it should generally work for most systems,
+        it might require adjustments depending on your system.
+      EOL
+    end
+
+  private
+    def switch_ruby_version_line
+      rbenv_installed = system("type rbenv > /dev/null 2>&1")
+      if rbenv_installed
+        'eval "$(rbenv init -)"'
+      end
+    end
+  end
+end

data/lib/lono/cli/new/test/blueprint.rb

@@ -0,0 +1,23 @@
+class Lono::CLI::New::Test
+  class Blueprint < Sequence
+    argument :name
+
+    def self.cli_options
+      [
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
+      ]
+    end
+    cli_options.each { |args| class_option(*args) }
+
+    def set_source
+      name = Lono.config.test.framework
+      framework = Lono::Plugin.find(name: name, type: "test_framework")
+      set_template_paths("#{framework.root}/lib/templates/blueprint")
+    end
+
+    def generate
+      dest = "app/blueprints/#{name}"
+      directory ".", dest
+    end
+  end
+end

data/lib/lono/cli/new/test/sequence.rb

@@ -0,0 +1,10 @@
+require 'fileutils'
+require 'active_support'
+require 'active_support/core_ext/string'
+require 'thor'
+require 'bundler'
+
+class Lono::CLI::New::Test
+  class Sequence < Lono::CLI::New::Sequence
+  end
+end

data/lib/lono/cli/new/test.rb

@@ -0,0 +1,8 @@
+class Lono::CLI::New
+  class Test < Lono::Command
+    Help = Lono::CLI::Help
+    long_desc Help.text("new/test/blueprint")
+    Blueprint.cli_options.each { |args| option(*args) }
+    register(Blueprint, "blueprint", "blueprint NAME", "Generate new blueprint test.")
+  end
+end

data/lib/lono/cli/new.rb

@@ -0,0 +1,31 @@
+class Lono::CLI
+  class New < Lono::Command
+    long_desc Help.text("new/blueprint")
+    Blueprint.cli_options.each { |args| option(*args) }
+    register(Blueprint, "blueprint", "blueprint NAME", "Generates new blueprint.")
+
+    long_desc Help.text("new/configset")
+    Configset.cli_options.each { |args| option(*args) }
+    register(Configset, "configset", "configset NAME", "Generates new configset.")
+
+    long_desc Help.text("new/extension")
+    Extension.cli_options.each { |args| option(*args) }
+    register(Extension, "extension", "extension NAME", "Generates new extension.")
+
+    long_desc Help.text("new/helper")
+    Helper.cli_options.each { |args| option(*args) }
+    register(Helper, "helper", "helper NAME", "Generates new helper.")
+
+    long_desc Help.text("new/project")
+    Project.cli_options.each { |args| option(*args) }
+    register(Project, "project", "project NAME", "Generates new project.")
+
+    long_desc Help.text("new/shim")
+    Shim.cli_options.each { |args| option(*args) }
+    register(Shim, "shim", "shim NAME", "Generates new shim.")
+
+    desc "test SUBCOMMAND", "test subcommands"
+    long_desc Help.text(:test)
+    subcommand "test", Test
+  end
+end

data/lib/lono/{opts.rb → cli/opts.rb}

@@ -5,7 +5,7 @@
 # Lono::Opts instead of Lono::CLI::Opts
 #
 # Also, there's Thor Options class, so this is named Opts to avoid having to fully qualify it.
-module Lono
+class Lono::CLI
   class Opts
     def initialize(cli)
       @cli = cli
@@ -17,23 +17,20 @@ module Lono
       end
     end
 
-    def source
+    def yes
       with_cli_scope do
-        option :source, desc: "url or path to file with template"
+        option :yes, aliases: :y, type: :boolean, desc: "Bypass are you sure prompt"
       end
     end
 
-    def stack
+    # Based on https://github.com/rails/thor/blob/ab3b5be455791f4efb79f0efb4f88cc6b59c8ccf/lib/thor/actions.rb#L48
+    def runtime_options
       with_cli_scope do
-        option :stack, desc: "stack name. defaults to blueprint name."
-      end
-    end
+        option :force, :type => :boolean, :aliases => "-f", :group => :runtime,
+                             :desc => "Overwrite files that already exist"
 
-    def template
-      with_cli_scope do
-        option :template, desc: "override convention and specify the template file to use"
-        option :param, desc: "override convention and specify the param file to use"
-        option :variable, desc: "override convention and specify the variable file to use"
+        option :skip, :type => :boolean, :aliases => "-s", :group => :runtime,
+                            :desc => "Skip files that already exist"
       end
     end
 

data/lib/lono/{s3.rb → cli/s3.rb}

@@ -1,23 +1,25 @@
-module Lono
-  class S3 < Command
+class Lono::CLI
+  class S3 < Lono::Command
+    opts = Opts.new(self)
+
     desc "deploy", "deploys lono managed s3 bucket"
     long_desc Help.text("s3/deploy")
     def deploy
-      Bucket.new(options).deploy
+      Lono::Bucket.new(options).deploy
     end
 
     desc "show", "shows lono managed s3 bucket"
     long_desc Help.text("s3/show")
-    option :sure, type: :boolean, desc: "Bypass are you sure prompt"
+    opts.yes
     def show
-      Bucket.new(options).show
+      Lono::Bucket.new(options).show
     end
 
     desc "delete", "deletes lono managed s3 bucket"
     long_desc Help.text("s3/delete")
-    option :sure, type: :boolean, desc: "Bypass are you sure prompt"
+    opts.yes
     def delete
-      Bucket.new(options).delete
+      Lono::Bucket.new(options).delete
     end
   end
 end

data/lib/lono/cli/script/base.rb

@@ -0,0 +1,5 @@
+class Lono::CLI::Script
+  class Base < Lono::CLI::Base
+    SCRIPTS_INFO_PATH = "#{Lono.root}/output/data/scripts_info.txt"
+  end
+end

data/lib/lono/cli/script/build.rb

@@ -0,0 +1,72 @@
+require "digest"
+require "fileutils"
+
+class Lono::CLI::Script
+  class Build < Base
+    # Only avaialble after script has been built.
+    def self.scripts_name
+      new.scripts_name
+    end
+
+    def run
+      reset
+      if Dir["#{@blueprint.root}/scripts/*"].empty?
+        return
+      else
+        puts "Detected scripts"
+      end
+
+      puts "Tarballing scripts folder to scripts.tgz"
+      tarball_path = create_tarball
+      save_scripts_info(tarball_path)
+      puts "Tarball created at #{tarball_path}"
+    end
+
+    # Only avaialble after script has been built.
+    def scripts_name
+      IO.read(SCRIPTS_INFO_PATH).strip
+    end
+
+    def reset
+      FileUtils.rm_f(SCRIPTS_INFO_PATH)
+    end
+
+    def create_tarball
+      # https://apple.stackexchange.com/questions/14980/why-are-dot-underscore-files-created-and-how-can-i-avoid-them
+      # using system to avoid displaying command
+      system "cd #{@blueprint.root}/app && dot_clean ." if system("type dot_clean > /dev/null 2>&1")
+
+      # https://serverfault.com/questions/110208/different-md5sums-for-same-tar-contents
+      # Using tar czf directly results in a new m5sum each time because the gzip
+      # timestamp is included.  So using:  tar -c ... | gzip -n
+      sh "cd #{@blueprint.root}/app && tar -c scripts | gzip -n > scripts.tgz" # temporary scripts.tgz file
+
+      rename_with_md5!
+    end
+
+    # Apppend a md5 to file after it's been created and moves it to
+    # output/scripts/scripts-[MD5].tgz
+    def rename_with_md5!
+      md5_path = "output/#{@blueprint.name}/scripts/scripts-#{md5sum}.tgz"
+      FileUtils.mkdir_p(File.dirname(md5_path))
+      FileUtils.mv("#{@blueprint.root}/scripts.tgz", md5_path)
+      md5_path
+    end
+
+    def save_scripts_info(scripts_name)
+      FileUtils.mkdir_p(File.dirname(SCRIPTS_INFO_PATH))
+      IO.write(SCRIPTS_INFO_PATH, scripts_name)
+    end
+
+    # cache this because the file will get removed
+    def md5sum
+      @md5sum ||= Digest::MD5.file("#{@blueprint.root}/scripts.tgz").to_s[0..7]
+    end
+
+    def sh(command)
+      puts "=> #{command}"
+      system command
+    end
+
+  end
+end

data/lib/lono/cli/script/upload.rb

@@ -0,0 +1,49 @@
+require "filesize"
+
+class Lono::CLI::Script
+  class Upload < Base
+    include Lono::AwsServices
+
+    def run
+      return unless scripts_built?
+
+      upload(tarball_path)
+      puts "Uploaded #{File.basename(s3_dest)} to s3."
+    end
+
+    def upload(tarball_path)
+      puts "Uploading scripts.tgz (#{filesize}) to #{s3_dest}"
+      obj = s3_resource.bucket(bucket_name).object(key)
+      start_time = Time.now
+      obj.upload_file(tarball_path)
+      time_took = pretty_time(Time.now-start_time).color(:green)
+      puts "Time took to upload code to s3: #{time_took}"
+    end
+
+    def filesize
+      Filesize.from(File.size(tarball_path).to_s + " B").pretty
+    end
+
+    def s3_dest
+      "s3://#{bucket_name}/#{key}"
+    end
+
+    def key
+      # Example key: cloudformation/development/scripts/scripts-md5
+      "#{Lono.env}/output/#{@blueprint.name}/scripts/#{File.basename(tarball_path)}"
+    end
+
+    def bucket_name
+      Lono::S3::Bucket.name
+    end
+
+    # Scripts are only built if the app/scripts folder is non empty
+    def scripts_built?
+      File.exist?(SCRIPTS_INFO_PATH) && !tarball_path.empty?
+    end
+
+    def tarball_path
+      IO.read(SCRIPTS_INFO_PATH).strip
+    end
+  end
+end