careacademy-runbook 1.2.0

data/lib/runbook/extensions/ssh_config.rb

@@ -0,0 +1,78 @@
+module Runbook::Extensions
+  module SSHConfig
+    def self.blank_ssh_config
+      {
+        servers: [],
+        parallelization: {},
+      }
+    end
+
+    def ssh_config
+      @ssh_config ||= Runbook::Extensions::SSHConfig.blank_ssh_config
+    end
+
+    module DSL
+      def ssh_config(&block)
+        config = Class.new do
+          attr_reader :dsl
+          prepend Runbook::Extensions::SSHConfig
+        end.new
+        dsl_class = Runbook::DSL.class(
+          Runbook::Extensions::SSHConfig::DSL,
+        )
+        config.instance_variable_set(:@dsl, dsl_class.new(config))
+        config.dsl.instance_eval(&block)
+        config.ssh_config
+      end
+
+      def parallelization(strategy: , limit: 2, wait: 2)
+        parent.ssh_config[:parallelization] = {
+          strategy: strategy,
+          limit: limit,
+          wait: wait,
+        }
+      end
+
+      def server(server)
+        parent.ssh_config[:servers].clear
+        parent.ssh_config[:servers] << server
+      end
+
+      def servers(*servers)
+        parent.ssh_config[:servers].clear
+        servers.flatten.each do |server|
+          parent.ssh_config[:servers] << server
+        end
+      end
+
+      def path(path)
+        parent.ssh_config[:path] = path
+      end
+
+      def user(user)
+        parent.ssh_config[:user] = user
+      end
+
+      def group(group)
+        parent.ssh_config[:group] = group
+      end
+
+      def env(env)
+        parent.ssh_config[:env] = env
+      end
+
+      def umask(umask)
+        parent.ssh_config[:umask] = umask
+      end
+    end
+  end
+
+  Runbook::Entities::Step.prepend(SSHConfig)
+  Runbook::Entities::Step::DSL.prepend(SSHConfig::DSL)
+  Runbook::Entities::Section.prepend(SSHConfig)
+  Runbook::Entities::Section::DSL.prepend(SSHConfig::DSL)
+  Runbook::Entities::Setup.prepend(SSHConfig)
+  Runbook::Entities::Setup::DSL.prepend(SSHConfig::DSL)
+  Runbook::Entities::Book.prepend(SSHConfig)
+  Runbook::Entities::Book::DSL.prepend(SSHConfig::DSL)
+end

data/lib/runbook/extensions/statements.rb

@@ -0,0 +1,31 @@
+module Runbook::Extensions
+  module Statements
+    module DSL
+      ruby2_keywords def method_missing(name, *args, &block)
+        if (klass = Statements::DSL._statement_class(name))
+          klass.new(*args, &block).tap do |statement|
+            parent.add(statement)
+
+            if statement.respond_to?(:into)
+              Runbook.runtime_methods << statement.into
+            end
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to?(name, include_private = false)
+        !!(Statements::DSL._statement_class(name) || super)
+      end
+
+      def self._statement_class(name)
+        "Runbook::Statements::#{name.to_s.camelize}".constantize
+      rescue NameError
+      end
+    end
+  end
+
+  Runbook::Entities::Setup::DSL.prepend(Statements::DSL)
+  Runbook::Entities::Step::DSL.prepend(Statements::DSL)
+end

data/lib/runbook/extensions/steps.rb

@@ -0,0 +1,24 @@
+module Runbook::Extensions
+  module Steps
+    module DSL
+      def step(title=nil, *tags, labels: {}, &block)
+        if title.is_a?(Symbol)
+          tags.unshift(title)
+          title = nil
+        end
+
+        Runbook::Entities::Step.new(
+          title,
+          tags: tags,
+          labels: labels,
+        ).tap do |step|
+          parent.add(step)
+          step.dsl.instance_eval(&block) if block
+        end
+      end
+    end
+  end
+
+  Runbook::Entities::Book::DSL.prepend(Steps::DSL)
+  Runbook::Entities::Section::DSL.prepend(Steps::DSL)
+end

data/lib/runbook/extensions/tmux.rb

@@ -0,0 +1,13 @@
+module Runbook::Extensions
+  module Tmux
+    module LayoutDSL
+      def layout(layout)
+        Runbook::Statements::Layout.new(layout).tap do |layout|
+          parent.add(layout)
+        end
+      end
+    end
+  end
+
+  Runbook::Entities::Book::DSL.prepend(Tmux::LayoutDSL)
+end

data/lib/runbook/generator.rb

@@ -0,0 +1,38 @@
+module Runbook
+  class Generator < Thor
+    include Runbook::CLIBase
+    include Thor::Actions
+
+    Runbook::Generators::Base.set_base_options(self)
+
+    def self._unique_class_options(generator)
+      generator.class_options.values.reject do |class_option|
+        class_option.group == "Runtime" ||
+          class_option.group == "Base"
+      end
+    end
+
+    Runbook.generators.each do |generator|
+      desc(generator.usage, generator.description, generator.options)
+
+      long_desc(generator.long_description)
+
+      _unique_class_options(generator).each do |co|
+        method_option(
+          co.name,
+          desc: co.description,
+          required: co.required,
+          default: co.default,
+          aliases: co.aliases,
+          type: co.type,
+          banner: co.banner,
+          hide: co.hide,
+        )
+      end
+
+      define_method(generator.command) do |*args|
+        invoke(generator, args)
+      end
+    end
+  end
+end

data/lib/runbook/generators/base.rb

@@ -0,0 +1,45 @@
+module Runbook::Generators
+  module Base
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(Thor::Actions)
+
+      set_base_options(base)
+      base.check_unknown_options!
+    end
+
+    def self.set_base_options(base)
+      base.class_option(
+        :root,
+        group: :base,
+        default: ".",
+        desc: "The root directory for your generated code",
+      )
+      base.add_runtime_options!
+    end
+
+    module ClassMethods
+      def command
+        self.to_s.gsub("Runbook::Generators::", "").underscore
+      end
+
+      def usage
+        args = arguments.map(&:banner).join(" ")
+        args += " " unless args.empty?
+        "#{command} #{args}[options]"
+      end
+
+      def description
+        "Generate a #{command}"
+      end
+
+      def long_description
+        description
+      end
+
+      def options
+        {}
+      end
+    end
+  end
+end

data/lib/runbook/generators/dsl_extension/dsl_extension.rb

@@ -0,0 +1,29 @@
+module Runbook::Generators
+  class DslExtension < Thor::Group
+    include ::Runbook::Generators::Base
+
+    source_root File.dirname(__FILE__)
+
+    def self.description
+      "Generate a dsl_extension for adding custom runbook DSL functionality"
+    end
+
+    def self.long_description
+      <<-LONG_DESC
+      This generator provides a template for extending Runbook's DSL. Using a
+      DSL extension, you can add custom commands to a book, section, or step
+      that can be used in your runbooks.
+      LONG_DESC
+    end
+
+    argument :name, desc: "The name of your dsl_extension, e.x. rollback_section"
+
+    def create_dsl_extension
+      target = File.join(
+        parent_options[:root],
+        "#{name.underscore}.rb",
+      )
+      template('templates/dsl_extension.tt', target)
+    end
+  end
+end

data/lib/runbook/generators/dsl_extension/templates/dsl_extension.tt

@@ -0,0 +1,25 @@
+# Remember to require this file in a runbook config file
+# or in your project so it is available in your runbooks
+# See https://github.com/braintree/runbook/tree/master/lib/runbook/extensions
+# for examples of DSL extensions
+module MyProject::RunbookExtensions
+  module <%= name.classify %>
+    module DSL
+      # def description(msg)
+      #   Runbook::Statements::Description.new(msg).tap do |desc|
+      #     # All DSLs can reference their parent object using
+      #     # the parent method. This allows you to modify the
+      #     # parent book, section, or step of the DSL
+      #     parent.add(desc)
+      #   end
+      # end
+    end
+  end
+
+  # Uncomment the below statements to add the the DSL methods to
+  # Book, Section, and Step DSLs respectively. Now this method can
+  # be called from the corresponding DSL in your runbooks
+  # Runbook::Entities::Book::DSL.prepend(<%= name.classify %>::DSL)
+  # Runbook::Entities::Section::DSL.prepend(<%= name.classify %>::DSL)
+  # Runbook::Entities::Step::DSL.prepend(<%= name.classify %>::DSL)
+end

data/lib/runbook/generators/generator/generator.rb

@@ -0,0 +1,43 @@
+module Runbook::Generators
+  class Generator < Thor::Group
+    include ::Runbook::Generators::Base
+
+    source_root File.dirname(__FILE__)
+
+    def self.usage
+      "generator NAME [options]"
+    end
+
+    def self.description
+      "Generate a runbook generator named NAME, e.x. acme_runbook"
+    end
+
+    argument :name, desc: "The name of your generator for populating boilerplate"
+
+    def create_generator_directory
+      target = File.join(
+        parent_options[:root],
+        name.underscore,
+      )
+      empty_directory(target)
+    end
+
+    def create_templates_directory
+      target = File.join(
+        parent_options[:root],
+        name.underscore,
+        "templates",
+      )
+      empty_directory(target)
+    end
+
+    def create_generator
+      target = File.join(
+        parent_options[:root],
+        name.underscore,
+        "#{name.underscore}.rb",
+      )
+      template('templates/generator.tt', target)
+    end
+  end
+end

data/lib/runbook/generators/generator/templates/generator.tt

@@ -0,0 +1,53 @@
+module Runbook::Generators
+  # Remember to require this class in a runbook config file such as your
+  # Runbookfile so it can be used from the command line. Note that you cannot
+  # require this generator from a config file specified on the command line.
+  class <%= name.classify %> < Thor::Group
+    include ::Runbook::Generators::Base
+
+    source_root File.dirname(__FILE__)
+
+    # Uncomment this method to customize the generator's usage
+    # description in runbook's help description.
+    #
+    # def self.usage
+    #   args = arguments.map(&:banner).join(" ")
+    #   args += " " unless args.empty?
+    #   "<%= name.underscore %> #{args}[options]"
+    # end
+
+    # Uncomment this method to customize the generator's
+    # description in runbook's help message.
+    #
+    # def self.description
+    #   "Generate a <%= name %>"
+    # end
+
+    # Uncomment this method to customize the generator's
+    # long description in runbook's help message.
+    #
+    # def self.long_description
+    #   <<-LONG_DESC
+    #   Here you can fully describe the options of your generator.
+    #   LONG_DESC
+    # end
+
+    # Argument example
+    # argument :name, desc: "The name of your <%= name.underscore %>, e.x. deploy_nginx"
+
+    # Option example
+    # class_option :include-readme, default: true, type: :boolean
+
+    # Example of a generator step
+    # See: https://github.com/erikhuda/thor/wiki/Generators
+    # for further documentation on using thor generators.
+    #
+    # def create_<%= name.underscore %>
+    #   target = File.join(
+    #     parent_options[:root],
+    #     "#{name.underscore}.rb",
+    #   )
+    #   template('templates/<%= name.underscore %>.tt', target)
+    # end
+  end
+end

data/lib/runbook/generators/project/project.rb

@@ -0,0 +1,301 @@
+module Runbook::Generators
+  class Project < Thor::Group
+    include ::Runbook::Generators::Base
+
+    source_root File.dirname(__FILE__)
+
+    def self.description
+      "Generate a project for your runbooks"
+    end
+
+    def self.long_description
+      <<-LONG_DESC
+      This generator generates a project for your runbooks. It creates a
+      project skeleton to hold your runbooks, runbook extensions, shared
+      code, configuration, tests, and dependencies.
+      LONG_DESC
+    end
+
+    argument :name, desc: "The name of your project, e.x. acme_runbooks"
+
+    class_option :"shared-lib-dir", type: :string,
+      desc: "Target directory for shared runbook code"
+    class_option :test, type: :string, enum: ["rspec", "minitest"],
+      default: "rspec", desc: %Q{Test-suite, "rspec" or "minitest"}
+    class_option :ci, type: :string, enum: ["github", "travis", "gitlab", "circle"],
+      default: "github", desc: %Q{CI Service, "github", "travis", "gitlab", or "circle"}
+
+    def init_gem
+      bundle_exists = "which bundle 2>&1 1>/dev/null"
+      raise "Please ensure bundle is installed" unless system(bundle_exists)
+      bundler_version = Gem::Version.new(Bundler::VERSION)
+
+      inside(parent_options[:root]) do
+        test = "--test #{options[:test]}"
+        ci = "--ci #{options[:ci]}"
+        changelog = "--no-changelog" if bundler_version >= Gem::Version.new("2.2.8")
+        continue = (
+          run("bundle gem #{_name} #{test} #{ci} --rubocop #{changelog} --no-coc --no-mit") ||
+          options[:pretend]
+        )
+        exit 1 unless continue
+      end
+    end
+
+    def remove_unneeded_files
+      dirs = [
+        parent_options[:root],
+        _name,
+      ]
+
+      gemspec_file = File.join(*dirs, "#{_name}.gemspec")
+      if File.exist?(gemspec_file)
+        @gemspec_file_contents = File.readlines(gemspec_file)
+      end
+      remove_file(gemspec_file)
+
+      readme = File.join(*dirs, "README.md")
+      remove_file(readme)
+
+      gemfile = File.join(*dirs, "Gemfile")
+      if File.exist?(gemfile)
+        @gemfile_file_contents = File.readlines(gemfile)
+      end
+      remove_file(gemfile)
+
+      base_file = File.join(*dirs, "lib", "#{_name}.rb")
+      remove_file(base_file)
+
+      version_file_path = [
+        "lib",
+        _name,
+        "version.rb",
+      ]
+      version_file = File.join(*dirs, *version_file_path)
+      remove_file(version_file)
+    end
+
+    def shared_lib_dir
+      msg = [
+        "Where should shared runbook code live?",
+        "Use `lib/#{_name}` for runbook-only projects",
+        "Use `lib/#{_name}/runbook` for projects used for non-runbook tasks",
+        "Shared runbook code path:",
+      ]
+
+      if options.has_key?("shared-lib-dir")
+        @shared_lib_dir = options["shared-lib-dir"]
+      else
+        @shared_lib_dir = ask(msg.join("\n"))
+      end
+    end
+
+    def create_readme
+      target = File.join(
+        parent_options[:root],
+        _name,
+        "README.md",
+      )
+
+      template("templates/README.md.tt", target)
+    end
+
+    def create_gemfile
+      target = File.join(
+        parent_options[:root],
+        _name,
+        "Gemfile",
+      )
+
+      template("templates/Gemfile.tt", target)
+
+      # Add development dependencies from gemspec
+      if @gemspec_file_contents
+        gems = @gemspec_file_contents.select do |line|
+          line =~ /  spec.add_development_dependency/
+        end.map do |line|
+          line.gsub(/  spec.add_development_dependency/, "gem")
+        end.join
+
+        append_to_file(target, "\n#{gems}", verbose: false)
+      end
+
+      # Add gemfile gems
+      if @gemfile_file_contents
+        gems = @gemfile_file_contents.select do |line|
+          line =~ /^gem /
+        end.join
+
+        append_to_file(target, "\n#{gems}", verbose: false)
+      end
+
+    end
+
+    def create_base_file
+      target = File.join(
+        parent_options[:root],
+        _name,
+        "lib",
+        "#{_name}.rb",
+      )
+
+      template("templates/base_file.rb.tt", target)
+    end
+
+    def modify_rakefile
+      target = File.join(
+        parent_options[:root],
+        _name,
+        "Rakefile",
+      )
+
+      gsub_file(target, /^require "bundler\/gem_tasks"\n/, "", verbose: false)
+    end
+
+    def create_ruby_version
+      target = File.join(
+        parent_options[:root],
+        _name,
+        ".ruby-version",
+      )
+
+      create_file(target, "ruby-#{RUBY_VERSION}\n")
+    end
+
+    def create_ruby_gemset
+      target = File.join(
+        parent_options[:root],
+        _name,
+        ".ruby-gemset",
+      )
+
+      create_file(target, "#{_name}\n")
+    end
+
+    def create_runbookfile
+      target = File.join(
+        parent_options[:root],
+        _name,
+        "Runbookfile",
+      )
+
+      template("templates/Runbookfile.tt", target)
+    end
+
+    def create_runbooks_directory
+      dirs = [
+        parent_options[:root],
+        _name,
+        "runbooks",
+      ]
+      target = File.join(*dirs)
+
+      empty_directory(target)
+      _keep_dir(target)
+    end
+
+    def create_extensions_directory
+      dirs = [
+        parent_options[:root],
+        _name,
+        "lib",
+        "runbook",
+        "extensions",
+      ]
+      target = File.join(*dirs)
+
+      empty_directory(target)
+      _keep_dir(target)
+    end
+
+    def create_generators_directory
+      dirs = [
+        parent_options[:root],
+        _name,
+        "lib",
+        "runbook",
+        "generators",
+      ]
+      target = File.join(*dirs)
+
+      empty_directory(target)
+      _keep_dir(target)
+    end
+
+    def create_lib_directory
+      dirs = [
+        parent_options[:root],
+        _name,
+        @shared_lib_dir,
+      ]
+      target = File.join(*dirs)
+
+      empty_directory(target)
+      _keep_dir(target)
+    end
+
+    def update_bin_console
+      path = [
+        parent_options[:root],
+        _name,
+        "bin",
+        "console",
+      ]
+      target = File.join(*path)
+
+      old_require = /require "#{_name}"/
+      new_require = %Q(require_relative "../lib/#{_name}")
+      new_require += "\n\nRunbook::Configuration.load_config"
+      gsub_file(target, old_require, new_require, verbose: false)
+
+      old_require = /require "#{_name}"/
+      new_require = %Q(require_relative "../lib/#{_name}")
+      gsub_file(target, old_require, new_require, verbose: false)
+    end
+
+    def remove_bad_test
+      path = [
+        parent_options[:root],
+        _name,
+      ]
+
+      case options["test"]
+      when "rspec"
+        path << "spec"
+        path << "#{_name}_spec.rb"
+      when "minitest"
+        path << "test"
+        path << "#{_name}_test.rb"
+      end
+      target = File.join(*path)
+
+      bad_test = /  .*version.*\n.*\n  end\n\n/m
+      gsub_file(target, bad_test, "", verbose: false)
+    end
+
+    def runbook_project_overview
+      msg = [
+        "",
+        "Your runbook project was successfully created.",
+        "Remember to run `./bin/setup` in your project to install dependencies.",
+        "Add runbooks to the `runbooks` directory.",
+        "Add shared code to `#{@shared_lib_dir}`.",
+        "Execute runbooks using `bundle exec runbook exec <RUNBOOK_PATH>` from your project root.",
+        "See the README.md for more details.",
+        "\n",
+      ]
+
+      say(msg.join("\n"))
+    end
+
+    private
+
+    def _name
+      @name ||= name.underscore
+    end
+
+    def _keep_dir(dir)
+      create_file(File.join(dir, ".keep"), verbose: false)
+    end
+  end
+end

data/lib/runbook/generators/project/templates/Gemfile.tt

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+ruby "<%= RUBY_VERSION %>"
+
+gem "runbook", "~> <%= Runbook::VERSION %>"