woro 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39fa870f26707dbc1bdccabb493c211b526027b1
-  data.tar.gz: 97122ef9728188ced1c2ae8b5f7af175c6527b92
+  metadata.gz: 5a7d57892a65138472c52bcf5c91ead031cd022f
+  data.tar.gz: 5fc6dbd1d5e0ab491f9e06a1d17b87ccc69e86bd
 SHA512:
-  metadata.gz: e35e602e70f2c9b06d003633a4e820e164b36e79c17af6394285e1b15702e1ffd976cbb40252ca5bed8a59373f5c3120bf71682d7af4b334ea8fafa2443707ee
-  data.tar.gz: 0d2f2e650b2891e807e5b8766c240b607fa1dfc5d4c63a8fc2a0fc555dcf227b178a34b89490ab368864fc253784587e81fcac31a86a40f262102c60b8658a1b
+  metadata.gz: f0dda43342aab660543a9b115438ab7322ef00242a767518818ec7f81701f25efac7935b3973f2cbe2431819530d929906a489e1e0ead0fda3fc98ecf75fe7b8
+  data.tar.gz: 0a7e6eff1e8467046c18dfdf13eb3111865737438bbdac1f49f76d503ee95585a0c0441e8d630bb8e621099493b5c93ce84f85406a7aeffd2575b93295c8fece

data/README.md

@@ -3,14 +3,14 @@
 Write once, run once.
 
 Manage one-time remote tasks in your Rails project.
-Plugins with Mina that adds support for rake tasks hosted as gists.
+Plugins with Mina to add support for rake tasks hosted in remote collection, such as Gist.
 
-Say you have a data migration to perform on a remote server. The procedure is too complex to just do it in the remote console. Using database migration is evil. A rake task would be nice, but checking this in with the regular repository adds clutter, as you know you will only run this once.
-Woro offers a quick way of pushing rake tasks on the remote server, execute them and delete them instantly. Using Github's gist, you keep version control of the tasks and can share them with colleagues.
+Say you have a data migration to perform on a remote server. The procedure is too complex to just do it in the remote console and using database migrations would be evil. A rake task would be nice, but checking this in with the source code repository adds clutter, as you know you will only run this once.
+Woro offers a quick way of pushing rake tasks onto the remote server, execute them and delete them instantly. Using Github's gist, you keep version control of the tasks and can share them with colleagues.
 
-Woro helps you create rake task, that you can develop and run locally.
-Once you are ready, woro let's you push them online as a gist.
-Using a mina deployment setup, you these tasks are downloaded on the remote system, executing using rake and cleaned up afterwards.
+Woro helps you create rake tasks, that you can develop and run locally.
+Once you are ready, woro let's you push them online to a remote collection like Gist.
+Using a mina deployment setup, these tasks are downloaded on the remote system, executed by rake and cleaned up afterwards.
 
 ## Installation
 
@@ -55,7 +55,7 @@ end
 Then run:
 
 ```shell
-$ mina woro:init
+$ woro init
 ```
 
 This will create `lib/woro_tasks/` folder and `lib/tasks/woro.rake`.
@@ -64,7 +64,7 @@ Here the Woro task files are stored and edited locally.
 ## Usage
 
 ```shell
-$ mina woro:new task=cleanup_users
+$ woro new cleanup_users
 ```
 
 Can be used to create the template for a new task in `lib/tasks/`.
@@ -79,7 +79,7 @@ Once you are done writing the task and you want to execute it on the remote syst
 First you have to push them online.
 
 ```shell
-$ mina woro:push task=cleanup_users
+$ woro push cleanup_users
 ```
 
 _Attention, depending on whether you set up a Gist/Github login on
@@ -87,29 +87,22 @@ initialization. These tasks are online anonymous, but public, or
 private under the specified Github account._
 
 
-Now, to run a task remotely, specify the task:
+Now, to run a task remotely using mina, specify the task:
 
 ```shell
 $ mina woro:run task=cleanup_users
 ```
 
-
-Or do pushing and running in one step:
-
-```shell
-$ mina woro:execute task=cleanup_users
-```
-
 To show a list of all uploaded tasks do:
 
 ```shell
-$ mina woro:list
+$ woro list
 ```
 
 And finally you can download an existing task:
 
 ```shell
-$ mina woro:pull task=cleanup_users
+$ woro pull cleanup_users
 ```
 
 ## Contributing

data/bin/woro

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require 'commander/import'
+require 'woro'
+
+program :name, 'woro'
+program :version, Woro::VERSION
+program :description, 'Write once, run once - Management of one-time remote tasks
+Plugins with Mina to add support for rake tasks hosted in remote collection, such as Gist.
+
+Say you have a data migration to perform on a remote server. The procedure is too complex
+to just do it in the remote console and using database migrations would be evil.
+A rake task would be nice, but checking this in with the source code repository
+adds clutter, as you know you will only run this once.
+Woro offers a quick way of pushing rake tasks onto the remote server, execute them
+and delete them instantly. Using Github\'s gist, you keep version control of the tasks
+and can share them with colleagues.
+
+Woro helps you create rake tasks, that you can develop and run locally.
+Once you are ready, woro let\'s you push them online to a remote collection like Gist.
+Using a mina deployment setup, these tasks are downloaded on the remote system,
+executed by rake and cleaned up afterwards.'
+
+default_command :list
+
+command :init do |c|
+  c.syntax      = 'woro init [options]'
+  c.description = 'Initialize Woro in the current Rails directory and setup Gist collection'
+  c.option '--[no-]force', 'force overwrite of existing config file'
+  c.action do |args, options|
+
+    if agree 'Login to Gist/Github for private Woro tasks (Yes/No)?  '
+      Gist.login!
+    #else
+      #gen_access_token = agree "Secure gists via random access token?"
+    end
+
+
+    # create Gist with welcome file
+    # additional tasks will be added to this first gist
+    app_name = ask 'Application name: '
+    result = Woro::Gister.create_initial_gist(app_name)
+
+    # configure adapters
+    gist_adapter = {
+      gist_id: result['id'],
+      public: false
+    }
+    # TODO generate access token
+    #gist_adapter[:access_token] = 'access_token' if gen_access_token
+    adapters = { gist: gist_adapter }
+
+    unless File.exists? File.dirname(Woro::Configuration.config_file)
+      FileUtils.mkdir_p File.dirname(Woro::Configuration.config_file)
+    end
+    config = Woro::Configuration.save(adapters: adapters)
+    say 'Initialized at `./config/woro.yml`'
+
+    unless File.exists? config.woro_task_dir
+      FileUtils.mkdir_p
+      say "Create #{config.woro_task_dir}"
+    end
+
+    say "Create woro.rake in #{config.rake_task_dir}"
+    FileUtils.mkdir_p config.rake_task_dir if !File.exists? config.rake_task_dir
+    FileUtils.cp(File.dirname(__FILE__) + '/../lib/woro/templates/woro.rake', config.rake_task_dir)
+  end
+end
+
+command :new do |c|
+  c.syntax      = 'woro create <task> [options]'
+  c.summary     = 'Create new tasks'
+  c.description = 'Creates one or more new templated Rake tasks'
+  c.example 'Create task called "cleanup"', 'woro new cleanup'
+  c.example 'Creates tasks called "cleanup", "fix1" and "fix2"', 'woro new cleanup fix1 fix2'
+  c.option '--[no-]force', 'force overwrite of existing task file'
+  c.action do |args, options|
+    args.each do |arg|
+      config = Woro::Configuration.load
+      task = Woro::Task.new(config.adapters[:gist][:gist_id], arg)
+      force_overwrite = options.force
+      if !task.exists? || force_overwrite || agree("Overwrite existing #{task.file_path}?")
+        task.create_from_task_template
+        say "Created #{task.file_path}"
+      end
+    end
+  end
+end
+
+command :push do |c|
+  c.syntax      = 'woro push <task> [options]'
+  c.summary     = 'Push tasks to remote collection, updates existing tasks'
+  c.description = 'Pushes one or more local tasks to the remote collection. Existing tasks by this name in the remote connection will be updated.'
+  c.example 'Pushes the task "cleanup" to the remote collection', 'woro push cleanup'
+  c.action do |args, options|
+    args.each do |arg|
+      config = Woro::Configuration.load
+      # Pushes a new woro task by given name to gist, this can be done multiple time.
+      task = Woro::Task.new(config.adapters[:gist][:gist_id], arg)
+      if task.exists?
+        result = task.push
+        say "Uploaded #{task.file_path} to #{result['url']}"
+      else
+        say "Task #{task.task_name} not found at #{task.file_path}"
+      end
+    end
+  end
+end
+
+command :pull do |c|
+  c.syntax      = 'woro pull <task> [options]'
+  c.summary     = 'Pull Woro task from remote repository'
+  c.description = 'Pulls one task from the remote collection. Existing local tasks can be overwritten.'
+  c.example 'Pulls the task "cleanup" from the remote collection', 'woro pull cleanup'
+  c.option '--[no-]force', 'force overwrite of existing task file'
+  c.action do |args, options|
+    config = Woro::Configuration.load
+    # Pulls the  woro task by given name to gist, this can be done multiple time.
+    task = Woro::Task.new(config.adapters[:gist][:gist_id], args.first)
+    force_save = options.force
+    if !task.exists? || force_overwrite || agree("Overwrite existing #{task.file_path}?")
+      system "cd '#{config.woro_task_dir}' && curl -O -# #{task.raw_url}"
+      say "Downloaded #{task.task_name} to #{task.file_path}"
+    end
+  end
+end
+
+command :list do |c|
+  c.syntax      = 'woro [list|ls] [options]'
+  c.description = 'List tasks'
+  c.example 'List remote tasks', 'woro list'
+  c.example 'List all tasks', 'woro list --all'
+  c.option '-a', '--all', 'List all tasks'
+  c.action do |args, options|
+    abort "invalid command. See 'woro help' for more information" unless args.empty?
+    config = Woro::Configuration.load
+    files = Woro::Gister.get_list_of_files config.adapters[:gist][:gist_id]
+    tasks = files.map { |file_name, data| OpenStruct.new(name_with_args: file_name.split('.rake').first, comment: Woro::Gister.extract_description(data)) if file_name.include? '.rake' }
+    tasks.compact!
+    width ||= tasks.map { |t| t.name_with_args.length }.max || 10
+    tasks.each do |t|
+      puts "  %-#{width}s   # %s" % [ t.name_with_args, t.comment ]
+    end
+  end
+end
+alias_command :ls, :list
+

data/lib/woro/configuration.rb

@@ -0,0 +1,61 @@
+require 'yaml'
+require 'commander'
+include Commander::UI
+
+module Woro
+  class Configuration
+    attr_reader :adapters, :woro_task_dir
+
+    # Initialize configuration.
+    def initialize(options = {})
+      @woro_task_dir = Configuration.woro_task_dir
+      @adapters = options[:adapters]
+    end
+
+    # Load configuration file or default_options. Passed options take precedence.
+    def self.load(options = {})
+      user_options = options.reject{|k,v| ![:adapters, :app_name].include? k}
+
+      if !(File.exists? config_file)
+        File.open(config_file, 'w') { |file| YAML::dump(default_options, file) }
+        say "Initialized default config file in #{config_file}. See 'woro help init' for options."
+      end
+
+      config_file_options = YAML.load_file(config_file)
+      new(config_file_options.merge(user_options))
+    end
+
+    # Save configuration. Passed options take precendence over default_options.
+    def self.save(options = {})
+      user_options = options.reject{|k,v| ![:adapters, :app_name].include? k}
+      force_save = options.delete :force
+
+      if !(File.exists? config_file) || force_save
+        File.open(config_file, 'w') { |file| YAML::dump(default_options.merge(user_options), file) }
+        say "Initialized config file in #{config_file}"
+      else
+        say_error "Not overwriting existing config file #{config_file}, use --force to override. See 'woro help init'."
+      end
+      self
+    end
+
+    # Helpers
+
+    def self.config_file
+      File.join('config', 'woro.yml')
+    end
+
+    def self.woro_task_dir
+      File.join('lib', 'woro_tasks')
+    end
+
+    def self.rake_task_dir
+      File.join('lib', 'tasks')
+    end
+
+    def self.default_options
+      {
+      }
+    end
+  end
+end

data/lib/woro/gister.rb

@@ -1,22 +1,45 @@
 require 'gist'
 require 'net/https'
 
+# All classes and modules specific to Woro.
 module Woro
+  # Various shared static helpers
   class Gister
     class << self
-      def create_initial_gist(app_name)
-        Gist.gist("Welcome to the Woro Task Repository for #{app_name}", filename: app_name)
+      # Creates an initial welcome gist on project setup
+      # @param app_name [String] Name of the app is displayed in the initial welcome message
+      def create_initial_gist(app_name, access_token=nil)
+        Gist.gist("Welcome to the Woro Task Repository for #{app_name}", filename: app_name, access_token: access_token)
       end
 
+      # Retrieves metadata of the specified gist
+      # @param gist_id [String] id of the gist
+      # @return [Hash] parsed JSON hash
       def retrieve_gist(gist_id)
         service_url = "https://api.github.com/gists/#{gist_id}"
         response = Net::HTTP.get_response(URI.parse(service_url))
         JSON.parse(response.body)
       end
 
+      # Extract description from gist's data content string.
+      # @param data [Hash] gist data hash
+      # [String] description string
+      def extract_description(data)
+        data['content'].match(/desc ['"]([a-zA-Z0-9\s]*)['"]/)[1]
+      end
+
+      # Returns the list of files included in the specified gist
+      # @param gist_id [String] id of the gist
+      # @return [Hash] List of files in the format { filename: { data }}
       def get_list_of_files(gist_id)
         retrieve_gist(gist_id)['files']
       end
+
+      # Read the rake task template
+      # @return [String]
+      def read_template_file
+        File.read(File.dirname(__FILE__) + '/templates/task.rake')
+      end
     end
   end
 end

data/lib/woro/task.rb

@@ -2,43 +2,71 @@ require 'net/https'
 require 'erb'
 
 module Woro
+  # Task object, helps in the creation and management of gists.
   class Task
     attr_reader :task_name, :gist_id, :gist
 
     def initialize(gist_id, task_name)
-      @task_name = task_name
+      @task_name = Woro::Task.sanitize_task_name task_name
       @gist_id = gist_id
     end
 
+    # Create a new task based on a template rake-task.
+    # @param gist_id [String] gist to which the task is added
+    # @param task_name [String] sanitized name of the task, used throughout the further processing
+    # @return [Task] the created task
     def self.create(gist_id, task_name)
       task = Woro::Task.new(gist_id, task_name)
-      task.create_empty_task
+      task.create_from_task_template
+      task
     end
 
+    def self.sanitize_task_name(task_name)
+      task_name.strip.split(' ').first
+    end
+
+    # File name based on the task's name.
+    # @return [String]
     def file_name
       "#{task_name}.rake"
     end
 
+    # File name based on the task's filename (see #file_name).
+    # @return [String]
     def file_path
-      "lib/woro_tasks/#{file_name}"
+      File.join('lib','woro_tasks', file_name)
+    end
+
+    # Returns true if a task of this name exists locally
+    def exists?
+      File.exists? file_path
     end
 
-    def create_empty_task
+    # Creates a new rake task file at the file path (see #file_path).
+    def create_from_task_template
       b = binding
-      template = ERB.new(read_template_file).result(b)
+      template = ERB.new(Gister.read_template_file).result(b)
       File.open(file_path, 'w') do |f|
         f.puts template
       end
     end
 
-    def read_template_file
-      File.read(File.dirname(__FILE__) +"/templates/task.rake")
+    # Requests the content of the task file within the Gist collection
+    # from the server.
+    # @return [String]
+    def retrieve_raw_file
+      response = Net::HTTP.get_response(raw_url)
+      response.body
     end
 
+    # Read the content of the local rake task file on #file_path.
     def read_task_file
       File.read(file_path)
     end
 
+    # Push this task's file content to the Gist collection on the server.
+    # Existing contents by the same #file_name will be overriden, but
+    # can be accessed via Github or Gist's API.
     def push
       Gist.multi_gist({ file_name => read_task_file },
                        public: false,
@@ -46,21 +74,23 @@ module Woro
                        output: :all)
     end
 
+    # The Gist contains a collection of files.
+    # These are stored and accessed on Github.
+    # @return [Hash] parsed JSON hash of the gist's metadata
     def gist
       @gist ||= Gister.retrieve_gist(gist_id)
     end
 
+    # Retrieves the data hash included in the gist under the #file_name.
+    # @return [Hash] parsed JSON hash
     def retrieve_file_data
       gist['files'][file_name]
     end
 
+    # The raw url is a permalink for downloading the content rake task within
+    # the Gist as a file.
     def raw_url
       retrieve_file_data['raw_url']
     end
-
-    def retrieve_raw_file
-      response = Net::HTTP.get_response(raw_url)
-      response.body
-    end
   end
 end

data/lib/woro/tasks/capistrano.rake

@@ -0,0 +1,58 @@
+require 'ostruct'
+require 'woro/gister'
+require 'woro/task'
+
+# Capistrano Recipes for managing woro tasks
+#
+# Add these callbacks to have the delayed_job process restart when the server
+# is restarted:
+#
+#   after "deploy:stop",    "delayed_job:stop"
+#   after "deploy:start",   "delayed_job:start"
+#   after "deploy:restart", "delayed_job:restart"
+#
+# If you want to use command line options, for example to start multiple workers,
+# define a Capistrano variable delayed_job_args:
+#
+#   set :delayed_job_args, "-n 2"
+#
+# If you've got delayed_job workers running on a servers, you can also specify
+# which servers have delayed_job running and should be restarted after deploy.
+#
+#   set :delayed_job_server_role, :worker
+#
+
+Capistrano::Configuration.instance.load do
+  namespace :delayed_job do
+    def rails_env
+      fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
+    end
+
+    def args
+      fetch(:delayed_job_args, '')
+    end
+
+    def roles
+      fetch(:delayed_job_server_role, :app)
+    end
+
+    def delayed_job_command
+      fetch(:delayed_job_command, 'script/delayed_job')
+    end
+
+    desc 'Stop the delayed_job process'
+    task :stop, :roles => lambda { roles } do
+      run "cd #{current_path} && #{rails_env} #{delayed_job_command} stop #{args}"
+    end
+
+    desc 'Start the delayed_job process'
+    task :start, :roles => lambda { roles } do
+      run "cd #{current_path} && #{rails_env} #{delayed_job_command} start #{args}"
+    end
+
+    desc 'Restart the delayed_job process'
+    task :restart, :roles => lambda { roles } do
+      run "cd #{current_path} && #{rails_env} #{delayed_job_command} restart #{args}"
+    end
+  end
+end

data/lib/woro/tasks/mina.rake

@@ -1,113 +1,17 @@
 require 'ostruct'
-require 'woro/gister'
-require 'woro/task'
-
-def _tasks_dir
-  fetch(:tasks_dir, 'lib/woro_tasks')
-end
-
-def prompt(*args)
-  print(*args)
-  STDIN.gets.chomp
-end
-
-def sanitized_task_name
-  ENV['task'].strip.split(' ').first
-end
-
-def check_presence_of_task_name
-  if ENV['task'].nil?
-    print_error('No taskname given.')
-    raise 'No taskname given'
-  end
-end
-
-def extract_description(data)
-  data['content'].match(/desc ['"]([a-zA-Z0-9\s]*)['"]/)[1]
-end
+require 'woro'
 
 # tasks available to mina to run remotely
 namespace :woro do
-
-  desc 'Initialize new Woro repository'
-  task :init do
-    print status 'Configure Gist/Github access'
-
-    login_gist = prompt "Login to Gist/Github for private Woro tasks (Yes/No):"
-    if %w(yes y).include? login_gist
-      Gist.login!
-    #else
-    #  access_token = prompt "Secure gists via Access Token:"
-    end
-
-    # create Gist with welcome file
-    # additional tasks will be added to this first gist
-    app_name = fetch(:app_name, 'TestApp') #Rails.application.class.parent_name
-    result = Woro::Gister.create_initial_gist(app_name)
-
-    print status 'Setup in your project'
-    print_stdout "add this to your deploy.rb:"
-    print_stdout "set :woro_token, '#{result['id']}"
-
-    print status 'Create woro_tasks in lib/'
-    FileUtils.mkdir_p _tasks_dir if !File.exists? _tasks_dir
-
-    print status 'Create woro.rake in lib/tasks/'
-    FileUtils.cp(File.dirname(__FILE__) +"/templates/woro.rake", 'lib/tasks/')
-  end
-
-  desc 'Create new Woro task'
-  task :new do
-    check_presence_of_task_name
-    print_status "Create lib/woro_tasks/#{sanitized_task_name}.rake"
-    Woro::Task.create(fetch(:woro_token), sanitized_task_name)
-  end
-
-  desc 'Push and run Woro task remotely'
-  task execute: environment do
-    invoke :'woro:push'
-    invoke :'woro:run'
-  end
-
-  desc 'Push Woro task to remote repository, updates existing'
-  task :push do
-    check_presence_of_task_name
-    # Pushes a new woro task by given name to gist, this can be done multiple time.
-    task = Woro::Task.new(fetch(:woro_token), sanitized_task_name)
-    print_status "Upload lib/woro_tasks/#{sanitized_task_name}.rake"
-    task.push
-  end
-
-  desc 'Pull Woro task from remote repository'
-  task :pull do
-    check_presence_of_task_name
-    # Pulls the  woro task by given name to gist, this can be done multiple time.
-    task = Woro::Task.new(fetch(:woro_token), sanitized_task_name)
-    print_status "Download #{sanitized_task_name} to lib/woro_tasks/#{sanitized_task_name}.rake"
-    system "cd 'lib/tasks' && curl -O -# #{task.raw_url}"
-  end
-
   desc 'Run Woro task remotely'
   task run: :environment do
-    check_presence_of_task_name
-    task = Woro::Task.new(fetch(:woro_token), sanitized_task_name)
-
-    print_status "Execute #{sanitized_task_name} remotely"
+    config = Woro::Configuration.load
+    task = Woro::Task.new(config.adapter[:gist][:gist_id], ENV['task'])
+    print_status "Execute #{task.task_name} remotely"
     in_directory "#{app_path}" do
       queue! "cd 'lib/tasks' && curl -O #{task.raw_url}"
-      queue! "#{bundle_prefix} rake woro:#{sanitized_task_name}"
+      queue! "#{bundle_prefix} rake woro:#{task.task_name}"
       queue! "rm lib/tasks/#{task.file_name}"
     end
   end
-
-  desc 'List all remote Woro tasks'
-  task :list do
-    files = Woro::Gister.get_list_of_files(fetch(:woro_token))
-    tasks = files.map { |file_name, data| OpenStruct.new(name_with_args: file_name.split('.rake').first, comment: extract_description(data)) if file_name.include? '.rake' }
-    tasks.compact!
-    width ||= tasks.map { |t| t.name_with_args.length }.max || 10
-    tasks.each do |t|
-      puts "  #{name} %-#{width}s   # %s" % [ t.name_with_args, t.comment ]
-    end
-  end
 end

data/lib/woro/version.rb

@@ -1,3 +1,4 @@
 module Woro
-  VERSION = "0.0.2"
+  # Look shiny!
+  VERSION = "0.1.0"
 end

data/lib/woro.rb

@@ -0,0 +1,4 @@
+require 'woro/version'
+require 'woro/task'
+require 'woro/gister'
+require 'woro/configuration'

data/woro.gemspec

@@ -18,8 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "mina", ">= 0.2.1"
   spec.add_dependency "gist"
+  spec.add_dependency "commander"
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,31 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: woro
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Daniel Senff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-19 00:00:00.000000000 Z
+date: 2015-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: mina
+  name: gist
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: gist
+  name: commander
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -181,7 +181,8 @@ dependencies:
 description: One-time migration task management on remote servers through mina.
 email:
 - mail@danielsenff.de
-executables: []
+executables:
+- woro
 extensions: []
 extra_rdoc_files: []
 files:
@@ -190,9 +191,13 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/woro
 - lib/mina/woro.rb
+- lib/woro.rb
+- lib/woro/configuration.rb
 - lib/woro/gister.rb
 - lib/woro/task.rb
+- lib/woro/tasks/capistrano.rake
 - lib/woro/tasks/mina.rake
 - lib/woro/templates/task.rake
 - lib/woro/templates/woro.rake