class Buildr::POM

Constants

POM_TO_SPEC_MAP
SCOPES_TRANSITIVE
SCOPES_WE_USE

Attributes

parent[R]

Parent POM if referenced by this POM.

project[R]

POM project as Hash (using XmlSimple).

Public Class Methods

load(arg) click to toggle source

Load new POM object form various kind of sources such as artifact, hash representing spec, filename, XML.

# File lib/buildr/java/pom.rb, line 36
def load(source)
  case source
  when Hash
    load(Buildr.artifact(source).pom)
  when Artifact
    pom = source.pom
    pom.invoke
    load(pom.to_s)
  when Rake::FileTask
    source.invoke
    load(source.to_s)
  when String
    filename = File.expand_path(source)
    unless pom = cache[filename]
      trace "Loading m2 pom file from #{filename}"
      begin
        pom = POM.new(IO.read(filename))
      rescue REXML::ParseException => e
        fail "Could not parse #{filename}, #{e.continued_exception}"
      end
      cache[filename] = pom
    end
    pom
  else
    raise ArgumentError, 'Expecting Hash spec, Artifact, file name or file task'
  end
end

Public Instance Methods

dependencies(scopes?) → artifacts click to toggle source

dependencies(:scopes = [:runtime, :test, ...], :optional = true) → artifacts

Returns list of required dependencies as specified by the POM. You can specify which scopes to use (e.g. “compile”, “runtime”); use nil for dependencies with unspecified scope. The default scopes are nil, “compile” and “runtime” (aka SCOPES_WE_USE) and no optional dependencies. Specifying optional = true will return all optional dependencies matching the given scopes.

# File lib/buildr/java/pom.rb, line 85
def dependencies(options = {})
  # backward compatibility
  options = { :scopes => options } if Array === options

  # support symbols, but don't fidget with nil
  options[:scopes] = (options[:scopes] || SCOPES_WE_USE).map { |s| s.to_s if s }

  # try to cache dependencies also
  @depends_for_scopes ||= {}
  unless depends = @depends_for_scopes[options]
    declared = project['dependencies'].first['dependency'] rescue nil
    depends = (declared || [])
    depends = depends.reject { |dep| value_of(dep['optional']) =~ /true/ } unless options[:optional]
    depends = depends.map { |dep|
        spec = pom_to_hash(dep, properties)
        apply = managed(spec)
        spec = apply.merge(spec) if apply

        next if options[:exclusions] && options[:exclusions].any? { |ex| dep['groupId'] == ex['groupId'] && dep['artifactId'] == ex['artifactId'] }

        # calculate transitive dependencies
        if options[:scopes].include?(spec[:scope])
          spec.delete(:scope)

          exclusions = dep['exclusions'].first['exclusion'] rescue nil
          transitive_deps = POM.load(spec).dependencies(:exclusions => exclusions, :scopes => (options[:scopes_transitive] || SCOPES_TRANSITIVE) ) rescue []

          [Artifact.to_spec(spec)] + transitive_deps
        end
      }.flatten.compact #.uniq_by{|spec| art = spec.split(':'); "#{art[0]}:#{art[1]}"}
    @depends_for_scopes[options] = depends
  end
  depends
end

managed() → hash click to toggle source

managed(hash) → hash

The first form returns all the managed dependencies specified by this POM in dependencyManagement. The second form uses a single spec hash and expands it from the current/parent POM. Used to determine the version number if specified in dependencyManagement instead of dependencies.

# File lib/buildr/java/pom.rb, line 150
def managed(spec = nil)
  if spec
    managed.detect { |dep| [:group, :id, :type, :classifier].all? { |key| spec[key] == dep[key] } } ||
      (parent ? parent.managed(spec) : nil)
  else
    @managed ||= begin
      managed = project['dependencyManagement'].first['dependencies'].first['dependency'] rescue nil
      managed ? managed.map { |dep| pom_to_hash(dep, properties) } : []
    end
  end
end

properties() → hash click to toggle source

Returns properties available to this POM as hash. Includes explicit properties and pom.xxx/project.xxx properties for groupId, artifactId, version and packaging.

# File lib/buildr/java/pom.rb, line 125
def properties()
  @properties ||= begin
    pom = %w(groupId artifactId version packaging).inject({}) { |hash, key|
      value = project[key] || (parent ? parent.project[key] : nil)
      hash[key] = hash["pom.#{key}"] = hash["project.#{key}"] = value_of(value) if value
      hash
    }
    pom = %w(groupId artifactId version).inject(pom) { |hash, key|
      value = parent.project[key]
      hash[key] = hash["pom.parent.#{key}"] = hash["project.parent.#{key}"] = value_of(value) if value
      hash
    } if parent
    props = project['properties'].first rescue {}
    props = props.inject({}) { |mapped, pair| mapped[pair.first] = value_of(pair.last, props) ; mapped }
    (parent ? parent.properties.merge(props) : props).merge(pom)
  end
end