veracode 1.0.0.alpha

data/bin/veracode

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+$:.unshift Dir.pwd
+
+unless File.exists?("script/rails")
+  $stderr.puts "Current directory #{File.basename(Dir.pwd).dump} does not appear to be a Rails 3 application."
+  exit
+end
+APP_PATH = File.expand_path('config/application')
+APP_NAME = File.basename(Dir.pwd)
+COMMAND = "#{$0} #{ARGV.join(' ')}"
+
+require 'veracode'
+
+$options =  {
+              :phase1 => false, 
+              :phase2 => false, 
+              :phase3 => true,
+              :archive_source => true,
+              :include_inherited => false,
+              :jruby => false,
+            }
+
+subcommand = ARGV.shift
+case subcommand
+  when "prepare", "prep"
+    OptionParser.new do |opts|
+      opts.banner = "Usage: veracode prepare [options]"
+
+      opts.on("-v", "--verbose", "Run verbosely") do
+        $options[:verbose] = true
+      end
+
+      opts.on("-a", "--all", "Archive objects at all stages") do
+        $options[:phase1] = true
+        $options[:phase2] = true
+      end
+
+      opts.on("-f", "--file", "Disassemble .rb files") do
+        $options[:disasm] = true
+      end
+
+      opts.on("-j", "--jruby", "Force JRuby mode") do
+        $options[:jruby] = true
+      end
+
+      opts.on("--[no-]source", "[Don't] Include source code in archive") do |s|
+        $options[:archive_source] = s
+      end
+
+      opts.on("-D", "--debug", "Enable debug output") do
+        $DEBUG = true
+      end
+
+    end.parse!
+
+    Veracode.prepare
+
+  when "help", nil
+    ARGV.clear
+    ARGV.unshift "--help"
+
+    OptionParser.new do |opts|
+      opts.banner = "Usage: veracode prepare [options]"
+    end.parse!
+
+  else
+    $stderr.puts "#{subcommand.dump} is not a valid subcommand"
+
+    ARGV.clear
+    ARGV.unshift "--help"
+
+    OptionParser.new do |opts|
+      opts.banner = "Usage: veracode prepare [options]"
+    end.parse!
+
+end
+
+

data/lib/veracode.rb

@@ -0,0 +1,739 @@
+require 'zlib'
+require 'zip/zip'
+require "veracode/version"
+
+module Veracode
+  @run_id = nil
+
+  # Metadata and method disassemblies for all Modules (.txt.gz)
+  @disasmlog = nil
+  @disasmlog_filename = "disasm.txt.gz"
+
+  # Error log including capture of STDERR and any errors generated by the gem (.log)
+  @errorlog = nil
+  @errorlog_filename = "error.log"
+
+  # Index file containing the names of files present in the application directory (.txt)
+  @index_filename = "index.txt"
+
+  # Manifest file containing original names of all files in archive (.txt)
+  @manifest = []
+  @manifest_filename = "manifest.txt"
+
+  # The final archive that will be uploaded to Veracode for analysis (.zip)
+  @archive = nil
+  @archive_filename = nil
+  @archive_dirname = nil
+
+
+  def self.init
+    @run_id = Time.now.strftime("%Y%m%d%H%M%S")
+    @archive_dirname = File.join("tmp","veracode-#{@run_id}")
+
+    if !Dir.exists?("tmp")
+      begin
+        Dir.mkdir("tmp")
+      rescue Exception => e
+        $stderr.puts "Directory 'tmp' does not exist and cannot be created: #{e.message}"
+        exit
+      end
+    end
+
+    while Dir.exists?(@archive_dirname)
+      @run_id = Time.now.strftime("%Y%m%d%H%M%S")
+      @archive_dirname = File.join("tmp","veracode-#{@run_id}")
+    end
+
+    begin
+      Dir.mkdir(@archive_dirname)
+    rescue Exception => e
+      $stderr.puts "Unable to make directory #{@archive_dirname}: #{e.message}"
+      exit
+    end
+
+    @archive_filename   = File.join("tmp","veracode-#{APP_NAME}-#{@run_id}.zip")
+
+    @errorlog_filename  = File.join(@archive_dirname, @errorlog_filename)
+    @disasmlog_filename = File.join(@archive_dirname, @disasmlog_filename)
+    @index_filename     = File.join(@archive_dirname, @index_filename)
+    @manifest_filename  = File.join(@archive_dirname, @manifest_filename)
+
+    # Try touching each of the files to be written
+    [@disasmlog_filename, @errorlog_filename, @index_filename, @manifest_filename].each {|f|
+      begin
+        File.open(f, "wb") {}
+      rescue Exception => e
+        $stderr.puts "Unable to create file #{f}: #{e.message}"
+        exit
+      else
+        @manifest << f
+      end
+    }
+
+    begin
+      @errorlog = File.open(@errorlog_filename, "wb")
+      log_error "COMMAND: #{COMMAND}"
+      log_error "RUBY_DESCRIPTION: #{RUBY_DESCRIPTION}"
+      log_error "RAILS_VERSION: " + `rails --version`.chomp
+      log_error "GEM_VERSION: #{Veracode::VERSION}"
+      log_error "PWD: #{Dir.pwd.to_s.dump}"
+      log_error "APP_NAME: #{APP_NAME.dump}"
+      log_error "RUNID: #{@run_id}"
+    rescue Exception => e
+      $stderr.puts "Unable to create errorlog #{@errorlog_filename}: #{e.message}"
+      @errorlog = $stderr
+    else
+      STDERR.reopen(@errorlog)
+    end
+
+    index_application
+
+    @manifest += Dir.glob("*").keep_if {|f| File.file?(f)}
+
+#     {app config db doc lib log public script test tmp vendor}
+    %w{app config        lib log public script          vendor}.each {|dirname|
+      @manifest += Dir[File.join(dirname, "**", "*")].keep_if {|f| File.file?(f)}
+    }
+    @manifest += Dir[File.join("db", "**", "*.rb")]
+
+    if $options[:archive_source]
+      # Add any other ruby files not already added
+      @manifest |= Dir[File.join("**","*.rb")]
+      # Add any other erb files not already added
+      @manifest |= Dir[File.join("**","*.erb")]
+      # Add any other haml files not already added
+      @manifest |= Dir[File.join("**","*.haml")]
+    end
+    
+  end
+
+  def self.index_application
+    File.open(@index_filename, "wb") {|index_file|
+      Dir[File.join("**","*")].keep_if {|f| File.file?(f)}.sort.each {|f|
+        index_file.puts f.dump
+      }
+    }    
+  end
+
+  def self.pack_manifest
+
+    puts "Archiving disassembly and source files"
+
+    begin
+      File.open(@manifest_filename, "wb") { |mf|
+        @manifest.sort.each { |f|
+          mf.puts f.to_s.dump        
+        }
+      }
+    rescue Exception => e
+      log_error e.message
+      $stderr.puts "Unable to write manifest file #{@manifest_filename}: #{e.message}"
+    end
+
+    @errorlog.flush
+
+    begin
+      Zip::ZipFile.open(@archive_filename, Zip::ZipFile::CREATE) { |zf|
+        @manifest.each {|file|
+
+          if file.start_with?(@archive_dirname)
+            name_in_archive = file.sub(/^#{@archive_dirname + File::SEPARATOR}/,"")          
+          else
+            name_in_archive = File.join(APP_NAME, file)
+          end        
+
+          puts "Adding #{file} to archive as #{name_in_archive}" if $options[:verbose]
+          zf.add(name_in_archive, file)
+        }
+      }      
+    rescue Exception => e
+      $stderr.puts "Unable to create archive #{@manifest_filename}: #{e.message}"
+      exit
+    end
+
+    puts "Please upload #{@archive_filename}"
+  end
+
+  def self.cleanup
+    [@disasmlog_filename, @errorlog_filename, @index_filename, @manifest_filename].each {|f|
+      begin
+        File.delete(f)
+      rescue Exception => e
+        log_error "Unable to delete #{f.to_s.dump} (#{e.message})"
+      end
+    }
+
+    begin
+      Dir.delete(@archive_dirname)
+    rescue Exception => e
+      puts "Unable to remove #{@archive_dirname.to_s.dump} (#{e.message})"
+      log_error "Unable to remove #{@archive_dirname.to_s.dump} (#{e.message})"
+    end
+  end
+
+  def self.baseline
+    self.update
+    @baseline_objects = @objects
+    @baseline_modules = @modules
+    @baseline_classes = @classes
+  end
+
+  def self.rebaseline
+    self.baseline
+  end
+
+  def self.update
+    @objects = ObjectSpace.each_object.to_a
+    @modules = ObjectSpace.each_object(Module).to_a
+    @classes = ObjectSpace.each_object(Class).to_a
+  end
+
+  def self.stats
+    puts "#{ObjectSpace.each_object.count.to_s} objects"
+    puts "#{ObjectSpace.each_object(Module).count.to_s} modules"
+    puts "#{ObjectSpace.each_object(Class).count.to_s} classes"
+    puts
+  end
+
+
+  ##############################################################################
+  # Helpers
+  def self.glob_require(files)
+    Dir.glob(files) do |f|
+      print "Requiring #{f.to_s} " if $options[:verbose]
+      
+      begin
+        require File.expand_path(f)
+      rescue Exception => e
+        puts "(failed: #{e.message})" if $options[:verbose]
+        log_error "Unable to require #{File.expand_path(f).to_s.dump} (#{e.message})"
+      else
+        puts "(OK)" if $options[:verbose]
+      end
+
+    end
+  end
+
+  def self.safe_name(o)
+    case 
+    when o == ActiveSupport::TimeWithZone
+      "ActiveSupport::TimeWithZone"
+    when o.is_a?(Module)
+      ( o.name.nil? ? o.to_s : o.name )
+    when o.is_a?(Method), o.is_a?(UnboundMethod)
+      o.name.to_s
+    else
+      o.to_s
+    end
+  end
+  
+  def self.quote(o)
+    o.to_s.dump
+  end
+  
+  def self.quote_if_string(o)
+    ( o.is_a?(String) ? o.dump : o.inspect )
+  end
+  
+  def self.good_type?(o)
+    %w{
+        Array
+        Bignum
+        Class
+        FalseClass
+        Fixnum
+        Float
+        Hash
+        Module
+        NilClass
+        Range
+        Rational
+        Regexp
+        String
+        Symbol
+        Time
+        TrueClass
+      }.include?(o.class.to_s)
+  end
+
+  def self.safe_inspect(o)
+    if o.is_a?(Array)
+      "[" + 
+        o.map {|i| safe_inspect(i) }.join(", ") + 
+      "]"
+    elsif o.is_a?(Hash)
+      "{" + 
+        o.map {|k,v| "#{safe_inspect(k)}=>#{safe_inspect(v)}" }.join(", ") + 
+      "}"
+    elsif o.is_a?(Module)
+      safe_name(o)
+    elsif good_type?(o)
+      quote_if_string(o)
+    else
+      ":veracode_nil" # not a white-listed type
+    end
+  end
+
+  def self.log_error(data)
+    @errorlog.printf "veracode [%s] %s\n", Time.now.to_s, data.to_s.chomp
+  end
+
+
+  ##############################################################################
+  # Archiving
+  def self.prepare_archive
+    @disasmlog = Zlib::GzipWriter.new(File.open(@disasmlog_filename, "wb"), nil, nil)
+    @disasmlog.puts "#{RUBY_ENGINE}-#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+    @disasmlog.puts "# " + `rails --version`.chomp
+    @disasmlog.puts
+  end
+
+  def self.finalize_archive
+    @disasmlog.close unless @disasmlog.nil?
+  end
+
+  def self.add_to_archive(data)
+    if @disasmlog.nil?
+      prepare_archive
+    end
+    @disasmlog.write(data)
+  end
+
+
+  def self.format_method(m, kind, with_disasm=true)
+    return "" unless ((m.is_a? Method ) || (m.is_a? UnboundMethod))
+
+    puts "  #{kind}_method #{quote(safe_name(m))}" if $options[:verbose]
+
+    formatted = "#{kind}_method #{quote(safe_name(m))} #{m.parameters.to_s}\n"
+
+    if with_disasm
+      insns = RubyVM::InstructionSequence.disassemble(m)
+      formatted += ( (insns.nil? || insns.empty?) ? 
+                     "== disasm\n== end disasm\n" : 
+                     "#{insns}== end disasm\n" 
+                   )
+    end
+
+    formatted
+  end
+
+  def self.format_variable(v_symbol, v, kind)
+    puts "  #{quote(kind)} variable #{quote(v_symbol)}" if $options[:verbose]
+
+    "#{kind}_variable %s %s%s\n" % 
+      [quote(v.class), quote(v_symbol), ( good_type?(v) ? " = #{safe_inspect(v)}" : "")]
+  end
+
+  def self.format_constant(c_symbol, c)
+    puts "  constant #{quote(c_symbol)}" if $options[:verbose]
+
+    "constant %s %s%s\n" % 
+      [quote(c.class), quote(c_symbol), ( good_type?(c) ? " = #{safe_inspect(c)}" : "")]
+  end
+
+
+  ##############################################################################
+  # Archiving Headers
+  def self.class_header(c)
+    return "" unless c.is_a? Class
+
+    puts "  class header" if $options[:verbose]
+
+    case
+    when c.superclass.nil? # this should only happen for BasicObject
+      return ""
+    when c.superclass.name.nil? # in case the parent is anonymous
+      name = c.superclass.to_s.dump
+    else
+      name = c.superclass.name.dump
+    end
+
+    "superclass #{name}\n"
+  end
+
+  def self.module_header(m)
+    return "" unless m.is_a? Module
+
+    puts "  module header" if $options[:verbose]
+
+    ( m.included_modules.count > 0 ? 
+        m.included_modules.map {|m| "include #{m.inspect.dump}\n" }.join : 
+        ""
+    ) + 
+    ( m.singleton_class.included_modules.count > 0 ? 
+        m.singleton_class.included_modules.map {|m| "extend #{m.inspect.dump}\n" }.join : 
+        ""
+    )
+  end
+
+
+  ##############################################################################
+  # Archiving Contents
+  def self.module_contents(m, with_disasm=true)
+    return "" unless m.is_a? Module
+
+    puts "  module contents" if $options[:verbose]
+
+    formatted_contents = ""
+
+    m.constants($options[:include_inherited]).each do |c_symbol|
+      begin
+        c = m.const_get(c_symbol) if m.const_defined? c_symbol
+        formatted_contents += format_constant(c_symbol, c)
+      rescue Exception => e
+        log_error "Error archiving constant #{c_symbol.to_s.dump}: #{e.message}"
+        formatted_contents += format_constant(c_symbol, :veracode_nil)
+      end
+    end
+
+    m.class_variables.each do |v_symbol|
+      begin
+        v = m.class_variable_get(v_symbol)
+        formatted_contents += format_variable(v_symbol, v, "class")
+      rescue Exception => e
+        log_error "Error archiving class variable #{v_symbol.to_s.dump}: #{e.message}"
+        formatted_contents += format_variable(v_symbol, :veracode_nil, "class")
+      end
+    end
+
+    if m.respond_to?(:global_variables)
+      m.global_variables.each do |v_symbol|
+        begin
+          v = eval(v_symbol.to_s)
+          formatted_contents += format_variable(v_symbol, v, "global")
+        rescue Exception => e
+          log_error "Error archiving global variable #{v_symbol.to_s.dump}: #{e.message}"
+          formatted_contents += format_variable(v_symbol, :veracode_nil, "global")
+        end
+        
+      end
+    end
+
+    %w[ public protected private ].each {|p|
+      get_methods = (p + "_instance_methods").to_sym
+      if m.respond_to?(get_methods) && m.send(get_methods, $options[:include_inherited]).count > 0
+        m.send(get_methods, $options[:include_inherited]).each do |m_symbol|
+          begin
+            method = m.instance_method(m_symbol)
+            formatted_contents += format_method(method, "#{p.to_s}_instance", with_disasm)
+          rescue Exception => e
+            log_error "Error archiving #{p.to_s} instance method #{m_symbol.to_s.dump}: #{e.message}"
+          end
+        end
+      end
+    }
+
+    formatted_contents
+  end
+
+  def self.object_contents(o, with_disasm=true)
+    return "" unless o.is_a? Object
+
+    puts "  object contents" if $options[:verbose]
+
+    formatted_contents = ""
+
+    if o.respond_to?(:instance_variables) && o.instance_variables.count > 0
+      o.instance_variables.each do |v_symbol|
+        begin
+          v = o.instance_variable_get(v_symbol)
+          formatted_contents += format_variable(v_symbol, v, "instance")
+        rescue Exception => e
+          log_error "Error archiving instance variable #{v_symbol.to_s.dump}: #{e.message}"
+          formatted_contents += format_variable(v_symbol, :veracode_nil, "instance")
+        end
+      end
+    end
+
+    if o.respond_to?(:singleton_methods) && o.singleton_methods($options[:include_inherited]).count > 0
+      o.singleton_methods($options[:include_inherited]).each do |m_symbol|
+        begin
+          m = o.method(m_symbol)
+          formatted_contents += format_method(m, "singleton", with_disasm)
+        rescue Exception => e
+          log_error "Error archiving singleton method #{m_symbol.to_s.dump}: #{e.message}"
+        end
+      end
+    end
+
+    formatted_contents
+  end
+
+
+  ##############################################################################
+  # Archiving Objects
+  def self.archive(objects, with_disasm=true)
+
+    objects = objects - [Veracode]
+
+    if $options[:verbose]
+      puts "Archiving #{objects.count.to_s} objects" + (with_disasm ? " with disassembly" : "")
+      puts
+    end
+
+    objects.sort_by {|o| safe_name(o) }.each do |o|
+
+      puts "archiving #{o.class.to_s.downcase} #{quote(safe_name(o))}" if $options[:verbose]
+
+      add_to_archive "#{o.class.to_s.downcase} #{quote(safe_name(o))}\n" + 
+
+                     ( o.is_a?(Class)  ? class_header(o)  : "") + # superclass
+                     ( o.is_a?(Module) ? module_header(o) : "") + # included modules
+
+                     ( o.is_a?(Object) ? object_contents(o, with_disasm) : "") + 
+                     ( o.is_a?(Module) ? module_contents(o, with_disasm) : "") + 
+
+                     "end#{o.class.to_s.downcase}\n" + 
+                     "\n"
+    end
+
+  end
+
+
+  def self.compile_erb_templates
+
+    # Rails 3 has wrapped Erubis to handle block helpers in ERB templates
+    # a little differently, e.g.:
+    #   <%= form_for ... do %> 
+    # vs the normal ERB:
+    #   <% form_for ... do %>
+    # 
+    # This means if Rails 3 erb templates are compiled with ERB or Erubis
+    # the resulting ruby source code will contain syntax errors.
+    # To avoid this, use the ActionView templates and handlers
+
+    view_paths = []
+    view_paths += ActionController::Base.view_paths.to_a.map(&:to_s)
+    view_paths |= [File.expand_path("app/views")]
+
+    puts "Looking for erb templates in #{view_paths.join(", ")}" if $options[:verbose]
+
+    templates = view_paths.map { |vp|
+      Dir[File.join(vp, "**", "*.erb")]
+    }.flatten
+
+    return unless templates.count > 0
+
+    puts "Found #{templates.count} erb templates" if $options[:verbose]
+
+    templates.each {|template|
+
+      puts "Compiling template #{template}" if $options[:verbose]
+
+      begin
+
+        t = ActionView::Template.new(
+          File.read(template),
+          template,
+          ActionView::Template::Handlers::ERB,
+          :virtual_path => template
+        )
+
+        case t.method(:compile).arity
+        when 2  # Rails 3.1.0+
+          t.send(:compile, ActionView::Base.new, ActionView::CompiledTemplates)
+        when 3
+          t.send(:compile, {}, ActionView::Base.new, ActionView::CompiledTemplates)
+        end
+
+      rescue Exception => e
+        puts "Unable to compile template #{template}"
+        log_error "Unable to compile template #{template} (#{e.message})"
+      end
+
+    }
+
+    puts "Compiled templates: " + ActionView::CompiledTemplates.instance_methods.count.to_s if $options[:verbose]
+
+  end
+
+  def self.compile_haml_templates
+
+    view_paths = []
+    view_paths += ActionController::Base.view_paths.to_a.map(&:to_s)
+    view_paths |= [File.expand_path("app/views")]
+
+    puts "Looking for haml templates in #{view_paths.join(", ")}" if $options[:verbose]
+
+    templates = view_paths.map {|vp|
+      Dir[File.join(vp, "**", "*.haml")]
+    }.flatten
+
+    return unless templates.count > 0
+
+    begin
+      require 'action_view'
+      require 'haml'
+      require 'haml/template/plugin'
+    rescue Exception => e
+      log_error "Unable to satisfy haml dependencies (#{e.message})"
+      return
+    end
+
+    puts "Found #{templates.count} haml templates" if $options[:verbose]
+
+    templates.each {|template|
+
+      puts "Compiling template #{template}" if $options[:verbose]
+
+      begin
+
+        t = ActionView::Template.new(
+          File.read(template),
+          template,
+          Haml::Plugin,
+          :virtual_path => template
+        )
+
+        case t.method(:compile).arity
+        when 2  # Rails 3.1.0+
+          t.send(:compile, ActionView::Base.new, ActionView::CompiledTemplates)
+        when 3
+          t.send(:compile, {}, ActionView::Base.new, ActionView::CompiledTemplates)
+        end
+
+      rescue Exception => e
+        puts "Unable to compile template #{template}"
+        log_error "Unable to compile template #{template} (#{e.message})"
+      end
+
+    }
+
+    puts "Compiled templates: " + ActionView::CompiledTemplates.instance_methods.count.to_s if $options[:verbose]
+
+  end
+
+
+
+
+################################################################################
+# Subcommands
+  def self.prepare
+
+    init
+
+    puts "Preparing Ruby on Rails application #{APP_NAME.dump} for Veracode upload"
+    puts "Source code will be included in the archive" if $options[:archive_source]
+
+    if $options[:verbose]
+      puts Dir.pwd.to_s.dump
+      puts
+    end
+
+    if $options[:disasm]
+      rbfiles = File.join("**", "*.rb")
+      Dir[rbfiles].each do |f|
+        puts RubyVM::InstructionSequence.compile_file(f).disasm
+        puts
+      end
+      exit
+    end
+
+    prepare_archive
+
+    ################################################################
+    ## phase 1 - Create baseline
+    self.baseline
+    
+    puts "Phase 1 - Initial State" if $options[:verbose]
+    self.stats if $options[:verbose]
+    
+    if $options[:phase1]
+      puts "Processing and disassembling Ruby standard classes and modules"
+      archive(@modules)
+    end
+    ## /phase 1 - Create baseline
+    ################################################################
+
+
+
+    ################################################################
+    ## phase 2 - Require rails
+
+    puts "Phase 2 - Load Rails" if $options[:verbose]
+    begin
+      require "rails"
+    rescue Exception => e
+      puts "Unable to require rails: #{e.message}"
+      log_error "Unable to require rails: #{e.message}"
+      exit
+    else
+      puts "Required rails" if $options[:verbose]
+    end
+
+    self.update
+
+    self.stats if $options[:verbose]
+
+    if $options[:phase2]
+      puts "Processing and disassembling Rails classes and modules"
+      archive(@modules)
+    end
+    
+    self.rebaseline
+    ## /phase 2 - Require rails
+    ################################################################
+    
+    
+    
+    ################################################################
+    # phase 3 - require app
+
+    puts "Phase 3 - Imitate Rails" if $options[:verbose]
+
+    ## Imitate script/rails
+    # APP_PATH = File.expand_path('config/application')
+      # APP_PATH is already set in bin/veracode
+    #require File.expand_path('../../config/boot',  __FILE__)
+      glob_require "config/boot.rb"
+    #require 'rails/commands'
+      # this will trigger the console to be launched
+      # ARGV.clear
+      # ARGV << 'console'
+      # ARGV << '--sandbox'
+      # require 'rails/commands'
+
+    ## Imitate rails/commands when console
+    glob_require 'rails/commands/console'
+    # require APP_PATH # => config/application.rb
+
+    glob_require "config/application.rb"
+
+    Rails.application.require_environment! unless $options[:jruby]
+    # Following line will actually kick off IRB
+    # Rails::Console.start(Rails.application)
+    
+    # Imitate Rails::Console.initialize_console
+    # require "pp"
+    glob_require "rails/console/app"
+    glob_require "rails/console/helpers"
+
+    glob_require "app/models/**/*.rb"
+    glob_require "app/helpers/**/*.rb"
+    glob_require "app/controllers/application_controller.rb"
+    glob_require "app/controllers/**/*.rb"
+
+    compile_erb_templates
+    compile_haml_templates
+
+    self.update
+    self.stats if $options[:verbose]
+
+    if $options[:phase3]
+      puts "Processing and disassembling #{APP_NAME} classes and modules"
+      archive(@baseline_modules, false)
+      archive(@modules - @baseline_modules, true)
+    end
+
+    ## /phase 3 - require app
+    ################################################################
+
+    finalize_archive
+
+    pack_manifest
+    cleanup
+
+  end # self.prepare
+
+end

data/lib/veracode/version.rb

@@ -0,0 +1,3 @@
+module Veracode
+  VERSION = "1.0.0.alpha"
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: veracode
+version: !ruby/object:Gem::Version
+  version: 1.0.0.alpha
+  prerelease: 6
+platform: ruby
+authors:
+- Veracode
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: &70257511683960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70257511683960
+description: Prepares your Ruby on Rails app for submission to Veracode.
+email: devcontact@veracode.com
+executables:
+- veracode
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/veracode
+- lib/veracode.rb
+- lib/veracode/version.rb
+homepage: http://veracode.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: 1.9.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Command line tool for preparing your Ruby on Rails app for submission to
+  Veracode
+test_files: []