buildr 1.4.6-x86-mswin32 → 1.4.7-x86-mswin32

data/lib/buildr/core.rb

@@ -1,34 +0,0 @@
-# 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/core/common'
-require 'buildr/core/application'
-require 'buildr/core/jrebel'
-require 'buildr/core/project'
-require 'buildr/core/environment'
-require 'buildr/core/help'
-require 'buildr/core/build'
-require 'buildr/core/filter'
-require 'buildr/core/compile'
-require 'buildr/core/test'
-require 'buildr/core/shell'
-require 'buildr/core/run'
-require 'buildr/core/checks'
-require 'buildr/core/transports'
-require 'buildr/core/generate'
-require 'buildr/core/cc'
-require 'buildr/core/osx' if RUBY_PLATFORM =~ /darwin/
-require 'buildr/core/linux' if RUBY_PLATFORM =~ /linux/
-

data/lib/buildr/ide.rb

@@ -1,19 +0,0 @@
-# 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/ide/eclipse'
-require 'buildr/ide/idea'
-

data/lib/buildr/java.rb

@@ -1,25 +0,0 @@
-# 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 RUBY_PLATFORM == 'java' ? 'buildr/java/jruby' : 'buildr/java/rjb'
-require 'buildr/java/compiler'
-require 'buildr/java/external'
-require 'buildr/java/tests'
-require 'buildr/java/bdd'
-require 'buildr/java/packaging'
-require 'buildr/java/commands'
-require 'buildr/java/doc'
-require 'buildr/java/deprecated'

data/lib/buildr/java/jtestr_result.rb

@@ -1,331 +0,0 @@
-# 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.
-
-# necessary to require YAML even if it is mentioned by autoload as it fails on some platforms.
-require 'yaml'
-require 'fileutils'
-
-module Buildr #:nodoc:
-
-  module TestFramework
-
-    # A class used by buildr for jruby based frameworks, so that buildr can know
-    # which tests succeeded/failed.
-    class TestResult
-
-      class Error < ::Exception
-        attr_reader :message, :backtrace
-        def initialize(message, backtrace)
-          @message = message
-          @backtrace = backtrace
-          set_backtrace backtrace
-        end
-
-        def self.dump_yaml(file, e)
-          FileUtils.mkdir_p File.dirname(file)
-          File.open(file, 'w') { |f| f.puts(YAML.dump(Error.new(e.message, e.backtrace))) }
-        end
-
-        def self.guard(file)
-          begin
-            yield
-          rescue => e
-            dump_yaml(file, e)
-          end
-        end
-      end
-
-      attr_accessor :failed, :succeeded
-
-      def initialize
-        @failed, @succeeded = [], []
-      end
-    end
-  end
-
-  module JtestR
-
-    # An Rspec formatter used by JtestR
-    class YamlFormatter
-      attr_reader :result
-
-      attr_accessor :example_group, :options, :where
-
-      def initialize(options, where)
-        @options = options
-        @where = where
-      end
-
-      %w[ example_started
-          start_dump dump_failure dump_summary dump_pending ].each do |meth|
-        module_eval "def #{meth}(*args); end"
-      end
-
-      def example_group_started(example_group)
-        @example_group = example_group
-      end
-
-      def example_passed(example)
-        result.succeeded << example_name(example)
-      end
-
-      def example_pending(example, counter)
-        result.succeeded << example_name(example)
-      end
-
-      def example_failed(example, counter, failure)
-        result.failed << example_name(example)
-      end
-
-      def start(example_count)
-        @result = Buildr::TestFramework::TestResult.new
-      end
-
-      def close
-        result.succeeded = result.succeeded - result.failed
-        FileUtils.mkdir_p File.dirname(where)
-        File.open(where, 'w') { |f| f.puts YAML.dump(result) }
-      end
-
-    private
-      def example_name(example)
-        if Spec::Example::ExampleProxy === example
-          example_group.location.gsub(/:\d+$/, '')
-        else
-          example.name.gsub(/(.+)(\..+\(\))/, '\1')
-        end
-      end
-    end # YamlFormatter
-
-    # A JtestR ResultHandler
-    # Using this handler we can use RSpec formatters, like html/ci_reporter with JtestR
-    # Created for JTestrYamlFormatter
-    class ResultHandler
-
-      # Workaround for http://jira.codehaus.org/browse/JTESTR-68
-      module TestNGResultHandlerMixin
-        def onTestSuccess(test_result)
-          @result_handler.succeed_single(test_result.name)
-        end
-      end
-
-      class BacktraceTweaker
-        attr_reader :ignore_patterns
-        def initialize
-          @ignore_patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS.dup
-          # ignore jruby/jtestr backtrace
-          ignore_patterns << /org\.jruby\.javasupport\.JavaMethod\./
-          ignore_patterns << /jtestr.*\.jar!/i << /runner\.rb/
-        end
-
-        def clean_up_double_slashes(line)
-          line.gsub!('//','/')
-        end
-
-        def tweak_backtrace(error)
-          return if error.backtrace.nil?
-          error.backtrace.collect! do |line|
-            clean_up_double_slashes(line)
-            ignore_patterns.each do |ignore|
-              if line =~ ignore
-                line = nil
-                break
-              end
-            end
-            line
-          end
-          error.backtrace.compact!
-        end
-      end
-
-      class << self
-        # an rspec reporter used to proxy events to rspec formatters
-        attr_reader :reporter
-        attr_accessor :test_files
-
-        def init(argv = [], out = STDOUT, err = STDERR)
-          ::JtestR::TestNGResultHandler.module_eval { include TestNGResultHandlerMixin }
-          rspec_parser = ::Spec::Runner::OptionParser.new(err, out)
-          rspec_parser.order!(argv)
-          rspec_parser.options.backtrace_tweaker = BacktraceTweaker.new
-          @reporter = Spec::Runner::Reporter.new(rspec_parser.options)
-        end
-
-        def before
-          reporter.start(reporter.options.files.size)
-        end
-
-        def after
-          reporter.end
-          reporter.dump
-        end
-
-      end
-
-      module ExampleMethods
-        attr_accessor :name, :description, :__full_description, :location
-      end
-
-      def reporter
-        self.class.reporter
-      end
-
-      attr_accessor :example_group, :current_example, :current_failure
-
-      def initialize(name, desc, *args)
-        self.example_group = ::Spec::Example::ExampleGroup.new(desc)
-        example_group.extend ExampleMethods
-        example_group.name = name.to_s
-        if example_group.name[/Spec/]
-          example_group.description = desc.to_s
-        else
-          example_group.description = name.to_s
-        end
-        reporter.example_group_started(example_group)
-      end
-
-
-      def starting
-      end
-
-      def ending
-      end
-
-      def add_fault(fault)
-        self.current_failure = fault
-      end
-
-      def add_pending(pending)
-      end
-
-      def starting_single(name = nil)
-        self.current_failure = nil
-        self.current_example = Object.new
-        current_example.extend ::Spec::Example::ExampleMethods
-        current_example.extend ExampleMethods
-        name = name.to_s
-        current_example.location = name.to_s
-        current_example.name = name.gsub(/(.*)\((.+)\)/, '\2')
-        current_example.description = name
-        if example_group.name[/Spec/]
-          current_example.__full_description = "#{example_group.description} #{name}"
-        else
-          current_example.__full_description = "#{example_group.name}: #{name}"
-        end
-        reporter.example_started(current_example)
-      end
-
-      def succeed_single(name = nil)
-        reporter.example_finished(current_example, nil)
-      end
-
-      def fail_single(name = nil)
-        current_example.name = current_name
-        reporter.example_finished(current_example, current_error)
-      end
-
-      def error_single(name = nil)
-        current_example.name = current_name
-        reporter.example_finished(current_example, current_error)
-      end
-
-      def pending_single(name = nil)
-        error = ::Spec::Example::ExamplePendingError.new(name)
-        reporter.example_finished(current_example, error)
-      end
-
-    private
-      def detect_file(trace)
-        # find first matching test file in stacktrace
-        file = nil
-        first_pos = nil
-        ResultHandler.test_files.each do |f|
-          pos = trace.index(f)
-          if pos && (first_pos.nil? || pos < first_pos)
-            file = f
-            first_pos = pos
-          end
-        end
-        file || fail("JTestR::ResultHandler.detect_file failed: #{trace}")
-      end
-
-      def current_name(example = current_example, fault = current_failure)
-        return example.name unless fault
-        case fault
-        when Test::Unit::Error
-          detect_file(fault.long_display)
-        when Test::Unit::Failure
-          detect_file(fault.location.to_s)
-        when Spec::Runner::Reporter::Failure
-          detect_file(fault.exception.backtrace.to_s)
-        else
-          example.name
-        end
-      end
-
-      def current_error(fault = current_failure)
-        case fault
-        when nil
-          nil
-        when Test::Unit::Failure
-          Buildr::TestFramework::TestResult::Error.new(fault.message, fault.location)
-        when Test::Unit::Error
-          if fault.exception.is_a?(NativeException)
-            exception = fault.exception.cause
-            bt = exception.stack_trace.to_a
-          else
-            exception = fault.exception
-            bt = exception.backtrace
-          end
-          Buildr::TestFramework::TestResult::Error.new(exception.message, bt)
-        when Expectations::Results::Error
-          fault.exception
-        when Spec::Runner::Reporter::Failure
-          ex = fault.exception
-          Buildr::TestFramework::TestResult::Error.new(ex.message, ex.backtrace)
-        when Expectations::Results
-          file = fault.file
-          line = fault.line
-          Buildr::TestFramework::TestResult::Error.new(fault.message, ["#{fault.file}:#{fault.line}"])
-        else
-          if fault.respond_to?(:test_header)
-            fault.test_header[/\((.+)\)/]
-            test_cls, test_meth = $1.to_s, $`.to_s
-            exception = fault.exception
-            (class << exception; self; end).module_eval do
-              define_method(:backtrace) do
-                (["#{test_cls}:in `#{test_meth}'"] + stackTrace).map { |s| s.to_s }
-              end
-            end
-            exception
-          elsif fault.respond_to?(:method)
-            test_cls, test_meth = fault.method.test_class.name, fault.method.method_name
-            exception = fault.throwable
-            (class << exception; self; end).module_eval do
-              define_method(:backtrace) do
-                (["#{test_cls}:in `#{test_meth}'"] + stackTrace).map { |s| s.to_s }
-              end
-            end
-            exception
-          else
-            raise "Cannot handle fault #{fault.class}: #{fault.inspect}"
-          end
-        end
-      end
-
-    end # ResultHandler
-  end
-end
-

data/lib/buildr/java/jtestr_runner.rb.erb

@@ -1,116 +0,0 @@
-# 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.
-
-#  ___   ___     _  _  ___ _____    ___ ___ ___ _____    _____ _  _ ___ ___
-# |   \ / _ \   | \| |/ _ \_   _|  | __|   \_ _|_   _|  |_   _| || |_ _/ __|
-# | |) | (_) |  | .` | (_) || |    | _|| |) | |  | |      | | | __ || |\__ \
-# |___/ \___/   |_|\_|\___/ |_|    |___|___/___| |_|      |_| |_||_|___|___/
-#
-#  ___ ___ _    ___
-# | __|_ _| |  | __|  CHANGES TO THIS FILE WILL BE LOST
-# | _| | || |__| _|   AUTO-GENERATED BY BUILDR on <%= Time.now %>
-# |_| |___|____|___|  PREFER TO EDIT JtestR CONFIGURATION FILE:
-#
-# <%= user_config %>
-
-begin
-  <%= jruby_gem %>
-  <%= dependencies.map(&:to_s).inspect %>.each { |dep| $CLASSPATH << dep }
-  <%= runner.gems.inspect %>.each { |ary| JRuby.gem(*ary.flatten) }
-  <%= runner.requires.inspect %>.each { |rb| Kernel.require rb }
-
-  jtestr = JtestR::TestRunner.new
-
-  class << jtestr
-    def config(&block)
-      @config_blocks ||= []
-      @config_blocks << block if block
-      @config_blocks
-    end
-
-    def load_configuration
-      super
-      config.each { |block| @configuration.instance_eval(&block) }
-    end
-  end
-
-  jtestr.config do
-    classpath [] # already loaded
-    add_common_classpath false
-
-    <% ts = ( @jtestr_tests[:junit] & tests ).map { |c| 'Java.' + c } %>
-    junit [<%= ts.join(', ') %>]
-
-    <% ts = ( @jtestr_tests[:testng] & tests ).map { |c| 'Java.' + c } %>
-    testng [<%= ts.join(', ') %>]
-
-    <% ts = @jtestr_tests[:testunit] & tests %>
-    test_unit <%= ts.inspect %>
-
-    <% ts = @jtestr_tests[:story] & tests %>
-    story <%= ts.inspect %>
-
-    <% ts = @jtestr_tests[:rspec] & tests %>
-    rspec <%= ts.inspect %>
-
-    <% ts = @jtestr_tests[:expect] & tests %>
-    expectations <%= ts.inspect %>
-
-    ignore __FILE__
-
-    if File.file?(<%= user_config.inspect %>)
-      ignore <%= user_config.inspect %>
-      load <%= user_config.inspect %>
-    end
-  end # config
-
-  fake_out = StringIO.new
-
-  <% if runner.output == false %>
-     output = fake_out
-  <% elsif runner.output.kind_of?(String) %>
-     output = File.open(<%= result.output.inspect %>, 'w')
-  <% else %>
-     output = STDOUT
-  <% end %>
-
-  args = [ '<%= spec_dir %>', # the directory to search for jtestr files
-           JtestR::SimpleLogger::ERR, # log level (DEBUG/WARN/ERR)
-           JtestR::GenericResultHandler::QUIET, #output level (QUIET/VERBOSE)
-           fake_out, # output STDOUT
-           [], # groups to run
-           # Use JtestR::GenericResultHandler for debugging
-           Buildr::JtestR::ResultHandler, # result handler
-           []  # classpath
-         ]
-
-  argv = <%= runner.rspec.inspect %> || []
-  argv.push *<%= tests.inspect %>
-  Buildr::JtestR::ResultHandler.init(argv, output, output)
-  Buildr::JtestR::ResultHandler.test_files = <%= tests.inspect %>
-
-  jtestr.run *args
-
-rescue => e
-  Buildr::TestFramework::TestResult::Error.dump_yaml('<%= runner.result %>', e) rescue \
-  puts "-[--- ERROR ---]-", e.class, e.message, *e.backtrace
-end
-
-exit 0 # let buildr find the errors from the result yaml
-
-# Local Variables:
-# mode: ruby
-# End:
-