roro 0.3.22 → 0.3.23

data/lib/roro/cli/rollon.rb

@@ -1,147 +1,20 @@
 module Roro
   class CLI < Thor
 
-    class << self
-      private
-      def shared_options!
-        method_option :omakase, desc: "Use the Roro setup with some configuring. 'Omakase' translates as 'I'll leave it up to you.'", aliases: ['-d', '--default']
-        method_option :fatsutofodo, desc: 'Use the Roro setup without having to think.', aliases: ['-f', '--fast']
-        method_option :okonomi, desc: "Use Roro how you like. 'Okonomi' has the opposite meaning of omakase.", aliases: ['-i', '--interactive'] 
-      end
-  
-      alias_method :orig_desc, :desc
-  
-      def desc(*args)
-        orig_desc(*args)
-        shared_options!
-      end
-    end
-    rollonto = ' into Roro.'
-    desc "rollon", "Roll an existing app#{rollonto}"
-    def rollon(args={})
-      @config ||= Roro::Configuration.new(args, options) 
-      greenfield_actions 
-      greenfield_commands
-      manifest_actions
-      manifest_intentions
-      congratulations
-      startup_commands 
-    end
-    
-    desc "greenfield", "Greenfield a new app and roll it#{rollonto}"
-    def greenfield(args={})
-      args[:greenfield] = :greenfield
-
-      rollon(args)
-    end
-    
-    desc "greenfield::rails", "Greenfield a new Rails app and roll it#{rollonto}"
-  
-    map "greenfield::rails" => "greenfield_rails"
-    
-    def greenfield_rails
-      greenfield( { story: :rails } )
-    end
-    
-    desc "rollon::rails", "Roll an existing app#{rollonto}"
-    map "rollon::rails" => "rollon_rails"
-    
-    def rollon_rails(args={}) 
-      rollon( { story: :rails } )
-    end
-    
-    desc "rollon::rails::kubernetes", "Adds Kubernetes for production."
-    map "rollon::rails::kubernetes" => "rollon_rails_kubernetes"
-    
-    def rollon_rails_kubernetes(args={}) 
-      story = { 
-        rails: [
-          { database: :postgresql },
-          { kubernetes: :postgresql },
-          { ci_cd: :circleci}
-        ] 
-      }  
-      rollon( { story: story } )
-    end
+    desc 'rollon', 'Roll a fresh development story into the current directory.'
+    map 'rollon' => 'rollon'
 
-    desc "greenfield::rails::kubernetes", "Adds Kubernetes for production."
-    map "greenfield::rails::kubernetes" => "greenfield_rails_kubernetes"
-    
-    def greenfield_rails_kubernetes(args={}) 
-      story = { 
-        rails: [
-          { database: :postgresql },
-          { kubernetes: :postgresql },
-          { ci_cd: :circleci}
-        ] 
-      }  
-      rollon( { story: story } )
+    def rollon
+      configurator = Roro::Configurators::Configurator.new
+      configurator.rollon
     end
 
-    no_commands do 
-      
-      def configure_for_rollon(aroptions=nil)
-        @config ||= Roro::Configuration.new(options) 
-      end
-
-      def manifest_actions
-        @config.structure[:actions].each {|a| eval a }
-      end
-      
-      def manifest_intentions
-        @config.intentions.each {|k, v| eval(k.to_s) if v.eql?('y') }  
-      end 
-      
-      def greenfield_actions 
-        return unless @config.structure[:greenfield_actions] 
-        @config.structure[:greenfield_actions].each {|a| eval a }
-      end 
-      
-      def greenfield_commands 
-        return unless @config.structure[:greenfield_actions] 
-        @config.structure[:greenfield_commands].each {|a| eval a }
-      end
+    desc 'log itineraries', 'logs all possible itineraries in specified location'
+    map 'log_itineraries' => 'log_itineraries'
 
-      def congratulations(story=nil)
-        ( @config.story[:rollon]) 
-        if @config.structure[:greenfield]
-          usecase = 'greenfielded a new '
-        else 
-          usecase = 'rolled your existing ' 
-        end 
-        array = ["You've successfully "]
-        array << usecase
-        congrats = array.join("") 
-        puts congrats
-      end
-      
-      def startup_commands
-        congratulations( @config.story[:rollon])
-        cmd = @config.structure[:startup]
-        commands = cmd[:commands] 
-        question = []
-        question << "\n\n You can start your app up with some combination of these commands:\n"
-        commands.each { |c| question << "\t#{c}"}
-        question << "\nOr if you'd like Roro to try and do it for you:"
-        question = question.join("\n")
-        if ask(question, default: 'y', limited_to: ['y', 'n']).eql?("y")
-          commands.each {|a| system(a) }
-          puts "\n\n#{cmd[:success]}\n\n" 
-        end
-      end
-      
-      def yaml_from_template(file)
-        File.read(find_in_source_paths(file))
-      end
-      
-      def generate_config_story
-        roro_story = {
-          story: @config.story,
-          env_vars: @config.env,
-          intentions: @config.intentions
-        }
-        create_file ".roro_story.yml", roro_story.to_yaml 
-      end
+    def log_itineraries(location = 'test/fixtures/itineraries')
+      builder = Roro::Configurators::AdventureCaseBuilder.new
+      builder.log_itineraries('test/fixtures/itineraries')
     end
   end
-end
+end

data/lib/roro/cli.rb

@@ -1,34 +1,41 @@
+# frozen_string_literal: true
 
-require 'roro/cli/generate/generate_exposed'
-require 'roro/cli/generate/generate_keys'
-require 'roro/cli/generate/generate_obfuscated'
-require 'roro/cli/generate/generate_story'
-require 'roro/cli/greenfield/rails'
-require 'roro/cli/rollon'
-require 'roro/cli/rollon/rails/base/base'
-require 'roro/cli/rollon/rails/database/with_mysql'
-require 'roro/cli/rollon/rails/database/with_postgresql'
-require 'roro/cli/rollon/ruby_gem'
+require_relative 'cli/rollon'
+require_relative 'cli/generate/generate_containers'
+require_relative 'cli/generate/generate_environments'
+require_relative 'cli/generate/generate_exposed'
+require_relative 'cli/generate/generate_keys'
+require_relative 'cli/generate/generate_mise'
+require_relative 'cli/generate/generate_obfuscated'
 
 module Roro
   class CLI < Thor
-
     include Thor::Actions
-    
+
     def self.source_root
-      File.dirname(__FILE__) + '/templates'
+      "#{@template_root || File.dirname(__FILE__)}/templates"
+    end
+
+    def self.catalog_root
+      "#{File.dirname(__FILE__)}/stacks/catalog/unstoppable/developer_styles"
     end
-    
-    def self.story_root
-      File.dirname(__FILE__) + '/stories'
+
+    def self.mise_location
+      lookup = Dir.glob("#{Dir.pwd}/**/*.roro")&.first&.split("#{Dir.pwd}/")
+      if lookup
+        mise = lookup.last.split('/').first
+      else
+        mise = 'roro'
+      end
+      "#{Dir.pwd}/#{mise}"
+    end
+
+    def self.mise
+      mise_location.split("#{Dir.pwd}/").last
     end
-    
-    def self.test_fixture_root 
-      File.dirname(__FILE__) + '/test/fixtures'
-    end 
-    
-    def self.roro_environments 
-      %w(development production test staging ci)
+
+    def self.roro_environments
+      %w[base development production test staging ci]
     end
   end
 end

data/lib/roro/common/file_reflection.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Roro
+  module FileReflection
+
+    def source_files(dir, pattern)
+      Dir.glob("#{dir}/**/*#{pattern}")
+    end
+
+    def gather_environments(dir, ext)
+      environments = source_files(dir, ext).map do |file|
+        file.split('/').last.split('.').first
+      end
+      if environments.empty?
+        raise Roro::Error, "No #{ext} files in #{dir}"
+      else
+        environments.uniq
+      end
+    end
+
+    def get_key(environment, _dir = Roro::CLI.mise)
+      env_key = "#{environment.upcase}_KEY"
+      key_file = Dir.glob("#{Roro::CLI.mise}/keys/#{environment}.key").first
+      if ENV[env_key]
+        ENV[env_key]
+      elsif key_file
+        File.read(key_file).strip
+      else
+        raise Roro::Error, "No #{env_key} set. Please set one as a variable or in a file."
+      end
+    end
+  end
+end

data/lib/roro/common/utilities.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+require 'json'
+require 'yaml'
+
+module Roro
+  module Utilities
+
+    def stack_type(stack)
+      case
+      when stack_not_present?(stack)
+        :nonexistent
+      when stack_is_ignored?(stack)
+        :ignored
+      when stack_is_dotfile?(stack)
+        :dotfile
+      when stack_is_storyfile?(stack)
+        :storyfile
+      when stack_is_templates?(stack)
+        :templates
+      when stack_is_inflection?(stack)
+        :inflection
+      when stack_is_stack?(stack)
+        :stack
+      when stack_is_story?(stack)
+        :story
+      end
+    end
+
+    def stack_is_stack?(stack)
+      children(stack).any? do |c|
+        stack_is_inflection?(c) || stack_is_story?(c)
+      end
+    end
+
+    def stack_is_story?(stack)
+      children(stack).any? { |c| story_name(stack).eql?(file_name(c)) }
+    end
+
+    def stack_is_file?(stack)
+      File.file?(stack)
+    end
+
+    def stack_is_dotfile?(stack)
+      stack_is_file?(stack) &&
+        %w[keep gitkeep].include?(file_extension(stack))
+    end
+
+    def stack_is_storyfile?(stack)
+      stack_is_file?(stack) &&
+        %w[yml yaml].include?(file_extension(stack))
+    end
+
+    def stack_unpermitted?(stack)
+      stack_is_file?(stack) &&
+        !stack_is_storyfile?(stack) &&
+        !stack_is_dotfile?(stack)
+    end
+
+    def stack_is_inflection?(stack)
+      stack_stories(stack).empty? &&
+        !File.file?(stack) &&
+        !stack_is_ignored?(stack) &&
+        !stack_is_templates?(stack)
+    end
+
+    def story_is_empty?(story)
+      stack_is_storyfile?(story) &&
+        !read_yaml(story)
+    end
+
+    def stack_not_present?(stack)
+      !File.exist?(stack)
+    end
+
+    def stack_is_nil?(stack)
+      !File.exist?(stack)
+    end
+
+    def stack_is_story_path?(stack)
+      !stack_is_parent?(stack) &&
+        !stack_is_templates?(stack) &&
+        stack_is_node?(stack)
+    end
+
+    def stack_is_itinerary_path?(stack)
+      !stack_is_parent?(stack) &&
+        !stack_is_templates?(stack) &&
+        stack_is_node?(stack)
+    end
+
+    def stack_is_parent?(stack)
+      children(stack).any? { |c| stack_is_inflection?(c) }
+    end
+
+    def story_paths(stack)
+      children(stack).select { |c| stack_is_story_path?(c) }
+    end
+
+    def stack_stories(stack)
+      children(stack).select { |c| stack_is_storyfile?(c) }
+    end
+
+    def stack_is_templates?(stack)
+      stack.split('/').last.match?('templates')
+    end
+
+    def stack_is_ignored?(stack)
+      ignored = %w[test_dummy story_test test]
+      ignored.include?(stack.split('/').last)
+    end
+
+    def all_inflections(stack)
+      children(stack).select { |c| stack_is_inflection?(c) }
+    end
+
+    def children(stack)
+      Dir.glob("#{stack}/*")
+    end
+
+    def stack_is_node?(stack)
+      children(stack).any? { |w| w.include?('.yml') } && !stack_is_templates?(stack)
+    end
+
+    def stack_parent(stack)
+      tree = stack.split('/')
+      tree[-2]
+    end
+
+    def stack_parent_path(stack)
+      stack.split("/#{name(stack)}").first
+    end
+
+    def stack_is_empty?(stack)
+      !stack_is_file?(stack) &&
+        Dir.glob("#{stack}/**").empty?
+    end
+
+    def build_paths(stack, story_paths = nil)
+      story_paths ||= []
+      story_paths << stack if stack_is_story_path?(stack)
+      children(stack).each { |c| build_paths(c, story_paths) }
+      story_paths
+    end
+
+    def sanitize(hash)
+      (hash ||= {}).transform_keys!(&:to_sym).each do |key, value|
+        case value
+        when Array
+          value.each { |vs| sanitize(vs) }
+        when Hash
+          sanitize(value)
+        when true
+          hash[key] = true
+        when String || Symbol
+          hash[key] = value.to_sym
+        end
+      end
+    end
+
+    def name(stack)
+      stack.split('/').last
+    end
+
+    def file_name(story_file)
+      story_file.split('/').last.split('.').first
+    end
+
+    def file_extension(file)
+      file.split('.').last
+    end
+
+    def story_name(stack)
+      stack.split('/').last
+    end
+
+
+    def sentence_from(array)
+      array[1] ? "#{array[0..-2].join(', ')} and #{array[-1]}" : array[0]
+    end
+
+    def read_yaml(yaml_file)
+      JSON.parse(YAML.load_file(yaml_file).to_json, symbolize_names: true)
+    end
+  end
+end

data/lib/roro/configurator.rb

@@ -1,15 +1,15 @@
-require 'roro/configurator/eligibility'
-require 'roro/configurator/okonomi'
-require 'roro/configurator/omakase'
+# frozen_string_literal: true
+
+require_relative 'configurators/utilities'
+require_relative 'configurators/adventure_case_builder'
+require_relative 'configurators/adventure_chooser'
+require_relative 'configurators/adventure_writer'
+require_relative 'configurators/adventure_picker'
+require_relative 'configurators/question_asker'
+require_relative 'configurators/question_builder'
+require_relative 'configurators/configurator'
+require_relative 'configurators/catalog_builder'
+require_relative 'configurators/structure_builder'
+require_relative 'configurators/validator'
+
 
-module Roro 
-  module Configurator 
-    include Eligibility
-    include Okonomi
-    include Omakase
-  end
-  
-  class Configuration < Thor
-    include Roro::Configurator
-  end
-end

data/lib/roro/configurators/adventure_case_builder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Roro
+  module Configurators
+    class AdventureCaseBuilder
+
+      attr_reader :cases, :itineraries
+
+      def initialize(catalog=nil)
+        @catalog = catalog || Roro::CLI.catalog_root
+      end
+
+      def build_cases(stack, cases = [], array = [], position = 0 )
+        @base ||= stack
+
+        children(stack).each_with_index do |child, index|
+          if stack_type(stack).eql?(:inflection)
+            choice = "#{child.split(@base).last}"
+            next unless [:stack, :story].include?(stack_type(child))
+            case
+            when children(stack).last.eql?(child)
+              array = array.take(position)
+              array << choice
+              cases << array
+            when array.size.eql?(position)
+              array << choice
+            when array.size.eql?(position + 1)
+              cases << array
+              array = array.take(position)
+              array << choice
+            # when array.size.eql?(position - 1)
+            #   array = array.take(position)
+            when array.size.eql?(position + 2)
+              array = array.take(position)
+            else
+              cases << array
+              # array = array.take(position)
+            end
+            # position += 1
+          end
+          build_cases( child, cases, array, (position - index) + 1)
+        end
+        cases.uniq.sort
+      end
+
+      def build_itineraries(catalog)
+        @itineraries ||= []
+        @itineraries += build_itinerary(catalog)
+        children(catalog).each { |c| build_itineraries(c) }
+        @itineraries
+      end
+
+      private
+
+      def build_itinerary(catalog)
+        itinerary = []
+        all_inflections(catalog).each do |inflection|
+          paths = story_paths(inflection).map { |p| [p] }
+          itinerary = itinerary.empty? ? paths : itinerary.product(paths)
+        end
+        itinerary.map(&:flatten)
+      end
+    end
+  end
+end

data/lib/roro/configurators/adventure_chooser.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Roro
+  module Configurators
+    class AdventureChooser
+      include Utilities
+
+      attr_reader :itinerary, :stack, :manifest
+
+      def initialize
+        @asker     = AdventurePicker.new
+        @itinerary = []
+        @stack     = Roro::CLI.catalog_root
+      end
+
+      def build_itinerary(stack=nil)
+        @manifest ||= []
+        stack ||= @stack
+        case stack_type(stack)
+        when :storyfile
+          @manifest << stack
+        when :story
+          @manifest += stack_stories(stack)
+        when :stack
+          @manifest += stack_stories(stack)
+          children(stack).each { |c| build_itinerary(c) }
+        when :inflection
+          child = choose_adventure(stack)
+          @itinerary << child if stack_type(child).eql?(:story)
+          build_itinerary(child)
+        end
+        @manifest.uniq!
+        @itinerary.uniq!
+      end
+
+      def stack_is_alias?(catalog)
+        stack_is_storyfile?(catalog) &&
+          !read_yaml(catalog)[:aliased_to].nil?
+      end
+
+      def choose_adventure(inflection)
+        @asker.choose_adventure(inflection)
+      end
+    end
+  end
+end

data/lib/roro/configurators/adventure_picker.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Roro
+  module Configurators
+    class AdventurePicker < Thor
+      include Utilities
+
+      attr_reader :inflection
+
+      no_commands do
+        def choose_adventure(stack)
+          build_inflection(stack)
+          choice = ask(@inflection)
+          story_name = story_from(choice.to_s)
+          "#{stack}/#{story_name}"
+        end
+
+        def build_inflection(stack)
+          @stack = stack
+          prompt = inflection_prompt
+          options = inflection_options
+          prompt_options = humanize(options)
+          @inflection = ["#{prompt} #{prompt_options}", limited_to: options.keys]
+        end
+
+        def inflection_prompt
+          prompt = 'Please choose from these'
+          collection = name(@stack).gsub('_', ' ') + ":\n"
+          [prompt, stack_parent(@stack), collection].join(' ')
+        end
+
+        def inflection_options(stack = nil)
+          stack ||= @stack
+          Hash.new.tap do |h|
+            children(stack)
+              .map { |f| name(f) }
+              .sort
+              .each_with_index do |c, i|
+              h[(i + 1).to_s] = name(c)
+            end
+          end
+        end
+
+        def humanize(hash)
+          array = []
+          hash.map do |key, value|
+            preface = get_story_preface("#{@stack}/#{value}")
+            array << "\n(#{key}) #{value}:\n #{preface}"
+          end
+          array.join
+        end
+
+        def get_story_preface(story)
+          storyfile = "#{story}/#{name(story)}.yml"
+          if stack_is_storyfile?(storyfile)
+            read_yaml("#{story}/#{name(story)}.yml")[:preface]
+          else
+            nil
+          end
+        end
+
+        def story_from(key)
+          inflection_options[key]
+        end
+      end
+    end
+  end
+end

data/lib/roro/configurators/adventure_writer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Roro
+  module Configurators
+    class AdventureWriter < Thor
+      include Thor::Actions
+      include Utilities
+
+      attr_reader :itinerary, :stack, :manifest
+
+      no_commands do
+
+        def write(buildenv, storyfile)
+          @env = buildenv
+          actions = read_yaml(storyfile)[:actions]
+          unless actions.nil?
+            self.source_paths << "#{stack_parent_path(storyfile)}/templates"
+            actions.each do |a|
+              eval a
+            end
+          end
+        end
+
+        def interpolated_stack_path
+          "#{@env[:stack]}/#{@env[:story]}"
+        end
+
+        def interpolated_story_name
+          "#{@env[:story]}"
+        end
+      end
+    end
+  end
+end