cic-tools 0.0.1.alpha1

data/lib/commands/exercise/headless_browser_driver.rb

@@ -0,0 +1,15 @@
+require 'page_magic'
+
+HeadlessChrome = PageMagic::Driver.new(:headless_chrome) do |app, _options, _browser_alias_chosen|
+  # Write the code necessary to initialise the driver you have chosen
+  require 'selenium/webdriver'
+  capabilities = Selenium::WebDriver::Remote::Capabilities.chrome(
+    chromeOptions: { args: %w[headless no-sandbox disable-gpu window-size=1024,768] }
+  )
+
+  Capybara::Selenium::Driver.new app,
+                                 browser: :chrome,
+                                 desired_capabilities: capabilities
+end
+
+PageMagic.drivers.register HeadlessChrome

data/lib/commands/exercise/instructions.rb

@@ -0,0 +1,197 @@
+require_relative '../../utils/commandline'
+require_relative 'output'
+require 'fileutils'
+require 'yaml'
+require_relative 'headless_browser_driver'
+
+module Exercise
+  # module Instructions - Helper methods to be used within templates
+  module Instructions
+    include Commandline
+    include Commandline::Output
+
+    # class TimeoutError - error raised when something has taken to long
+    class TimeoutError < StandardError
+    end
+
+    # class EnvironmentVariableMissingError - error raised when environment variable is missing
+    class EnvironmentVariableMissingError < StandardError
+      def initialize(variable_name)
+        super "Environment variable not set for: #{variable_name}"
+      end
+    end
+
+    # Runs the given command after the current template has been rendered. This is useful for running commands to clean
+    # clean up. E.g. stopping a server that was previously started.
+    # @example
+    #   In ERB template:
+    #   <%= after_rendering_run('cic down') %>
+    # @param [String] command the command to be run.
+    # @return [String] the command input parameter is returned so that it can be displayed within a template
+    def after_rendering_run(command)
+      after_rendering_commands << command
+      command
+    end
+
+    # Captures and saves screenshots.
+    # Useful for adding images to your templates.
+    # @example
+    #   In ERB template:
+    #   ![Screenshot](<%= capture('http://the.url.com', 'filename.png') %>)
+    # @param [String] url the url to take a screenshot of.
+    # @param [String] filename the filename to save the screenshot to.
+    # @return [String] The filename of the saved screenshot
+    def capture(url, filename)
+      page_class = Class.new { include PageMagic }
+      session = PageMagic.session(browser: :headless_chrome, url: url)
+      session.visit(page_class, url: url)
+      session.browser.save_screenshot(filename)
+      filename
+    end
+
+    # Change directory
+    # Change directory so that subsequent commands are executed in the correct context
+    # @example
+    #   In ERB template:
+    #   <%= cd('path') %>
+    # @param [String] path the path to move to
+    # @return [String] the path moved to
+    def cd(path)
+      Dir.chdir(path)
+      "cd #{path}"
+    end
+
+    # Execute a command
+    # @example
+    #   In ERB template:
+    #   <%= command('mkdir my_directory') %>
+    # @param [String] command the command to execute
+    # @param [Boolean] fail_on_error whether to raise an error if the command fails to execute
+    # @return [String] the command that was executed
+    # @raise [CommandError] if command errors and if fail_on_error is set to to true
+    def command(command, fail_on_error: true)
+      result = test_command(command, fail_on_error: fail_on_error)
+      raise CommandError if result.error? && fail_on_error
+
+      command
+    end
+
+    # get the output of a command
+    # @example
+    #   In ERB template:
+    #   <%= command_output('mkdir my_directory') %>
+    # @param [String] command the command to execute.
+    # @return [String] the output of the command executed.
+    def command_output(command)
+      command command
+      last_command_output
+    end
+
+    # get value of an Environment variable
+    # @example
+    #   In ERB template:
+    #   <%= env('VARIABLE_NAME') %>
+    # @param [String] variable_name the variable name
+    # @return [String] the value of the specified environment variable.
+    # # @raise [EnvironmentVariableMissingError] if environment variable is undefined
+    def env(variable_name)
+      ENV[variable_name.to_s] || (raise EnvironmentVariableMissingError, variable_name)
+    end
+
+    # get the output of the last command that was run.
+    # @example
+    #   In ERB template:
+    #   <%= last_command_output %>
+    # @return [String] the output of the last command.
+    def last_command_output
+      Output.new(@result.stdout)
+    end
+
+    # Validate a path
+    # @example
+    #   In ERB template:
+    #   <%= path('the/path') %>
+    # @return [String] the output of the last command.
+    # @raise [RuntimeError] if given path does not exist
+    def path(path)
+      raise "#{path} does not exist" unless File.exist?(path)
+
+      path
+    end
+
+    # store strings that should be subsituted in the template on rendering
+    # @example
+    #   In ERB template:
+    #   <% substitute({'localhost' => '127.0.0.1'}) %>
+    # @param hash [Hash] values and their substitutes.
+    def substitute(hash)
+      @substitutes = hash
+    end
+
+    # Wait until the given block evaluates to true
+    # @example
+    #   In ERB template:
+    #   <%
+    #     wait_until do
+    #       # code
+    #     end
+    #   %>
+    # @param timeout_after [Fixnum] the number of seconds to wait before timing out.
+    # @param retry_every [Float] the number of seconds to wait before re-evaluating the given block again
+    # @raise [TimeoutError] if given block does not return true within the allowed time.
+    def wait_until(timeout_after: 5, retry_every: 0.1)
+      start_time = Time.now
+      until Time.now > start_time + timeout_after
+        return true if yield == true
+
+        sleep retry_every
+      end
+      raise TimeoutError, 'Action took to long'
+    end
+
+    # Write the given content to file
+    # @example
+    #   In ERB template:
+    #   <%
+    #     write_to_file('path/file.txt', 'content')
+    #   %>
+    # @param [String] path the path to write the file to.
+    # @param [Float] content the content to write to file
+    # @return [String] the path that the file was written to.
+    def write_to_file(path, content)
+      directory = File.dirname(path)
+      FileUtils.mkdir_p(directory)
+      File.write(path, content)
+      after_rendering_run("rm -rf #{path}")
+      path
+    end
+
+    protected
+
+    def after_rendering_commands
+      @after_rendering_commands ||= []
+    end
+
+    def test_command(command, fail_on_error: true)
+      say "running: #{command}" unless quiet?
+
+      result = @result = run(command)
+
+      if result.error? && fail_on_error
+        say error("failed to run: #{command}\n\n#{result}")
+      elsif quiet?
+        output.print '.'.green
+      else
+        say ok("Successfully ran: #{command}")
+      end
+
+      result
+    end
+
+    private
+
+    def substitutes
+      @substitutes ||= {}
+    end
+  end
+end

data/lib/commands/exercise/output.rb

@@ -0,0 +1,31 @@
+require_relative 'output/ansible'
+require_relative 'output/pytest'
+require_relative 'output/cic'
+module Exercise
+  class Output < String
+    def initialize(string)
+      string = string.scrub
+      bytes = string.bytes.delete_if { |byte| byte == 27 }
+      string = bytes.pack('U*')
+      super normalise(string.chomp)
+    end
+
+    def to_ansible_output
+      Ansible.new(self)
+    end
+
+    def to_cic_output
+      CIC.new(self)
+    end
+
+    def to_pytest_output
+      Pytest.new(self)
+    end
+
+    private
+
+    def normalise(string)
+      string.gsub(/\[[\d;]+m/, '')
+    end
+  end
+end

data/lib/commands/exercise/output/ansible.rb

@@ -0,0 +1,15 @@
+module Exercise
+  class Output < String
+    class Ansible < String
+      attr_reader :tasks, :play, :play_recap
+
+      def initialize(string)
+        super
+
+        @tasks = string.scan(/(TASK .*\**$\n.*\n)/).flatten
+        @play = string.scan(/(PLAY \[.*\**$)/).flatten.first
+        @play_recap = string.scan(/(PLAY RECAP.*\**$\n.*)/).flatten.first
+      end
+    end
+  end
+end

data/lib/commands/exercise/output/cic.rb

@@ -0,0 +1,18 @@
+module Exercise
+  class Output < String
+    class CIC < String
+      attr_reader :container_id, :cic_start_command, :cic_connect_command, :cic_stop_command
+
+      def initialize(string)
+        @container_id = chomp(string[/cic connect (.*)/, 1])
+        @cic_start_command = chomp(string[/(cic start .*)/, 1])
+        @cic_connect_command = chomp(string[/(cic connect .*)/, 1])
+        @cic_stop_command = chomp(string[/(cic stop .*)/, 1])
+      end
+
+      def chomp(string)
+        string&.chomp
+      end
+    end
+  end
+end

data/lib/commands/exercise/output/pytest.rb

@@ -0,0 +1,15 @@
+module Exercise
+  class Output < String
+    class Pytest < String
+      attr_reader :summary
+
+      def initialize(string)
+        @summary = chomp(string[/(=+.*100%\])/m, 1])
+      end
+
+      def chomp(string)
+        string&.chomp
+      end
+    end
+  end
+end

data/lib/commands/exercise/render_methods.rb

@@ -0,0 +1,150 @@
+require 'digest'
+require 'tmpdir'
+require_relative 'instructions'
+module Exercise
+  module DigestMethods
+    def digest(path:, digest_component:, excludes: [])
+      excludes = paths(*excludes)
+
+      files = files(path).sort.reject do |f|
+        excludes.include?(f) || ignored?(path, f)
+      end
+
+      content = files.map { |f| File.read(f) }.join
+      Digest::MD5.hexdigest(content << digest_component).to_s
+    end
+
+    def excluded_files(template)
+      all_files_templates = files(templates_directory(template))
+      rendered_files = all_files_templates.collect { |t| filename(t) }.find_all { |f| File.exist?(f) }
+      all_files_templates.reject { |file| file == template }.concat(rendered_files)
+    end
+
+    def paths(*paths)
+      paths.find_all { |excluded_file| File.exist?(excluded_file) }.collect { |path| full_path(path) }
+    end
+
+    private
+
+    def files(path)
+      files = paths(*Dir.glob("#{path}/**/*", ::File::FNM_DOTMATCH))
+      files.find_all { |f| !File.directory?(f) }
+    end
+
+    def filename(template)
+      "#{File.expand_path("#{File.dirname(template)}/..")}/#{File.basename(template, '.erb')}"
+    end
+
+    def full_path(path)
+      File.expand_path(path)
+    end
+
+    def git_ignore_content(path)
+      git_ignore_file = "#{path}/.gitignore"
+      File.exist?(git_ignore_file) ? File.read(git_ignore_file) : ''
+    end
+
+    def ignored?(path, file)
+      ignored_files(path).find { |ignore| file.include?(ignore) || Pathname.new(file).fnmatch?(ignore) }
+    end
+
+    def ignored_files(path)
+      files = git_ignore_content(path).lines.collect { |line| sanitise(line) }
+      files << '.git'
+    end
+  end
+
+  module RenderMethods
+    include Commandline::Output
+    include Instructions
+    include DigestMethods
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def render_exercise(template, digest_component: '')
+      say "Rendering: #{template}"
+      template = full_path(template)
+      current_dir = Dir.pwd
+
+      content = render(template)
+      File.open(filename(template), 'w') { |f| f.write("#{content}\n#{stamp(digest_component, template)}") }
+
+      say ok "Finished: #{template}"
+      true
+    rescue StandardError => e
+      say error "Failed to generate file from: #{template}"
+      say "#{e.message}\n#{e.backtrace}"
+      false
+    ensure
+      Dir.chdir(current_dir)
+    end
+
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+
+    def render_file_path(template)
+      template.gsub(%r{.templates/.*?erb}, File.basename(template)).gsub('.erb', '')
+    end
+
+    def templates_directory(template)
+      full_path(File.dirname(template))
+    end
+
+    private
+
+    def anonymise(string)
+      substitutes.each do |key, value|
+        string = string.gsub(key, value)
+      end
+      string
+    end
+
+    def stamp(digest_component, template)
+      "  \n\nRevision: #{digest(path: full_path("#{templates_directory(template)}/.."),
+                                digest_component: digest_component.to_s,
+                                excludes: excluded_files(template))}"
+    end
+
+    def reset
+      @result = nil
+      @after_rendering_commands = []
+    end
+
+    def render(template)
+      reset
+      template_content = File.read(File.expand_path(template))
+
+      erb_template = ERB.new(template_content)
+
+      result = run_in_temp_dir?(template_content) ? render_in_temp_dir(erb_template) : erb_template.result(binding)
+
+      anonymise(result)
+    ensure
+      after_rendering_commands.each { |command| test_command(command) }
+      say '' if quiet?
+    end
+
+    def filename(template)
+      "#{File.expand_path("#{File.dirname(template)}/..")}/#{File.basename(template, '.erb')}"
+    end
+
+    def render_in_temp_dir(erb_template)
+      output = nil
+      Dir.mktmpdir do |path|
+        original_dir = Dir.pwd
+        Dir.chdir(path)
+        output = erb_template.result(binding)
+        Dir.chdir(original_dir)
+      end
+      output
+    end
+
+    def run_in_temp_dir?(template_content)
+      /<%#\s*instruction:run_in_temp_directory\s*%>/.match?(template_content)
+    end
+
+    def sanitise(string)
+      string.chomp.strip
+    end
+  end
+end