lono 7.5.1 → 8.0.0.pre.rc2

data/lib/lono/inspector/graph.rb

@@ -1,125 +0,0 @@
-require "yaml"
-require "graph"
-
-module Lono::Inspector
-  class Graph < Base
-    def initialize(options={})
-      super
-      @nodes = [] # lookup map
-    end
-
-    def perform(template)
-      # little dirty but @template is used in data method so we dont have to pass it to the data method
-      @template = template
-
-      puts "Generating dependencies tree for template #{@template}..."
-      return if @options[:noop]
-
-      # First loop through top level nodes and build set depends_on property
-      node_list = [] # top level node list
-      resources = data["Resources"]
-      resources.each do |logical_id, resource|
-        node = Node.new(logical_id)
-        node.depends_on = normalize_depends_on(resource)
-        node.resource_type = normalize_resource_type(resource)
-        node_list << node
-      end
-
-      # Now that we have loop through all the top level resources once
-      # we can use the depends_on attribute on each node and set the
-      # children property since the identity nodes are in memory.
-      node_list.each do |node|
-        node.children = normalize_children(node_list, node)
-      end
-
-      # At this point we have a tree of nodes.
-      if @options[:display] == "text"
-        puts "CloudFormation Dependencies:"
-        node_list.each { |node| print_tree(node) }
-      else
-        print_graph(node_list)
-        puts "CloudFormation Dependencies graph generated."
-      end
-    end
-
-    # normalized DependOn attribute to an Array of Strings
-    def normalize_depends_on(resource)
-      dependencies = resource["DependOn"] || []
-      [dependencies].flatten
-    end
-
-    def normalize_resource_type(resource)
-      type = resource["Type"]
-      type.sub("AWS::", "") # strip out AWS to make less verbose
-    end
-
-    # It is possible with bad CloudFormation templates that the dependency is not
-    # resolved, but we wont deal with that.  Users can validate their CloudFormation
-    # template before using this tool.
-    def normalize_children(node_list, node)
-      kids = []
-      node.depends_on.each do |dependent_logical_id|
-        node = node_list.find { |n| n.name == dependent_logical_id }
-        kids << node
-      end
-      kids
-    end
-
-    def print_tree(node, depth=0)
-      spacing = "  " * depth
-      puts "#{spacing}#{node.name}"
-      node.children.each do |node|
-        print_tree(node, depth+1)
-      end
-    end
-
-    def print_graph(node_list)
-      check_graphviz_installed
-      digraph do
-        # graph_attribs << 'size="6,6"'
-        node_attribs << lightblue << filled
-
-        node_list.each do |n|
-          node(n.graph_name)
-          n.children.each do |child|
-            edge n.graph_name, child.graph_name
-          end
-        end
-
-        random = (0...8).map { (65 + rand(26)).chr }.join
-        path = "/tmp/cloudformation-depends-on-#{random}"
-        save path, "png"
-        # Check if open command exists and use it to open the image.
-        system "open #{path}.png" if system("type open > /dev/null 2>&1")
-      end
-    end
-
-    # Check if Graphiz is installed and prints a user friendly message if it is not installed.
-    # Provide instructions if on macosx.
-    def check_graphviz_installed
-      installed = system("type dot > /dev/null 2>&1") # dot is a command that is part of the graphviz package
-      unless installed
-        puts "It appears that the Graphviz is not installed.  Please install it to generate the graph."
-        if RUBY_PLATFORM =~ /darwin/
-          puts "You can install Graphviz with homebrew:"
-          puts "    brew install graphviz"
-        end
-        exit 1
-      end
-    end
-
-    class Node
-      attr_accessor :name, :resource_type, :children, :depends_on
-      def initialize(name)
-        @name = name
-        @children = []
-        @depends_on = []
-      end
-
-      def graph_name
-        type = "(#{resource_type})" if resource_type
-        [name, type].compact.join("\n")
-      end
-    end
-  end
-end

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