exctl 0.0.1

data/.attic/c_src/get-version.c

@@ -0,0 +1,245 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <time.h>
+#include <sys/time.h>
+#include <errno.h>
+#define GCC_VERSION (__GNUC__ * 10000 \
+                               + __GNUC_MINOR__ * 100 \
+                               + __GNUC_PATCHLEVEL__)
+#if GCC_VERSION >= 40500
+#define _unreachable()  __builtin_unreachable()
+#else
+#define _unreachable() do { abort(); } while(0)
+#endif
+#define xstr(N)  #N
+#define str(N)   xstr(N)
+#define perr()   perror("ERROR [line " str(__LINE__) "]")
+#define snap()   {perr(); exit(1);}
+#define $(EXPR)  if((EXPR) == -1) snap()
+#define $j(EXPR) if((EXPR) == -1) {perr(); goto err;}
+
+size_t quick_run(char **argv, char *buf, size_t max_len) {
+    int pfildes[2];
+    $( pipe(pfildes) );
+    int pid = vfork();
+    if(!pid) {
+        close (pfildes[0]);
+        dup2  (pfildes[1],1);
+        close (pfildes[1]);
+        execvp(argv[0], argv);
+        perr();
+        _exit(1);
+    } else $( pid );
+    close(pfildes[1]);
+    ssize_t size = read(pfildes[0], buf, max_len - 1);
+    $( size );
+    buf[size] = '\0';
+    close(pfildes[0]);
+    return (size_t)size;
+}
+#if 0
+// Safer version of quick_run if I ever run into trouble...
+size_t quick_run(const char *cmd) {
+    FILE   *proc = popen(cmd, "r");
+    size_t  size = fread(proc_output, sizeof(proc_output)-1, sizeof(char), proc);
+    proc_output[size-1] = '\0';
+    pclose(proc);
+    return size;
+}
+#endif
+
+
+void get_last_dirty_modification_stamp(char *buf, size_t max_size) {
+    int cwd;
+    cwd = 0;
+    char *cmd_gitroot [] = {"git", "rev-parse", "--show-toplevel", NULL};
+    char *cmd_gitdirty[] = {"git", "status", "--porcelain", "-uno", "-z", NULL};
+    int pfildes[2];
+    $j( pipe(pfildes) );
+    int pid = fork();
+    if(!pid) {
+        close (pfildes[0]);
+        dup2  (pfildes[1],1);
+        close (pfildes[1]);
+        execvp(cmd_gitdirty[0], cmd_gitdirty);
+        perr  ( );
+        _exit (1);
+        _unreachable();
+    } else $j( pid );
+    close(pfildes[1]);
+
+    char pathbuf[MAXPATHLEN + 5];
+    $j(cwd = open(".", O_RDONLY));
+    size_t pathlen = quick_run(cmd_gitroot, pathbuf, sizeof(pathbuf));
+    pathbuf[pathlen - 1] = '\0'; // chomp
+    $j(chdir(pathbuf));
+
+    FILE *cmd_res = fdopen(pfildes[0], "r");
+    if(cmd_res == NULL) $j(-1);
+
+    char    *line = pathbuf;
+    size_t   linecap = MAXPATHLEN + 5;
+    ssize_t  linelen;
+    int      ignore_one = 0;
+    time_t   newest_change = 0;
+    while( (linelen = getdelim(&line, &linecap, 0, cmd_res)) > 0) {
+        if(ignore_one) {
+            ignore_one = 0;
+            continue;
+        }
+        if(linelen > 3) {
+            if     (line[1] == 'M' || line[0] == 'M' ||
+                    line[1] == 'A' || line[0] == 'A' ||
+                    line[1] == 'R' || line[0] == 'R' ||
+                    line[1] == 'C' || line[0] == 'C' ||
+                    line[1] == 'U' || line[0] == 'U' ||
+                    line[1] == 'S' || line[0] == 'S' ||
+                    line[1] == '?' || line[0] == '?') {
+                // git never uses 'S'- but without it there is no... Marcus?
+                ignore_one = (line[1] == 'R' || line[0] == 'R');
+                struct stat fst;
+                if(stat(&(line[3]), &fst) == -1) {
+                    if(errno == ENOENT) continue;
+                    $j(-1);
+                }
+#ifdef __linux__
+                if(fst.st_mtime > newest_change) newest_change = fst.st_mtime;
+#else
+                if(fst.st_mtimespec.tv_sec > newest_change) newest_change = fst.st_mtimespec.tv_sec;
+#endif
+            }
+        }
+    }
+
+    if(newest_change < 0) {
+        struct timeval tp;
+        gettimeofday(&tp, NULL);
+        newest_change = tp.tv_sec;
+    }
+    struct tm tmval;
+    gmtime_r(&(newest_change), &tmval);
+    strftime(buf, max_size-1, "d.%Y%m%d.%H%M%S",&tmval);
+
+    if(fchdir(cwd)){};
+    close(cwd);
+    fclose(cmd_res);
+    return;
+
+err:
+    if(cwd) {
+        if(fchdir(cwd)){}
+        close(cwd);
+    }
+    exit(1);
+}
+
+
+#define adv(PCHR)    while(*(PCHR) != '\0' && *(PCHR) != '-' && *(PCHR) != '\n'){(PCHR)++;} (PCHR)[0]='\0';(PCHR)++
+#define pr(CONSTR)   $(write(STDOUT_FILENO, CONSTR, sizeof(CONSTR)-1))
+#define prs(BUF)     $(write(STDOUT_FILENO, BUF, strnlen(BUF, 256)))
+#define prl(BUF,LEN) $(write(STDOUT_FILENO, BUF, LEN))
+
+int main(int argc, char **argv) {
+    int   i;
+    int   is_dirty;
+
+    // Commands
+    char *cmd_gitdesc[] = {"git","describe", "--match", "v[0-9.]*", "--dirty", "--long", "--always", NULL};
+
+    // Some constants and buffers
+    char  describe_res  [256] = {0};
+    char  default_vmajor[]    = "v0.0.0";
+    char  default_vnumc []    = "0";
+    char  unknown_vnumc []    = "u";
+    char  dirty_is_true [32]  = {0};
+    char  dirty_is_false[]    = "c";
+
+    // Destination strings for various pieces.
+    char *vhash               = NULL;
+    char *vmajor              = NULL;
+    char *vdirty              = dirty_is_false;
+    char *vnum_commits        = unknown_vnumc;
+
+    quick_run(cmd_gitdesc, describe_res, sizeof(describe_res) - 5); // -5 for padding for parser below
+    char *p = describe_res;
+    if(*p == 'v') {
+        vmajor = p++; // Got git tag w/ version
+        adv(p); // Advance past & terminate vmajor
+        // Next will be either num_commits or hash
+        char *pstart = p;
+        while(1) {
+            if(*p == '-') {
+                vnum_commits = pstart;
+                adv(p);
+                vhash = p++;
+                break;
+            } else if(*p < '0' || *p > '9') {
+                vhash = pstart;
+                vnum_commits = default_vnumc;
+                break;
+            }
+            p++;
+        }
+    } else {
+        vmajor = default_vmajor; // No git tag with a version
+        vhash = describe_res;    // But we've got the vhash- skip to dirty-check
+        // TODO: calculate vnum_commits. In Ruby I was doing it like this:
+        //       >    plus_commits = `git shortlog -s`.scan(/\d+/) # should cut name off first
+        //       >    plus_commits = plus_commits.map{|p| p.to_i}.reduce(:+)
+    }
+
+    adv(p); // Advance to the end of and terminate the vhash
+    is_dirty = p[1] == 'i';
+
+    if(is_dirty) {
+        vdirty = dirty_is_true;
+        get_last_dirty_modification_stamp(vdirty, sizeof(dirty_is_true));
+    }
+
+    if(argc == 1) {
+        // Strictly the version
+        prs(vmajor);
+        if(is_dirty || vnum_commits[0]!='0') {
+            //pr ("+build.");
+            pr ("+");
+            prs(vnum_commits); pr (".");
+            prs(vdirty);       pr (".");
+            if(vhash[0] != 'g')     pr ("g");
+            prs(vhash);
+        }
+        pr("\n");
+    } else {
+        char *cmd_gitbranch[] = {"git", "rev-parse", "--abbrev-ref", "HEAD", NULL};
+        char  gitbr[256];
+        size_t gitbr_size = quick_run(cmd_gitbranch, gitbr, sizeof(gitbr));
+        gitbr[gitbr_size - 1] = '\0'; // chomp
+        for(i=1; i<argc; i++) {
+            int j=0;
+            while(argv[i][j] != 0) {
+                if(argv[i][j] > 0x60 && argv[i][j] < 0x7B) argv[i][j] -= 0x20;
+                j++;
+            }
+            // Define statements
+            pr("#define "); prl(argv[i],j); pr("_VERSION_MAJOR_STR \""); prs(vmajor); pr("\"\n");
+            pr("#define "); prl(argv[i],j); pr("_VERSION_BUILD_STR \"");
+            if(is_dirty || vnum_commits[0]!='0') {
+                //pr("+build.");
+                pr("+"); prs(vnum_commits); pr("."); prs(vdirty); pr(".");
+                if(vhash[0] != 'g') pr("g"); prs(vhash);
+            }
+            pr("\"\n");
+            pr("#define "); prl(argv[i],j); pr("_VERSION_DETAILS_STR_BRANCH \""); prs(gitbr); pr("\"\n");
+            pr("#define "); prl(argv[i],j); pr("_VERSION_DETAILS_STR_COMMIT \"");
+            (vhash[0] == 'g') ? ({prs(&(vhash[1]))}) : ({prs(vhash)});
+            pr("\"\n");
+        }
+    }
+
+    return 0;
+}

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 1.8.7"
+end

data/Gemfile.lock

@@ -0,0 +1,72 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (4.0.1)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    addressable (2.3.5)
+    atomic (1.1.14)
+    builder (3.2.2)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
+    git (1.2.6)
+    github_api (0.10.1)
+      addressable
+      faraday (~> 0.8.1)
+      hashie (>= 1.2)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    hashie (2.0.5)
+    highline (1.6.20)
+    httpauth (0.2.0)
+    i18n (0.6.5)
+    jeweler (1.8.8)
+      builder
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      nokogiri (= 1.5.10)
+      rake
+      rdoc
+    json (1.8.1)
+    jwt (0.1.8)
+      multi_json (>= 1.5)
+    minitest (4.7.5)
+    multi_json (1.8.2)
+    multi_xml (0.5.5)
+    multipart-post (1.2.0)
+    nokogiri (1.5.10)
+    oauth2 (0.9.2)
+      faraday (~> 0.8)
+      httpauth (~> 0.2)
+      jwt (~> 0.1.4)
+      multi_json (~> 1.0)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.1.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.1.5)
+    shoulda-matchers (2.4.0)
+      activesupport (>= 3.0.0)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  jeweler (~> 1.8.7)
+  rdoc (~> 3.12)
+  shoulda

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Joseph Wecker
+
+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/OPERUM.md

@@ -0,0 +1,17 @@
+- () for simplicity, just quickly gcc get-version if required when running
+- () default tasks
+  - () (project)
+    - () version
+    - () version.bump {.major|.minor|.patch}   # Defaults to patch
+    - () 
+
+  - () (iterate)
+    - () test
+    - () 
+
+  - () (deploy)
+    - () hotfix (... ?)
+    - () release
+      - () git tag with verion (or do that with bump instead and use '-...' build info until it's released?)
+      - () Also generates the reltools release etc.?
+    - () 

data/README.md

@@ -0,0 +1,17 @@
+exctl
+=====
+
+Project-specific command dispatcher using DRY and convention-over-configuration principles as much as possible.
+
+So for a given project you will be able to create a command heirarchy (think `git *` or `gem *`- now you can make
+`my-project *`) with the ability to detect and document (for command-line help as well as manpages) new tasks etc.
+
+This allows you to have development-related tasks, packaging/installing/deployment-related tasks, and of course
+runtime tasks (such as running the application).
+
+Why? Because I've reimplemented this so many times for specific projects that I'm finally abstracting it.
+
+Copyright
+---------
+
+Copyright (c) 2013 Joseph Wecker. See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name        = "exctl"
+  gem.homepage    = "http://github.com/josephwecker/exctl"
+  gem.license     = "MIT"
+  gem.summary     = %Q{Project-specific command-line task dispatcher generator.}
+  gem.description = %Q{Allows you to create a command-line dispatcher for a project to consolidate dev, release, and runtime workflows.}
+  gem.email       = "joseph.wecker@gmail.com"
+  gem.authors     = ["Joseph Wecker"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "exctl #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/notes.md

@@ -0,0 +1,107 @@
+
+
+why?
+----
+
+because I've done this over and over again:
+
+  - rake wrapper I did for jtv-web project (probably prettiest)
+  - imb- earlier metacon-like, then current dispatcher (most complete)
+  - quick command wrapper I did for fxsig
+  - metacon- bash version and start of C version
+  - some Proj stuff in shorthand
+  - lots of custom vim stuff that started to be a lot more project-aware
+  - I believe I might have even done one for zerl back in the day...
+  - not by me: rake, make, git, rebar, rvm, reltools output ctl script, most init.d type scripts...
+
+
+
+meta-exctl
+---------
+ - initiate project
+ - set up initial directory structure
+   - eventually different depending on various templates (e.g., erlang-apps, ruby gem, etc.)
+ - local version of exctl files
+ - create shell wrapper that has project-specific invocation name etc.
+ - command for dumping information about the project - including known tasks etc.
+
+
+aggregate features
+------------------
+
+- (convention over configuration)
+- quickly add and document external commands, scripts, code...
+- wrap around and delegate to rake, rebar, mix, custom code, and/or standalone scripts/shell-commands
+- dev/build tools integrated with / blended into server name
+- families of (high-level) commands (ala git)
+- families of commands (hierarchies- deps.get, db:create, ...)
+- execute sequential commands
+- default command (possibly contextual)
+- commands with automatically triggered precondition commands
+- semantic- explains itself, including most common / necessary commands (possibly contextual- i.e., build commands if it hasn't been built yet, run commands if it has, etc.)
+- automatic manpage generation from same definitions?
+- bash/zsh completion (automatically refreshed as necessary)
+- very fast
+- colored output
+- default help, man, version (semantic & w/ git) commands
+- allows for older style commandline args- at least expected gnu standards like -h, --help, -v, --version, etc.
+- correctly manipulates environment variables before delegating
+- @<env> environment shorthand
+- always show environment except for possibly --version etc...
+- default values
+- post-format entered values
+- allow for a configuration / environment / commandline-option option hierarchy
+- multiple instances / servers / daemons running simultaneously and potentially aware of each other
+- for compiled languages- make sure each environment has an isolated build target directory (including rel nodes for erlang, etc.)
+- usually a fallback build method that is going to be expected by a maintainer
+
+- tasks done "in the background" as much as possible- e.g., simply try to run the program and it will realize it needs
+  to compile the dev version first.
+
+(and some new features)
+
+- default 'status' command (long and short [for ps1 integration or something]) possibly plugin-able - git-state, build-state, coverage-state, running-instances, ...
+- automatic environment detection- e.g., via hostname, cwd, whoami, etc.
+- certain commands only allowed in certain environments
+- good synchronity between git version / tags and erlang (etc.) releases
+
+
+task families
+--------------
+ interact with the project (bump, package, conformance-test, ...)
+ interact with the system / environment (deploy, start, stat, stop, ...)
+ interact with an instance of the application (upgrade, attach, test, ...  environment-sensitive)
+
+(
+ - local control (run, stop, attach, upgrade, downgrade, etc.-  up/downgrade prefered to reload/restart)
+ - local testing, profiling, benchmarking, analyzing
+ - releasing, including integration, deployment, packaging, and release management
+ - project management (dependencies and submodules, ...)
+)
+
+(older misc notes)
+-------------------
+
+
+
+- Ability to have some kind of mock historical files for downloading during most tests
+- test, dev, and prod all running on same machine without interfering with each other
+- 
+
+- app-ctl tasks:
+  - init.d compatible:
+    - start
+    - stop
+    - restart
+    - try-restart (only restart if already running)
+    - reload
+    - force-reload
+    - status       information on currently running app - maybe list showing available versions as well
+
+  - node controller:
+
+  - custom:
+    - help
+    - queued
+    - 
+

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'exctl'
+
+class Test::Unit::TestCase
+end

data/test/test_exctl.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestExctl < Test::Unit::TestCase
+  should "get some tests written" do
+    flunk "need to write some tests."
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: exctl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joseph Wecker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+description: Allows you to create a command-line dispatcher for a project to consolidate
+  dev, release, and runtime workflows.
+email: joseph.wecker@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- .attic/c_src/get-version.c
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- OPERUM.md
+- README.md
+- Rakefile
+- VERSION
+- lib/exctl.rb
+- notes.md
+- test/helper.rb
+- test/test_exctl.rb
+homepage: http://github.com/josephwecker/exctl
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3627039586448779554
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Project-specific command-line task dispatcher generator.
+test_files: []