crackin 0.0.1.rc0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OWNmZTcwNTc3MmY2Yjc2NWQ2NDU0YTdmMWRlOTY3NWVjODhlNmM2ZA==
+  data.tar.gz: !binary |-
+    OTBmMmFlMDBlMWIyYjczNDQ0OTJmZDVjNWI3NmRkMjBjN2UyZTk4Zg==
+SHA512:
+  metadata.gz: !binary |-
+    NTRjYTI5MzAyZTRkMjlkZDkyZjY3ZWZjYjJjZTY4ZWVkMGQwYWU4MTZhZWU0
+    NTg5MzM1Yjk2MjVlMDMyNTAzOTQ1YWE5ZjI0Mzc2Y2IxZWVhZTE5MmM5NTEz
+    NWIzNTE0OTllNTRmMWIxYjI0YjZkZjdhMjcxNzI5YmM2ZDFhNjc=
+  data.tar.gz: !binary |-
+    NWUwNjYwYTU0NTkwNmUyNmZhNTk4NGIwZTIyMWM2M2ViNTViODkxYTFhNWMx
+    MjdjYWU5MzljZjIxNDhlYTY4MGE5M2E4Njg5NTViOWU5ZWQxY2M4ZmZkOTI3
+    MDBjY2Q4Nzk3MjMxNjYwNDBkODc1NDk5YWQ5ODM2NDhmYWEwMDE=

data/.crackin.yml

@@ -0,0 +1,14 @@
+---
+crackin:
+  name: crackin
+  scm: git
+  changelog: CHANGELOG.md
+  branch:
+    production: master
+    development: develop
+  status:
+    verbose: true
+  version: lib/crackin/version.rb
+  build:
+    command: rake build
+    after: []

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p448@crackin

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in crackin.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Shawn Catanzarite
+
+MIT License
+
+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,29 @@
+# Crackin
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'crackin'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install crackin
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 @@
+require "bundler/gem_tasks"

data/bin/crackin

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'clamp'
+require 'crackin'
+
+module Crackin
+  class Command < Clamp::Command
+    option %w{-c --config}, '[CONFIG]', 'configuration file', environment_variable: 'CRACKIN_CONFIG', default: './.crackin.yml' do |config|
+      Crackin::Config.load(config)
+    end
+    subcommand 'init', 'intialize a directory for use with crackin' do
+      def execute
+        data = {crackin: Crackin::Config.defaults}.deep_stringify_keys
+        File.open(".crackin.yml", "w+") {|f| f.write(data.to_yaml)}
+      end
+    end
+    subcommand 'status', 'show status information' do
+      def execute
+        puts Crackin::Status.new
+      end
+    end
+    subcommand 'release', 'commands for doing releases' do
+      option %w{-n --dryrun}, :flag, 'mock commands', default: false
+      subcommand 'major', 'major release' do
+        def execute
+          release_start(:major, dryrun?)
+        end
+      end
+      subcommand 'minor', 'minor release' do
+        def execute
+          release_start(:minor, dryrun?)
+        end
+      end
+      subcommand 'tiny', 'tiny release' do
+        def execute
+          release_start(:tiny, dryrun?)
+        end
+      end
+      subcommand 'rc', 'release candidate release' do
+        def execute
+          release_start(:rc, dryrun?)
+        end
+      end
+      subcommand 'beta', 'beta release' do
+        def execute
+          release_start(:beta, dryrun?)
+        end
+      end
+      subcommand 'alpha', 'alpha release' do
+        def execute
+          release_start(:alpha, dryrun?)
+        end
+      end
+      subcommand 'rollback', 'rollback release changes' do
+        def execute
+          release_rollback(dryrun?)
+        end
+      end
+      subcommand 'finish', 'complete release process' do
+        def execute
+          release_finish(dryrun?)
+        end
+      end
+    end
+
+    def state(wanted)
+      status = Crackin::Status.new
+      status.state == wanted
+    end
+    def release_start(type, real)
+      raise "cannot start release when you're not in state == development" unless state('development')
+      Crackin::Release.new(type).start(real: real)
+    end
+    def release_rollback(real)
+      raise "cannot rollback when you're not in state == releasing" unless state('releasing')
+      Crackin::Release.new(:none).rollback(real: real)
+    end
+    def release_finish(real)
+      raise "cannot finish when you're not in state == releasing" unless state('releasing')
+      Crackin::Release.new(:none).finish(real: real)
+    end
+  end
+end
+
+begin
+  Crackin::Command.run
+rescue => e
+  puts "error: #{e.message}"
+  e.backtrace.each {|l| puts "  #{l}"}
+  exit 1
+end

data/crackin.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'crackin/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "crackin"
+  spec.version       = Crackin::Version::STRING
+  spec.authors       = ["Shawn Catanzarite"]
+  spec.email         = ["me@shawncatz.com"]
+  spec.description   = %q{release the crackin - gem release management}
+  spec.summary       = %q{release the crackin - gem release management}
+  spec.homepage      = "http://github.com/shawncatz/crackin"
+  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 'git'
+  spec.add_dependency 'clamp'
+  spec.add_dependency 'activesupport'
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/crackin/changelog.rb

@@ -0,0 +1,152 @@
+module Crackin
+  class Changelog
+    def initialize(file, version, options={})
+      @options = {
+          first: false
+      }.merge(options)
+      @output = file
+      @version = version
+      @config = Crackin.config
+      @source = @config.source
+      @data = {}
+    end
+
+    def to_s
+      tags = order_tags([@version, source_tags, @data.keys].flatten.uniq).reverse
+      out = "### Changelog\n\n"
+      tags.each do |section|
+        lines = @data[section]
+        out += "##### #{section}:\n"
+        out += lines.join("\n") if lines
+        out += "\n\n"
+      end
+      out
+    end
+
+    def update
+      tags = ordered_tags
+      load
+      @data[@version] = between(tags.last, 'HEAD').uniq
+    end
+
+    def full
+      tags = ordered_tags
+      to = 'HEAD'
+      name = @version
+      tags.reverse_each do |from|
+        @data[name] = between(from, to).uniq
+        to = from
+        name = from
+      end
+    end
+
+    def save
+      File.open(@output, "w+") {|f| f.write(to_s)}
+    end
+
+    protected
+
+    def ordered_tags
+      order_tags(source_tags)
+    end
+
+    def order_tags(list)
+      ordered = list.sort_by { |e| tag_to_number(e) }
+      ordered #.reject { |e| (a, b, c, d) = e.split("."); !d.nil? }
+    end
+
+    def tag_to_number(tag)
+      (a, b, c, d) = tag.gsub(/^v/, "").split(".")
+      tags = {'rc' => 3, 'beta' => 2, 'alpha' => 1}
+      t = 4
+      n = 0
+      if d && d =~ /(\w+)(\d+)/
+        t = tags[$1]
+        n = $2
+      end
+      str = ("%03d%03d%03d%03d%03d" % [a, b, c, t, n])
+      number = str.to_i
+      #puts "## #{tag} => #{str} => #{number}"
+      number
+    end
+
+    def source_tags
+      @source.tags.all.map(&:name)
+    end
+
+    def load
+      return unless File.exists?(@output)
+      file = File.open(@output).read
+      section = nil
+      file.lines.each do |line|
+        next if line =~ /^$/
+        if line =~ /^#####\s+(.*):/
+          section = $1
+          next
+        end
+        if section
+          @data[section] ||= []
+          @data[section] << line.chomp
+        end
+      end
+    end
+
+    def between(from, to)
+      log = @source.between(from, to)
+      out = []
+      log.each do |c|
+        m = message(c.message)
+        out << m if m
+      end
+      out
+    end
+
+    def message(m)
+      out = nil
+      if m !~ /^(merge|v|version|changelog|crackin)/i
+        out = "* #{m}"
+      end
+      out
+    end
+
+    #def changelog(last=nil, single=false)
+    #  command="git --no-pager log --format='%an::::%h::::%s'"
+    #
+    #  list = `git tag`
+    #
+    #  puts "# Changelog"
+    #  puts
+    #
+    #  ordered = list.lines.sort_by { |e| (a, b, c) = e.gsub(/^v/, "").split("."); "%3d%3d%3d" % [a, b, c] }
+    #
+    #  ordered.reject { |e| (a, b, c, d) = e.split("."); !d.nil? }.reverse_each do |t|
+    #    tag = t.chomp
+    #
+    #    if last
+    #      check = {}
+    #      out = []
+    #      log = `#{command} #{last}...#{tag}`
+    #      log.lines.each do |line|
+    #        (who, hash, msg) = line.split('::::')
+    #        unless check[msg]
+    #          unless msg =~ /^Merge branch/ || msg =~ /CHANGELOG/ || msg =~ /^(v|version|changes for|preparing|ready for release|ready to release|bump version)*\s*(v|version)*\d+\.\d+\.\d+/
+    #            msg.gsub(" *", "\n*").gsub(/^\*\*/, "  *").lines.each do |l|
+    #              line = l =~ /^(\s+)*\*/ ? l : "* #{l}"
+    #              out << line
+    #            end
+    #            check[msg] = hash
+    #          end
+    #        end
+    #      end
+    #      puts "## #{last}:"
+    #      out.each { |e| puts e }
+    #      #puts log
+    #      puts
+    #    end
+    #
+    #    last = tag
+    #    exit if single
+    #  end
+    #end
+  end
+end

data/lib/crackin/config.rb

@@ -0,0 +1,63 @@
+require 'yaml'
+require 'active_support/all'
+
+module Crackin
+  class Config
+    attr_reader :source
+
+    def initialize(file="./.crackin.yml")
+      yaml = YAML.load_file(file)
+      @config = self.class.defaults.deep_merge(yaml['crackin']||{})
+      @source = Crackin::Scm.open(@config)
+    end
+
+    def [](key)
+      @config[key]
+    end
+
+    class << self
+      def load(file="./.crackin.yml")
+        @config = Crackin::Config.new(file)
+      end
+
+      def instance
+        @config || load
+      end
+
+      def defaults
+        {
+            name: '<app>',
+            scm: 'git',
+            changelog: 'CHANGELOG.md',
+            branch: {
+                production: 'master',
+                development: 'develop'
+            },
+            status: {
+                verbose: true
+            },
+            version: 'lib/<app>/version.rb',
+            build: {
+                command: 'rake build', # gem build :name.gemspec && mkdir -p pkg && mv :name.gem pkg
+                after: []
+            }
+
+        }.deep_stringify_keys
+      end
+    end
+  end
+
+  class << self
+    def config
+      Crackin::Config.instance
+    end
+
+    def version
+      Crackin::VersionFile.new(config['version'])
+    end
+
+    def source
+      config.source
+    end
+  end
+end

data/lib/crackin/ext/core/hash.rb

@@ -0,0 +1,13 @@
+class Hash
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end unless Hash.respond_to?(:deep_transform_keys)
+
+  def deep_stringify_keys
+    deep_transform_keys{ |key| key.to_s }
+  end unless Hash.respond_to?(:deep_stringify_keys)
+end

data/lib/crackin/ext/git/base.rb

@@ -0,0 +1,13 @@
+module Git
+  class Base
+    def tag_delete(tag_name)
+      tag = tag(tag_name)
+      self.lib.tag_delete(tag_name)
+      tag
+    end
+
+    def branch_current
+      self.lib.branch_current
+    end
+  end
+end

data/lib/crackin/ext/git/lib.rb

@@ -0,0 +1,7 @@
+module Git
+  class Lib
+    def tag_delete(tag_name)
+      command('tag', ['-d', tag_name])
+    end
+  end
+end

data/lib/crackin/release.rb

@@ -0,0 +1,187 @@
+module Crackin
+  class Release
+    def initialize(type)
+      @config = Crackin.config
+      @source = @config.source
+      @current = @source.current_branch
+      @type = type
+      @version = Crackin::VersionFile.new(@config['version'])
+      raise "unknown version type: #{type}" unless @version.respond_to?(type.to_sym)
+      @version.send(type.to_sym)
+    end
+
+    def start(options={})
+      o = {
+          real: true
+      }.merge(options)
+      # make sure no pending changes
+      raise "there are pending changes" if o[:real] && @source.pending?
+
+      puts "release: #{@version}"
+      run(start_actions)
+    end
+
+    def finish(options={})
+      o = {
+          real: true
+      }.merge(options)
+      run(finish_actions)
+    end
+
+    def rollback(options={})
+      puts "rolling back: #{@version}"
+      undo(start_actions)
+    end
+
+    protected
+
+    def run(actions)
+      begin
+        actions.each do |action|
+          puts ".. #{action[:name]}"
+          if action.keys.include?(:if) && !action[:if]
+            raise action[:failed] || "if statement evaluated to false"
+          end
+          action[:do].call
+          action[:success] = true
+        end
+      rescue => e
+        puts "** action failed: #{e.message}"
+        puts "## rolling back"
+        undo(actions)
+      end
+    end
+
+    def undo(actions)
+      actions.reverse.each do |action|
+        puts ".. undo: #{action[:name]}"
+        begin
+          action[:undo].call if action[:undo] #&& (action.keys.include?(:success) && action[:success])
+        rescue => e
+          puts "** failed: #{e.message}"
+        end
+      end
+    end
+
+    def start_actions
+      actions = []
+      # change branch
+      actions << {
+          name: "change to production branch",
+          do: -> { @source.change_branch(@config['branch']['production']) },
+          undo: -> { @source.change_branch(@config['branch']['development']) },
+          if: @current == @config['branch']['development']
+      }
+      # create release branch
+      actions << {
+          name: "create release branch",
+          do: -> { @source.create_branch("crackin_#{@version.name}") },
+          undo: -> { @source.delete_branch("crackin_#{@version.name}") },
+      }
+      # merge from develop
+      actions << {
+          name: "merge from develop",
+          do: -> { @source.merge_from(@config['branch']['development']) },
+          undo: -> { @source.uncommit },
+      }
+      # change version file
+      actions << {
+          name: "update version file",
+          do: -> { @version.save },
+          undo: -> { @source.reset },
+      }
+      # changelog
+      actions << {
+          name: "update changelog",
+          do: -> {
+            changelog = Crackin::Changelog.new(@config['changelog'], @version.name)
+            changelog.update
+            changelog.save
+          },
+          undo: -> { @source.reset },
+      }
+      actions
+    end
+
+    def finish_actions
+      actions = []
+      unless File.exist?(File.expand_path('~/.gem/credentials'))
+        puts "gem credentials are not saved, you must run 'gem push pkg/#{@config['name']}-#{@version.name}.gem' to set them"
+        return
+      end
+      # commit
+      actions << {
+          name: "commit version and changelog",
+          do: -> { @source.commit(@version.name) },
+          undo: -> { @source.uncommit },
+      }
+      # change branch
+      actions << {
+          name: "change to production branch",
+          do: -> { @source.change_branch(@config['branch']['production']) },
+          undo: -> { @source.change_branch(@config['branch']['development']) },
+          #if: -> { @current != @config['branch']['production'] }
+      }
+      # merge from crackin branch
+      actions << {
+          name: "merge from crackin release branch",
+          do: -> { @source.merge_from(@current) },
+          undo: -> { @source.uncommit },
+      }
+      # tag
+      actions << {
+          name: "create tag",
+          do: -> { @source.tags.create(@version.name) },
+          undo: -> { @source.tags.delete(@version.name) },
+      }
+      # build
+      actions << {
+          name: "run build",
+          do: -> { raise "system command failed" unless system(@config['build']['command']) },
+      }
+      # push
+      actions << {
+          name: "source push",
+          do: -> { @source.push },
+      }
+      # push tags
+      actions << {
+          name: "tags push",
+          do: -> { @source.push_tags('origin', @config['branch']['production']) },
+      }
+      # gem push
+      actions << {
+          name: "gem push 'pkg/#{@config['name']}-#{@version.number}.gem'",
+          do: -> {
+            raise "system command failed" unless system("gem push pkg/#{@config['name']}-#{@version.number}.gem")
+          },
+          undo: -> {
+            puts "** You will need to manually yank the gem that was pushed."
+          }
+      }
+      # change branch
+      actions << {
+          name: "change to development branch",
+          do: -> { @source.change_branch(@config['branch']['development']) },
+          undo: -> { @source.change_branch(@config['branch']['production']) },
+      }
+      # merge from production
+      actions << {
+          name: "merge from production",
+          do: -> { @source.merge_from(@config['branch']['production']) },
+          undo: -> { @source.uncommit },
+      }
+      # delete release branch
+      actions << {
+          name: "delete release branch",
+          do: -> { @source.delete_branch("crackin_#{@version.name}") },
+      }
+      # push
+      actions << {
+          name: "source push",
+          do: -> { @source.push },
+      }
+      actions
+    end
+  end
+end

data/lib/crackin/scm/git.rb

@@ -0,0 +1,111 @@
+require 'git'
+require 'shellwords'
+
+module Crackin
+  module Scm
+    class Git < Base
+      attr_reader :git
+      def initialize(config={})
+        super
+        #@git = ::Git.open(@options[:working], log: Logger.new(STDOUT))
+        @git = ::Git.open(@options[:working])
+      end
+
+      def log
+        @git.log
+      end
+
+      def between(from, to)
+        @git.log.between(from, to)
+      end
+
+      def tags
+        Tags.new(@git)
+      end
+
+      def commit(message)
+        @git.commit_all(message)
+      end
+
+      def uncommit
+        @git.reset_hard('HEAD^')
+      end
+
+      def reset
+        @git.checkout_file('--', '.')
+        @git.clean(d: true, force: true)
+        #pending.keys.each do |p|
+        #  puts "pending: #{p}"
+        #  @git.checkout_file('--', p)
+        #end
+      end
+
+      def merge_from(from)
+        @git.branch(from).merge
+      end
+
+      def current_branch
+        @git.branch_current
+      end
+
+      def change_branch(to)
+        @git.checkout(to)
+      end
+
+      def create_branch(name)
+        branch = @git.branch(Shellwords.escape(name))
+        branch.create
+        branch.checkout
+      end
+
+      def delete_branch(name)
+        @git.checkout
+        @git.branch(Shellwords.escape(name)).delete
+      end
+
+      def push
+        @git.push
+      end
+
+      def push_tags(remote=@git.remote, branch=current_branch)
+        @git.push(remote, branch, true)
+      end
+
+      def pending
+        s = @git.status
+        d = {}
+        d.merge! s.changed
+        d.merge! s.added
+        d.merge! s.deleted
+        d.merge! s.untracked
+        d
+      end
+
+      def pending?
+        pending.count > 0
+      end
+    end
+
+    class Tags < Git
+      def initialize(git)
+        @git = git
+      end
+
+      def find(name)
+        @git.tag(name)
+      end
+
+      def create(name)
+        @git.add_tag(name)
+      end
+
+      def all
+        @git.tags
+      end
+
+      def destroy(name)
+        @git.tag_delete(name)
+      end
+    end
+  end
+end

data/lib/crackin/scm.rb

@@ -0,0 +1,45 @@
+module Crackin
+  module Scm
+    class Base
+      def initialize(config={})
+        @options = {
+            production: 'master',
+            working: File.expand_path('.')
+        }.merge(config)
+      end
+
+      def commit(message)
+        raise "not implemented"
+      end
+
+      def change_branch
+        raise "not implemented"
+      end
+
+      def push
+        raise "not implemented"
+      end
+
+      def tag
+        raise "not implemented"
+      end
+
+      def push_tags
+        raise "not implemented"
+      end
+    end
+
+    class << self
+      def open(options)
+        name = options['scm'] || 'git'
+        klass = "Crackin::Scm::#{name.capitalize}".constantize
+        #puts "loading: #{klass}"
+        klass.new(options)
+      end
+    end
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/scm/*.rb"].each do |file|
+  require "#{file.gsub(/\.rb/, '')}"
+end

data/lib/crackin/status.rb

@@ -0,0 +1,144 @@
+module Crackin
+  class Status
+    attr_reader :state
+
+    def initialize
+      @config = Crackin.config
+      @source = @config.source
+      @verbose = @config['status']['verbose']
+      @version = Crackin::VersionFile.new(@config['version'])
+      @notices = []
+
+      process
+    end
+
+    def process
+      if (@source.current_branch =~ /^crackin_/) == 0
+        # we're releasing
+        @state = 'releasing'
+        @notices << notice_releasing
+        @notices << notice_releasing_pending if @source.pending
+        @notices << notice_releasing_finish
+      elsif @source.current_branch == @config['branch']['development']
+        @state = 'development'
+        @notices << notice_development
+      elsif @source.current_branch == @config['branch']['production']
+        @state = 'production'
+        @notices << notice_production
+      else
+        @state = 'unknown'
+        @notices << notice_unknown
+      end
+    end
+
+    def releasing?
+      @state == 'releasing'
+    end
+
+    def production?
+      @state == 'production'
+    end
+
+    def development?
+      @state == 'development'
+    end
+
+    def unknown?
+      @state == 'unknown'
+    end
+
+    def status_line
+      "crackin # '#{@version}' # on branch: '#{@source.current_branch}' ('#{@state}') # pending changes: '#{@source.pending?}'"
+    end
+
+    def to_s
+      out = []
+      out += @notices if @verbose
+      out << status_line
+      out.join("\n")
+    end
+
+    protected
+
+    def notice_releasing
+      <<-RELEASING
+You are in the midst of a release.
+      RELEASING
+    end
+
+    def notice_releasing_pending
+      <<-PENDING
+There are pending changes.
+Most likely, these are the changes made for you by Crackin.
+The changes include updating your version file and change log.
+Verify the changes and add any additional comments to the change log.
+      PENDING
+    end
+
+    def notice_releasing_finish
+      <<-FINISH
+To continue run the following command:
+  crackin release finish
+
+To abort - if you've changed your mind - run the following command:
+  crackin release rollback
+      FINISH
+    end
+
+    def notice_development
+      <<-DEV
+You are ready for development. Make changes to the develop branch, or merge
+features from feature branches.
+Commit and push your changes.
+
+When you wish to start a release, run the following command:
+  crackin release <type>
+
+Crackin uses semantic versioning, for more information see: http://semver.org
+<type> can be one of the following:
+
+  crackin release major  # => release #{@version.dup.major}
+  crackin release minor  # => release #{@version.dup.minor}
+  crackin release tiny   # => release #{@version.dup.tiny}
+  crackin release rc     # => release #{@version.dup.rc}    # tag type
+  crackin release beta   # => release #{@version.dup.beta}  # tag type
+  crackin release alpha  # => release #{@version.dup.alpha} # tag type
+
+subsequent tag type releases increment the tag number rc1, beta1, alpha1.
+you can release a main type release which will clear the tag.
+An example timeline of releases:
+
+  start             v0.4.0
+  alpha release     v0.4.1.alpha0
+  alpha release     v0.4.1.alpha1
+  beta release      v0.4.1.beta0
+  rc release        v0.4.1.rc0
+  rc release        v0.4.1.rc1
+  tiny release      v0.4.1
+      DEV
+    end
+
+    def notice_production
+      <<-PRODUCTION
+You are on the production branch. Normal work will happen on development branches.
+For now, Crackin does not support any other process than the default:
+  1. make changes to development branch, or merge changes there from feature branches.
+  2. crackin release <type> - merge development and production, update version and change log.
+
+*** HOT FIX RELEASES ARE NOT YET SUPPORTED ***
+      PRODUCTION
+    end
+
+    def notice_unknown
+      <<-UNKNOWN
+You are in an unknown state. Normally this happens for one of two reasons:
+
+1. There is a problem with your configuration.
+   Make sure that you have the branch values configured correctly
+2. You are doing feature development on a feature branch.
+   This is ok, you just need to merge your changes to your development branch
+   Then you can use crackin to do releases.
+      UNKNOWN
+    end
+  end
+end

data/lib/crackin/version.rb

@@ -0,0 +1,10 @@
+module Crackin
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    TINY = 1
+    TAG = 'rc0'
+    LIST = [MAJOR, MINOR, TINY, TAG]
+    STRING = LIST.compact.join(".")
+  end
+end

data/lib/crackin/version_file.rb

@@ -0,0 +1,100 @@
+module Crackin
+  class VersionFile
+    def initialize(path)
+      @path = path
+      load
+    end
+
+    def load
+      File.read(@path).lines.each do |line|
+        @major = $1.to_i if line =~ /MAJOR\s+=\s+(\d+)/
+        @minor = $1.to_i if line =~ /MINOR\s+=\s+(\d+)/
+        @tiny = $1.to_i if line =~ /TINY\s+=\s+(\d+)/
+        if line =~ /TAG\s+=\s+(.*)/
+          @tag = $1
+          @tag.gsub!(/['"]/, '')
+          @tag = nil if @tag == 'nil'
+        end
+      end
+    end
+
+    def save
+      out = []
+      tag = @tag ? "'#{@tag}'" : "nil"
+      File.open(@path).lines.each do |line|; line.chomp!
+        line.gsub!(/(\s+)MAJOR\s+=\s+\d+/, "\\1MAJOR = #{@major}")
+        line.gsub!(/(\s+)MINOR\s+=\s+\d+/, "\\1MINOR = #{@minor}")
+        line.gsub!(/(\s+)TINY\s+=\s+\d+/, "\\1TINY = #{@tiny}")
+        line.gsub!(/(\s+)TAG\s+=\s+(nil|['"].*['"])/, "\\1TAG = #{tag}")
+        out << line
+      end
+      File.open(@path, "w+") {|f| f.write(out.join("\n"))}
+    end
+
+    def name
+      "v#{number}"
+    end
+
+    def to_s
+      name
+    end
+
+    def to_a
+      [@major, @minor, @tiny, @tag].compact
+    end
+
+    def number
+      to_a.join('.')
+    end
+
+    def major
+      @major += 1
+      @minor = 0
+      @tiny = 0
+      @tag = nil
+      name
+    end
+
+    def minor
+      @minor += 1
+      @tiny = 0
+      @tag = nil
+      name
+    end
+
+    def tiny
+      @tiny += 1 unless @tag
+      @tag = nil
+      name
+    end
+
+    def rc
+      tag('rc')
+      name
+    end
+
+    def beta
+      tag('beta')
+      name
+    end
+
+    def alpha
+      tag('alpha')
+      name
+    end
+
+    def tag(type)
+      if @tag =~ /#{type}(\d+)/
+        num = $1.to_i + 1
+        @tag = "#{type}#{num}"
+      else
+        @tiny += 1
+        @tag = "#{type}0"
+      end
+    end
+
+    def none
+
+    end
+  end
+end

data/lib/crackin.rb

@@ -0,0 +1,11 @@
+require 'crackin/version'
+require 'crackin/scm'
+require 'crackin/config'
+require 'crackin/status'
+require 'crackin/version_file'
+require 'crackin/changelog'
+require 'crackin/release'
+
+require 'crackin/ext/git/base'
+require 'crackin/ext/git/lib'
+require 'crackin/ext/core/hash'

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: crackin
+version: !ruby/object:Gem::Version
+  version: 0.0.1.rc0
+platform: ruby
+authors:
+- Shawn Catanzarite
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: release the crackin - gem release management
+email:
+- me@shawncatz.com
+executables:
+- crackin
+extensions: []
+extra_rdoc_files: []
+files:
+- .crackin.yml
+- .gitignore
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/crackin
+- crackin.gemspec
+- lib/crackin.rb
+- lib/crackin/changelog.rb
+- lib/crackin/config.rb
+- lib/crackin/ext/core/hash.rb
+- lib/crackin/ext/git/base.rb
+- lib/crackin/ext/git/lib.rb
+- lib/crackin/release.rb
+- lib/crackin/scm.rb
+- lib/crackin/scm/git.rb
+- lib/crackin/status.rb
+- lib/crackin/version.rb
+- lib/crackin/version_file.rb
+homepage: http://github.com/shawncatz/crackin
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: release the crackin - gem release management
+test_files: []