roro 0.3.30 → 0.3.33

data/lib/roro/configurators/adventure_writer.rb

@@ -11,17 +11,204 @@ module Roro
       no_commands do
 
         def write(buildenv, storyfile)
+          @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
@@ -31,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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'yaml'
 
 module Roro
@@ -19,15 +20,17 @@ module Roro
         @asker     = QuestionAsker.new
         @writer    = AdventureWriter.new
         @env       = @structure[:env]
+        @log       = @structure
       end
 
       def rollon
         validate_stack
         choose_adventure
-        satisfy_dependencies
+        # satisfy_dependencies
         build_env
         write_story
-        structure[:env] = structure[:env].merge(@dependency_hash)
+        # structure[:env] = structure[:env].merge(@dependency_hash)
+        write_log
       end
 
       def validate_stack
@@ -41,14 +44,16 @@ module Roro
       end
 
       def build_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 satisfy_dependencies
+      #   @satisfier = DependencySatisfier.new
+      #   @dependency_hash = @satisfier.satisfy_dependencies(manifest)
+      # end
 
       def accrete_story(story)
         content = read_yaml(story)[:env]
@@ -63,8 +68,59 @@ module Roro
         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.sort.each { |m| @writer.write(@structure, 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

@@ -1,136 +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
+# # 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_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