roro 0.3.28 → 0.3.33

data/lib/roro/configurators/adventure_picker.rb

@@ -3,6 +3,7 @@
 module Roro
   module Configurators
     class AdventurePicker < Thor
+
       include Utilities
 
       attr_reader :inflection
@@ -11,7 +12,7 @@ module Roro
         def choose_adventure(stack)
           build_inflection(stack)
           say("Rolling story on from stack: #{@stack}\n\n")
-          say(@getsome)
+          say(@prompt)
           choice = ask(@inflection)
           story_name = story_from(choice.to_s)
           "#{stack}/#{story_name}"
@@ -22,13 +23,13 @@ module Roro
           prompt = inflection_prompt
           options = inflection_options
           prompt_options = humanize(options)
-          @getsome = "#{prompt}\n"
+          @prompt = "#{prompt}\n"
           @inflection = ["#{prompt_options}\n\n", "Choices: [#{set_color(options.keys.map { |k| k.to_i }.join(' '), :blue)}]"]
         end
 
         def inflection_prompt
           prompt = 'Please choose from these'
-          collection = name(@stack).gsub('_', ' ') + ":\n"
+          collection = stack_name(@stack).gsub('_', ' ') + ":\n"
           [prompt, stack_parent(@stack), collection].join(' ')
         end
 
@@ -36,10 +37,10 @@ module Roro
           stack ||= @stack
           Hash.new.tap do |h|
             children(stack)
-              .map { |f| name(f) }
+              .map { |f| stack_name(f) }
               .sort
               .each_with_index do |c, i|
-              h[(i + 1).to_s] = name(c)
+              h[(i + 1).to_s] = stack_name(c)
             end
           end
         end
@@ -54,9 +55,9 @@ module Roro
         end
 
         def get_story_preface(story)
-          storyfile = "#{story}/#{name(story)}.yml"
+          storyfile = "#{story}/#{stack_name(story)}.yml"
           if stack_is_storyfile?(storyfile)
-            read_yaml("#{story}/#{name(story)}.yml")[:preface]
+            read_yaml("#{story}/#{stack_name(story)}.yml")[:preface]
           else
             nil
           end

data/lib/roro/configurators/adventure_writer.rb

@@ -11,16 +11,206 @@ module Roro
       no_commands do
 
         def write(buildenv, storyfile)
-          @env = buildenv
+          @buildenv = buildenv
+          @storyfile = storyfile
+          @env = buildenv[:env]
+          @env[:force] = true
+          @env[:exit_on_failure] = true
           actions = read_yaml(storyfile)[:actions]
           unless actions.nil?
-            self.source_paths << "#{stack_parent_path(storyfile)}/templates"
             actions.each do |a|
-              eval a
+              self.source_paths.shift
+              self.source_paths << "#{stack_parent_path(storyfile)}/templates"
+              begin
+                eval a
+                if ENV['RORO_DOCUMENT_LAYERS'].eql?('true')
+                  save_layer(storyfile)
+                end
+              rescue
+                raise Error, msg: "#{a} #{storyfile}"
+              end
             end
           end
         end
 
+        def copy_manifest(dir = nil)
+          paths = manifest_paths
+          paths.each do |path|
+            self.source_paths.shift
+            self.source_paths << path
+            begin
+
+              directory '', '.', @env
+            rescue
+              Roro::Error
+            end
+          end
+        end
+
+        # def polish
+        #   if File.exist?('polisher')
+        #     FileUtils.cp_r('polisher/.', '.')
+        #     FileUtils.rm_rf('polisher')
+        #   end
+        # end
+
+        def save_layer(stack)
+          stacks = Roro::CLI.stacks
+          reflector = Reflector.new
+          parent = stack_name(stack.split("#{stacks}/").last).split('.').first
+          @buildenv[:itinerary].each do |i|
+            index = reflector.itinerary_index(@buildenv[:itinerary], i)
+            ['dummy', "layers/#{parent}"].each do |dir|
+              target = "#{stacks}/#{i}/test/#{index}/#{dir}"
+              artifacts = Dir.glob("#{target}/**/{*,.*}")
+              artifacts.map! { |a| a.split("#{target}/").last }.each do |g|
+                t = "#{target}/#{g}"
+                if File.file?(g) && File.exist?(t)
+                  FileUtils.cp(g, t) unless File.read(g).eql?(File.read(t))
+                end
+              end
+            end
+          end
+        end
+
+        def success_response(url, desired_response = '200')
+          actual_response = system("curl -o /dev/null -s -w '%{http_code}\n' http://localhost")
+          raise Roro::Error unless actual_response.eql?(desired_response)
+        end
+
+        def generate_mise
+           generator = Roro::CLI.new
+           generator.generate_mise
+           generator.generate_containers 'app', 'db'
+           generator.generate_environments @env
+           generator.generate_keys
+        end
+
+        def copy_layer(dir)
+          paths = template_paths
+          paths.each do |path|
+            self.source_paths.shift
+            self.source_paths << path
+            begin
+              directory dir, '.', @env
+            rescue
+              Roro::Error
+            end
+          end
+        end
+
+        def epilogue(log)
+          array = []
+          log[:itinerary].each do |i|
+            parent_path = stack_parent_path(i)
+            if stack_parent(i).eql?('versions')
+              keyword = stack_parent(parent_path)
+            else
+              keyword = stack_name(i)
+            end
+            array << keyword
+          end
+          "https://www.handsomefencer.com/tutorials/#{array.join('-')}"
+        end
+
+        def write_log(log)
+          create_file 'mise/log.yml', log.to_yaml
+          say 'Arigato.'
+          say epilogue(log)
+        end
+
+        def section(name)
+          array = []
+          section_partials(name).each do |p|
+            array << read_partial(p)
+          end
+          array.empty? ? (raise Roro::Error) : array.join("\n")
+        end
+
+        def section_partials(name)
+          array = partials.select do  |p|
+            p.match?(/#{name}/)
+          end
+          matchers = array.map { |p| p.split("/partials/#{name}/").last }.uniq
+          innermosts = []
+          matchers.each do |m|
+            duplicates = array.select do |p|
+              p.match? m
+            end
+            innermosts<< duplicates.last
+          end
+          innermosts
+        end
+
+        def partial(name)
+          read_partial(partials.select { |p| p.match?(/_#{name}.*.erb/) }.last)
+        end
+
+        def read_partial(partial)
+          begin
+            ERB.new(File.read(partial)).result(binding) if partial
+          rescue
+            msg = "Missing variable in #{partial}"
+            raise Roro::Error, msg
+          end
+        end
+
+        def partials
+          array = []
+          itinerary = @buildenv[:itinerary]
+          itinerary.each do |file|
+            array += partials_for(file)
+          end
+          array.uniq
+        end
+
+        def partials_for(ancestor = nil, crumbs = nil, paths = [] )
+          if crumbs.nil?
+            origin = Roro::CLI.stacks
+            crumbs = ancestor.split("#{origin}/").last.split('/')
+            ancestor = origin
+          end
+          path = "#{ancestor}/templates/partials"
+          paths += Dir.glob("#{path}/**/_*.erb") if File.exist?(path)
+          if crumbs.empty?
+            paths
+          else
+            partials_for("#{ancestor}/#{crumbs.shift}", crumbs, paths)
+          end
+        end
+
+        def manifest_paths(dir = nil, stack = nil, array = nil, paths = [] )
+          dir   ||= 'manifest'
+          stack ||= Roro::CLI.stacks
+          array ||= @storyfile.split("#{stack}/").last.split('/')
+          path = "#{stack}/templates/#{dir}"
+          if File.exist?(path)
+            paths << path
+          end
+          child = "#{stack}/#{array.shift}"
+          array.empty? ? paths : manifest_paths(dir, child, array, paths)
+        end
+
+        def template_paths_for(stack, array = nil, paths = [] )
+          if array.nil?
+            array ||= stack.split("#{stack}/").last.split('/')
+            stack = Roro::CLI.stacks
+          end
+          path = "#{stack}/templates"
+          if File.exist?(path)
+            paths << path
+          end
+          array.empty? ? paths : template_paths_for("#{stack}/#{array.shift}", array, paths)
+        end
+
+        def template_paths
+          array = []
+          @buildenv[:itinerary].each do |stack|
+            array += template_paths_for(stack)
+          end
+          array.uniq
+        end
+
         def interpolated_stack_path
           "#{@env[:stack]}/#{@env[:story]}"
         end
@@ -28,7 +218,11 @@ module Roro
         def interpolated_story_name
           "#{@env[:story]}"
         end
+
+        def interpolated_app_name
+          @env[:base][:app_name][:value]
+        end
       end
     end
   end
-end
+end

data/lib/roro/configurators/catalog_builder.rb

@@ -10,7 +10,7 @@ module Roro
       end
 
       def self.base
-        Roro::CLI.catalog_root
+        Roro::CLI.stacks
       end
     end
   end

data/lib/roro/configurators/configurator.rb

@@ -5,11 +5,12 @@ require 'yaml'
 module Roro
   module Configurators
     class Configurator
+
       include Utilities
 
       attr_reader :structure, :itinerary, :manifest, :stack, :env
 
-      def initialize(options = {} )
+      def initialize(options = {})
         @options   = options ? options : {}
         @stack     = options[:stack] || CatalogBuilder.build
         @validator = Validator.new(@stack)
@@ -18,13 +19,18 @@ module Roro
         @structure = StructureBuilder.build
         @asker     = QuestionAsker.new
         @writer    = AdventureWriter.new
+        @env       = @structure[:env]
+        @log       = @structure
       end
 
       def rollon
         validate_stack
         choose_adventure
+        # satisfy_dependencies
         build_env
         write_story
+        # structure[:env] = structure[:env].merge(@dependency_hash)
+        write_log
       end
 
       def validate_stack
@@ -34,30 +40,87 @@ module Roro
       def choose_adventure
         @adventure.build_itinerary(@stack)
         @itinerary = @adventure.itinerary
-        @manifest = @adventure.manifest
+        @manifest  = @adventure.manifest
       end
 
       def build_env
-        @env = @structure[:env]
-        manifest.each { |story| accrete_story(story) }
+        manifest.each do |story|
+          accrete_story(story)
+        end
         override_environment_variables
       end
 
+      # def satisfy_dependencies
+      #   @satisfier = DependencySatisfier.new
+      #   @dependency_hash = @satisfier.satisfy_dependencies(manifest)
+      # end
+
       def accrete_story(story)
         content = read_yaml(story)[:env]
-        content.keys.each { |k| @env[k].merge!(content[k]) } if content
+        content.keys.each { |k| @structure[:env][k].merge!(content[k]) } if content
       end
 
       def override_environment_variables
-        @env.each do |e, v| v.each do |k, v|
-            answer = @asker.confirm_default(@builder.override(e, k, v), v)
+        @structure[:env].each do |e, h| h.each do |k, v|
+            answer = @asker.confirm_default(@builder.override(e, k, v), h)
             answer.eql?('') ? return : v[:value] = answer
           end
         end
       end
 
+      # def copy_stage_dummy(stage)
+      #   location = Dir.pwd
+      #   index = itinerary_index(stage).index(itinerary)
+      #   test_dir = "#{stack_parent_path(stage)}/test"
+      #   return unless File.exist?(test_dir)
+      #   stage_dummy = "#{test_dir}/#{index}/dummy"
+      #   generated = Dir.glob("#{location}/**/*")
+      #   dummies = Dir.glob("#{stage_dummy}/**/*")
+      #   dummies.each do |dummy|
+      #     generated.select do |g|
+      #       if dummy.split(stage_dummy).last.match?(g.split(Dir.pwd).last)
+      #         if File.file?(g)
+      #           FileUtils.cp_r(g, "#{stage_dummy}#{g.split(Dir.pwd).last}")
+      #         end
+      #       end
+      #     end
+      #   end
+      # end
+
+      def itinerary_index(stage)
+        itineraries = read_yaml("#{Roro.gem_root}/test/fixtures/matrixes/itineraries.yml")
+        foo = itineraries.select! do |i|
+          i.include?(stack_parent_path(stage.split(Roro::CLI.stacks).last))
+        end
+        foo
+      end
+
       def write_story
-        @manifest.each { |m| @writer.write(@env, m) }
+        @manifest.each do |m|
+          @structure[:itinerary] = @itinerary
+          @writer.write(@structure, m)
+          # copy_stage_dummy(m) if ENV['RORO_ENV'].eql?('test')
+        end
+      end
+
+      def write_log
+        @log[:dependency_hash] = @dependency_hash
+        @log[:itinerary]       = @itinerary
+        @log[:manifest]        = @manifest
+        @log[:stack]           = @stack
+        @log[:structure]       = @structure
+        @writer.write_log(@log)
+      end
+
+      private
+
+      def stage_dummy_index(stack)
+        itineraries = read_yaml("#{Roro::CLI.test_root}/fixtures/matrixes/itineraries.yml")
+        adventures = itineraries.select! do |i|
+          candidate = stack.split(Roro::CLI.stacks).last
+          i.include? stack_parent_path(candidate)
+        end
+        adventures.index(itinerary)
       end
     end
   end

data/lib/roro/configurators/dependency_satisfier.rb

@@ -0,0 +1,135 @@
+# # frozen_string_literal: true
+#
+# require 'os'
+#
+# module Roro
+#   module Configurators
+#     class DependencySatisfier < Thor
+#       include Thor::Actions
+#       include Utilities
+#
+#       attr_reader :dependencies, :checks, :dependencies, :manifest, :builder, :env
+#
+#       no_commands do
+#
+#         def satisfy_dependencies(manifest = [])
+#           @manifest = manifest
+#           @builder = {
+#             actions: [],
+#             env: {}
+#           }
+#           @dependencies = {}.tap do |d|
+#             d.merge!(gather_base_dependencies)
+#             d.merge!(gather_stack_dependencies)
+#           end
+#           gather_checks
+#           checks.each { |c| validate_check(c) }
+#           checks.each { |c| satisfy(c) }
+#           install_dependencies
+#
+#         end
+#
+#         def install_dependencies
+#           actions = @builder[:actions]
+#           actions.each do |a|
+#             eval a
+#           end
+#           @env = @builder[:env] || {}
+#         end
+#
+#         def gather_base_dependencies(stack = Roro::CLI.dependency_root)
+#           {}.tap do |b|
+#             children(stack).each { |c| b.merge!(read_yaml(c)) }
+#           end
+#         end
+#
+#         def gather_stack_dependencies
+#           {}.tap do |b|
+#             manifest.each { |c| b.merge!(read_yaml(c)[:dependencies] || {}) }
+#           end
+#         end
+#
+#         def gather_checks
+#           @checks = []
+#           manifest.each do |f|
+#             read_yaml(f).dig(:depends_on)&.each do |c|
+#               @checks << c
+#             end
+#           end
+#           @checks
+#         end
+#
+#         def validate_check(check)
+#           msg = "No #{check} dependency exists. Please define it before depending on it."
+#           dependencies[check.to_sym] || raise(Roro::Error, msg)
+#         end
+#
+#         def satisfy(check)
+#           d = dependencies[check.to_sym]
+#           return if dependency_met?(check)
+#           help = hint(d, :help)
+#           lucky = hint(d, :lucky)
+#           msg = ["\n\n#{set_color("Missing Dependency", :yellow)}: #{check}"]
+#           if lucky
+#             msg << "        #{set_color("Platform", :yellow)}: #{platform}"
+#             msg << "    #{set_color("Install with", :yellow)}: $ #{lucky.shift}"
+#             lucky.each do |c|
+#             msg << "                  $ #{c}"
+#             end
+#           end
+#           if help
+#             msg << "            Help: #{help}" if help
+#           end
+#           say(msg.join("\n\s\s"))
+#           if lucky && yes?("Do you feel lucky?")
+#             @builder ||= {
+#               actions: [],
+#               env: {}
+#             }
+#             @builder[:env].merge!(d.dig(:env) || {})
+#             @builder[:actions] = @builder[:actions] + lucky
+#           end
+#         end
+#
+#
+#         def hint(hash, key)
+#           hash
+#           case
+#           when OS.linux? && hash.dig(:overrides, platform_for(hash), key )
+#             hash.dig(:overrides, platform_for(hash), key)
+#           when hash.dig(:overrides, platform, key)
+#             hash.dig(:overrides, platform, key)
+#           when hash.dig(key)
+#             hash.dig(key)
+#           end
+#         end
+#
+#         def dependency_met?(command)
+#           system(command.to_s) ? true : false
+#         end
+#
+#         def platform_for(dependency)
+#           overrides = dependency.dig(:overrides)
+#           return if overrides.nil? || overrides.empty?
+#           return platform if overrides.keys.include?(platform)
+#           overrides.select do |key, value|
+#             return key if value.dig(:aliases)&.include?(platform.to_s)
+#           end
+#         end
+#
+#         def platform
+#           case
+#           when OS.linux?
+#             distro
+#           else
+#             OS.host_os.to_sym
+#           end
+#         end
+#
+#         def distro
+#           OS.parse_os_release[:ID].to_sym
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/roro/configurators/question_asker.rb

@@ -13,16 +13,16 @@ module Roro
           answer.size > 1 ? answer : override_default(question)
         end
 
-        def confirm_default(question, default)
+        def confirm_default(question, hash)
           options = { "y": "yes", "n": "no", 'a': 'accept all defaults'}
           humanized_options = options.map {|key, value|
             "(#{key}) #{value}"
           }
           getsome = "Would you like to accept the default value?\n"
           prompt = [question, getsome, humanized_options, "\n"].join("\n")
-          case ask(prompt)
+          case ask(prompt, path: hash[:path])
           when 'y'
-            default
+            hash[:value]
           when 'n'
             override_default(question)
           when 'a'

data/lib/roro/configurators/question_builder.rb

@@ -21,7 +21,7 @@ module Roro
 
       def override_prompt(environment, key, value)
         name = value.dig(:name) || key
-        prompt = "Would you like to accept the default value for #{name}?\n"
+        # prompt = "Would you like to accept the default value for #{name}?\n"
         help = value.dig(:help) ? "#{value.dig(:help)}" : nil
         default = "#{key}=#{value[:value]}"
         ["\nEnvironment: #{environment}",
@@ -42,17 +42,17 @@ module Roro
 
       def inflection_prompt
         prompt = 'Please choose from these'
-        collection = name(@inflection).gsub('_', ' ') + ":\n"
+        collection = stack_name(@inflection).gsub('_', ' ') + ":\n"
         [prompt, stack_parent(@inflection), collection].join(' ')
       end
 
       def inflection_options
         Hash.new.tap do |h|
           children(@inflection)
-            .map { |f| name(f) }
+            .map { |f| stack_name(f) }
             .sort
             .each_with_index do |c, i|
-            h[(i + 1).to_s] = name(c)
+            h[(i + 1).to_s] = stack_name(c)
           end
         end
       end
@@ -67,9 +67,9 @@ module Roro
       end
 
       def get_story_preface(story)
-        storyfile = "#{story}/#{name(story)}.yml"
+        storyfile = "#{story}/#{stack_name(story)}.yml"
         if stack_is_storyfile?(storyfile)
-          read_yaml("#{story}/#{name(story)}.yml")[:preface]
+          read_yaml("#{story}/#{stack_name(story)}.yml")[:preface]
         else
           nil
         end