backlog 0.34.1 → 0.34.2

data/vendor/plugins/goldspike/init.rb

@@ -1 +0,0 @@
-# Include hook code here

data/vendor/plugins/goldspike/install.rb

@@ -1,4 +0,0 @@
-# Install the templates
-require 'rails_generator'
-options = { :collision => :skip }
-Rails::Generator::Base.instance('goldspike', [], options).command('create').invoke!

data/vendor/plugins/goldspike/lib/create_war.rb

@@ -1,102 +0,0 @@
-#
-# Building a war file
-#
-# By Robert Egglestone
-#    Fausto Lelli (*minor* patches for windows platform, plugin dist.)
-#
-
-require 'fileutils'
-require 'java_library'
-require 'war_config'
-require 'packer'
-require 'util'
-
-module War
-  class Creator
-
-    attr_accessor :config
-
-    def initialize(config = Configuration.instance)
-      @config = config
-      @java_lib_packer = JavaLibPacker.new(@config)
-      @ruby_lib_packer = RubyLibPacker.new(@config)
-      @webapp_packer = WebappPacker.new(@config)
-      @file_packer = FileLibPacker.new(@config)
-    end
-
-    def standalone=(value)
-      @config.standalone = value
-    end
-
-    def create_shared_war
-      @config.standalone = false
-      create_war_file
-    end
-
-    def create_standalone_war
-      @config.standalone = true
-      create_war_file
-    end
-
-    def clean_war
-      FileUtils.remove_file(@config.war_file) if File.exists?(@config.war_file)
-    end
-
-    def create_war_file
-      assemble
-      create_war
-    end
-
-    def assemble
-      WLog.info 'Assembling web application'
-      add_java_libraries
-      if config.standalone
-        add_ruby_libraries
-      end
-      add_configuration_files
-      add_files
-    end
-
-    private
-
-    def create_war
-      WLog.info 'Creating web archive'
-      @webapp_packer.create_war
-    end
-
-    def add_files
-      @file_packer.add_files
-    end
-
-    def add_java_libraries
-      @java_lib_packer.add_java_libraries
-    end
-
-    def add_ruby_libraries
-      @ruby_lib_packer.add_ruby_libraries
-    end
-
-    def add_configuration_files
-      require 'erb'
-      FileUtils.makedirs(File.join(config.staging, 'WEB-INF'))
-      war_file_dir = File.join(config.staging, 'WEB-INF')
-      Dir.foreach(war_file_dir) do |file|        
-        output = case file
-          when /\.\Z/ # ignore dotfiles
-            nil
-          when /\.erb\Z/
-            output_file = file.gsub(/\.erb\Z/, '')
-            template = File.read(File.join(war_file_dir, file))
-            erb = ERB.new(template)
-            erb.result(binding)
-          end
-    
-        unless output.nil? 
-          File.open(File.join(config.staging, 'WEB-INF', output_file), 'w') { |out| out << output}      
-        end
-        
-      end
-    end
-
-  end #class
-end #module

data/vendor/plugins/goldspike/lib/java_library.rb

@@ -1,131 +0,0 @@
-#
-# A library which can hopefully be obtained through one of the following mechanisms:
-# + A local artifact: lib/java/jruby-0.9.1.jar
-# + An artifact in a local maven repo: ~/.m2/repository/org/jruby/jruby/0.9.1/jruby-0.9.1/jar
-# + An artifact in a remote maven repo: http://www.ibiblio.com/maven2/org/jruby/jruby/0.9.1/jruby-0.9.1/jar
-#
-require 'util'
-
-module War
-  class JavaLibrary
-    
-    attr_accessor :name, :version, :locations, :config
-    
-    def initialize(name, version, config)
-      @config = config
-      @name = name
-      @version = version
-      @locations = local_locations(name, version)
-    end
-    
-    def file
-      "#{name}-#{version}.jar"
-    end
-    
-    def install(config, target_file)
-      found = false
-      for location in locations
-        if location[0,5] == 'http:' || location[0,6] == 'https:'
-          found = install_remote(config, location, target_file)
-        else
-          found = install_local(config, location, target_file)
-        end
-        break if found
-      end
-      
-      unless found
-        # all attempts have failed, inform the user
-        raise <<-ERROR
-        The library #{self} could not be obtained from in any of the following locations:
-          + #{locations.join("
-        + ")}
-        ERROR
-      end
-    end
-    
-    def install_local(config, file, target_file)
-      return false unless File.exists?(file)
-      FileUtils.copy(file, target_file)
-      return true
-    end
-    
-    def install_remote(config, location, target_file)
-      response = read_url(location)
-      return false unless response
-      File.open(target_file, 'wb') { |out| out << response.body }
-      return true
-    end
-    
-    # properly download the required files, taking account of redirects
-    # this code is almost straight from the Net::HTTP docs
-    def read_url(uri_str, limit=10)
-      raise ArgumentError, 'HTTP redirect too deep' if limit == 0
-      require 'net/http'
-      require 'uri'
-      # setup the proxy if available
-      http = Net::HTTP
-      if ENV['http_proxy']
-        proxy = URI.parse(ENV['http_proxy'])
-        http = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password)
-      end
-      # download the file
-      response = http.get_response(URI.parse(uri_str))
-      case response
-      when Net::HTTPSuccess then response
-      when Net::HTTPRedirection then read_url(response['location'], limit - 1)
-      else false
-      end
-    end
-    
-    def to_s
-      "#{name}-#{version}"
-    end
-        
-    def local_locations(name, version, type='jar')
-      WLog.debug("locations for " + name + " " + version);
-      paths = []
-      if config.local_java_lib
-        paths << File.join(config.local_java_lib, "#{name}-#{version}.#{type}")
-        paths << File.join(config.local_java_lib, "#{name}.#{type}")
-      end
-      if config.jruby_home
-        paths << File.join(config.jruby_home, 'lib', "#{name}-#{version}.#{type}")
-        paths << File.join(config.jruby_home, 'lib', "#{name}.#{type}")
-      end
-      WLog.debug("paths: " + paths.join("\n"))
-      return paths
-    end
-
-  end #class
-
-  class MavenLibrary < JavaLibrary
-
-    attr_accessor :group, :name, :version, :config
-
-    def initialize (group, name, version, config)
-      @config = config
-      @group = group
-      @name = name
-      @version = version
-      @locations = maven_locations(group, name, version)   
-    end
-
-    def maven_locations(group, artifact, version, type='jar')
-      WLog.debug("locations for " + group + " " + artifact + " " + version);
-      paths = []
-      maven_local_repository = config.maven_local_repository
-      maven_remote_repository = config.maven_remote_repository
-      if maven_local_repository
-        paths << File.join(maven_local_repository, group.gsub('.', File::SEPARATOR), artifact, version, "#{artifact}-#{version}.#{type}")
-      end
-      if maven_remote_repository
-        paths << "#{maven_remote_repository}/#{group.gsub('.', '/')}/#{artifact}/#{version}/#{artifact}-#{version}.#{type}"
-      end
-      WLog.debug("paths: " + paths.join("\n"))
-      return paths
-    end
-
-  end
-
-
-end #module

data/vendor/plugins/goldspike/lib/packer.rb

@@ -1,215 +0,0 @@
-require 'util'
-
-module War
-  
-  class Packer
-  
-    attr_accessor :config
-  
-    def initialize(config = Configuration.instance)
-      @config = config
-    end
-    
-    def install(source, dest, mode=0644)
-      # File.install is disabled because of a performance problem under JRuby,
-      # without it the task may fail if the original gem files were not writable by the owner
-      #File.install(source, dest, mode)
-      FileUtils.copy(source, dest)
-    end
-    
-    def copy_tree(files, target, strip_prefix='')
-      files.each do |f|
-        relative = f[strip_prefix.length, f.length]
-        target_file = File.join(target, relative)
-        if File.directory?(f)
-          FileUtils.makedirs(target_file)
-        elsif File.file?(f)
-          WLog.debug "  Copying #{f} to #{relative}"
-          FileUtils.makedirs(File.dirname(target_file))
-          install(f, target_file)
-        end
-      end    
-    end
-    
-    def compile_tree(dir, config)
-      return unless config.compile_ruby
-      # find the libraries
-      classpath_files = Rake::FileList.new(File.join(config.staging, 'WEB-INF', 'lib', '*.jar'))
-      classpath_files_array = classpath_files.to_a
-      classpath_files_array.collect! {|f| File.expand_path(f) }
-      classpath = classpath_files_array.join(config.os_path_separator)
-      # compile the files
-      os_dir = dir.gsub(File::SEPARATOR, config.os_separator)
-      unless system("cd #{os_dir} && java -cp #{classpath} org.jruby.webapp.ASTSerializerMain")
-        raise "Error: failed to preparse files in #{dir}, returned with error code #{$?}"    
-      end
-    end
-    
-    def jar(target_file, source_dir, files, compress=true)
-      os_target_file = target_file.gsub(File::SEPARATOR, config.os_separator)
-      os_source_dir = source_dir.gsub(File::SEPARATOR, config.os_separator)
-      flags = '-cf'
-      flags += '0' unless compress
-      files_list = files.join(' ')
-      unless system("jar #{flags} \"#{os_target_file}\" -C \"#{os_source_dir}\" #{files_list}")
-        raise "Error: failed to create archive, error code #{$?}"
-      end
-    end
-    
-  end
-  
-  class FileLibPacker < Packer
-    def add_files
-      WLog.info("Packing needed files ...")
-
-      staging = config.staging
-      lib = File.join(staging, 'WEB-INF', 'lib')
-      classes = File.join(staging, 'WEB-INF', 'classes')
-      base = File.join(staging, 'WEB-INF')
-      install(:lib, lib)
-      install(:classes, classes)
-      install(:base, base)
-    end
-
-    def install(dir_sym, dir)
-      WLog.debug("assembling files in " + dir + " directory")
-      FileUtils.makedirs(dir)
-      WLog.debug("need to assemble #{config.files.select{|k,v| v[:directory] == dir_sym }.size} files")
-      for name, file_info in config.files
-        next unless file_info[:directory] == dir_sym
-        WLog.debug("file to add " + name )
-        target = File.join(dir, name)
-        WLog.debug("should install to " + target)
-        file = file_info[:location]
-        if !File.exists?(target) || File.mtime(target) < File.mtime(file_info[:location])
-          WLog.info "  adding file #{name}"
-          if File.exists?(file)
-            FileUtils.copy(file, target)
-          else
-            WLog.warn "file '#{file}' does not exist"
-          end
-        end
-      end
-    end
-  end
-    
-  class JavaLibPacker < Packer
-    
-    def initialize(config)
-      super(config)
-    end
-    
-    def add_java_libraries
-      WLog.info("Packing needed Java libraries ...")
-      staging = config.staging
-      lib = File.join(staging, 'WEB-INF', 'lib')
-      WLog.debug("assembling files in " + lib + " directory")
-      FileUtils.makedirs(lib)
-      WLog.debug("need to assemble #{config.java_libraries.size} libraries")
-      for library in config.java_libraries.values
-        WLog.debug("library to assemble " + library.name )
-        target = File.join(lib, library.file)
-        WLog.debug("should install to " + target)
-        unless File.exists?(target)
-          WLog.info "  adding Java library #{library}"
-          library.install(config, target)
-        end
-      end
-    end
-  end
-  
-  class RubyLibPacker < Packer
-
-    def initialize (config)
-      super(config)
-    end
-    
-    def add_ruby_libraries
-      # add the gems
-      WLog.info("Packing needed Ruby gems ...")
-      gem_home = File.join(config.staging, 'WEB-INF', 'gems')
-      FileUtils.makedirs(gem_home)
-      FileUtils.makedirs(File.join(gem_home, 'gems'))
-      FileUtils.makedirs(File.join(gem_home, 'specifications'))
-      for gem in config.gem_libraries
-        copy_gem(gem[0], gem[1], gem_home)
-      end
-    end
-    
-    def copy_gem(name, match_version, target_gem_home)
-      require 'rubygems'
-      matched = Gem.source_index.search(name, match_version)
-      raise "The #{name} gem is not installed" if matched.empty?
-      gem = matched.last
-
-      gem_target = File.join(target_gem_home, 'gems', gem.full_gem_path.split('/').last)
-
-      unless File.exists?(gem_target)
-        # package up the gem
-        WLog.info "  adding Ruby gem #{gem.name} version #{gem.version}"
-        # copy the specification
-        install(gem.loaded_from, File.join(target_gem_home, 'specifications'), 0644)
-        # copy the files
-        FileUtils.makedirs(gem_target)
-        gem_files = Rake::FileList.new(File.join(gem.full_gem_path, '**', '*'))
-        copy_tree(gem_files, gem_target, gem.full_gem_path)
-        # compile the .rb files to .rb.ast.ser
-        compile_tree(File.join(gem_target, 'lib'), config)
-      end
-      
-      # handle dependencies
-      if config.add_gem_dependencies
-        for gem_child in gem.dependencies
-          #puts "  Gem #{gem.name} requires #{gem_child.name} "
-          copy_gem(gem_child.name, gem_child.requirements_list, target_gem_home)
-        end
-      end
-    end
-    
-  end
-  
-  class WebappPacker < Packer
-
-    def initialize(config)
-      super(config)
-    end
-    
-    def create_war
-      # we can't include a directory, but exclude it's files
-      webapp_files = Rake::FileList.new
-      webapp_files.include('*')
-      webapp_files.exclude('*.war')
-      webapp_files.exclude(/tmp$/)
-      webapp_files.include(File.join('tmp', '*'))
-      webapp_files.exclude(File.join('tmp', 'jetty'))
-      config.excludes.each do |exclude|
-        webapp_files.exclude(exclude)
-      end
-
-      jar(config.war_file, config.staging, webapp_files)
-    end
-    
-    def add_webapp
-      staging = config.staging
-      WLog.info 'Packing web application ...'
-      FileUtils.makedirs(staging)
-      webapp_files = Rake::FileList.new(File.join('.', '**', '*'))
-      webapp_files.exclude(staging)
-      webapp_files.exclude('*.war')
-      webapp_files.exclude(config.local_java_lib)
-      webapp_files.exclude(File.join('public', '.ht*'))
-      webapp_files.exclude(File.join('public', 'dispatch*'))
-      webapp_files.exclude(File.join('log', '*.log'))
-      webapp_files.exclude(File.join('tmp', 'cache', '*'))
-      webapp_files.exclude(File.join('tmp', 'sessions', '*'))
-      webapp_files.exclude(File.join('tmp', 'sockets', '*'))
-      webapp_files.exclude(File.join('tmp', 'jetty'))
-      config.excludes.each do |exclude|
-        webapp_files.exclude(exclude)
-      end
-      copy_tree(webapp_files, staging)
-      compile_tree(staging, config)
-    end
-    
-  end  
-end