roro 0.3.22 → 0.3.23

data/lib/roro/configurators/catalog_builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Roro
+  module Configurators
+    class CatalogBuilder
+      attr_reader :structure
+
+      def self.build(override=nil)
+        override || self.base
+      end
+
+      def self.base
+        Roro::CLI.catalog_root
+      end
+    end
+  end
+end

data/lib/roro/configurators/configurator.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Roro
+  module Configurators
+    class Configurator
+      include Utilities
+
+      attr_reader :structure, :itinerary, :manifest, :stack, :env
+
+      def initialize(options = {} )
+        @options   = options ? options : {}
+        @stack     = options[:stack] || CatalogBuilder.build
+        @validator = Validator.new(@stack)
+        @adventure = AdventureChooser.new
+        @builder   = QuestionBuilder.new
+        @structure = StructureBuilder.build
+        @asker     = QuestionAsker.new
+        @writer    = AdventureWriter.new
+      end
+
+      def rollon
+        validate_stack
+        choose_adventure
+        build_env
+        write_story
+      end
+
+      def validate_stack
+        @validator.validate(@stack)
+      end
+
+      def choose_adventure
+        @adventure.build_itinerary(@stack)
+        @itinerary = @adventure.itinerary
+        @manifest = @adventure.manifest
+      end
+
+      def build_env
+        @env = @structure[:env]
+        manifest.each { |story| accrete_story(story) }
+        override_environment_variables
+      end
+
+      def accrete_story(story)
+        content = read_yaml(story)[:env]
+        content.keys.each { |k| @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[:value] = answer unless answer.eql?('y')
+          end
+        end
+      end
+
+      def write_story
+        @manifest.each { |m| @writer.write(@env, m) }
+      end
+    end
+  end
+end

data/lib/roro/configurators/eligibility.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Roro
+  module Configurators
+    module Eligibility
+      def screen_target_directory
+        @structure[:greenfield] ? confirm_directory_empty : confirm_directory_app
+        handle_roro_artifacts
+      end
+
+      def confirm_directory_app
+        confirm_dependency({
+                             system_query: 'ls -A',
+                             warning: "This is an empty directory. You can generate a new and fully
+            dockerized Rails backend using the 'omakase' command here here but if
+            you want to containerize an existing backend -- which is what the 'rollon'
+            command is for -- you'll need to navigate to a directory with an backend we
+            can roll onto.",
+                             suggestion: '$ roro omakase',
+                             conditional: "!Dir.glob('*').empty?"
+                           })
+      end
+
+      def confirm_directory_empty
+        confirm = confirm_dependency({
+                                       system_query: 'ls -A',
+                                       warning: 'this is not an empty directory. Roro will not omakase a new Rails backend unless either a) the current directory is empty or b) you run omakase with the --force flag',
+                                       suggestion: '$ roro omakase --force',
+                                       conditional: "Dir.glob('*').empty?" # || (Dir.glob('*').size.eql?(1) && Dir.glob('roro_configurator.yml'))"
+                                     })
+        confirm || true
+      end
+
+      def artifacts?
+        @appname = @env[:main_app_name]
+        @artifacts = {}
+        hash = {
+          containers: {
+            list: "docker ps --filter name=#{@appname}\ -a",
+            remove: ' -q | xargs docker stop | xargs docker rm -f'
+          },
+          volumes: {
+            list: "docker volume ls --filter name=#{@appname}*",
+            remove: ' -q | xargs docker volume rm -f'
+          },
+          networks: {
+            list: "docker network ls --filter name=#{@appname}",
+            remove: ' -q | xargs docker network rm'
+          },
+          images: {
+            list: "docker image ls #{@appname}*",
+            remove: ' -q | xargs docker rmi -f'
+          }
+        }
+        hash.each do |k, v|
+          check = IO.popen("#{v[:list]} -q").count.positive?
+          @artifacts[k] = v if check
+        end
+        true if @artifacts.empty?
+      end
+
+      def handle_roro_artifacts
+        return if artifacts?
+
+        question = [
+          "\n\nThis machine has some docker artifacts which may clash with ",
+          "RoRo moving forward. You can verify their existence with:\n"
+        ]
+        @artifacts.each { |_k, v| question << "\t$ #{v[:list]}" }
+        question << "\nYou can remove these artifacts with something like:\n"
+        @artifacts.each { |_k, v| question << "\t$ #{v[:list]} #{v[:remove]}" }
+        question << "\nWould you like RoRo to attempt to remove them for you?"
+        choices = { 'y' => 'Yes', 'n' => 'No' }
+
+        choices.each { |k, v| question << "(#{k}) #{v}" }
+
+        prompt = question.join
+        answer = ask(prompt, default: 'y', limited_to: choices.keys)
+
+        if answer.eql?('y')
+
+          @artifacts.each do |k, v|
+            puts "Attempting to remove #{k}"
+            system(v[:list] + v[:remove])
+          end
+        end
+      end
+
+      def confirm_dependency(options)
+        msg = []
+        msg << ''
+        msg << delineator
+        msg << "It looks like #{options[:warning]}. The following bash command returns false:"
+        msg << "\t$ #{options[:system_query]}"
+        msg << 'Try this:'
+        msg << ("\t#{options[:suggestion]}")
+        msg << delineator
+        conditional = options[:conditional] ? eval(options[:conditional]) : system(options[:system_query])
+        query = options[:system_query]
+        if conditional == false
+
+          raise Roro::Error, msg.join("\n\n")
+        else
+          true
+        end
+      end
+
+      def confirm_dependencies
+        dependencies.each do |dependency|
+          confirm_dependency(dependency)
+        end
+      end
+
+      private
+
+      def delineator
+        ('-' * 80)
+      end
+
+      def dependencies
+        [
+          {
+            system_query: 'which docker',
+            warning: "Docker isn't installed",
+            suggestion: 'https://docs.docker.com/install/'
+          }, {
+            system_query: 'which docker-compose',
+            warning: "Docker Compose isn't installed",
+            suggestion: 'https://docs.docker.com/compose/install/'
+          }, {
+            system_query: 'docker info',
+            warning: "the Docker daemon isn't running",
+            suggestion: 'https://docs.docker.com/config/daemon/#start-the-daemon-manually'
+          }
+        ]
+      end
+    end
+  end
+end

data/lib/roro/configurators/question_asker.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Roro
+  module Configurators
+    class QuestionAsker < Thor
+
+      include Thor::Actions
+
+      no_commands do
+        def override_default(question)
+          prompt = "Please supply a value:"
+          answer = ask([question, prompt].join("\n"))
+          answer.size > 1 ? answer : override_default(question)
+        end
+
+        def confirm_default(question)
+          options = { "y": "yes", "n": "no"}
+          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")
+          answer = ask(prompt, limited_to: options.keys.map(&:to_s))
+          answer.eql?('n') ? override_default(question) : 'y'
+        end
+      end
+    end
+  end
+end

data/lib/roro/configurators/question_builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Roro
+  module Configurators
+    class QuestionBuilder
+
+      attr_reader :question, :storyfile, :inflection
+
+      def initialize(args={})
+        case
+        when args[:inflection]
+          @inflection = args[:inflection]
+        when args[:storyfile]
+          @storyfile = args[:storyfile]
+        end
+      end
+
+      def override(environment, key, value, override_value=nil)
+        @question = "#{override_prompt(environment, key, value)}"
+      end
+
+      def override_prompt(environment, key, value)
+        name = value.dig(:name) || key
+        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}",
+         "       name: #{name}",
+         "        key: #{key}",
+         "   variable: #{value[:value]}",
+         "    default: #{default}",
+         "       help: #{help}\n"
+        ].join("\n")
+      end
+
+      def build_inflection
+        prompt = inflection_prompt
+        options = inflection_options
+        prompt_options = humanize(options)
+        @question = ["#{prompt} #{prompt_options}", limited_to: options.keys]
+      end
+
+      def inflection_prompt
+        prompt = 'Please choose from these'
+        collection = 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) }
+            .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("#{@inflection}/#{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

data/lib/roro/configurators/structure_builder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Roro
+  module Configurators
+    class StructureBuilder
+      attr_reader :structure
+
+      def self.build(override=nil)
+        base.merge(override ||= {})
+      end
+
+      def self.base
+        @structure = {
+          actions: [''],
+          env: {
+            base: {},
+            development: {},
+            staging: {},
+            production: {}
+          },
+          preface: '',
+          questions: [
+            {
+              question: '',
+              help: '',
+              action: ''
+            }
+          ],
+          success: ''
+        }
+      end
+    end
+  end
+end

data/lib/roro/configurators/utilities.rb

@@ -0,0 +1,188 @@
+# # frozen_string_literal: true
+# require 'json'
+# require 'yaml'
+#
+# module Roro
+#   module Configurators
+#
+#     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
+# end

data/lib/roro/configurators/validator.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Roro
+  module Configurators
+    class Validator
+      include Utilities
+      attr_reader :stack, :structure, :permitted_hidden_extensions, :permitted_story_extensions, :ext_permitted
+
+      def initialize(stack = nil, structure = nil)
+        @stack         = stack     || Roro::CLI.catalog_root
+        @structure     = structure || StructureBuilder.build
+        @error         = Roro::CatalogError
+        @permitted_story_extensions  = %w[yml yaml]
+        @permitted_hidden_extensions = %w[.keep .gitkeep]
+        @permitted_extensions        = @permitted_story_extensions +
+                                       @permitted_hidden_extensions
+      end
+
+      ## TODO: validate ambiguous
+      # Add validation to ensure story directory has either a) a matching storyfile or b)
+      # at least one child stack, story, or inflection.
+
+      def base_validate(s)
+        case
+        when stack_is_nil?(s)
+          @msg = 'Catalog not present'
+        when stack_is_ignored?(s)
+          return
+        when stack_is_empty?(s)
+          @msg = 'Catalog cannot be an empty folder'
+        when stack_unpermitted?(s)
+          @msg = 'Catalog has unpermitted extension'
+        when stack_unrecognized?(s)
+          @msg = 'Catalog must be a story, a stack, or an inflection'
+        end
+      end
+
+      def stack_unrecognized?(stack)
+        stack_type(stack).nil?
+      end
+
+      def validate(stack = nil)
+        @msg = nil
+        stack ||= @stack
+        @stack_root ||= stack
+        base_validate(stack)
+        case stack_type(stack)
+        when :storyfile
+          validate_plot(read_yaml(stack))
+        when :story
+          children(stack).each { |c| validate(c) }
+        when :inflection
+          children(stack).each { |c| validate(c) }
+        when :stack
+          children(stack).each { |c| validate(c) }
+        end
+        raise(@error, "#{@msg} in #{stack}") unless @msg.nil?
+      end
+
+      def validate_plot(plot, structure = @structure)
+        case status(plot, structure)
+        when :plot_empty
+          @msg = 'Story file is empty'
+        when :unexpected_class
+          @msg = "'#{plot}' must be an instance of #{structure.class}"
+        when :array_empty
+          @msg = 'Story contains an empty array'
+        when :unpermitted_keys
+          @msg = "#{@unpermitted} not in permitted keys: #{@permitted}"
+        when :hash_value_nil
+          @msg = "Value for :#{plot.key(nil)} must not be nil"
+        when :array_valid
+          plot.each { |item| validate_plot(item, structure[0]) }
+        when :hash_expecting_values
+          plot.each { |k, v| validate_plot(v, structure[k]) }
+        end
+      end
+
+      def status(plot, structure)
+        case
+        when !plot
+          :plot_empty
+        when !plot.is_a?(structure.class)
+          :unexpected_class
+        when plot.is_a?(Array) && plot.any?(nil)
+          :array_empty
+        when plot.is_a?(Hash) && story_has_unpermitted_keys?(plot, structure)
+          :unpermitted_keys
+        when plot.is_a?(Hash) && story_has_nil_value?(plot)
+          :hash_value_nil
+        when plot.is_a?(Hash) && structure.keys&.any?
+          :hash_expecting_values
+        when plot.is_a?(Array)
+          :array_valid
+        end
+      end
+
+      def story_has_unpermitted_keys?(content, structure)
+        @permitted = structure&.keys
+        @unpermitted = content.keys - @permitted
+        @permitted.any? && @unpermitted.any?
+      end
+
+      def story_has_nil_value?(content)
+        content&.values&.include?(nil)
+      end
+    end
+  end
+end

data/lib/roro/crypto/cipher.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Roro
+  module Crypto 
+    class Cipher
+
+      def initialize(options = {})
+        @standard = options[:standard] || 'AES-128-CBC' 
+        @salt     = options[:salt]     || '8 octets' 
+        @cipher   = OpenSSL::Cipher.new @standard
+      end
+
+      def generate_key
+        Base64.encode64(@cipher.random_key)
+      end
+
+      def encrypt(decrypted, key)
+        build_cipher(key)
+        Base64.encode64(@cipher.update(decrypted) + @cipher.final)
+      end
+
+      def decrypt(encrypted, key)
+        build_cipher(key)
+        @cipher.decrypt.pkcs5_keyivgen @key, @salt
+        @cipher.update(Base64.decode64 encrypted) + @cipher.final
+      end
+      
+      private
+      
+      def build_cipher(key)
+        @cipher.encrypt.pkcs5_keyivgen @key=key, @salt
+      end
+    end 
+  end 
+end