code-tools 5.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5bccd6fecbea6c93c32b92522d03fc000ebe403b
+  data.tar.gz: 927adb322732ca9f2f37cff0372d0f5c215810be
+SHA512:
+  metadata.gz: 596b5fec512b56871f04ed48d2633fd567ba80efa53c7b2bb5732b92643d707e8b8dcf76651dcea097b3323a8b212f0f6957ace5fef32ea9a543c780b8b83bd1
+  data.tar.gz: e9335f94a397cc1333d31aa0bd3df41fb3aa282840f1e50c39f07bfd67091d600d25572c0db1e9e59a7a8f72b312b0d5c14c4b5fd44a904aba874aa1e053a80b

data/bin/code-tools

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+puts "vamper - Version stamper"
+puts "ender - CR/LF line ending fixer"
+puts "spacer - Space/tab line fixer"

data/bin/ender

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'methadone'
+
+class Tool
+  include Methadone::Main
+  include Methadone::CLILogging
+
+  main do |input_file|
+    unless File.exist?(input_file)
+      error "File #{input_file} does not exist"
+      next 1
+    end
+
+    output_file = options[:output_file]
+
+    if output_file.nil?
+      output_file = input_file
+    end
+
+    # Read the entire file and determine all the different line endings
+    file_contents = IO.read(input_file)
+    num_cr = 0
+    num_lf = 0
+    num_crlf = 0
+    num_lines = 1
+
+    i = 0
+    while i < file_contents.length do
+      c = file_contents[i]
+
+      if c == "\r"
+        if i < file_contents.length - 1 and file_contents[i + 1] == "\n"
+          num_crlf += 1
+          i += 1
+        else
+          num_cr += 1
+        end
+
+        num_lines += 1
+      elsif c == "\n"
+        num_lf += 1
+        num_lines += 1
+      end
+      i += 1
+    end
+
+    num_endings = (num_cr > 0 ? 1 : 0) + (num_lf > 0 ? 1 : 0) + (num_crlf > 0 ? 1 : 0)
+    le = num_endings > 1 ? :mixed : num_cr > 0 ? :cr : num_lf > 0 ? :lf : :crlf
+    msg = "\"#{input_file}\", #{le.to_s}, #{num_lines} lines"
+
+    if options[:mode].nil?
+      info msg
+      next 1
+    end
+
+    if options[:mode] == :auto
+      # Find the most common line ending and make that the automatic line ending
+      auto_line_ending = :lf
+      n = num_lf
+
+      if num_crlf > n
+        auto_line_ending = :crlf
+        n = num_crlf
+      end
+
+      if num_cr > n
+        auto_line_ending = :cr
+      end
+
+      options[:mode] = auto_line_ending
+    end
+
+    new_num_lines = 1
+
+    if (options[:mode] == :cr and num_cr + 1 == num_lines) or
+        (options[:mode] == :lf and num_lf + 1 == num_lines) or
+        (options[:mode] == :crlf and num_crlf + 1 == num_lines)
+      # We're not changing the line endings; nothing to do
+      new_num_lines = num_lines
+    else
+      newline_chars =
+        options[:mode] == :cr ? "\r" :
+        options[:mode] == :lf ? "\n" :
+        "\r\n"
+
+      file = nil
+
+      begin
+        file = File.new(output_file, 'w')
+
+        i = 0
+        while i < file_contents.length
+          c = file_contents[i]
+
+          if c == "\r"
+            if i < file_contents.length - 1 && file_contents[i + 1] == "\n"
+              i += 1
+            end
+
+            new_num_lines += 1
+            file.write(newline_chars)
+          elsif c == "\n"
+            new_num_lines += 1
+            file.write(newline_chars)
+          else
+            file.write(c)
+          end
+
+          i += 1
+        end
+      rescue Exception => e
+        error "unable to write #{output_file}. #{e.to_s}"
+        next 1
+      ensure
+        file.close() unless !file
+      end
+
+      msg += " -> \"#{output_file}\", #{options[:mode].to_s}, #{new_num_lines} lines"
+    end
+
+    info msg
+  end
+
+  change_logger Methadone::CLILogger.new
+
+  description 'Ender - the line ending fixer'
+  version '5.0.0'
+
+  on("-o", "--output-file FILE", "The output file. Default is the same as the input file.")
+  on("-m", "--mode MODE",
+    "The convert mode, either auto, cr, lf, crlf. auto will use the most commonly occurring ending. "\
+    "Updates will only be done when this argument is given.") do |mode|
+    options[:mode] = case mode
+      when 'auto', 'a'
+        :auto
+      when 'lf'
+        :lf
+      when 'cr'
+        :cr
+      when 'crlf'
+        :crlf
+      else
+        exit_now! "Unknown mode #{mode}"
+    end
+  end
+
+  arg :input_file, "Input file to check or convert"
+
+  go!
+end

data/bin/spacer

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'methadone'
+require 'spacer'
+
+class Tool
+  include Methadone::Main
+  include Methadone::CLILogging
+
+  # When reporting the tool indicates beginning-of-line \(BOL\) tabs and spaces.
+  # When replacing, all tabs not at the beginning of a line are replaced with spaces.
+  # Spaces and tabs inside multi-line C# strings (@"...") and inside Ruby \%Q\(...\) strings
+  # are ignored.
+  # Note that conversion to tabs may still leave the file as mixed as some lines may have
+  # spaces that are not a whole number multiple of the tabstop size.  In that case use the
+  # -round option to remove smooth out the spurious spaces.
+
+  def self.get_whitespace_type(bol)
+    (bol.tabs > 0) ? (bol.spaces > 0 ? :mixed : :tabs) : :spaces
+  end
+
+  def self.read_file_lines(filename)
+    # Read the entire file
+    file_contents = File.read(filename)
+
+    # Convert to a list of lines, preserving the end-of-lines
+    lines = []
+    s = 0
+    i = 0
+
+    while i < file_contents.length do
+      c = file_contents[i]
+      c1 = i < file_contents.length - 1 ? file_contents[i + 1] : "\0"
+
+      if c == "\r"
+        i += 1
+
+        if c1 == "\n"
+          i += 1
+        end
+      elsif c == "\n"
+        i += 1
+      else
+        i += 1
+        next
+      end
+
+      lines.push(file_contents[s, i - s])
+      s = i
+    end
+
+    if s != i
+      lines.push(file_contents[s, i - s])
+    end
+
+    lines
+  end
+
+  main do |input_file|
+    unless File.exist?(input_file)
+      error "File #{input_file} does not exist"
+      next 1
+    end
+
+    output_file = options[:output_file]
+
+    if output_file.nil?
+      output_file = input_file
+    end
+
+    if File.extname(input_file) == '.cs'
+      file_type = :csharp
+    else
+      file_type = :text
+    end
+
+    lines = read_file_lines(input_file)
+
+    if file_type == :text
+      before = Spacer::Text.count_bol_spaces_and_tabs(lines)
+    else
+      before = Spacer::CSharp.count_bol_spaces_and_tabs(lines)
+    end
+
+    if !options[:mode].nil?
+      if file_type == :text
+        Spacer::Text.untabify(lines, options[:tabsize])
+      else
+        Spacer::CSharp.untabify(lines, options[:tabsize])
+      end
+
+      if options[:mode] == :tabs
+        if file_type == :text
+          Spacer::Text.tabify(lines, options[:tabsize], options[:round])
+        else
+          Spacer::CSharp.tabify(lines, options[:tabsize], options[:round])
+        end
+      end
+    end
+
+    msg = "\"#{input_file}\", #{file_type.to_s}, #{get_whitespace_type(before).to_s}"
+
+    if !options[:mode].nil?
+      if file_type == :text
+        after = Spacer::Text.count_bol_spaces_and_tabs(lines)
+      else
+        after = Spacer::CSharp.count_bol_spaces_and_tabs(lines)
+      end
+
+      file = nil
+
+      begin
+        file = File.new(output_file, 'w')
+
+        for line in lines do
+          file.write(line)
+        end
+      ensure
+        file.close() unless file == nil
+      end
+
+      msg += " -> \"#{output_file}\", #{get_whitespace_type(after).to_s}"
+    end
+
+    info msg
+  end
+
+  description 'Spacer - source file space/tab fixer tool'
+  version '5.0.0'
+
+  options[:tabsize] = 4
+  options[:round] = false
+
+  on("-o", "--output-file FILE", "The output file. Default is the same as the input file.")
+  on("-m", "--mode MODE","The convert mode (tabs or spaces) Default is to just display the files current state."\
+     "Updates will only be done when this argument is given.") do |mode|
+    options[:mode] = case mode
+      when 'tabs', 't'
+        :tabs
+      when 'spaces', 's'
+        :spaces
+      else
+        exit_now! "Unknown mode #{mode}"
+    end
+  end
+  on("-t", "--tabsize TABSIZE", "Tab size in spaces to assume. Default is #{options[:tabsize]} spaces.")
+  on("-r", "--round", "When tabifying, round BOL spaces down to an exact number of tabs.")
+
+  arg :input_file, "Input file to check or convert"
+
+  go!
+end

data/bin/vamper

@@ -0,0 +1,180 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'methadone'
+require 'vamper'
+require 'tzinfo'
+
+class Tool
+  include Methadone::Main
+  include Methadone::CLILogging
+
+  def self.find_version_file()
+    dir = Dir.pwd
+
+    while dir.length != 0
+      files = Dir.glob('*.version')
+      if files.length > 0
+        file = files[0]
+        break
+      else
+        if dir == '/'
+          dir = ''
+        else
+          dir = File.expand_path('..', dir)
+        end
+      end
+    end
+
+    if file.nil?
+      exit_now! 'Unable to find a .version file in this or parent directories.'
+    end
+
+    file
+  end
+
+  def self.get_full_date(now)
+    now.year * 10000 + now.month * 100 + now.mday
+  end
+
+  def get_jdate(now, start_year)
+    (((now.year - start_year + 1) * 10000) + (now.month * 100) + now.mday).to_s
+  end
+
+  main do |input_file|
+    if input_file.nil? or !File.exist?(input_file)
+      input_file = find_version_file
+    end
+
+    input_file = File.expand_path(input_file)
+
+    project_name = File.basename(input_file, '.version')
+    version_config_file_name = "#{File.dirname(input_file)}/#{project_name}.version.config"
+
+    info "Version file is '#{input_file}'"
+    info "Version config is '#{version_config_file_name}'"
+    info "Project name is '#{project_name}'"
+
+    if File.exists?(input_file)
+      version_data = Vamper::VersionFile.new(File.open(input_file))
+    else
+      version_data = Vamper::VersionFile.new
+    end
+
+    now = TZInfo::Timezone.get(version_data.time_zone).now
+
+    case version_data.build_value_type
+      when :JDate
+        build = get_jdate(now, version_data.start_year)
+
+        if version_data.build != build
+          version_data.revision = 0
+          version_data.build = build
+        else
+          version_data.revision += 1
+        end
+      when :Incremental
+        version_data.build += 1
+        version_data.revision = 0
+      else # :FullDate
+        build = get_full_date(now)
+
+        if version_data.build != build
+          version_data.revision = 0
+          version_data.build = build
+        else
+          version_data.revision += 1
+        end
+    end
+
+    tags = version_data.tags
+
+    case version_data.build_value_type
+      when :FullDate
+        build_str = build.to_s
+        tags[:DashBuild] = build_str[0..3] + '-' + build_str[4..5] + '-' + build_str[6..7]
+    end
+
+    info 'Version tags are:'
+    tags.each { |key, value|
+      info "  #{key}=#{value}"
+    }
+
+    if options[:update]
+      info 'Updating version information:'
+    end
+
+    unless File.exists?(version_config_file_name)
+      FileUtils.cp(Vamper::VersionConfigFile.get_default_file, version_config_file_name)
+    end
+
+    version_config_file = Vamper::VersionConfigFile.new(File.open(version_config_file_name), tags)
+    file_list = version_data.files.map { |file_name| file_name.replace_tags!(tags) }
+
+    file_list.each do |file_name|
+      path = File.expand_path(File.join(File.dirname(input_file), file_name))
+      path_file_name = File.basename(path)
+      match = false
+
+      for file_type in version_config_file.file_types do
+        match = file_type.file_specs.any? { |file_spec| file_spec.match(path_file_name) }
+        unless match
+          next
+        end
+
+        if file_type.write
+          dir = File.dirname(path)
+          unless Dir.exists?(dir)
+            error "Directory '#{dir}' does not exist to write file ''#{path_file_name}''"
+            exit(1)
+          end
+
+          if options[:update]
+            IO.write(path, file_type.write)
+          end
+        else # !file_type.write
+          if File.exists?(path)
+            if options[:update]
+              file_type.updates.each do |update|
+                content = IO.read(path)
+                # At this point the only ${...} variables left in the replace strings are Before and After
+                # This line converts the ${...} into \k<...> to put captured groups from search back
+                # into the replace string.
+                content.gsub!(%r(#{update.search})m, update.replace.gsub(/\${(\w+)}/,'\\\\k<\\1>'))
+                IO.write(path, content)
+              end
+            end
+          else
+            error "file #{path} does not exist to update"
+            exit(1)
+          end
+        end
+
+        break
+      end
+
+      unless match
+        error "file '#{path}' has no matching file type in the .version.config"
+        exit(1)
+      end
+
+      info path
+
+      if options[:update]
+        version_data.write_to(File.open(input_file, 'w'))
+      end
+    end
+  end
+
+  description 'Vamper - file version stamper'
+  version '5.0.0'
+
+  options[:update] = false
+
+  on("-u", "--update", "Actually do the update.")
+
+  arg :input_file, "A version file. Default is to search parent directories for *.version", :optional
+
+  go!
+end

data/lib/core_ext.rb

@@ -0,0 +1,54 @@
+class String
+  def underscore
+    self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr('-', '_').
+        downcase
+  end
+
+  def replace_tags(tags)
+    str = self
+    tags.each { |name, value|
+      str = str.gsub(%r(\$\{#{name.to_s}\})m, value)
+    }
+    str
+  end
+
+  def replace_tags!(tags)
+    tags.each { |name, value|
+      self.gsub!(%r(\$\{#{name.to_s}\})m, value)
+    }
+    self
+  end
+
+  # colorization
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def yellow
+    colorize(33)
+  end
+
+  def blue
+    colorize(34)
+  end
+
+  def pink
+    colorize(35)
+  end
+
+  def light_blue
+    colorize(36)
+  end
+
+end

data/lib/spacer/csharp.rb

@@ -0,0 +1,142 @@
+require 'ostruct'
+
+module Spacer
+  module CSharp
+    def self.count_bol_spaces_and_tabs(lines)
+      bol = OpenStruct.new
+      bol.tabs = 0
+      bol.spaces = 0
+      in_multi_line_string = false
+
+      for line in lines do
+        in_bol = true
+        i = 0
+        while i < line.length do
+          c = line[i]
+          c1 = i < line.length - 1 ? line[i + 1] : "\0"
+
+          if in_multi_line_string and c == "\"" and c1 != "\""
+            in_multi_line_string = false
+          elsif c == "@" and c1 == "\""
+            in_multi_line_string = true
+            i += 1
+          elsif in_bol and !in_multi_line_string and c == " "
+            bol.spaces += 1
+          elsif in_bol and !in_multi_line_string and c == "\t"
+            bol.tabs += 1
+          else
+            in_bol = false
+          end
+          i += 1
+        end
+      end
+
+      bol
+    end
+
+    def self.untabify(lines, tabsize)
+      # Expand tabs anywhere on a line, but not inside @"..." strings
+      in_multi_line_string = false
+
+      i = 0
+      while i < lines.length do
+        line = lines[i]
+        in_string = false
+        new_line = ""
+        j = 0
+
+        while j < line.length do
+          c_1 = j > 0 ? line[j - 1] : '\0'
+          c = line[j]
+          c1 = j < line.length - 1 ? line[j + 1] : '\0'
+
+          raise "line #{i + 1} has overlapping regular and multiline strings" if (in_string and in_multi_line_string)
+
+          if !in_multi_line_string and c == "\t"
+            # Add spaces to next tabstop
+            num_spaces = tabsize - (new_line.length % tabsize)
+
+            new_line += " " * num_spaces
+          elsif !in_multi_line_string and !in_string and c == "\""
+            in_string = true
+            new_line += c
+          elsif !in_multi_line_string and !in_string and c == "@" and c1 == "\""
+            in_multi_line_string = true
+            new_line += c
+            j += 1
+            new_line += c1
+          elsif in_string and c == "\"" and c_1 != "\\"
+            in_string = false
+            new_line += c
+          elsif in_multi_line_string and c == "\"" and c1 != "\""
+            in_multi_line_string = false
+            new_line += c
+          else
+            new_line += c
+          end
+
+          lines[i] = new_line
+          j += 1
+        end
+        i += 1
+      end
+    end
+
+    def self.tabify(lines, tabsize, round_down_spaces)
+      # Insert tabs for spaces, but only at the beginning of lines and not inside @"..." or "..." strings
+      in_multi_line_string = false
+      i = 0
+
+      while i < lines.length do
+        line = lines[i]
+        in_string = false
+        bol = true
+        num_bol_spaces = 0
+        new_line = ""
+        j = 0
+
+        while j < line.length do
+          c_1 = j > 0 ? line[j - 1] : "\0"
+          c = line[j]
+          c1 = j < line.length - 1 ? line[j + 1] : "\0"
+
+          if !in_string and !in_multi_line_string and bol and c == " "
+            # Just count the spaces
+            num_bol_spaces += 1
+          elsif !in_string and !in_multi_line_string and bol and c != " "
+            bol = false
+
+            new_line += "\t" * (num_bol_spaces / tabsize)
+
+            if !round_down_spaces
+              new_line += " " * (num_bol_spaces % tabsize)
+            end
+            # Process this character again as not BOL
+            j -= 1
+          elsif !in_multi_line_string and !in_string and c == '"'
+            in_string = true
+            new_line += c
+          elsif !in_multi_line_string and !in_string and c == "@" and c1 == "\""
+            in_multi_line_string = true
+            new_line += c
+            j += 1
+            new_line += c1
+          elsif in_string and c == "\"" and c_1 != "\\"
+            in_string = false
+            new_line += c
+          elsif in_multi_line_string and c == "\"" and c1 != "\""
+            in_multi_line_string = false
+            new_line += c
+          else
+            new_line += c
+          end
+
+          lines[i] = new_line
+          j += 1
+        end
+        i += 1
+      end
+    end
+
+  end
+end

data/lib/spacer/text.rb

@@ -0,0 +1,85 @@
+module Spacer
+  module Text
+    def self.count_bol_spaces_and_tabs(lines)
+      bol = OpenStruct.new
+      bol.spaces = 0
+      bol.tabs = 0
+
+      for line in lines do
+        for i in 0...line.length do
+          c = line[i]
+
+          if c == " "
+            bol.spaces += 1
+          elsif c == "\t"
+            bol.tabs += 1
+          else
+            break
+          end
+        end
+      end
+
+      bol
+    end
+
+    def self.untabify(lines, tabsize)
+      i = 0
+      while i < lines.length do
+        line = lines[i]
+        j = 0
+        new_line = ""
+
+        while j < line.length do
+          c = line[j]
+
+          if c == "\t"
+            num_spaces = tabsize - (new_line.length % tabsize)
+            new_line += " " * num_spaces
+          else
+            new_line += c
+          end
+          j += 1
+        end
+
+        lines[i] = new_line
+        i += 1
+      end
+    end
+
+    def self.tabify(lines, tabsize, round_down_spaces)
+      i = 0
+      while i < lines.length do
+        line = lines[i]
+        j = 0
+        bol = true
+        num_bol_spaces = 0
+        new_line = ""
+
+        while j < line.length do
+          c = line[j]
+
+          if bol and c == " "
+            num_bol_spaces += 1
+          elsif bol and c != " "
+            bol = false
+            new_line += "\t" * (num_bol_spaces / tabsize)
+
+            if !round_down_spaces
+              new_line += " " * (num_bol_spaces % tabsize)
+            end
+
+            new_line += c
+          else
+            new_line += c
+          end
+
+          j += 1
+        end
+
+        lines[i] = new_line
+        i += 1
+      end
+    end
+
+  end
+end

data/lib/spacer.rb

@@ -0,0 +1,2 @@
+require 'spacer/text'
+require 'spacer/csharp'

data/lib/vamper/default.version.config

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<VersionConfig>
+  <FileType>
+    <Name>Ruby Files</Name>
+    <FileSpec>*.rb</FileSpec>
+    <Update>
+      <Search>(?'Before'\$VERSION=\')([0-9]+\.[0-9]+\.[0-9]+)-[0-9]+\.[0-9]+(?'After'\')</Search>
+      <Replace>${Before}${Major}.${Minor}.${Patch}-${Build}.${Revision}${After}</Replace>
+    </Update>
+  </FileType>
+  <FileType>
+    <Name>Version-in-a-text-file</Name>
+    <FileSpec>*.version.txt</FileSpec>
+    <Write>Release ${Major}.${Minor}.${Build}.${Revision}</Write>
+  </FileType>
+  <FileType>
+    <Name>Windows Manifest File</Name>
+    <FileSpec>WMManifest.xml</FileSpec>
+    <Update>
+      <Search>(?'Before'Version=")([0-9]+\.[0-9]+)(?'After'\.[0-9]+\.[0-9]+")</Search>
+      <Replace>${Before}${Major}.${Minor}${After}</Replace>
+    </Update>
+  </FileType>
+  <FileType>
+    <Name>C# Source</Name>
+    <FileSpec>*.cs</FileSpec>
+    <Update>
+      <Search>(?'Before'AssemblyVersion\(")([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)(?'After'"\))</Search>
+      <Replace>${Before}${Major}.${Minor}.0.0${After}</Replace>
+    </Update>
+    <Update>
+      <Search>(?'Before'AssemblyFileVersion\(")([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)(?'After'"\))</Search>
+      <Replace>${Before}${Major}.${Minor}.${Build}.${Revision}${After}</Replace>
+    </Update>
+    <Update>
+      <Search>(?'Before'AssemblyProduct\(")([^"]*)(?'After'"\))</Search>
+      <Replace>${Before}${Product}${After}</Replace>
+    </Update>
+    <Update>
+      <Search>(?'Before'AssemblyCopyright\(")([^"]*)(?'After'"\))</Search>
+      <Replace>${Before}${Copyright}${After}</Replace>
+    </Update>
+    <Update>
+      <Search>(?'Before'AssemblyCompany\(")([^"]*)(?'After'"\))</Search>
+      <Replace>${Before}${Company}${After}</Replace>
+    </Update>
+  </FileType>
+  <FileType>
+    <Name>Windows RC File</Name>
+    <FileSpec>*.rc</FileSpec>
+    <Update>
+      <Search>(?'Before'FILEVERSION )([0-9]+,[0-9]+,[0-9]+,[0-9]+)</Search>
+      <Replace>${Before}${Major},${Minor},${Build},${Revision}</Replace>
+    </Update>
+    <Update>
+      <Search>(?'Before'PRODUCTVERSION )([0-9]+,[0-9]+,[0-9]+,[0-9]+)</Search>
+      <Replace>${Before}${Major},${Minor},${Build},${Revision}</Replace>
+    </Update>
+    <Update>
+      <Search>(?'Before'"FileVersion",[ \t]*")([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)(?'After'")</Search>
+      <Replace>${Before}${Major}.${Minor}.${Build}.${Revision}${After}</Replace>
+    </Update>
+    <Update>
+      <Search>(?'Before'"ProductVersion",[ \t]*")([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)(?'After'")</Search>
+      <Replace>${Before}${Major}.${Minor}.${Build}.${Revision}${After}</Replace>
+    </Update>
+  </FileType>
+  <FileType>
+    <Name>WiX Files</Name>
+    <FileSpec>*.wxi</FileSpec>
+    <FileSpec>*.wxs</FileSpec>
+    <Update>
+      <Search>(?'Before'ProductVersion = ")([0-9]+\.[0-9]+)(?'After'")</Search>
+      <Replace>${Before}${Major}.${Minor}${After}</Replace>
+    </Update>
+    <Update>
+      <Search>(?'Before'ProductBuild = ")([0-9]+\.([0-9]|[1-9][0-9]))(?'After'")</Search>
+      <Replace>${Before}${Build}.${Revision}${After}</Replace>
+    </Update>
+  </FileType>
+  <FileType>
+    <Name>.NET Config Files</Name>
+    <FileSpec>*.config</FileSpec>
+    <Update>
+      <Search>(?'Before', +Version=)\d+\.\d+(?'After'\.0\.0 *,)</Search>
+      <Replace>${Before}${Major}.${Minor}${After}</Replace>
+    </Update>
+  </FileType>
+  <FileType>
+    <Name>Visual Studio Project Files</Name>
+    <FileSpec>*.csproj</FileSpec>
+    <Update>
+      <Search>(?'Before'&lt;OutputName&gt;" + projectName + @"_)([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)(?'After'&lt;/OutputName&gt;)</Search>
+      <Replace>${Before}${Major}.${Minor}.${Build}.${Revision}${After}</Replace>
+    </Update>
+  </FileType>
+  <FileType>
+    <Name>VSIX Manifest</Name>
+    <FileSpec>*.vsixmanifest</FileSpec>
+    <Update>
+      <Search>(?'Before'&lt;Version&gt;)([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)(?'After'&lt;/Version&gt;)</Search>
+      <Replace>${Before}${Major}.${Minor}.${Build}.${Revision}${After}</Replace>
+    </Update>
+  </FileType>
+</VersionConfig>

data/lib/vamper/version_config_file.rb

@@ -0,0 +1,42 @@
+require 'nokogiri'
+require_relative '../core_ext.rb'
+
+module Vamper
+  class VersionConfigFile
+
+    def self.get_default_file
+      File.join(File.dirname(__FILE__), 'default.version.config')
+    end
+
+    def initialize(io, tags)
+      doc = Nokogiri::XML(io)
+
+      @file_types = []
+      doc.xpath('/VersionConfig/FileType').each do |node|
+        file_type_struct = Struct.new(:name, :file_specs, :updates, :write)
+        search_replace_struct = Struct.new(:search, :replace)
+        file_type = file_type_struct.new
+        file_type.name = node.name
+        file_type.file_specs = node.xpath('FileSpec').map { |sub_node|
+          Regexp.new('^' + Regexp::escape(sub_node.text).gsub('\\*', '.*').gsub('\\?', '.') + '$')
+        }
+        update_node_set = node.xpath('Update')
+        if update_node_set
+          # Replace ${...} entries in the replace string with equivalent tags if available
+          file_type.updates = update_node_set.map { |sub_node|
+            s_and_r = search_replace_struct.new(
+              %r(#{sub_node.at_xpath('Search').text.gsub(/\(\?'(\w+)'/, '(?<\\1>')}),
+              sub_node.at_xpath('Replace').text.replace_tags(tags))
+          }
+        end
+        write_node = node.at_xpath('Write')
+        if write_node
+          file_type.write = write_node.text.replace_tags(tags)
+        end
+        @file_types.push(file_type)
+      end
+    end
+
+    attr_reader :file_types
+  end
+end

data/lib/vamper/version_file.rb

@@ -0,0 +1,97 @@
+require 'nokogiri'
+require_relative '../core_ext.rb'
+
+module Vamper
+  class BadVersionFile < StandardError; end
+
+  class VersionFile
+    attr_reader :tags
+
+    def initialize(io)
+      if io
+        @doc = Nokogiri::XML(io, &:noblanks)
+
+        unless @doc.root.name == 'Version'
+          raise BadVersionFile, 'Root element must be Version'
+        end
+      else
+        @doc = Nokogiri::XML::Document.new
+        @doc.root.add_child(Nokogiri::XML::Element.new('Version', @doc))
+      end
+
+      add_attribute @doc.root, :BuildValueType => :JDate
+      add_child_list_element @doc.root, :Files, :Tags
+      add_child_element tags_element,
+        :Major => 1, :Minor => 0, :Build => 0, :Patch => 0, :Revision => 0, :TimeZone => 'UTC'
+      add_child_element tags_element, {:StartYear => TZInfo::Timezone.get(self.time_zone).now.year}
+    end
+
+    def add_attribute(parent_node, attr_definitions)
+      attr_definitions.each { |attr_symbol, attr_default|
+        method_name = attr_symbol.to_s.underscore
+        unless parent_node[attr_symbol]
+          parent_node[attr_symbol] = attr_default
+        end
+        define_singleton_method(method_name.to_sym) {
+          parent_node[attr_symbol].to_sym
+        }
+        define_singleton_method((method_name + '=').to_sym) { |value|
+          parent_node[attr_symbol] = value.to_s
+        }
+      }
+    end
+
+    def add_child_list_element(parent_element, *element_symbols)
+      element_symbols.each { |element_symbol|
+        name = element_symbol.to_s
+        elem = parent_element.at(name)
+        unless elem
+          elem = parent_element.add_child(Nokogiri::XML::Element.new(name, @doc))
+        end
+
+        method_name = name.underscore + '_element'
+        define_singleton_method(method_name.to_sym) {
+          elem
+        }
+      }
+    end
+
+    def add_child_element(parent_element, element_definitions)
+      element_definitions.each { |element_symbol, element_default|
+        name = element_symbol.to_s
+        elem = parent_element.at(name)
+        unless elem
+          elem = parent_element.add_child(Nokogiri::XML::Element.new(name, @doc))
+          elem.content = element_default.to_s
+        end
+
+        method_name = name.underscore
+        case element_default
+          when Fixnum
+            define_singleton_method(method_name.to_sym) {
+              Integer(elem.content)
+            }
+          when String
+            define_singleton_method(method_name.to_sym) {
+              elem.content.to_s
+            }
+        end
+        define_singleton_method((method_name + '=').to_sym) { |value|
+          elem.content = value.to_s
+        }
+      }
+    end
+
+    def write_to(io)
+      @doc.write_xml_to(io, :indent_text => ' ', :indent => 2)
+    end
+
+    def tags
+      Hash[tags_element.children.select {|node| node.name != 'text'}.map {|node| [node.name.to_sym, node.content]}]
+    end
+    def files
+      files_element.children.select {|node| node.name != 'text'}.map {|node| node.content}
+    end
+
+  end
+end

data/lib/vamper.rb

@@ -0,0 +1,3 @@
+require 'vamper/version_file'
+require 'vamper/version_config_file'
+require 'core_ext.rb'

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: code-tools
+version: !ruby/object:Gem::Version
+  version: 5.0.0
+platform: ruby
+authors:
+- John Lyon-smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: methadone
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: Tools for source code maintenance, including version stamping, line endings
+  and tab/space conversion.
+email: john@jamoki.com
+executables:
+- code-tools
+- ender
+- spacer
+- vamper
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/code-tools
+- bin/ender
+- bin/spacer
+- bin/vamper
+- lib/core_ext.rb
+- lib/spacer.rb
+- lib/spacer/csharp.rb
+- lib/spacer/text.rb
+- lib/vamper.rb
+- lib/vamper/default.version.config
+- lib/vamper/version_config_file.rb
+- lib/vamper/version_file.rb
+homepage: http://rubygems.org/gems/code_tools
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Source code tools
+test_files: []