singularity_dsl 1.2.5

data/lib/singularity_dsl/dsl/runner.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require 'singularity_dsl/dsl/batch'
+require 'singularity_dsl/dsl/dsl'
+require 'singularity_dsl/errors'
+require 'singularity_dsl/runstate'
+
+module SingularityDsl
+  # DSL classes & fxs
+  module Dsl
+    # class that runs Singularity::Dsl
+    class Runner
+      include SingularityDsl::Errors
+
+      attr_reader :state, :dsl
+
+      def initialize
+        @dsl = Dsl.new
+        @state = Runstate.new
+      end
+
+      def execute(batch = false, pass_errors = false)
+        @dsl.registry.run_list(batch).each do |task|
+          task.execute.tap do |status|
+            failed = task.failed_status status
+            record_failure task if failed
+            resource_fail task if failed && !pass_errors
+          end
+        end
+      end
+
+      def load_ex_script(path)
+        @dsl.instance_eval(::File.read path)
+      end
+
+      def post_actions
+        @dsl.error_proc.call if @state.error
+        @dsl.fail_proc.call if @state.failed
+        @dsl.success_proc.call unless @state.failed || @state.error
+        @dsl.always_proc.call
+      end
+
+      private
+
+      def record_failure(task)
+        failure = klass_failed(task)
+        failure += " #{task.task_name}" if task.task_name
+        @state.add_failure failure
+      end
+
+      def raise_dsl_set_err(dsl)
+        fail "Invalid object given #{dsl}"
+      end
+
+      def execute_task(task)
+        failed = false
+        begin
+          failed = task.execute
+        rescue ::StandardError => err
+          @state.add_error "#{err.message}\n#{err.backtrace}"
+          resource_err task
+        end
+        failed
+      end
+    end
+  end
+end

data/lib/singularity_dsl/dsl/utils.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module SingularityDsl
+  # DSL classes & fxs
+  module Dsl
+    # Utility functions mixin module
+    module Utils
+      def task_name(klass)
+        klass.to_s.split(':').last
+      end
+
+      def task(klass)
+        task_name(klass).downcase.to_sym
+      end
+
+      def task_list
+        klasses = []
+        SingularityDsl.constants.each do |klass|
+          klass = SingularityDsl.const_get(klass)
+          next unless klass.is_a? Class
+          next unless klass < Task
+          klasses.push klass
+        end
+        klasses
+      end
+    end
+  end
+end

data/lib/singularity_dsl/errors.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module SingularityDsl
+  # error & failure classes / methods
+  module Errors
+    class ResourceFail < RuntimeError
+    end
+
+    class ResourceError < RuntimeError
+    end
+
+    def klass_name(obj)
+      return obj.class if obj.class < Object
+      obj
+    end
+
+    def klass_error(klass)
+      klass = klass_name klass
+      "#{klass} threw an exception while executing"
+    end
+
+    def klass_failed(klass)
+      klass = klass_name klass
+      "#{klass} failed."
+    end
+
+    def resource_fail(klass)
+      fail ResourceFail, klass_failed(klass)
+    end
+
+    def resource_err(klass)
+      fail ResourceError, klass_error(klass)
+    end
+  end
+end

data/lib/singularity_dsl/files.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module SingularityDsl
+  # File helper fx mixin
+  module Files
+    private
+
+    def files_in_path(path)
+      paths = [path] if ::File.file? path
+      paths = dir_glob path if ::File.directory? path
+      paths ||= []
+      paths
+    end
+
+    def dir_glob(dir)
+      dir = ::File.join dir, '**'
+      ::Dir.glob dir
+    end
+  end
+end

data/lib/singularity_dsl/git_helper.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+require 'mixlib/shellout'
+
+module SingularityDsl
+  # wrapper class for rugged
+  class GitHelper
+    attr_reader :dir
+
+    def initialize
+      throw 'git not installed' unless git_installed
+    end
+
+    def clean_reset
+      fail 'failed to clean' unless (reset | clean) == 0
+    end
+
+    def checkout_remote(branch, remote)
+      remote_action branch, remote, 'checkout'
+    end
+
+    def merge_remote(branch, url)
+      remote_action branch, url, 'merge'
+    end
+
+    def diff_remote(branch, url, flags = '')
+      flags = flags.join ' ' if flags.kind_of? Array
+      cmd = remote_cmd branch, url, "diff #{flags}"
+      task = Mixlib::ShellOut.new cmd
+      task.run_command
+      task.stdout
+    end
+
+    def add_remote(url)
+      remote = remote_from_url url
+      exec("git remote add #{remote} #{url}")
+      fetch_all
+    end
+
+    def remove_remote(url)
+      remote = remote_from_url url
+      return 0 if remote.eql? 'origin'
+      exec("git remote rm #{remote}")
+    end
+
+    private
+
+    def remote_cmd(branch, url, action)
+      remote = remote_from_url url
+      "git #{action} #{remote}/#{branch}"
+    end
+
+    def remote_action(branch, url, action)
+      status = exec(remote_cmd branch, url, action)
+      fail "failed to #{action}" unless status == 0
+      status
+    end
+
+    def remote_from_url(url)
+      return 'origin' if url.nil? || !url
+      url.split(':').last.gsub('/', '_')
+    end
+
+    def fetch_all
+      exec 'git fetch --all'
+    end
+
+    def remotes
+      (`git remote`.split "\n") - ['origin']
+    end
+
+    def index_path
+      ::File.join(@repo.path, 'index')
+    end
+
+    def git_installed
+      !`which git`.empty?
+    end
+
+    def reset
+      exec 'git add . && git reset --hard'
+    end
+
+    def clean
+      exec 'git clean -fdx'
+    end
+
+    def exec(cmd)
+      task = Mixlib::ShellOut.new cmd
+      task.run_command
+      task.exitstatus
+    end
+  end
+end

data/lib/singularity_dsl/runstate.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module SingularityDsl
+  # abstraction class for the overall runtime state
+  class Runstate
+    attr_reader :errors, :failures, :error, :failed
+
+    def initialize
+      @error = false
+      @errors = []
+      @failed = false
+      @failures = []
+    end
+
+    def add_failure(fail_msg)
+      @failed = true
+      @failures.push fail_msg
+    end
+
+    def add_error(err_msg)
+      @error = true
+      @errors.push err_msg
+    end
+
+    def exit_code
+      return 1 if @error || @failed
+      0
+    end
+  end
+end

data/lib/singularity_dsl/stdout.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'rainbow'
+
+module SingularityDsl
+  # mixin for output wrappers
+  module Stdout
+    def info(message)
+      puts Rainbow(message).cyan
+    end
+
+    def data(message)
+      puts Rainbow(message).green
+    end
+  end
+end

data/lib/singularity_dsl/task.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module SingularityDsl
+  # Task abstraction class
+  class Task
+    def initialize(&block)
+      instance_eval(&block) unless block.nil?
+    end
+
+    def validate_file(file)
+      throw "Cannot find #{file}" unless File.exist? file
+    end
+
+    def execute
+      fail 'SingularityDsl::Task::execute not implemented'
+    end
+
+    def failed_status(status)
+      ![nil, 0, false].include? status
+    end
+
+    def description
+      "Runs #{self.class} task"
+    end
+
+    def task_name
+      false
+    end
+  end
+end

data/lib/singularity_dsl/tasks/rake.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'rake'
+
+# Rake Task
+class Rake < Task
+  attr_accessor :target, :rake
+
+  def initialize(&block)
+    ::Rake.application.init
+    @rake = ::Rake.application
+    super(&block)
+  end
+
+  def target(target)
+    @target = target
+    @target.strip!
+  end
+
+  def execute
+    throw 'target is required' if @target.nil?
+    @rake.load_rakefile
+    ret = @rake[@target].invoke
+    return ret.count if ret.kind_of? Array
+    ret
+  end
+
+  def description
+    'Simple resource to just wrap the Rake CLI'
+  end
+end

data/lib/singularity_dsl/tasks/rspec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'rspec'
+
+# RSpec Task
+class RSpec < Task
+  attr_accessor :spec_dir, :config_file
+
+  def initialize(&block)
+    @spec_dir ||= './spec'
+    @config_file ||= './.rspec'
+    super(&block)
+  end
+
+  def config_file(file)
+    validate_file file
+    @config_file = file
+  end
+
+  def spec_dir(dir)
+    validate_file dir
+    @spec_dir = dir
+  end
+
+  def execute
+    ::RSpec::Core::Runner.run([@spec_dir])
+  end
+
+  def description
+    'Run RSpec tests. Uses RSpec::Core'
+  end
+end

data/lib/singularity_dsl/tasks/rubocop.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'rubocop'
+
+# Rubocop task
+# Intentionally NOT a rake task - for some reason the syck YAML parser
+# that Rubocop uses internally freaks out when a
+# ::Rake::Application[:task].invoke is called from a task
+class Rubocop < Task
+  # :files     => specific files to run against
+  # :cfg_file  => separate config file
+  def initialize(&block)
+    @default_config = './.rubocop.yml'
+    @files = []
+    @cfg_files = [@default_config]
+    @cfg_store = ::RuboCop::ConfigStore.new
+    super(&block)
+  end
+
+  def config_file(file)
+    validate_file file
+
+    return if @cfg_files.include? file
+    warn 'Loading multiple configs' if File.exist? @default_config
+
+    @cfg_files.push file
+
+    # this does a merge of options...
+    @cfg_store.options_config = file
+  end
+
+  def file(file)
+    validate_file file
+    @files.push file
+  end
+
+  def execute
+    inspector = ::RuboCop::FileInspector.new({})
+    # yes, have to pass in a block
+    inspector.process_files files, @cfg_store do
+      false
+    end
+  end
+
+  def description
+    'Runs rubocop, loads .rubocop.yml from ./'
+  end
+
+  private
+
+  def files
+    ::RuboCop::TargetFinder.new(@cfg_store).find @files
+  end
+end

data/lib/singularity_dsl/tasks/shell_task.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require 'mixlib/shellout'
+require 'singularity_dsl/stdout'
+
+# shell-out resource for any ol commands
+class ShellTask < SingularityDsl::Task
+  include SingularityDsl::Stdout
+
+  attr_reader :shell, :conditionals, :alternative, :no_fail
+  attr_writer :live_stream
+
+  def initialize(&block)
+    @live_stream = STDOUT
+    @conditionals = []
+    @no_fail = false
+    @alternative = 'echo "no alternative shell cmd defined"'
+    super(&block)
+  end
+
+  def condition(cmd)
+    invalid_cmd 'condition' unless cmd.is_a? String
+    @conditionals.push cmd
+  end
+
+  def no_fail(switch)
+    fail 'no_fail must be bool' unless bool? switch
+    @no_fail = switch
+  end
+
+  def alt(cmd)
+    invalid_cmd 'alt' unless cmd.is_a? String
+    @alternative = cmd
+  end
+
+  def command(cmd)
+    @task_name = cmd
+    @shell = setup_shell cmd
+  end
+
+  def task_name
+    return @task_name if @task_name
+    super
+  end
+
+  def execute
+    throw 'command never defined' if @shell.nil?
+    command @alternative unless evaluate_conditionals
+    @live_stream <<  log_shell if @live_stream
+    @shell.run_command
+    return 0 if @no_fail
+    @shell.exitstatus
+  end
+
+  def description
+    'Runs a SH command using Mixlib::ShellOut'
+  end
+
+  private
+
+  def log_shell(pre = '', shell = false)
+    shell ||= @shell
+    pre ||= ''
+    log = "[ShellTask]:#{pre}:#{shell.command}"
+    data(log)
+  end
+
+  def bool?(val)
+    val.is_a?(TrueClass) || val.is_a?(FalseClass)
+  end
+
+  def setup_shell(cmd)
+    shell = ::Mixlib::ShellOut.new cmd
+    shell.live_stream = @live_stream if @live_stream
+    shell
+  end
+
+  def invalid_cmd(type)
+    throw "#{type} must be string"
+  end
+
+  def evaluate_conditionals
+    @conditionals.all? do |cmd|
+      shell = setup_shell cmd
+      log_shell '[conditional]', shell
+      shell.run_command
+      !failed_status(shell.exitstatus)
+    end
+  end
+end

data/lib/singularity_dsl/version.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+# version const for gem
+module SingularityDsl
+  VERSION = '1.2.5'
+end

data/lib/singularity_dsl.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+# YEAH, THAT'S RIGHT
+if RUBY_PLATFORM =~ /mswin|mingw32|windows/
+  throw 'Sorry, wont run on mswin|mingw32|windows'
+end
+
+require 'singularity_dsl/application'
+require 'singularity_dsl/dsl/components'

data/singularity_dsl.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'singularity_dsl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'singularity_dsl'
+  spec.version       = SingularityDsl::VERSION
+  spec.authors       = ['chr0n1x']
+  spec.email         = ['heilong24@gmail.com']
+  spec.description   = %q{DSL for your SingularityCI instance.}
+  spec.summary       = %q{}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'mixlib-shellout', '~> 1.4'
+  spec.add_dependency 'rainbow', '~> 2.0.0'
+  spec.add_dependency 'rake', '~> 10.3'
+  spec.add_dependency 'rspec', '~> 2.6'
+  spec.add_dependency 'rubocop', '~> 0.23.0'
+  spec.add_dependency 'terminal-table', '~> 1.4'
+  spec.add_dependency 'thor', '~> 0.19'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'gem-release'
+end

data/spec/singularity_dsl/application_spec.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+require 'singularity_dsl/application'
+
+describe 'Application' do
+  let(:app) { SingularityDsl::Application.new }
+
+  context '#initialize' do
+    it 'creates base runner' do
+      expect(app.runner).to be_kind_of SingularityDsl::Dsl::Runner
+    end
+  end
+
+  context '#load_script' do
+    it 'just calls runner.load_ex_script' do
+      stub_res = 'spooooooky ghooooost'
+      expect(app.runner).to(receive(:load_ex_script).and_return stub_res)
+      expect(app.load_script 'dummy').to eql stub_res
+    end
+  end
+
+  context '#run' do
+    it 'logs resource failures' do
+      # don't want the entire thing to exit...
+      app.stub(:post_task_runner_actions)
+      app.runner.stub(:execute).and_raise(SingularityDsl::Errors::ResourceFail)
+      expect(app).to receive(:log_resource_fail)
+      app.run
+    end
+
+    it 'runner post-script actions are evaulated on failure' do
+      app.stub(:post_task_runner_actions)
+      app.stub(:log_resource_fail)
+      app.runner.stub(:execute).and_raise(SingularityDsl::Errors::ResourceFail)
+      expect(app).to receive(:post_task_runner_actions)
+      app.run
+    end
+
+    it 'logs resource errors' do
+      app.stub(:post_task_runner_actions)
+      app.runner.stub(:execute).and_raise(SingularityDsl::Errors::ResourceError)
+      expect(app).to receive(:log_resource_error)
+      app.run
+    end
+
+    it 'runner post-script actions are evaulated on error' do
+      app.stub(:post_task_runner_actions)
+      app.stub(:log_resource_error)
+      app.runner.stub(:execute).and_raise(SingularityDsl::Errors::ResourceError)
+      expect(app).to receive(:post_task_runner_actions)
+      app.run
+    end
+
+    it 'runner post-script actions are evaulated on error' do
+      app.stub(:post_task_runner_actions)
+      app.stub(:execute)
+      expect(app.runner.state).to receive :exit_code
+      app.run
+    end
+  end
+
+  context '#post_task_runner_actions' do
+    it 'outputs warning when script fails' do
+      app.stub :script_warn
+      app.runner.stub :post_actions
+      app.stub :exit_run
+      app.runner.state.stub(:failed).and_return true
+      expect(app).to receive(:script_warn)
+      app.post_task_runner_actions
+    end
+
+    it 'outputs warning when script errors' do
+      app.stub :script_error
+      app.runner.stub :post_actions
+      app.stub :exit_run
+      app.runner.state.stub(:error).and_return true
+      expect(app).to receive(:script_error)
+      app.post_task_runner_actions
+    end
+  end
+
+  context '#change_list' do
+    it 'returns a sorted list' do
+      expect(app.change_list(%w(b c e a d)))
+        .to eql %w(a b c d e)
+    end
+
+    it 'handles empty lists' do
+      expect(app.change_list([])).to eql []
+    end
+  end
+end