lono 7.5.2 → 8.0.0.pre.rc1

data/lib/lono/jade/circular.rb

@@ -1,26 +0,0 @@
-class Lono::Jade
-  module Circular
-    def check_for_circular_dependency!
-      circular = circular_dependency?
-      return unless circular
-
-      puts "ERROR: jade circular dependency detected".color(:red)
-      puts "circular dependency: #{parent_names.join(" => ")}"
-      exit 1
-    end
-
-    def circular_dependency?
-      parent_names.uniq.size != parent_names.size
-    end
-
-    def parent_names
-      names = [self.name] # include initial jade name to detect circular dependency earlier
-      parent = registry.parent
-      while parent
-        names << parent.name
-        parent = parent.registry.parent
-      end
-      names
-    end
-  end
-end

data/lib/lono/jade/materializer/final.rb

@@ -1,10 +0,0 @@
-class Lono::Jade::Materializer
-  class Final
-    def build(jades)
-      return if jades.empty?
-      list = jades.map(&:name).uniq.join(", ") # possible to have different versions. only showing names and removing duplicates
-      puts "Materializing #{list}..."
-      GemsBuilder.new(jades).build
-    end
-  end
-end

data/lib/lono/jade/materializer/gems_builder.rb

@@ -1,81 +0,0 @@
-require 'open3'
-
-class Lono::Jade::Materializer
-  class GemsBuilder
-    extend Memoist
-
-    def initialize(*jades)
-      @jades = jades.flatten
-      @build_root = "#{Lono.root}/tmp/jades"
-    end
-
-    def build
-      puts "GemsBuilder#build materializing #{@jades.map(&:name)}" if ENV['LONO_DEBUG']
-      remove_gemfile
-      gemfile = build_gemfile(@jades)
-      return unless gemfile
-      write(gemfile)
-      bundle
-    end
-
-    def build_gemfile(jades)
-      return if jades.empty?
-
-      lines = []
-      jades.each do |jade|
-        return if local_exist?(jade)
-        args = source.gem_args(jade)
-        line = %Q|gem #{args}|
-        lines << line unless lines.include?(line)
-      end
-      lines.sort!
-      lines.join("\n") + "\n"
-    end
-
-    def bundle
-      Bundler.with_unbundled_env do
-        bundle_install
-      end
-    end
-
-    def bundle_install
-      command = "cd #{@build_root} && bundle install"
-      puts "=> #{command}" if ENV['LONO_DEBUG']
-      stdout, stderr, status = Open3.capture3(command)
-
-      unless status.success?
-        names = @jades.map(&:name)
-        gem_text = names.size == 1 ? "gem" : "gems"
-        puts "Fail to build #{gem_text} #{names.join(', ')}".color(:red)
-        puts "Failed running => #{command}"
-        puts stdout
-        puts stderr
-        if stderr.include?("correct access rights")
-          puts "Are you sure you have access to the git repo and the repo exists?".color(:yellow)
-        end
-        exit 1
-      end
-    end
-
-    # When a local version is found, will use that version
-    def local_exist?(jade)
-      !!jade.finder.find(jade.name, local_only: true)
-    end
-
-    def write(gemfile)
-      path = "#{@build_root}/Gemfile"
-      FileUtils.mkdir_p(File.dirname(path))
-      IO.write(path, gemfile)
-    end
-
-    def remove_gemfile
-      FileUtils.rm_f("#{@build_root}/Gemfile")
-      FileUtils.rm_f("#{@build_root}/Gemfile.lock")
-    end
-
-    def source
-      Source.new
-    end
-    memoize :source
-  end
-end

data/lib/lono/jade/materializer/source.rb

@@ -1,54 +0,0 @@
-class Lono::Jade::Materializer
-  class Source
-    def initialize(lono_settings=nil)
-      @lono_settings = lono_settings || Lono::Setting.new.data
-    end
-
-    # String provide to gem method in Gemfile.  Example:
-    #
-    #      gem "mygem", "v0.1.0", git: "xxx"
-    #
-    def gem_args(jade)
-      args = jade.registry.args
-      args = args.map { |s| %Q|"#{s}"| }.join(', ')
-
-      options = options(jade)
-      options = options.inject([]) { |r,(k,v)| r << %Q|#{k}: "#{v}"| }.join(', ')
-
-      "#{args}, #{options}"
-    end
-
-    def options(jade)
-      registry = jade.registry
-      options = registry.gem_options
-      # Direct source provided as part of configset call
-      #
-      #    configset("ssm", git: "https://github.com/owner/ssm")
-      #    configset("ssm", path: "/path/to/ssm")
-      #    configset("ssm", source: "https://rubygems.org")
-      #
-      if options.key?(:git) || options.key?(:path) || options.key?(:source)
-        return(options)
-      end
-
-      # Otherwise use the sources location settings, which does not include the repo name
-      materalized_options = if location.include?("git@") || location.include?("https")
-        {git: "#{location}/#{jade.repo}"}
-      else
-        {path: "#{location}/#{jade.repo}"}
-      end
-      materalized_options.merge(options)
-    end
-
-    def location
-      ENV["LONO_MATERIALIZED_GEMS_SOURCE"] ||
-      Lono::Configset::Register::Blueprint.source ||
-      settings["source"] ||
-      "git@github.com:boltopspro" # default_location
-    end
-
-    def settings
-      @lono_settings.dig("materialized_gems") || {}
-    end
-  end
-end

data/lib/lono/jade/materializer.rb

@@ -1,15 +0,0 @@
-require "bundler"
-
-class Lono::Jade
-  class Materializer
-    extend Memoist
-
-    def initialize(jade)
-      @jade = jade
-    end
-
-    def build
-      Materializer::GemsBuilder.new(@jade).build
-    end
-  end
-end

data/lib/lono/jade/registry.rb

@@ -1,64 +0,0 @@
-class Lono::Jade
-  class Registry
-    attr_reader :args, :options
-    attr_accessor :caller_line, :parent, :depends_on
-    def initialize(args, options)
-      @args, @options = args, options
-    end
-
-    def name
-      @args.first
-    end
-
-    def gem_options
-      options = @options.dup
-      # Delete special options that is not supported by bundler Gemfile
-      options.delete(:repo)
-      options.delete(:resource) # configset
-      options.delete(:vars) # configset
-      options
-    end
-
-    # configset
-    def resource
-      @options[:resource]
-    end
-
-    def resource=(v)
-      @options[:resource] = v
-    end
-
-    def vars
-      options[:vars] || {}
-    end
-
-    class_attribute :tracked_configsets, default: []
-    class_attribute :downloaded_configsets, default: []
-    class_attribute :tracked_extensions, default: []
-    class_attribute :downloaded_extensions, default: []
-
-    class << self
-      def register_configset(args, options)
-        registry = new(args, options)
-        jade_type = determine_jade_type(caller)
-        jade = Lono::Jade.new(registry.name, jade_type, registry)
-        self.tracked_configsets << jade
-        registry
-      end
-
-      def determine_jade_type(caller)
-        if caller.detect { |l| l =~ %r{config/configsets.rb} }
-          'blueprint/configset'
-        else
-          'configset'
-        end
-      end
-
-      def register_extension(args, options)
-        registry = new(args, options)
-        self.tracked_extensions << registry
-        registry
-      end
-    end
-  end
-end

data/lib/lono/jade.rb

@@ -1,110 +0,0 @@
-module Lono
-  class Jade
-    include Circular
-    extend Memoist
-
-    delegate :source_type, to: :jadespec
-
-    attr_accessor :dependencies, :from, :depends_ons
-    attr_reader :name, :type, :registry, :jadespec
-    def initialize(name, type, registry={})
-      # type: one of blueprint, configset, blueprint/configset
-      # registry holds either original registry from configset definition or parent jade which can be used to get the original configset defintion
-      @name, @type, @registry = name, type, registry
-      @materialized = false
-      @resolved = false
-      @depends_ons = []
-    end
-
-    def repo
-      @registry.options[:repo] || @name
-    end
-
-    # root is kind of special. root is needed for materialization but can accidentally get called too early
-    # before materialization. So treat it specially with an error.
-    def root
-      raise "ERROR: root is not available until jade has been materialized" unless @jadespec
-      @jadespec.root
-    end
-
-    def dependencies
-      @depends_ons.map do |registry|
-        jade = Lono::Jade.new(registry.depends_on, registry.parent.type, registry) # not same sig as register_configset?
-        Lono::Jade::Registry.tracked_configsets << jade
-        jade
-      end
-    end
-
-    def resource_from_parent
-      parent = registry.parent # using local variable intentionally
-      resource = nil
-      while parent # go all the way to the highest parent
-        resource = parent.registry.resource
-        parent = parent.registry.parent
-      end
-      resource
-    end
-
-    def materialize
-      @jadespec = finder.find(@name)
-      download unless @jadespec
-      # Pretty tricky. Flush memoized finder(true) since download changes filesystem. Not memoizing at all is 2x slower
-      @jadespec = finder(true).find(@name)
-      return nil unless @jadespec
-      if @jadespec.source_type == "materialized"
-        # possible "duplicated" jade instances with same name but will uniq in final materialized Gemfile
-        case @jadespec.lono_type
-        when "configset"
-          Lono::Jade::Registry.downloaded_configsets << self
-        when "extension"
-          Lono::Jade::Registry.downloaded_extensions << self
-        end
-      end
-      evaluate_meta_rb
-      @jadespec
-    end
-    memoize :materialize
-
-    # Must return config to set @jadespec in materialize
-    # Only allow download of Lono::Blueprint::Configset::Jade
-    # Other configsets should be configured in project Gemfile.
-    #
-    # Cases:
-    #
-    #    1a) blueprint/configset top-level - download
-    #    1b) blueprint/configset depends_on - download
-    #    2a) configset top-level - dont download, will report to user with validate_all!
-    #    2b) configset depends_on - download
-    #    3) extension - download
-    #
-    def download
-      return if finder.find(@name, local_only: true) # no need to download because locally found
-      return unless %w[blueprint/configset configset extension].include?(@type)
-      # Comment out. Unsure if this complexity is worth it. Always download jades.
-      # Only download jades that came from depends_on
-      # return unless @registry.parent || %w[blueprint/configset extension].include?(@type)
-      materializer = Materializer.new(self)
-      materializer.build
-    end
-    memoize :download
-
-    def evaluate_meta_rb
-      return unless %w[blueprint/configset configset].include?(@type)
-      meta = Lono::Configset::Meta.new(self)
-      meta.evaluate
-    end
-
-    def resolved!
-      @resolved = true
-    end
-
-    def resolved?
-      @resolved
-    end
-
-    def finder
-      "Lono::Finder::#{@type.camelize}".constantize.new
-    end
-    memoize :finder
-  end
-end

data/lib/lono/jadespec.rb

@@ -1,68 +0,0 @@
-require "rubygems"
-
-module Lono
-  class Jadespec
-    extend Memoist
-
-    attr_accessor :from
-    attr_reader :root, :source_type
-    def initialize(root, source_type)
-      @root, @source_type = root, source_type
-    end
-
-    def name
-      exist? ? gemspec.name : "not gemspec file found for @root: #{@root}"
-    end
-
-    def exist?
-      !!gemspec_file
-    end
-
-    def gemspec
-      Gem::Specification::load(gemspec_file)
-    end
-    memoize :gemspec
-
-    def gemspec_file
-      Dir.glob("#{@root}/*.gemspec").first
-    end
-
-    def lono_type
-      deprecation_check(metadata)
-      metadata["lono_type"] || detect_type
-    end
-
-    def detect_type
-      configset = Dir.glob("#{@root}/lib/configset.*").size > 0
-      configset ? "configset" : "blueprint"
-    end
-
-    def lono_strategy
-      deprecation_check(metadata)
-      return metadata["lono_strategy"] if metadata["lono_strategy"]
-      lono_type == "blueprint" ? "dsl" : "erb" # TODO: default to dsl for configset also in next major release
-    end
-
-    # backward-compatiable for now
-    def auto_camelize
-      metadata["lono_auto_camelize"] || false
-    end
-
-    def metadata
-      gemspec.metadata || {}
-    end
-    memoize :metadata
-
-  private
-    @@deprecation_check_shown = {}
-    def deprecation_check(metadata)
-      return unless ENV['LONO_DEPRECATION_SOFT']
-      return if @@deprecation_check_shown[name]
-
-      unless metadata["lono_type"]
-        puts "DEPRECATION WARNING: lono_type is not set for #{name}".color(:yellow)
-      end
-      @@deprecation_check_shown[name] = true
-    end
-  end
-end

data/lib/lono/new/helper.rb

@@ -1,15 +0,0 @@
-module Lono::New::Helper
-  private
-  def project_class_name
-    project_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 underscored_name
-    project_name.underscore
-  end
-
-  # project_name is also available from new.rb:
-  #   argument :project_name
-end

data/lib/lono/new.rb

@@ -1,95 +0,0 @@
-module Lono
-  class New < Sequence
-    include Helper
-
-    argument :project_name
-
-    # Ugly, but when the class_option is only defined in the Thor::Group class
-    # it doesnt show up with cli-template new help :(
-    # If anyone knows how to fix this let me know.
-    # Also options from the cli can be pass through to here
-    def self.cli_options
-      [
-        [:bundle, type: :boolean, default: true, desc: "Runs bundle install on the project"],
-        [:demo, type: :boolean, default: false, desc: "Also generate demo blueprint"],
-        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files."],
-        [:git, type: :boolean, default: true, desc: "Git initialize the project"],
-        [:type, default: "dsl", desc: "Blueprint type: dsl or erb"],
-      ]
-    end
-
-    cli_options.each do |args|
-      class_option(*args)
-    end
-
-    # for specs
-    def set_cwd
-      @cwd = Dir.pwd
-    end
-
-    def create_project
-      puts "=> Creating new project called #{project_name}."
-      directory ".", "#{@cwd}/#{project_name}"
-    end
-
-    def create_starter_blueprint
-      return unless @options[:demo]
-      # https://github.com/erikhuda/thor/wiki/Invocations
-      Lono::Blueprint::New.start(["demo", "--from-new", "--type", @options[:type], "--project-name", project_name])
-    end
-
-    # After this commands are executed with the newly created project
-    def set_destination_root
-      destination_root = "#{@cwd}/#{project_name}"
-      self.destination_root = destination_root
-      FileUtils.cd(self.destination_root)
-    end
-
-    def make_executable
-      chmod("exe", 0755 & ~File.umask, verbose: false) if File.exist?("exe")
-    end
-
-    def git_init
-      return if File.exist?(".git") # this is a clone repo
-      run_git_init
-    end
-
-    def bundle_install
-      return unless options[:bundle]
-
-      puts "=> Installing dependencies with: bundle install"
-      Bundler.with_unbundled_env do
-        system("BUNDLE_IGNORE_CONFIG=1 bundle install")
-      end
-    end
-
-    def git_commit
-      run_git_commit
-    end
-
-    def welcome_message
-      puts <<~EOL
-        #{"="*64}
-        Congrats 🎉 You have successfully created a lono project.  Check things out by going into the created infra folder.
-
-            cd #{project_name}
-
-        To create a new blueprint run:
-
-            lono blueprint new demo
-
-        To deploy the blueprint:
-
-            lono cfn deploy my-demo --blueprint demo
-
-        If you name the stack according to conventions, you can run:
-
-            lono cfn deploy demo
-
-        To list and create additional blueprints refer to https://lono.cloud/docs/core/blueprints
-
-        More info: https://lono.cloud/
-      EOL
-    end
-  end
-end

data/lib/lono/param.rb

@@ -1,14 +0,0 @@
-module Lono
-  class Param < Command
-    class_option :verbose, type: :boolean
-    class_option :noop, type: :boolean
-    class_option :mute, type: :boolean
-
-    desc "generate BLUEPRINT", "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)
-      Generator.new(options.merge(blueprint: blueprint)).generate
-    end
-  end
-end

data/lib/lono/pro/base.rb

@@ -1,16 +0,0 @@
-require "text-table"
-
-class Lono::Pro
-  class Base
-    extend Memoist
-
-    def initialize(options={})
-      @options = options
-    end
-
-    def api
-      Lono::Api::Client.new
-    end
-    memoize :api
-  end
-end

data/lib/lono/pro/repo.rb

@@ -1,28 +0,0 @@
-class Lono::Pro
-  class Repo < Base
-    def run
-      data = api.repos(@options[:type])
-      # data = data[7..9]
-      header = ["Name", "Docs", "Description"]
-      rows = data.map do |d|
-        desc = truncate(d[:description])
-        [d[:name], d[:docs_url], desc]
-      end
-      show_table(header, rows)
-    end
-
-  private
-    def truncate(string, max=36)
-      string.length > max ? "#{string[0...max]}..." : string
-    end
-
-    def show_table(header, data)
-      table = Text::Table.new
-      table.head = header
-      data.each do |item|
-        table.rows << item
-      end
-      puts table
-    end
-  end
-end

data/lib/lono/pro.rb

@@ -1,15 +0,0 @@
-module Lono
-  class Pro < Lono::Command
-    desc "blueprints", "Lists available BoltOps Pro blueprints"
-    long_desc Help.text("pro/blueprints")
-    def blueprints
-      Repo.new(options.merge(type: "blueprint")).run
-    end
-
-    desc "configsets", "Lists available BoltOps Pro configsets"
-    long_desc Help.text("pro/configsets")
-    def configsets
-      Repo.new(options.merge(type: "configset")).run
-    end
-  end
-end

data/lib/lono/project_checker.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-module Lono
-  # Checks to see command is running in a lono project.
-  # If not, provide a friendly message and possibly exit.
-  class ProjectChecker
-    class << self
-      @@checked = false
-      def check
-        return if @@checked
-
-        unless File.exist?("#{Lono.root}/configs/settings.yml")
-          puts "ERROR: Could not find configs/settings.yml file. Are you sure you are in lono project?".color(:red)
-          quit 1
-        end
-
-        @@checked = true
-      end
-
-      # Dont exit for this one. It's okay. But show a warning.
-      def empty_templates
-        if Dir["#{Lono.config.templates_path}/**/*"].empty?
-          puts "INFO: The app/templates folder does not contain any lono template definitions.".color(:yellow)
-        end
-      end
-
-      def quit(signal)
-        if ENV['LONO_TEST'] == '1'
-          signal == 0 || raise("Not in lono project. pwd: #{Dir.pwd}")
-        else
-          exit(signal)
-        end
-      end
-    end
-  end
-end

data/lib/lono/registration/base.rb

@@ -1,37 +0,0 @@
-class Lono::Registration
-  class Base
-    extend Memoist
-
-    def initialize(options={})
-      @options = options
-    end
-
-    # Same api call for temp_key and registration_key
-    def request_verification(info)
-      with_safety do
-        api.verify(info)
-      end
-    end
-
-    def get_temp_key
-      with_safety do
-        api.temp_key # grab temp registration key
-      end
-    end
-
-    def with_safety
-      yield
-    rescue Errno::ECONNREFUSED, Errno::EAFNOSUPPORT
-      raise if Lono::API != Lono::API_DEFAULT
-    end
-
-    def api
-      Lono::Api::Client.new
-    end
-    memoize :api
-
-    def say(msg)
-      puts msg if @options[:cli]
-    end
-  end
-end