Buildr C0 Coverage Information - RCov

 # 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.

 # Rubygems 1.3.6 removed the 'version' accessor so monkey-patch it back to

 # circumvent version validation.  This is needed because Gem::Version doesn't

 # accept version specs with dashes.

 unless Gem::Version.new(0).respond_to?(:version=)

       # re-prime @segments

       @segments = nil

 module Buildr

   #

   # See ArtifactNamespace#need

   class VersionRequirement

     CMP_PROCS = Gem::Requirement::OPS.dup

     else

       Gem::Requirement::OPS.keys.map { |k| Regexp.quote k }.join "|"

     CMP_CHARS = CMP_PROCS.keys.join

     class << self

       def version?(str)

       # is +str+ a version requirement?

       def requirement?(str)

       # :call-seq:

       #    VersionRequirement.create(" >1 <2 !(1.5) ") -> requirement

       #

       # parse the +str+ requirement

       def create(str)

         raise "Failed to parse #{str.inspect} due to: #{e}"

       end

       private

         comparator, version = $1, $2

       def negate(vreq)

         vreq

       end

       def normalize(str)

         str.gsub!(/\s+(and|\&\&)\s+/, ' & ')

         str = str.join(' ')

           else 'requirement("' + expr + '")'

     def initialize(op, *requirements) #:nodoc:

     # Is this object a composed requirement?

     #   VersionRequirement.create('1').composed? -> false

     #   VersionRequirement.create('1 | 2').composed? -> true

     #   VersionRequirement.create('1 & 2').composed? -> true

     def composed?

     # Return the last requirement on this object having an = operator.

     def default

         else

           default = r.default

         end

       end

       default

     # Test if this requirement can be satisfied by +version+

     def satisfied_by?(version)

       unless version.kind_of?(Gem::Version)

         raise "Invalid version: #{version.inspect}" unless self.class.version?(version)

         version = Gem::Version.new(0).tap { |v| v.version = version.strip }

       end

       message = op == :| ? :any? : :all?

       result = requirements.send message do |req|

         if Array === req

           cmp, rv = *req

           CMP_PROCS[cmp || '='].call(version, rv)

         else

           req.satisfied_by?(version)

         end

       end

       negative ? !result : result

     end

     # Either modify the current requirement (if it's already an or operation)

     # or create a new requirement

     def |(other)

     # Either modify the current requirement (if it's already an and operation)

     # or create a new requirement

     def &(other)

     # return the parsed expression

     def to_s

       str = "( " + str + " )" if negative || requirements.size > 1

       str = "!" + str if negative

       str

     end

     attr_accessor :negative

       if negative == other.negative && @op == op && other.requirements.size == 1

         @requirements << other.requirements.first

         self

       else

         self.class.new(op, self, other)

       end

     end

   end # VersionRequirement