buildr-gemjar 1.0.0

data/vendor/buildr/addon/buildr/antlr.rb

@@ -0,0 +1,65 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'buildr/java'
+
+
+module Buildr
+  # Provides ANTLR grammar generation tasks. Require explicitly using <code>require "buildr/antlr"</code>.
+  module ANTLR
+    REQUIRES = [ "org.antlr:antlr:jar:3.0", "antlr:antlr:jar:2.7.7", "org.antlr:stringtemplate:jar:3.0" ]
+
+    Java.classpath << REQUIRES
+
+    class << self
+      def antlr(*args)
+        options = Hash === args.last ? args.pop : {}
+        rake_check_options options, :output, :token
+
+        args = args.flatten.map(&:to_s).collect { |f| File.directory?(f) ? FileList[f + "/**/*.g"] : f }.flatten
+        args = ["-o",  options[:output]] + args if options[:output]
+        if options[:token]
+          # antlr expects the token directory to exist when it starts
+          mkdir_p options[:token]
+          args = ["-lib",  options[:token]] + args
+        end
+        Java.load
+        #Java.org.antlr.Tool.new_with_sig("[Ljava.lang.String;", args).process
+        Java.org.antlr.Tool.new(args.to_java(Java.java.lang.String)).process
+      end
+    end
+
+    def antlr(*args)
+      if Hash === args.last
+        options = args.pop
+        in_package = options[:in_package].split(".")
+        token = options[:token].split(".") if options[:token]
+      else
+        in_package = []; token = nil
+      end
+      file(path_to(:target, :generated, :antlr)=>args.flatten) do |task|
+        args = {:output=>File.join(task.name, in_package)}
+        args.merge!({:token=>File.join(task.name, token)}) if token
+        ANTLR.antlr task.prerequisites, args
+      end
+    end
+
+  end
+
+  class Project
+    include ANTLR
+  end
+end

data/vendor/buildr/addon/buildr/bnd.rb

@@ -0,0 +1,147 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership. The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module Buildr
+  module Bnd
+    class << self
+      # The specs for requirements
+      def dependencies
+        ["biz.aQute:bnd:jar:0.0.384"]
+      end
+
+      # Repositories containing the requirements
+      def remote_repository
+        "http://www.aQute.biz/repo"
+      end
+
+      def bnd_main(*args)
+        cp = Buildr.artifacts(self.dependencies).each(&:invoke).map(&:to_s)
+        Java::Commands.java 'aQute.bnd.main.bnd', *(args + [{ :classpath => cp }])
+      end
+    end
+    
+    class BundleTask < Rake::FileTask
+      attr_reader :project
+      attr_accessor :classpath
+
+      def [](key)
+        @params[key]
+      end
+
+      def []=(key, value)
+        @params[key] = value
+      end
+
+      def classpath_element(dependencies)
+        artifacts = Buildr.artifacts([dependencies])
+        self.prerequisites << artifacts
+        artifacts.each do |dependency|
+          self.classpath << dependency.to_s
+        end
+      end
+
+      def to_params
+        params = self.project.manifest.merge(@params).reject { |k, v| v.nil? }
+        params["-classpath"] ||= self.classpath.collect(&:to_s).join(", ")
+        params['Bundle-SymbolicName'] ||= [self.project.group, self.project.name.gsub(':', '.')].join('.')
+        params['Bundle-Name'] ||= self.project.comment || self.project.name
+        params['Bundle-Description'] ||= self.project.comment
+        params['Bundle-Version'] ||= self.project.version
+        if params["Include-Resource"].nil? && !project.resources.target.nil?
+          params["Include-Resource"] = "#{project.resources.target}/"
+        end
+        params['-removeheaders'] ||= "Include-Resource,Bnd-LastModified,Created-By,Implementation-Title,Tool"
+
+        params
+      end
+
+      def project=(project)
+        @project = project
+      end
+
+      def classpath=(classpath)
+        @classpath = []
+        Buildr.artifacts([classpath.flatten.compact]).each do |dependency|
+          self.prerequisites << dependency
+          @classpath << dependency.to_s
+        end
+        @classpath
+      end
+
+      def classpath
+        @classpath ||= ([project.compile.target] + project.compile.dependencies).flatten.compact
+      end
+
+      protected
+
+      def initialize(*args) #:nodoc:
+        super
+        @params = {}
+        enhance do
+          filename = self.name
+          # Generate BND file with same name as target jar but different extension
+          bnd_filename = filename.sub /(\.jar)?$/, '.bnd'
+
+          params = self.to_params
+          params["-output"] = filename
+          File.open(bnd_filename, 'w') do |f|
+            f.print params.collect { |k, v| "#{k}=#{v}" }.join("\n")
+          end
+
+          Buildr::Bnd.bnd_main( "build", "-noeclipse", bnd_filename )
+          begin
+            Buildr::Bnd.bnd_main( "print", "-verify", filename )
+          rescue => e
+            rm filename
+            raise e
+          end
+        end
+      end
+    end
+
+    module ProjectExtension
+      include Extension
+
+      first_time do
+        desc "Does `bnd print` on the packaged bundle and stdouts the output for inspection"
+        Project.local_task("bnd:print")
+      end
+
+      def package_as_bundle(filename)
+        project.task('bnd:print' => [filename]) do |task|
+          Buildr::Bnd.bnd_main("print", filename)
+        end
+
+        dirname = File.dirname(filename)
+        directory(dirname)
+
+        # Add Buildr.application.buildfile so it will rebuild if we change settings
+        task = BundleTask.define_task(filename => [Buildr.application.buildfile, dirname])
+        task.project = self
+        # the last task is the task considered the packaging task
+        task
+      end
+
+      # Change the bundle package to .jar extension
+      def package_as_bundle_spec(spec)
+        spec.merge(:type => :jar)
+      end
+    end
+  end
+end
+
+class Buildr::Project
+  include Buildr::Bnd::ProjectExtension
+end

data/vendor/buildr/addon/buildr/cobertura.rb

@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+if Buildr::VERSION < '1.5'
+  Buildr.application.deprecated "'buildr/cobertura', use 'buildr/java/cobertura' instead"
+  require 'buildr/java/cobertura'
+else
+  raise "#{__FILE__} should be removed since its use is deprecated since version 1.3.4"
+end

data/vendor/buildr/addon/buildr/drb.rb

@@ -0,0 +1,281 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+
+require 'delegate'
+require 'drb/drb'
+
+
+module Buildr
+
+  # This addon allows you start a DRb server hosting a buildfile, so that
+  # you can later invoke tasks on it without having to load
+  # the complete buildr runtime again.
+  #
+  # Usage:
+  #
+  #   buildr -r buildr/drb drb:start
+  #
+  # Once the server has been started you can invoke tasks using a simple script:
+  #
+  #   #!/usr/bin/env ruby
+  #   require 'rubygems'
+  #   require 'buildr/drb'
+  #   Buildr::DRbApplication.run
+  #
+  # Save this script as 'dbuildr', make it executable and use it to invoke tasks.
+  #
+  #   dbuildr clean compile
+  #
+  # The dbuildr script will run as the server if there isn't one already running.
+  # Subsequent calls to dbuildr will act as the client and invoke the tasks you
+  # provide in the server.
+  # If the buildfile has been modified it will be reloaded on the BuildrServer.
+  #
+  # JRuby users can use a nailgun client to invoke tasks as fast as possible
+  # without having to incur JVM startup time.
+  # See the documentation for buildr/nailgun.
+  module DRbApplication
+
+    port = ENV['DRB_PORT'] || 2111
+    PORT = port.to_i
+
+    class SavedTask #:nodoc:
+
+      def initialize(original)
+        @original = original.clone
+        @prerequisites = original.prerequisites.clone if original.respond_to?(:prerequisites)
+        @actions = original.actions.clone if original.respond_to?(:actions)
+      end
+
+      def name
+        @original.name
+      end
+
+      def actions
+        @actions ||= []
+      end
+
+      def prerequisites
+        @prerequisites ||= []
+      end
+
+      def define!
+        @original.class.send(:define_task, @original.name => prerequisites).tap do |task|
+          task.comment = @original.comment
+          actions.each { |action| task.enhance &action }
+        end
+      end
+    end # SavedTask
+
+    class Snapshot #:nodoc:
+
+      attr_accessor :projects, :tasks, :rules, :layout, :options
+
+      # save the tasks,rules,layout defined by buildr
+      def initialize
+        @rules = Buildr.application.instance_eval { @rules || [] }.clone
+        @options = Buildr.application.options.clone
+        @options.rakelib ||= ['tasks']
+        @layout = Layout.default.clone
+        @projects = Project.instance_eval { @projects || {} }.clone
+        @tasks = Buildr.application.tasks.inject({}) do |hash, original|
+          unless projects.key? original.name # don't save project definitions
+            hash.update original.name => SavedTask.new(original)
+          end
+          hash
+        end
+      end
+
+    end # Snapshot
+
+    class << self
+
+      attr_accessor :original, :snapshot
+
+      def run
+        begin
+          client = connect
+        rescue DRb::DRbConnError => e
+          run_server!
+        else
+          run_client(client)
+        end
+      end
+
+      def client_uri
+        "druby://:#{PORT + 1}"
+      end
+
+      def remote_run(cfg)
+        with_config(cfg) { Buildr.application.remote_run(self) }
+      rescue => e
+        cfg[:err].puts e.message
+        e.backtrace.each { |b| cfg[:err].puts "\tfrom #{b}" }
+        raise e
+      end
+
+      def save_snapshot(app)
+        if app.instance_eval { @rakefile }
+          @snapshot = self::Snapshot.new
+          app.buildfile_reloaded!
+        end
+      end
+
+    private
+
+      def server_uri
+        "druby://:#{PORT}"
+      end
+
+      def connect
+        buildr = DRbObject.new(nil, server_uri)
+        uri = buildr.client_uri # obtain our uri from the server
+        DRb.start_service(uri)
+        buildr
+      end
+
+      def run_client(client)
+        client.remote_run :dir => Dir.pwd, :argv => ARGV,
+                          :in  => $stdin, :out => $stdout, :err => $stderr
+      end
+
+      def setup
+        unless original
+          # Create the stdio delegator that can be cached (eg by fileutils)
+          delegate_stdio
+
+          # Lazily load buildr the first time it's needed
+          require 'buildr'
+
+          # Save the tasks,rules,layout defined by buildr
+          # before loading any project
+          @original = self::Snapshot.new
+
+          Buildr.application.extend self
+          save_snapshot(Buildr.application)
+        end
+      end
+
+      def run_server
+        setup
+        DRb.start_service(server_uri, self)
+        puts "#{self} waiting on #{server_uri}"
+      end
+
+      def run_server!
+        setup
+        if RUBY_PLATFORM[/java/]
+          require 'buildr/nailgun'
+          Buildr.application['nailgun:drb'].invoke
+        else
+          run_server
+          DRb.thread.join
+        end
+      end
+
+      def delegate_stdio
+        $stdin  = SimpleDelegator.new($stdin)
+        $stdout = SimpleDelegator.new($stdout)
+        $stderr = SimpleDelegator.new($stderr)
+      end
+
+      def with_config(remote)
+        @invoked = true
+        set = lambda do |env|
+          ARGV.replace env[:argv]
+          $stdin.__setobj__(env[:in])
+          $stdout.__setobj__(env[:out])
+          $stderr.__setobj__(env[:err])
+          Buildr.application.instance_variable_set :@original_dir, env[:dir]
+        end
+        original = {
+          :dir => Buildr.application.instance_variable_get(:@original_dir),
+          :argv => ARGV,
+          :in => $stdin.__getobj__,
+          :out => $stdout.__getobj__,
+          :err => $stderr.__getobj__
+        }
+        begin
+          set[remote]
+          yield
+        ensure
+          set[original]
+        end
+      end
+
+    end # class << DRbApplication
+
+    def remote_run(server)
+      @options = server.original.options.clone
+      init 'Distributed Buildr'
+      if @rakefile
+        if buildfile_needs_reload?
+          reload_buildfile(server, server.original)
+        else
+          clear_invoked_tasks(server.snapshot || server.original)
+        end
+      else
+        reload_buildfile(server, server.original)
+      end
+      top_level
+    end
+
+    def buildfile_reloaded!
+      @last_loaded = buildfile.timestamp if @rakefile
+    end
+
+  private
+
+    def buildfile_needs_reload?
+      !@last_loaded || @last_loaded < buildfile.timestamp
+    end
+
+    def reload_buildfile(server, snapshot)
+      clear_for_reload(snapshot)
+      load_buildfile
+      server.save_snapshot(self)
+    end
+
+    def clear_for_reload(snapshot)
+      Project.clear
+      @tasks = {}
+      @rules = snapshot.rules.clone
+      snapshot.tasks.each_pair { |name, saved| saved.define! }
+      Layout.default = snapshot.layout.clone
+    end
+
+    def clear_invoked_tasks(snapshot)
+      @rules = snapshot.rules.clone
+      (@tasks.keys - snapshot.projects.keys).each do |name|
+        if saved = snapshot.tasks[name]
+          # reenable this task, restoring its actions/prereqs
+          task = @tasks[name]
+          task.reenable
+          task.prerequisites.replace saved.prerequisites.clone
+          task.actions.replace saved.actions.clone
+        else
+          # tasks generated at runtime, drop it
+          @tasks.delete(name)
+        end
+      end
+    end
+
+    task('drb:start') { run_server! } if Buildr.respond_to?(:application)
+
+  end # DRbApplication
+
+end
+