samus 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 500fa4456778f282bf501ea9d1731a5199f0a2bd
+  data.tar.gz: 1bfac1ac68d3be949d286dacdec5ef710609c2a8
+SHA512:
+  metadata.gz: bb354e91c9058f483c8a339ffc9b0f331b152e92a548dd6516c86bd2a56e3caa308dcbad3d287f5cd4ffa2ebb423c438ee48929e8660ab60afb2174810532be2
+  data.tar.gz: 21d5e9b38e12c614416c75eff044a8c94b49900f913a3e1e2635d6f86c6dcf6f50dd34ca6a3602700e2897a0c8373d967857e78f09048720dccc2118570d4617

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Loren Segal
+
+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,255 @@
+# Samus
+
+Samus helps you automate the release of Open Source Software. Samus works
+through a manifest file to describe discrete steps that you typically perform
+when packaging and publishing code.
+
+Samus comes with a set of built-in commands that let you prepare your
+repository, push your changes, package your library, and upload it to various
+locations / package managers. Samus is also open-source, so you can contribute
+new commands if you think they are useful to others. Finally, Samus allows you
+to install and share custom commands and credentials for building and publishing
+your code. That's right, Samus has a mechanism to share publishing credentials
+in a fairly secure way, so you can reliably publish releases from almost any
+machine.
+
+## Usage
+
+Samus is driven by a manifest file that describes the steps to perform when
+building or publishing a release. You can just use Samus to publish, or you
+can use it for both, it's your choice.
+
+### Publishing
+
+If you can handle building all of your assets on your own, you can use Samus
+just to publish your code. Create a manifest file called manifest.json and
+put it in a directory with all of your assets. The manifest file is just a
+list of discrete actions like so (minus comments):
+
+```js
+{
+  "actions": [
+    {
+      "files": "git.tgz",       // this is an archive of your git repository
+      "action": "git-push",
+      "arguments": {
+        "remotes": "origin",
+        "refs": "master v1.5.0" // the v1.5.0 is a tag for your release
+      }
+    },
+    {
+      "action": "gem-push",
+      "files": ["my-built-gemfile.gem"],
+      "credentials": "my-credentials-key"
+    }
+  ]
+}
+```
+
+Note: The credentials section defines a flat file or executable Samus looks
+at to get your key for authentication. See the "Custom Commands & Credentials"
+section below for how to point to this file.
+
+Now just run `samus publish .`, and Samus will run these commands in order,
+pushing your Git repository and your RubyGem to the world.
+
+### Building
+
+In most cases you will want some help staging a release; Samus can help with
+that too. Just in the same way you created a manifest for publishing, you
+create a manifest file for building your release. The only difference is now
+you include build-time actions, in addition to your publish actions.
+
+Here is an example that updates your version.rb file, commits and tags the
+release, and zips up your repository and RubyGem for publishing. Call
+it "samus.json" for easier integration:
+
+```js
+// samus.json:
+{
+  "actions": [
+    {
+      "action": "fs-sedfiles",
+      "files": ["lib/my-gem/version.rb"],
+      "arguments": {
+        "search": "VERSION = ['\"](.+?)['\"]",
+        "replace": "VERSION = '$version'"
+      }
+    },
+    {
+      "action": "git-commit",
+      "files": ["lib/my-gem/version.rb"]
+    },
+    {
+      "action": "git-merge", // merge new commit into master branch
+      "arguments": {
+        "branch": "master"
+      }
+    },
+    {
+      "action": "archive-git-full",
+      "files": ["git.tgz"],
+      "publish": [{
+        "action": "git-push",
+        "arguments": {
+          "remotes": "origin",
+          "refs": "master v$version"
+        }
+      }]
+    },
+    {
+      "action": "gem-build",
+      "files": ["my-gem.gemspec"],
+      "publish": [
+        {
+          "action": "gem-push",
+          "files": ["my-gem-$version.gem"],
+          "credentials": "my-credentials-key"
+        }
+      ]
+    }
+  ]
+}
+```
+
+It looks a little longer, but it contains all of the steps to automate when
+bumping the VERSION constant, tagging a version, merging into the master
+branch, and building the gem. To build a release with this manifest, simply
+type:
+
+```sh
+$ samus build 1.5.0
+```
+
+Samus will look for `samus.json` and build a release for version 1.5.0 of your
+code. It will produce an archive called `release-v1.5.0.tar.gz` that you
+can then publish with:
+
+```sh
+$ samus publish release-v1.5.0.tar.gz
+```
+
+You may have noticed some funny looking "$version" strings in the above
+manifest. Those strings will be replaced with the version provided in the
+build command, so all the correct tagging and building will be handled for you.
+
+You will also notice that the publish commands are part of this manifest.
+In build mode, Samus handles building of the manifest.json document, grabbing
+any of the "publish" sections of an action and throwing them in the final
+manifest.json. As illustrated above, not all actions require a publish section.
+If you want to inspect the manifest file that Samus created, you can build
+your release as a directory instead of a zip with `--no-zip`.
+
+Note: If you didn't name your manifest samus.json you can simply enter the
+filename in the build command as `samus build VERSION manifest.json`.
+
+## Built-in Commands
+
+Samus comes with a number of built-in commands optimized for dealing with
+the Git workflow. You can use `samus show-cmd` to list all available commands,
+both for building and publishing a release. Each command has documentation
+for which files and arguments it accepts.
+
+```sh
+$ samus show-cmd
+... a list of commands ...
+```
+
+To view a specific command, make sure to include the stage (`build` or
+`publish`):
+
+```sh
+$ samus show-cmd publish git-push
+Publish Command: git-push
+
+Pushes Git repository refs to a set of remotes.
+
+Files:
+  * The repository archive filename.
+
+Arguments:
+  * refs:    a space delimited set of commits, branches, or tags to push.
+  * remotes: a space delimited set of remotes to push refs to.
+```
+
+## Custom Commands & Credentials
+
+Sometimes you will need to create custom commands that do specific things
+for your project. If they are generic, you should submit them to this project,
+but if not, you can install custom commands that only you have access to.
+This goes for credentials too, which you can install privately on your
+machine.
+
+Samus works best when custom packages are Git-backed (preferably private)
+repositories. In this case, you can simply type `samus install REPO` to
+download the repository to your machine:
+
+```sh
+$ samus install git@github.com:my_org/samus_config
+```
+
+Of course, Samus doesn't need these custom packages to be Git-backed. All
+the above command does is clone a repository into the ~/.samus directory.
+The above command creates:
+
+```
+.samus/
+  `- samus_config/
+     `- commands/
+        `- build/
+           `- my-command
+     `- credentials/
+        `- my-credentials-key
+```
+
+### Commands
+
+Commands in Samus are just shell scripts. Samus passes all argument values
+(the keys from the "arguments" section of the manifest) in as environment
+variables with a prefixed underscore. For example, the `rake-task` command
+is just: 
+
+```sh
+#!/bin/sh
+
+rake $_task
+```
+
+The `$_task` variable is the "task" argument from the manifest.
+
+### Credentials
+
+Custom credentials are just flat files or executables in the `credentials/`
+directory of your custom package. When you use the "credentials" section in
+a publish action of the manifest, the value should match the filename of
+a file in one of your credentials directories. For instance, for the
+`my-credentials-key` value in our manifest examples, you should have:
+
+```
+.samus/samus_config/credentials/my-credentials-key
+```
+
+This file is either a flat file with the format:
+
+```
+Key: THE_API_KEY
+Secret: THE_SECRET
+```
+
+Or, alternatively, an *executable* which prints the above format to standard
+out.
+
+These values are read in by Samus and get exposed as `$__creds_key` and
+`$__creds_secret` respectively in Samus commands. You can provide other
+metadata as well, which would be included as `$__creds_name` (for the
+line "NAME: value").
+
+## Contributing & TODO
+
+Please help by contributing commands that Samus can use to build or publish
+code. Integration with different package managers would be helpful, as well
+as improving the kinds of build-time tasks that are exposed.
+
+## Copyright
+
+Samus was created by Loren Segal in 2014 and is available under MIT license.

data/bin/samus

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/samus'
+require 'optparse'
+require 'tmpdir'
+
+command = case ARGV.shift
+when 'install'
+  Dir.mkdir(Samus::CONFIG_PATH) unless File.directory?(Samus::CONFIG_PATH)
+  Dir.chdir(Samus::CONFIG_PATH) { system "git clone #{ARGV.shift}" }
+  exit
+when 'update'
+  Samus.config_paths.each do |path|
+    Dir.chdir(path) do
+      if File.directory?('.git')
+        puts "[I] Updating #{path}"
+        system "git pull"
+      else
+        puts "[S] Skipping non-Git directory #{path}"
+      end
+    end
+  end
+  exit
+when 'show-cmd'
+  stage = ARGV.shift
+  if stage
+    name = ARGV.shift
+    if name
+      Samus::Command.new(stage, name).show_help
+    else
+      Samus::Command.list_commands(stage)
+    end
+  else
+    Samus::Command.list_commands
+  end
+  exit
+when 'publish', 'push'; Samus::Publisher
+when 'build';  Samus::Builder
+end
+
+dry_run = false
+zip_release = true
+opts = OptionParser.new do |opts|
+  opts.banner  = "Usage: samus publish [options] <directory> [directory ...]\n"
+  opts.banner += "       samus build [options] <version> [build.json]\n"
+  opts.banner += "       samus show-cmd [stage] [name]\n"
+
+  opts.separator ""
+  opts.separator "Options:"
+  opts.on("--dry-run", "Print commands, don't run them") do |v|
+    dry_run = true
+  end
+  if command == Samus::Builder
+    opts.on("--[no-]zip", "Zip release directory") do |zip|
+      zip_release = zip
+    end
+  end
+end
+opts.parse!
+
+if command == Samus::Publisher
+  ARGV.each do |dir|
+    fail "Aborting due to missing path #{dir}" unless File.exist?(dir)
+  end
+
+  ARGV.each do |dir|
+    if File.directory?(dir)
+      command.new(dir).publish(dry_run)
+    elsif File.file?(dir) # it has to be an archive
+      Dir.mktmpdir do |tmpdir|
+        system "tar -xzf #{dir} -C #{tmpdir}"
+        command.new(tmpdir).publish(dry_run)
+      end
+    end
+  end
+elsif command == Samus::Builder
+  $VERSION = ARGV.shift
+  fail "Missing version" if $VERSION.nil?
+  $VERSION = $VERSION.sub(/^v/, '')
+
+  (ARGV.empty? ? ['samus.json'] : ARGV).each do |file|
+    command.new(file).build(dry_run, zip_release)
+  end
+else
+  puts opts
+  exit 1
+end

data/commands/build/archive-git-full

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+tar cfz $__build_dir/$1 .git $(git ls-files)

data/commands/build/archive-git-full.help.md

@@ -0,0 +1,7 @@
+Archives a complete Git repository (including .git directory).
+
+Files:
+  * The name of the archived repository.
+
+Arguments:
+  * (none)

data/commands/build/archive-tgz

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+tar cfz $__build_dir/$1 $_paths

data/commands/build/archive-tgz.help.md

@@ -0,0 +1,7 @@
+Archives a set of paths into a gzipped tar file.
+
+Files:
+  * The name of the archive to build.
+
+Arguments:
+  * paths: a space delimited set of paths to add to the archive.

data/commands/build/archive-zip

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+zip -qr $__build_dir/$1 $_paths

data/commands/build/archive-zip.help.md

@@ -0,0 +1,7 @@
+Archives a set of paths into a zip file.
+
+Files:
+  * The name of the archive to build.
+
+Arguments:
+  * paths: a space delimited set of paths to add to the archive.

data/commands/build/fs-copy

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+cp -r $* $__build_dir/$_destination

data/commands/build/fs-copy.help.md

@@ -0,0 +1,8 @@
+Copies a set of files into the build directory.
+
+Files:
+  * A list of files to copy into the build directory.
+
+Arguments:
+  * destination: (optional) a subdirectory within the build directory to copy
+                 files to.

data/commands/build/fs-mkdir

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+mkdir -p $__build_dir/$*

data/commands/build/fs-mkdir.help.md

@@ -0,0 +1,7 @@
+Creates a sub-directory in the build directory.
+
+Files:
+  * The subdirectory to create. Can be a complex directory.
+
+Arguments:
+  * (none)

data/commands/build/fs-rmrf

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+rm -rf $*