lono 6.1.11 → 7.0.0

data/lib/lono/configset/evaluate_file.rb

@@ -0,0 +1,8 @@
+class Lono::Configset
+  module EvaluateFile
+    def evaluate_file(path)
+      return unless path && File.exist?(path)
+      instance_eval(IO.read(path), path)
+    end
+  end
+end

data/lib/lono/configset/list.rb

@@ -0,0 +1,67 @@
+require "text-table"
+
+class Lono::Configset
+  class List
+    def initialize(options={})
+      @options = options
+      @stack, @blueprint, @template, @param = Lono::Conventions.new(options).values
+    end
+
+    def run
+      if @blueprint
+        blueprint_configsets
+      else
+        project_configsets
+      end
+    end
+
+    def project_configsets
+      Lono::Finder::Configset.list(filter_materialized: true, message: "Project configsets:")
+    end
+
+    def blueprint_configsets
+      Lono::Configset::Preparer.new(@options).run # register and materialize gems
+
+      @final ||= []
+
+      project = Lono::Configset::Register::Project.new(@options)
+      project.register
+      finder = Lono::Finder::Configset.new
+      finder.list("Configsets available to project and can used with configs:") if @options[:verbose]
+      puts "Configsets project is using for the #{@blueprint} blueprint:" if @options[:verbose]
+      show(project.configsets, finder.find_all, "project")
+
+      blueprint = Lono::Configset::Register::Blueprint.new(@options)
+      blueprint.register
+      finder = Lono::Finder::Blueprint::Configset.new
+      finder.list("Configsets available to #{@blueprint} blueprint:") if @options[:verbose]
+      puts "Configsets built into the blueprint:" if @options[:verbose]
+      show(blueprint.configsets, finder.find_all, "blueprint")
+
+      table = Text::Table.new
+      table.head = ["Name", "Path", "Type", "From"]
+      @final.each do |spec|
+        pretty_root = spec.root.sub("#{Lono.root}/",'')
+        table.rows << [spec.name, pretty_root, spec.source_type, spec.from]
+      end
+
+      if table.rows.empty?
+        puts "No configsets being used."
+      else
+        puts "Configsets used by #{@blueprint.color(:green)} blueprint:"
+        puts table
+      end
+    end
+
+    def show(configsets, all, from)
+      configsets.each do |c|
+        puts "    #{c.name}" if @options[:verbose]
+        spec = all.find { |jadespec| jadespec.name == c.name }
+        next unless spec
+        spec.from = from
+        @final << spec
+      end
+      puts "" if @options[:verbose]
+    end
+  end
+end

data/lib/lono/configset/loader.rb

@@ -0,0 +1,98 @@
+require "json"
+
+class Lono::Configset
+  class Loader
+    extend Memoist
+    include Dsl
+    include EvaluateFile
+
+    def initialize(registry={}, options={})
+      @registry, @options = registry, options
+      @name, @resource = registry.name, registry.resource
+      @blueprint = Lono::Conventions.new(options).blueprint
+    end
+
+    def metdata_configset
+      load
+    end
+
+    def load
+      path = find_path
+      copy_instance_variables
+      content = RenderMePretty.result(path, context: self)
+      if File.extname(path) == ".yml"
+        load_yaml(content)
+      else
+        JSON.load(content)
+      end
+    end
+    memoize :load
+
+    def load_yaml(content)
+      # Write to file so can use Yamler::Validator
+      path = "/tmp/lono/configset.yml"
+      FileUtils.mkdir_p(File.dirname(path))
+      IO.write(path, content)
+      Lono::Yamler::Validator.new(path).validate!
+      Lono::Yamler::Loader.new(content).load
+    end
+
+    def find_path
+      paths = %w[configset.yml configset.json].map { |p| "#{configset_root}/lib/#{p}" }
+      paths.find { |p| File.exist?(p) }
+    end
+
+    def configset_root
+      config = finder_class.find(@name)
+      unless config
+        puts "finder_class #{finder_class}"
+        raise "Unable to find configset #{@name.inspect}"
+      end
+      config.root
+    end
+
+    # Allow overriding in subclasses
+    def finder_class
+      Lono::Finder::Configset
+    end
+
+    def copy_instance_variables
+      load_blueprint_predefined_variables
+      load_project_predefined_variables
+      load_inline_project_variables
+    end
+
+    def load_blueprint_predefined_variables
+      path = "#{configset_root}/lib/variables.rb"
+      evaluate_file(path)
+    end
+
+    def load_project_predefined_variables
+      paths = [
+        "#{Lono.root}/configs/#{@blueprint}/configsets/variables.rb", # global
+        "#{Lono.root}/configs/#{@blueprint}/configsets/#{@name}/variables.rb", # configset specific
+      ]
+      paths.each do |path|
+        evaluate_file(path)
+      end
+    end
+
+    # Copy options from the original configset call as instance variables so its available. So:
+    #
+    #   configset("ssm", resource: "Instance", some_var: "test")
+    #
+    # Stores in the Configset::Registry
+    #
+    #   register = {name: "ssm", resource: "Instance", some_var: "test"}
+    #
+    # That has is passed into Loader.new(register, options)
+    #
+    # So these @registry varibles are copied over to instance variables.
+    #
+    def load_inline_project_variables
+      @registry.vars.each do |k,v|
+        instance_variable_set("@#{k}", v)
+      end
+    end
+  end
+end

data/lib/lono/configset/loader/dsl.rb

@@ -0,0 +1,9 @@
+class Lono::Configset::Loader
+  module Dsl
+    def indent(text, indentation_amount)
+      text.split("\n").map do |line|
+        " " * indentation_amount + line
+      end.join("\n")
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Lono::Configset::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/configset/materializer/gems_builder.rb

@@ -0,0 +1,81 @@
+require 'open3'
+
+module Lono::Configset::Materializer
+  class GemsBuilder
+    extend Memoist
+
+    def initialize(*jades)
+      @jades = jades.flatten
+      @build_root = "#{Lono.root}/tmp/configsets"
+    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_original_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?".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/configset/materializer/jade.rb

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

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

@@ -0,0 +1,54 @@
+module Lono::Configset::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/configset/meta.rb

@@ -0,0 +1,19 @@
+class Lono::Configset
+  class Meta
+    extend Memoist
+    include EvaluateFile
+    include Dsl
+
+    class_attribute :registries
+    self.registries = []
+
+    def initialize(jade)
+      @jade = jade
+    end
+
+    def evaluate
+      path = "#{@jade.root}/lib/meta.rb"
+      evaluate_file(path) # DSL depends_on sets @jade.depends_on decorated options
+    end
+  end
+end

data/lib/lono/configset/meta/dsl.rb

@@ -0,0 +1,12 @@
+class Lono::Configset::Meta
+  module Dsl
+    def depends_on(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      registry = Lono::Configset::Registry.new(args, options)
+      registry.depends_on = args.first
+      registry.parent = @jade
+      already_has = @jade.depends_ons.detect { |d| d.name == registry.name && d.args == registry.args }
+      @jade.depends_ons << registry unless already_has
+    end
+  end
+end

data/lib/lono/configset/new.rb

@@ -0,0 +1,84 @@
+class Lono::Configset
+  class New < Lono::Sequence
+    include Lono::Blueprint::Helper
+
+    argument :configset_name
+
+    def self.source_root
+      templates = File.expand_path("../../templates", File.dirname(__FILE__))
+      "#{templates}/configset"
+    end
+
+    def self.cli_options
+      [
+        [:demo, type: :boolean, default: true, desc: "Include demo template"],
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files."],
+      ]
+    end
+
+    cli_options.each do |args|
+      class_option(*args)
+    end
+
+    # for specs
+    def set_cwd
+      @cwd = ENV['LONO_TEST'] ? File.dirname(Lono.root) : "#{Dir.pwd}/app/configsets"
+    end
+
+    def set_variables
+      @demo = @options[:demo]
+      @demo = false if ENV["LONO_ORG"] # overrides --demo CLI option
+    end
+
+    def create_project
+      puts "=> Creating new configset called #{configset_name}."
+      if @demo
+        options = {}
+      else
+        create_file "#{@cwd}/#{configset_name}/lib/configset.yml"
+        options = {exclude_pattern: %r{configset\.yml}}
+      end
+
+      directory ".", "#{@cwd}/#{configset_name}", options
+    end
+
+    def create_license
+      return unless ENV['LONO_LICENSE_FILE']
+      copy_file ENV['LONO_LICENSE_FILE'], "#{@cwd}/#{configset_name}/LICENSE.txt"
+    end
+
+    # After this commands are executed with the newly created project
+    def set_destination_root
+      destination_root = "#{@cwd}/#{configset_name}"
+      self.destination_root = destination_root
+      @old_dir = Dir.pwd # for reset_current_dir
+      FileUtils.cd(self.destination_root)
+    end
+
+    def welcome_message
+      puts <<~EOL
+        #{"="*64}
+        Congrats 🎉 You have successfully created a lono configset.
+
+        Cd into your configset and check things out.
+
+            cd #{configset_name}
+
+        More info: https://lono.cloud/docs/core/configsets
+
+      EOL
+    end
+
+    def tree
+      tree_installed = system("type tree > /dev/null")
+      return unless tree_installed
+
+      structure = `tree .`
+      puts <<~EOL
+        Here is the structure of your configset:
+
+        #{structure}
+      EOL
+    end
+  end
+end