lono 6.1.11 → 7.0.0

data/lib/lono/importer/service/coder.rb

@@ -0,0 +1,81 @@
+require 'base64'
+require 'json'
+require 'net/http'
+
+class Lono::Importer::Service::Coder
+  def initialize(template, options={})
+    @template, @options = template, options
+  end
+
+  def translate
+    url = "#{Lono::API}/code"
+    http = net_http_client(url)
+    req = net_http_request(url,
+      template: Base64.encode64(@template), # Base64 JSON for special chars that Rack::LintWrapper cannot process
+      lono_version: Lono::VERSION,
+      lono_command: lono_command,
+    )
+    res = http.request(req) # send request
+
+    if res.code == "200"
+      data = JSON.load(res.body)
+      ruby_code = print(data) # returns data["ruby_code"] / passthrough
+      ruby_code
+    else
+      puts "Error: Unable to convert template to Ruby code."
+      puts "The error has been reported."
+      puts "Non-successful http response status code: #{res.code}"
+      # puts "headers: #{res.each_header.to_h.inspect}"
+      exit 1
+    end
+  end
+
+private
+  def print(data)
+    return if ENV['LONO_PRO_TEST']
+
+    if data["error"]
+      # Code was processed but there was this error with an HTTP 200 OK
+      $stderr.puts "ERROR: #{data["error"]}".color(:red)
+      if data["message"]
+        $stderr.puts data["message"]
+      end
+      return
+    end
+
+    validity = data["valid_ruby"] ? "valid" : "invalid"
+    if validity == "valid"
+      $stderr.puts "INFO: The generated Ruby code is has #{validity} syntax."
+    else
+      $stderr.puts "WARN: The generated Ruby code is has #{validity} syntax. Providing because it may be small errors.".color(:yellow) # note redirection disables color
+    end
+
+    $stderr.puts <<~EOL
+      Translated ruby code below:
+
+    EOL
+    ruby_code = data["ruby_code"]
+    puts ruby_code
+    ruby_code
+  end
+
+  def net_http_client(url)
+    uri = URI(url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.open_timeout = http.read_timeout = 30
+    http.use_ssl = true if uri.scheme == 'https'
+    http
+  end
+
+  def net_http_request(url, data)
+    req = Net::HTTP::Post.new(url) # url includes query string and uri.path does not, must used url
+    text = JSON.dump(data)
+    req.body = text
+    req.content_length = text.bytesize
+    req
+  end
+
+  def lono_command
+    "#{$0} #{ARGV.join(' ')}"
+  end
+end

data/lib/lono/inspector/base.rb

@@ -1,30 +1,25 @@
 module Lono::Inspector
-  class Base
-    delegate :required_parameters, :optional_parameters, :parameters, :data,
-             to: :output_template
-
+  class Base < Lono::AbstractBase
     extend Memoist
-    include Lono::Blueprint::Root
 
-    def initialize(blueprint, template, options)
-      @blueprint, @template, @options = blueprint, template, options
+    def run
+      generate
+      templates = @template_name ? [@template_name] : all_templates
+      templates.each do |template_name|
+        perform(template_name)
+      end
     end
 
-    def run
-      blueprints = Lono::Blueprint::Find.one_or_all(@blueprint)
-      blueprints.each do |blueprint|
-        @blueprint = blueprint # intentional overwrite
+    def generate
+      if @options[:source]
+        Lono::Cfn::Download.new(@options).run
+      else
         generate_templates
-        set_blueprint_root(blueprint)
-        templates = @template_name ? [@template_name] : all_templates
-        templates.each do |template_name|
-          perform(template_name)
-        end
       end
     end
 
     def generate_templates
-      Lono::Template::Generator.new(@blueprint, @options.clone.merge(quiet: false)).run
+      Lono::Template::Generator.new(@options.merge(quiet: false)).run
     end
 
     def all_templates
@@ -33,10 +28,5 @@ module Lono::Inspector
         path.sub("#{templates_path}/", '').sub('.yml','') # template_name
       end
     end
-
-    def output_template
-      Lono::OutputTemplate.new(@blueprint, @template)
-    end
-    memoize :output_template
   end
 end

data/lib/lono/inspector/graph.rb

@@ -3,7 +3,7 @@ require "graph"
 
 module Lono::Inspector
   class Graph < Base
-    def initialize(blueprint, template, options)
+    def initialize(options={})
       super
       @nodes = [] # lookup map
     end

data/lib/lono/inspector/summary.rb

@@ -1,5 +1,8 @@
 module Lono::Inspector
   class Summary < Base
+    delegate :required_parameters, :optional_parameters, :parameters, :parameter_groups, :data,
+             to: :output_template
+
     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
@@ -8,34 +11,50 @@ module Lono::Inspector
       return if @options[:noop]
 
       print_parameters_summary
-
-      puts "Resources:"
+      puts "# Resources:"
       print_resource_types
     end
 
     def print_parameters_summary
       if parameters.empty?
         puts "There are no parameters in this template."
-      else
-        print_parameters("Required Parameters (#{required_parameters.size})", required_parameters)
-        print_parameters("Optional Parameters (#{optional_parameters.size})", optional_parameters)
+        return
+      end
+
+      shown = []
+      puts "# Parameters Total (#{parameters.size})"
+      parameter_groups.each do |label, parameters|
+        puts "# Parameter Group (#{parameters.size}): #{label}"
+        parameters.each do |name|
+          puts parameter_line(name)
+          shown << name
+        end
+      end if output_template.parameter_groups
+
+      parameters.each do |name, data|
+        puts parameter_line(name) unless shown.include?(name)
       end
     end
 
-    def print_parameters(label, parameters)
-      puts "#{label}:"
-      if parameters.empty?
-        text = label.downcase.include?("required") ? "required" : "optional"
-        puts "  There are no #{text} parameters."
+    def parameter_line(name)
+      data = parameters[name]
+      example = description_example(data["Description"])
+      if data["Default"].nil?
+        line = "#{name}=#{example} # (required)"
       else
-        parameters.each do |logical_id, p|
-          output = "  #{logical_id} (#{p["Type"]})"
-          if p["Default"]
-            output << " Default: #{p["Default"]}"
-          end
-          puts output
-        end
+        default = data["Default"]
+        line = "# #{name}=#{default}"
+        line = "#{line} # #{example}" if example
       end
+      line
+    end
+
+    def description_example(description)
+      default = ''
+      return default unless description
+      md = description.match(/(Example|IE): (.*)/)
+      return default unless md
+      md[2]
     end
 
     def resource_types
@@ -62,5 +81,10 @@ module Lono::Inspector
       end
       printf "%3s %s\n", resource_types.size, "Total"
     end
+
+    def output_template
+      Lono::Output::Template.new(@blueprint, @template)
+    end
+    memoize :output_template
   end
 end

data/lib/lono/jade.rb

@@ -0,0 +1,103 @@
+module Lono
+  class Jade
+    include Circular
+    extend Memoist
+    class_attribute :tracked
+    self.tracked = []
+    class_attribute :downloaded
+    self.downloaded = []
+
+    delegate :template_type, :auto_camelize, :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 = []
+      self.class.tracked << self
+    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|
+        Lono::Jade.new(registry.depends_on, registry.parent.type, registry)
+      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
+        self.class.downloaded << self
+      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.
+    def download
+      return if finder.find(@name, local_only: true) # no need to download because locally found
+      # 4 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
+      return unless %w[blueprint/configset configset].include?(@type) # TODO: support materializing nested blueprints later
+      # only download jades that came from depends_on
+      return unless @registry.parent || @type == "blueprint/configset"
+      jade = Lono::Configset::Materializer::Jade.new(self)
+      jade.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/jade/circular.rb

@@ -0,0 +1,26 @@
+class Lono::Jade
+  module Circular
+    def check_for_circular_dependency!
+      circular = circular_dependency?
+      return unless circular
+
+      puts "ERROR: configset 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/jadespec.rb

@@ -0,0 +1,41 @@
+require "rubygems"
+
+module Lono
+  class Jadespec
+    extend Memoist
+
+    delegate :name, to: :gemspec
+
+    attr_accessor :from
+    attr_reader :root, :source_type
+    def initialize(root, source_type)
+      @root, @source_type = root, source_type
+    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 template_type
+      metadata[:template_type] || "dsl"
+    end
+
+    def auto_camelize
+      metadata[:auto_camelize] || false
+    end
+
+    def metadata
+      gemspec.metadata.deep_symbolize_keys
+    end
+    memoize :metadata
+  end
+end

data/lib/lono/new.rb

@@ -58,7 +58,7 @@ module Lono
       return unless options[:bundle]
 
       puts "=> Installing dependencies with: bundle install"
-      Bundler.with_clean_env do
+      Bundler.with_unbundled_env do
         system("BUNDLE_IGNORE_CONFIG=1 bundle install")
       end
     end
@@ -88,7 +88,7 @@ module Lono
 
         To list and create additional blueprints refer to https://lono.cloud/docs/core/blueprints
 
-        More info: http://lono.cloud/
+        More info: https://lono.cloud/
       EOL
     end
   end

data/lib/lono/opts.rb

@@ -0,0 +1,43 @@
+# Note moving this under Lono::CLI::Opts messes with the zeitwerk autoloader.
+# A weird workaround is calling Lono::CLI::Opts right after the autoloader and then it seems to fix itself.
+# It may be because there's a custom infleciton cli => CLI. Unsure.
+# Unsure if there are other side-effects with the workaround so named this:
+# 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 Opts
+    def initialize(cli)
+      @cli = cli
+    end
+
+    def clean
+      with_cli_scope do
+        option :clean, type: :boolean, default: true, desc: "remove all output files before generating"
+      end
+    end
+
+    def source
+      with_cli_scope do
+        option :source, desc: "url or path to file with template"
+      end
+    end
+
+    def stack
+      with_cli_scope do
+        option :stack, desc: "stack name. defaults to blueprint name."
+      end
+    end
+
+    def template
+      with_cli_scope do
+        option :template, desc: "override convention and specify the template file to use"
+      end
+    end
+
+  private
+    def with_cli_scope(&block)
+      @cli.instance_eval(&block)
+    end
+  end
+end