duty 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b04eb166b84df79f038e4cd1f03181ff7294049
+  data.tar.gz: 8cec611a0d0fcbf8ae02de1ea3ed798633fed7e7
+SHA512:
+  metadata.gz: 1fd3ce618dcc3c2e631715efcb138558345e7b7b6481e9655443f14c668b4de115f66983239e3cb769cd2ff73c9cec63f543c68e0c2c326a10505af9bf6ecff4
+  data.tar.gz: 4b7e91969a5d696d976c3d7ea0739fdbec15e16fef9c89a74f62f7e215a4a468e466419c7f58943406ccd9ba06a280f9fe7139420afc1cb1d392851af52be0d5

data/.duty.yml.sample

@@ -0,0 +1 @@
+tasks: /path/to/my/project/specific/tasks

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+.duty.yml
+pkg

data/.ruby-gemset

@@ -0,0 +1 @@
+duty

data/.ruby-version

@@ -0,0 +1 @@
+2.2.3

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.3

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jan Owiesniak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+[![Build Status](https://travis-ci.org/JanOwiesniak/duty.svg?branch=master)](https://travis-ci.org/JanOwiesniak/duty) [![Inline docs](http://inch-ci.org/github/JanOwiesniak/duty.svg?branch=master)](http://inch-ci.org/github/JanOwiesniak/duty)
+
+# Duty
+
+Craft.
+Don't battle.
+Do your duty, let me handle the rest.
+
+## Installation
+
+```
+$ gem install duty
+```
+
+## Add executable to your $PATH
+
+```
+$ export PATH="$PATH:$HOME/path/to/duty/bin"
+```
+```
+
+## Add shell completion
+
+This gem supports a simple shell completion for
+[Bash](https://www.gnu.org/software/bash/) and [ZSH](http://www.zsh.org).
+To enable this feature load the completion functions:
+
+```
+source duty.completion
+```
+
+## Usage
+
+```
+$ duty <task> [<args>]
+```
+
+## Naming conventions
+
+Task names should be a combination of one verb joined with one or more nouns.
+
+Examples:
+
+* `start-feature`
+* `continue-feature`
+
+## List of official duty plugins
+
+* [duty-git](https://github.com/JanOwiesniak/duty-git)
+
+## Extend duty with your own tasks
+
+* Create a new `tasks` dir
+* Create one or more duty task files in there
+* Create a .duty file e.g. in your home dir
+
+### How does a basic duty task looks like?
+
+path/to/your/new/tasks/my_new_task.rb
+
+```ruby
+require 'duty/tasks/base'
+
+module Duty
+  module Tasks
+    class MyNewTask < Duty::Tasks::Base
+    end
+  end
+end
+```
+
+### How does a .duty file looks like?
+
+.duty
+
+```
+tasks:
+  git: /path/to/my/git/specific/tasks
+  projectA: /path/to/my/projectA/specific/tasks
+  projectB: /path/to/my/projectB/specific/tasks
+```
+
+### How to use my own task?
+
+Your new task will be immediately available from the CLI.
+
+```
+duty
+```
+
+Fire up the CLI and execute your new task.
+Duty will tell you what you have to do next.
+
+```
+duty <your-task>
+```
+
+## Contributing
+
+1. [Fork](http://github.com/JanOwiesniak/duty/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'spec'
+  t.test_files = FileList['spec/*_spec.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/bin/duty

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# Finds the path to the 'lib' directory of Duty. Follows symlinks, which
+# comes in handy.
+def find_lib_path
+  path = __FILE__
+  while File.symlink?(path)
+    path = File.expand_path(File.readlink(path), File.dirname(path))
+  end
+  File.join(File.dirname(File.expand_path(path)), '..', 'lib')
+end
+
+$LOAD_PATH.unshift(find_lib_path)
+
+require 'duty'
+
+Duty::CLI.new(ARGV).exec

data/bin/duty.completion

@@ -0,0 +1,18 @@
+if [ -n "$BASH_VERSION" ]; then
+  _duty_complete() {
+    COMPREPLY=()
+    local word=${COMP_WORDS[COMP_CWORD]}
+    local completions=$(duty --cmplt "${word}")
+    COMPREPLY=( $completions )
+  }
+  complete -F _duty_complete duty
+elif [ -n "$ZSH_VERSION" ]; then
+  _duty_complete() {
+    local word completions
+    word="$1"
+    completions="$(duty --cmplt "${word}")"
+    reply=( "${(ps:\n:)completions}" )
+  }
+
+  compctl -K _duty_complete duty
+fi

data/duty.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "duty/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "duty"
+  spec.version       = Duty::VERSION
+  spec.authors       = ["Jan Owiesniak"]
+  spec.email         = ["owiesniak@mailbox.org"]
+
+  spec.summary       = "Extendable Task Manager"
+  spec.description   = "Duty provides a CLI for high-level tasks"
+  spec.homepage      = "https://github.com/JanOwiesniak/duty"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.executables   = spec.files.grep(%r{^bin\/}) { |f| File.basename(f) }
+
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.8"
+end

data/lib/duty/cli.rb

@@ -0,0 +1,215 @@
+require 'duty/registry'
+require 'duty/plugins'
+require 'duty/meta'
+
+module Duty
+  class CLI
+    DUTY_CONFIG_FILENAME = '.duty.yml'
+    attr_reader :registry
+
+    def initialize(args)
+      @input = Input.new(args)
+      @output = Output.new
+      @registry = Duty::Registry.load(plugins)
+    end
+
+    def exec
+      stdout usage if help?
+      stdout completion if completion?
+      run_task
+    end
+
+    private
+
+    attr_reader :input, :output
+
+    def plugins
+      Duty::Plugins.load(DUTY_CONFIG_FILENAME)
+    end
+
+    def stdout(string)
+      $stdout.puts string
+      exit 0
+    end
+
+    def help?
+      input.help?
+    end
+
+    def usage
+      Duty::Meta::Help.new(self).to_s
+    end
+
+    def completion?
+      input.completion?
+    end
+
+    def completion
+      Duty::Meta::Completion.new(self, input.drop(1)).to_s
+    end
+
+    def run_task
+      begin
+        task.run
+      rescue NameError => e
+        stdout invalid_task(e.message)
+      end
+    end
+
+    def task
+      input.task_class.new(input.task_input, view)
+    end
+
+    def invalid_task(error_message)
+      "duty: `#{input.join(' ')}` is not a duty task. Failed with: #{error_message}"
+    end
+
+    def view
+      if verbose?
+        VerboseView.new(output)
+      else
+        View.new(output)
+      end
+    end
+
+    def verbose?
+      input.verbose?
+    end
+
+    class Input
+      def initialize(args)
+        @args = [args].flatten
+      end
+
+      def[](index)
+        @args[index]
+      end
+
+      def drop(index)
+        @args.drop(1)
+      end
+
+      def task_name
+        task, *rest = @args
+        task
+      end
+
+      def task_class
+        name = task_name.split('-').collect(&:capitalize).join
+        Object.const_get("Duty::Tasks::#{name}")
+      end
+
+      def task_input
+        task, *rest = @args
+        rest
+      end
+
+      def join(seperator='')
+        @args.join(seperator)
+      end
+
+      def verbose?
+        @args.include?('-v') || @args.include?('--verbose')
+      end
+
+      def completion?
+        @args.first == '--cmplt'
+      end
+
+      def help?
+        @args.empty? || @args == %w(-h) || @args == %w(--help)
+      end
+    end
+
+    class Output
+      def print(*args)
+        $stdout.puts(*args)
+      end
+
+      def error(*args)
+        $stderr.puts(*args)
+      end
+    end
+
+    class View
+      def initialize(output)
+        @output = output
+      end
+
+      def task_explain(task)
+        task_class = task.class
+        description = task_class.description
+        usage = task_class.usage
+
+        @output.print(description)
+        @output.print(usage)
+      end
+
+      def task_success(task)
+        task_name = task.class.name
+        success("#{task_name} task executed")
+      end
+
+      def task_failure(task)
+        task_name = task.class.name
+        failure("#{task_name} task aborted")
+      end
+
+      def command_success(command)
+        description = command.description
+        success(description)
+      end
+
+      def command_failure(command)
+        description = command.description
+        failure(description)
+      end
+
+      private
+
+      def success(msg)
+        @output.print([check_mark, msg].join(' '))
+      end
+
+      def failure(msg)
+        @output.error([cross_mark, msg].join(' '))
+      end
+
+      def cross_mark
+        unicode("2715")
+      end
+
+      def check_mark
+        unicode("2713")
+      end
+
+      def unicode(code)
+        ["0x#{code}".hex].pack('U')
+      end
+    end
+
+    class VerboseView < View
+      def command_success(command)
+        success(command_msg(command))
+      end
+
+      def command_failure(command)
+        failure(command_msg(command))
+      end
+
+      private
+
+      def command_msg(command)
+        [command.description, command_logs(command)].join(' ')
+      end
+
+      def command_logs(command)
+        elements = command.logger.flatten
+
+        if elements.any?
+          ["|>", elements.join(' | ')].join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/duty/meta/completion.rb

@@ -0,0 +1,41 @@
+module Duty
+  module Meta
+    class Completion
+      def initialize(cli, args)
+        @registry = cli.registry
+        @humanizer = Humanizer.new
+        @input = args.join(" ").downcase
+      end
+
+      def to_s
+        possible_completions
+      end
+
+      private
+
+      attr_reader :registry, :humanizer
+
+      def possible_completions
+        matching_tasks.join("\n")
+      end
+
+      def matching_tasks
+        humanized_tasks.select do |cmd|
+          cmd.start_with?(@input)
+        end
+      end
+
+      def humanized_tasks
+        registry.plugins.map do |plugin|
+          tasks_for(plugin)
+        end.flatten
+      end
+
+      def tasks_for(plugin)
+        plugin.tasks.map do |task_class|
+          humanizer.task(task_class)
+        end
+      end
+    end
+  end
+end

data/lib/duty/meta/help.rb

@@ -0,0 +1,44 @@
+module Duty
+  module Meta
+    class Help
+      def initialize(cli)
+        @registry = cli.registry
+        @humanizer = Humanizer.new
+      end
+
+      def to_s
+        usage
+      end
+
+      private
+
+      attr_reader :registry, :humanizer
+
+      def usage
+        msg = <<-EOF
+Usage: duty <task> [<args>]
+
+Tasks:
+
+#{plugins}
+        EOF
+      end
+
+      def plugins
+        registry.plugins.map do |plugin|
+          [namespace_for(plugin), tasks_for(plugin)].join("\n")
+        end.join("\n")
+      end
+
+      def namespace_for(plugin)
+        "[" + plugin.namespace + "]"
+      end
+
+      def tasks_for(plugin)
+        plugin.tasks.map do |task_class|
+          [" • ", humanizer.task(task_class).ljust(20), task_class.description].join
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/duty/meta/humanizer.rb

@@ -0,0 +1,19 @@
+require 'duty/registry'
+
+module Duty
+  module Meta
+    class Humanizer
+      def task(klass)
+        klass.to_s.
+          gsub(/([A-Z])/, '-\1').
+          split('-').
+          reject(&:empty?).
+          map(&:downcase).
+          join('-').
+          split('::').
+          last.
+          gsub(/^-/,'')
+      end
+    end
+  end
+end

data/lib/duty/meta.rb

@@ -0,0 +1,3 @@
+require 'duty/meta/completion'
+require 'duty/meta/help'
+require 'duty/meta/humanizer'

data/lib/duty/plugins.rb

@@ -0,0 +1,50 @@
+require 'duty/tasks'
+require 'yaml'
+
+module Duty
+  module Plugins
+    def self.load(filename)
+      if File.exists?(filename)
+        duty_config = YAML.load(File.read(filename))
+        tasks = duty_config["tasks"]
+        tasks.map do |namespace, task_dir|
+          Plugin.new(namespace, task_dir) if Dir.exists?(task_dir)
+        end
+      end
+    end
+
+    class Plugin
+      TASK_NAMESPACE = Duty::Tasks
+      def initialize(namespace, task_dir)
+        @namespace = namespace
+        @task_dir = task_dir
+      end
+
+      def namespace
+        @namespace
+      end
+
+      def require_tasks
+        task_files = File.expand_path(File.join(@task_dir, "*.rb"))
+        Dir[task_files].each do |path|
+          require path.gsub(/(\.rb)$/, '')
+        end
+      end
+
+      def tasks
+        task_names = TASK_NAMESPACE.constants - [:Base]
+        task_names.reduce([]) do |task_classes, task_name|
+          task_class = TASK_NAMESPACE.const_get(task_name)
+          task_classes << task_class if valid?(task_class)
+          task_classes
+        end
+      end
+
+      private
+
+      def valid?(task_class)
+        task_class.superclass == TASK_NAMESPACE::Base
+      end
+    end
+  end
+end

data/lib/duty/registry.rb

@@ -0,0 +1,16 @@
+module Duty
+  class Registry
+    def self.load(plugins = [])
+      new(plugins).tap {|registry| registry.require_tasks }
+    end
+
+    attr_reader :plugins
+    def initialize(plugins)
+      @plugins = plugins
+    end
+
+    def require_tasks
+      plugins.each {|plugin| plugin.require_tasks }
+    end
+  end
+end

data/lib/duty/tasks.rb

@@ -0,0 +1,205 @@
+module Duty
+  module Tasks
+    class Base
+      ExecutionError = Class.new(RuntimeError)
+
+      def initialize(arguments, view)
+        @arguments = arguments
+        @view = view
+        @parallel = []
+      end
+
+      def run
+        if !valid?
+          task_explain
+        else
+          begin
+            execute_in_thread
+            task_success
+          rescue ExecutionError
+            task_failure
+          end
+        end
+      end
+
+      def self.name
+        self.to_s.split('::').last
+      end
+
+      def self.description
+        "TODO: Describe your task by overwriting `self.description`"
+      end
+
+      def self.usage
+        "TODO: Explain your task by overwriting `self.usage`"
+      end
+
+      def execute
+        ruby(Proc.new{},'Describe your task')
+        ruby(Proc.new{},'Explain your task')
+        ruby(Proc.new{ raise ExecutionError.new },'TODO: Implement your task by overwriting `execute`')
+      end
+
+      private
+
+      def execute_in_thread
+        Thread.new do
+          execute
+          @parallel.each {|thread| thread.join }
+        end.join
+      end
+
+      def valid?
+        !todo?(self.class.description) && !todo?(self.class.usage)
+      end
+
+      def todo?(string)
+        string.match(/TODO/)
+      end
+
+      def task_explain
+        @view.task_explain(self)
+      end
+
+      def task_success
+        @view.task_success(self)
+      end
+
+      def task_failure
+        @view.task_failure(self)
+      end
+
+      def command_success(command)
+        @view.command_success(command)
+      end
+
+      def command_failure(command)
+        @view.command_failure(command)
+      end
+
+      def parallel(&blk)
+        @parallel << Thread.new(&blk)
+      end
+
+      def ruby(desc = 'Unknown ruby command', &blk)
+        handle_errors(Ruby.run(desc, blk))
+      end
+
+      def sh(desc = 'Unknown shell command', &blk)
+        handle_errors(Shell.run(desc, blk))
+      end
+
+      def handle_errors(command)
+        if command.success?
+          command_success(command)
+        else
+          command_failure(command)
+          raise ExecutionError.new
+        end
+      end
+
+      class Command
+        def initialize(description, callable)
+          @description = description 
+          @callable = callable
+          @success = false
+          @error = nil
+          @logger = []
+        end
+
+        def self.run(description, callable)
+          new(description, callable).tap {|command| command.execute}
+        end
+
+        def success?
+          @success
+        end
+
+        def description
+          @description
+        end
+
+        def logger
+          @logger
+        end
+
+        def error
+          @error
+        end
+      end
+
+      class Ruby < Command
+        def execute
+          begin
+            @callable.call
+            @success = true
+          rescue Exception => e
+            @error = "ERROR: #{e.inspect}"
+          ensure
+            @logger << summary 
+            @logger << error
+          end
+        end
+
+        private
+
+        def summary
+          "[RUBY] #{@callable.inspect}"
+        end
+      end
+
+      class Shell < Command
+        require 'open3'
+        def execute
+          if !cmd
+            @success = true
+            return
+          end
+
+          begin
+            @stdout, @stderr, @status = Open3.capture3(cmd)
+            @success = true if status.success?
+          rescue Exception => e
+            @error = "ERROR: #{e.inspect}"
+          ensure
+            @logger << summary 
+            @logger << error
+          end
+        end
+
+        private
+
+        def summary
+          [
+            "[SHELL]",
+            "COMMAND: #{cmd}",
+            "DIR: #{dir}",
+            "STDOUT: #{stdout}",
+            "STDERR: #{stderr}",
+            "STATUS: #{status}"
+          ]
+        end
+
+        def stdout
+          @stdout
+        end
+
+        def stderr
+          @stderr
+        end
+
+        def status
+          @status
+        end
+
+        def cmd
+          @cmd ||= @callable.call
+        end
+
+        def dir
+          Dir.pwd
+        end
+      end
+    end
+  end
+end

data/lib/duty/version.rb

@@ -0,0 +1,3 @@
+module Duty
+  VERSION = "0.1.0"
+end

data/lib/duty.rb

@@ -0,0 +1,6 @@
+require 'duty/cli'
+require 'duty/tasks'
+require 'duty/version'
+
+module Duty
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: duty
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jan Owiesniak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+description: Duty provides a CLI for high-level tasks
+email:
+- owiesniak@mailbox.org
+executables:
+- duty
+- duty.completion
+extensions: []
+extra_rdoc_files: []
+files:
+- ".duty.yml.sample"
+- ".gitignore"
+- ".gitmodules"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/duty
+- bin/duty.completion
+- duty.gemspec
+- lib/duty.rb
+- lib/duty/cli.rb
+- lib/duty/meta.rb
+- lib/duty/meta/completion.rb
+- lib/duty/meta/help.rb
+- lib/duty/meta/humanizer.rb
+- lib/duty/plugins.rb
+- lib/duty/registry.rb
+- lib/duty/tasks.rb
+- lib/duty/version.rb
+homepage: https://github.com/JanOwiesniak/duty
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Extendable Task Manager
+test_files: []