step-up 0.1.0 → 0.2.0

data/.stepuprc

@@ -0,0 +1,31 @@
+notes:
+  after_versioned:
+    #strategy: "remove"
+    strategy: "keep"
+    section: "versioning"
+    changelog_message: "available on {version}"
+  sections:
+    - name: "changes"
+      prefix: "change: "
+      label: "Changes:"
+      tag: "change"
+    - name: "bugfixes"
+      prefix: "bugfix: "
+      label: "Bugfixes:"
+      tag: "bugfix"
+    - name: "features"
+      prefix: "feature: "
+      label: "Features:"
+      tag: "feature"
+    - name: "deploy_steps"
+      prefix: "deploy_step: "
+      label: "Deploy steps:"
+      tag: "deploy_step"
+versioning:
+  version_mask: "v0.0.0.9.rc9"
+  version_levels:
+    - major
+    - minor
+    - tiny
+    - patch
+    - rc

data/README.md

@@ -1,3 +1,32 @@
-# LastVersion: a project to versioning projects
+# StepUp: a project to 'step up' projects
 
-LastVersion is an utility to manage versioning tags on git projects.
+StepUp is an utility to manage versioning, based on source control management features (i.e. tags and notes of Git). That is, you don't need to keep track of your application version in a file anymore.
+Initially it just supports Git as SCM. But more SCM's are planned in the future.
+
+For now the only feature will help you to check the application version based on the default version pattern from StepUp.
+
+The next (real soon) features to come are:
+- create notes
+- increment versions based on notes
+- pattern of version defined by user
+- and lots more
+
+### Installation
+
+gem install step-up
+
+### Usage
+
+1) Enter your directory project
+
+2) Run StepUp and see the magic 
+
+### Commands
+
+stepup
+
+  Shows your application version
+  
+stepup -h
+
+  Shows the current features

data/Rakefile

@@ -33,7 +33,7 @@ task :install => :build do
   if gem.nil?
     puts "could not install the gem"
   else
-    sh "gem uninstall step-up && gem install #{ gem }"
+    sh "gem uninstall --ignore-dependencies --executables step-up; gem install #{ gem }"
   end
 end
 

data/lib/step-up.rb

@@ -5,6 +5,7 @@ module StepUp
     autoload :Git, 'step-up/driver/git.rb'
   end
   autoload :GitExtensions, 'step-up/git_extensions.rb'
+  autoload :RangedNotes, 'step-up/ranged_notes.rb'
   module Parser
     autoload :VersionMask, 'step-up/parser/version_mask.rb'
   end

data/lib/step-up/cli.rb

@@ -3,24 +3,269 @@ require 'step-up'
 
 module StepUp
   class CLI < Thor
-    map %w(--version -v) => :gem_version
+    include Thor::Actions
+    map %w(--version -v) => :gem_version  # $ stepup [--version|-v]
     
     default_task :version
 
-    desc "", "show the last version of the application"
-    def version
-      puts StepUp::Driver::Git.last_version
+    desc "version ACTION [OPTIONS]", "manage versions of your project"
+    method_options %w(levels -L) => :boolean # $ stepup version [--levels|-L]
+    method_options %w(level -l) => :string, %w(steps -s) => :boolean, %w(message -m) => :string, :'no-editor' => :boolean  # $ stepup version create [--level|-l <level-name>] [--steps|-s] [--message|-m <comment-string>] [--no-editor]
+    VERSION_ACTIONS = %w[show create help]
+    def version(action = nil)
+      action = "show" unless VERSION_ACTIONS.include?(action)
+      if self.respond_to?("version_#{action}")
+        send("version_#{action}")
+      else
+        puts "invalid action: #{action}"
+      end
     end
 
-    desc "notes [object]", "show notes for the next version"
-    method_options :clean => :boolean
-    def notes(commit_base = nil)
-      puts StepUp::Driver::Git.unversioned_notes(commit_base, options[:clean])
+    desc "init", "adds .stepuprc to your project and prepare your local repository to use notes"
+    method_options :update => :boolean
+    def init
+      content = File.read(File.expand_path("../config/step-up.yml", __FILE__))
+      if options[:update] || ! File.exists?(".stepuprc")
+        puts "#{File.exists?(".stepuprc") ? 'updating' : 'creating' } .stepuprc"
+        File.open(".stepuprc", "w") do |f|
+          f.write content
+        end
+      end
+      remotes_with_notes = driver.fetched_remotes('notes')
+      unfetched_remotes = driver.fetched_remotes - remotes_with_notes
+      unless remotes_with_notes.any? || unfetched_remotes.empty?
+        if unfetched_remotes.size > 1
+          remote = choose(unfetched_remotes, "Which remote would you like to fetch notes?")
+          return unless unfetched_remotes.include?(remote)
+        else
+          remote = unfetched_remotes.first
+        end
+        puts "Adding attribute below to .git/config (remote.#{ remote })"
+        puts "  fetch = +refs/notes/*:refs/notes/*"
+        `git config --add remote.#{ remote }.fetch +refs/notes/*:refs/notes/*`
+      end
+    end
+
+    desc "changelog --top=<num> --format={default|wiki|html}", "show changelog from each version tag"
+    method_options %w[top -n] => :numeric
+    method_options %w[format -f] => :string
+    def changelog
+      log = []
+      method_name = "changelog_format_#{ options[:format] }"
+      method_name = "changelog_format_default" unless respond_to?(method_name)
+      driver.all_version_tags.each_with_index do |tag, index|
+        break if options[:top] && index >= options[:top]
+        log << send(method_name, tag)
+      end
+      puts log.join("\n\n")
+    end
+
+    desc "notes ACTION [object] [OPTIONS]", "show notes for the next version"
+    method_options :clean => :boolean, :steps => :boolean, :"-m" => :string, :since => :string
+    def notes(action = "show", commit_base = nil)
+      unless %w[show add remove help].include?(action)
+        commit_base ||= action
+        action = "show"
+      end
+      if self.respond_to?("notes_#{action}")
+        send("notes_#{action}", commit_base)
+      else
+        puts "invalid action: #{action}"
+      end
     end
     
     desc "-v, --version", "show the last version of the gem"
     def gem_version
       puts StepUp::VERSION
     end
+
+    protected
+
+    def changelog_format_default(tag)
+      tag_info = driver.version_tag_info(tag)
+      created_at = tag_info[:date].strftime("%b/%d %Y %H:%M %z")
+    "\033[0;33m#{tag} (#{created_at} by #{tag_info[:tagger]})\033[0m\n\n#{ tag_info[:message] }"
+    end
+
+    def changelog_format_html(tag)
+      tag_info = driver.version_tag_info(tag)
+      created_at = tag_info[:date].strftime("%b/%d %Y %H:%M %z")
+      log = []
+      log << "<h3 class=\"changelog_header\">#{tag} (#{created_at} by #{tag_info[:tagger]})</h3>"
+      log << " <pre class=\"changelog_description\">"
+      log << tag_info[:message].gsub(/^/, '  ')
+      log << " </pre>"
+      log << "<br/>"
+      log.join("\n")
+    end
+
+    def changelog_format_wiki(tag)
+      tag_info = driver.version_tag_info(tag)
+      created_at = tag_info[:date].strftime("%b/%d %Y %H:%M %z")
+      log = []
+      log << "== #{tag} (#{created_at} by #{tag_info[:tagger]}) ==\n"
+      log << tag_info[:message].gsub(/^(\s+)-/, '\1*')
+      log.join("\n")
+    end
+
+    def notes_show(commit_base = nil)
+      message = []
+      message << "Showing notes since #{ options[:since] }#{ " (including notes of tags: #{ ranged_notes.scoped_tags.join(", ")})" if ranged_notes.scoped_tags.any? }" unless options[:since].nil?
+      message << "---"
+      message << get_notes
+      puts message.join("\n")
+    end
+
+    def notes_remove(commit_base)
+      commit_base = "HEAD" if commit_base.nil?
+      ranged_notes = StepUp::RangedNotes.new(driver, nil, commit_base)
+      notes = ranged_notes.notes_of(ranged_notes.last_commit).as_hash
+      sections = notes.keys
+      if sections.empty?
+        puts "No notes found"
+      else
+        if sections.size > 1
+          section = choose(sections, "Which section you want to remove notes?")
+          return unless sections.include?(section)
+        else
+          section = sections.first
+        end
+        steps = driver.steps_to_remove_notes(section, ranged_notes.last_commit)
+        print_or_run(steps, options[:steps])
+      end
+    end
+
+    def notes_add(commit_base = nil)
+      message = options[:m] 
+      message = nil if options[:m] =~ /^(|m)$/
+      message ||= get_message("Note message:\n>>", " >")
+      unless message.empty?
+        section = choose(CONFIG.notes_sections.names, "Choose a section to add the note:")
+        return if section.nil? || ! CONFIG.notes_sections.names.include?(section)
+        steps = driver.steps_for_add_notes(section, message, commit_base)
+        print_or_run(steps, options[:steps])
+      end
+    end
+
+    def version_show
+      if options[:levels]
+        puts "Current version levels:"
+        version_levels.each  do |level|
+          puts " - #{level}"
+        end
+      else
+        puts driver.last_version_tag("HEAD", true)
+      end
+    end
+
+    def version_create
+      level = options[:level] || version_levels.last
+      message = get_notes(true, get_custom_message)
+      message = edit_message(driver.class::VERSION_MESSAGE_FILE_PATH, message) unless options[:'no-editor']
+
+      if message.strip.empty?
+        puts "\ninvalid version message: too short"
+        return
+      end
+
+      if version_levels.include? level
+        steps = driver.steps_to_increase_version(level, "HEAD", message)
+        print_or_run(steps, options[:steps])
+      else
+        puts "invalid version create option: #{level}"
+      end
+    end
+    
+    private
+
+    def edit_message(temp_file, initial_content)
+      File.open(temp_file, "w"){ |f| f.write initial_content }
+      editor = driver.editor_name
+      if editor =~ /\w/
+        if editor =~ /^vim?\b/
+          system "#{ editor } #{ temp_file }"
+        else
+          `#{ editor } #{ temp_file } && wait $!`
+        end
+        File.read(temp_file).rstrip
+      end
+    end
+
+    def driver
+      @driver ||= StepUp::Driver::Git.new
+    end
+
+    def ranged_notes
+      unless defined? @ranged_notes
+        tag = options[:since] || driver.last_version_tag
+        if tag =~ /[1-9]/
+          tag = tag.gsub(/\+\d*$/, '')
+        else
+          tag = nil
+        end
+        @ranged_notes = StepUp::RangedNotes.new(driver, tag, "HEAD")
+      end
+      @ranged_notes
+    end
+
+    def get_notes(clean = options[:clean], custom_message = nil)
+      changelog_options = {}
+      changelog_options[:mode] = :with_objects unless clean
+      changelog_options[:custom_message] = custom_message
+      notes = (options[:since].nil? ? ranged_notes.notes : ranged_notes.all_notes)
+      notes.as_hash.to_changelog(changelog_options)
+    end
+
+    def choose(list, statement)
+      puts statement
+      list.each_with_index do |item, index|
+        puts "  #{ index + 1 }. #{ item }"
+      end
+      value = ask(">>")
+      if value =~ /^\d+$/
+        value = value.to_i
+        value > 0 && list.size > value - 1 ? list[value - 1] : nil
+      else
+        value.empty? ? nil : value
+      end
+    end
+
+    def get_message(prompt1, prompt2, total_breaks = 1)
+      lines = []
+      prompt = prompt1
+      empty = total_breaks - 1
+      line = nil
+      begin
+        lines << line unless line.nil?
+        line = raw_ask(prompt)
+        prompt = prompt2
+        empty = line.empty? ? empty + 1 : 0
+      end while empty < total_breaks
+      lines.join("\n").gsub(/\n+\z/, '').gsub(/\A\n+/, '')
+    end
+
+    def raw_ask(statement, color = nil)
+      say("#{statement} ", color)
+      $stdin.gets.chomp
+    end
+
+    def version_levels
+      CONFIG["versioning"]["version_levels"]
+    end
+    
+    def print_or_run(steps, print)
+      if print
+        puts steps.join("\n")
+      else
+        steps.each do |step|
+          run step
+        end
+      end
+    end
+    
+    def get_custom_message
+      message = options[:message]
+      (message && !message.strip.empty?) ? message : nil
+    end
   end
 end

data/lib/step-up/config.rb

@@ -2,7 +2,72 @@ require 'yaml'
 module StepUp
   CONFIG = {}
 
-  def self.load_config path
+  module ConfigExt
+    def method_missing(m, *args, &block)
+      super unless self.key?(m.to_s)
+      value = self[m.to_s]
+      if value.is_a?(Hash) && ! value.kind_of?(ConfigExt)
+        class << value
+          include ConfigExt
+        end
+      end
+      value
+    end
+  end
+  module ConfigSectionsExt
+    def names
+      map{ |section| section.is_a?(String) ? section : section["name"] }
+    end
+
+    def prefixes
+      map{ |section| section.is_a?(String) ? to_prefix(section) : (section["prefix"] || to_prefix(section["name"])) }
+    end
+
+    def labels
+      map{ |section| section.is_a?(String) ? to_label(section) : (section["label"] || to_label(section["name"])) }
+    end
+
+    def tags
+      map{ |section| section.is_a?(String) ? to_tag(section) : (section["tag"] || to_tag(section["name"])) }
+    end
+
+    def label(section)
+      labels[names.index(section)]
+    end
+
+    def tag(section)
+      tags[names.index(section)]
+    end
+
+    private
+
+    def to_prefix(name)
+      "#{ (name.respond_to?(:singularize) ? name.singularize : name).gsub(/_/, ' ') }: "
+    end
+
+    def to_label(name)
+      "#{ name.capitalize.gsub(/_/, ' ') }:"
+    end
+
+    def to_tag(name)
+      name.respond_to?(:singularize) ? name.singularize : name
+    end
+  end
+  class << CONFIG
+    include ConfigExt
+
+    def notes_sections
+      sections = notes.sections
+      unless sections.kind_of?(ConfigSectionsExt)
+        class << sections
+          include ConfigSectionsExt
+        end
+      end
+      sections
+    end
+  end
+
+  def self.load_config(path)
     return CONFIG unless File.exists? path
     CONFIG.merge! YAML.load_file(path)
   rescue TypeError => e
@@ -10,5 +75,5 @@ module StepUp
   end
 
   load_config File.expand_path('../config/step-up.yml', __FILE__)
-  load_config '.versionrc' # from working folder
+  load_config '.stepuprc' # from working folder
 end

data/lib/step-up/config/step-up.yml

@@ -5,13 +5,25 @@ notes:
     section: "versioning"
     changelog_message: "available on {version}"
   sections:
-    - changes
-    - bugfixes
-    - features
-    - deploy_steps
+    - name: "changes"
+      prefix: "change: "
+      label: "Changes:"
+      tag: "change"
+    - name: "bugfixes"
+      prefix: "bugfix: "
+      label: "Bugfixes:"
+      tag: "bugfix"
+    - name: "features"
+      prefix: "feature: "
+      label: "Features:"
+      tag: "feature"
+    - name: "deploy_steps"
+      prefix: "deploy_step: "
+      label: "Deploy steps:"
+      tag: "deploy_step"
 versioning:
   version_mask: "v0.0.0.9.rc9"
-  version_parts:
+  version_levels:
     - major
     - minor
     - tiny