RSpec Results

 

 

Buildr::Project check task
should execute last thing from package task
should execute all project's expectations
should succeed if there are no expectations
should succeed if all expectations passed
should fail if any expectation failed
Buildr::Project#check
should add expectation
should treat no arguments as expectation against project
should treat single string argument as description, expectation against project
should treat single object argument as subject
should treat first object as subject, second object as description
should work without block
Buildr::Checks::Expectation matchers
should include Buildr matchers exist and contain
should include RSpec matchers like be and eql
should include RSpec predicates like be_nil and be_empty
Buildr::Checks::Expectation exist
should pass if file exists
should fail if file does not exist
should not attempt to invoke task
should pass if ZIP path exists
should fail if ZIP path does not exist
should pass if ZIP entry exists
should fail if ZIP path does not exist
Buildr::Checks::Expectation be_empty
should pass if file has no content
should fail if file has content
should fail if file does not exist
should pass if directory is empty
should fail if directory has any files
should pass if ZIP path is empty
should fail if ZIP path has any entries
should pass if ZIP entry has no content
should fail if ZIP entry has content
should fail if ZIP entry does not exist
Buildr::Checks::Expectation contain(file)
should pass if file content matches string
should pass if file content matches pattern
should pass if file content matches all arguments
should fail unless file content matchs all arguments
should fail if file content does not match
should fail if file does not exist
Buildr::Checks::Expectation contain(directory)
should pass if directory contains file
should pass if directory contains glob pattern
should pass if directory contains all arguments
should fail unless directory contains all arguments
should fail if directory is empty
should fail if directory does not exist
Buildr::Checks::Expectation contain(zip.entry)
should pass if ZIP entry content matches string
should pass if ZIP entry content matches pattern
should pass if ZIP entry content matches all arguments
should fail unless ZIP path contains all arguments
should fail if ZIP entry content does not match
should fail if ZIP entry does not exist
Buildr::Checks::Expectation contain(zip.path)
should pass if ZIP path contains file
should handle deep nesting
should pass if ZIP path contains pattern
should pass if ZIP path contains all arguments
should fail unless ZIP path contains all arguments
should fail if ZIP path is empty
Buildr::JBehave
should apply to projects having JBehave sources
should be selected by :jbehave name
should select a java compiler for its sources
should include JBehave dependencies
should include JMock dependencies
should include classes whose name ends with Behavior
should include classes implementing Behaviours
Buildr::Cobertura project-specific clean
should remove the instrumented directory
should remove the reporting directory
Buildr::Cobertura project-specific instrumented directory
should have a default value
should be overridable
should be created during instrumentation
Buildr::Cobertura project-specific instrumentation
should happen after compile
should put classes from compile.target in the instrumented directory
should touch instrumented directory if anything instrumented
should not touch instrumented directory if nothing instrumented
Buildr::Cobertura project-specific testing classpath
should give priority to instrumented classes over non-instrumented ones
should have the test coverage tools artifacts
Buildr::Cobertura project-specific html report
should have html files
should contain full source code, including comments
Buildr::Cobertura cross-project reporting
should have a default target
Buildr::Cobertura cross-project reporting in html
should be a defined task
should happen after project instrumentation and testing
should have html files
should contain full source code, including comments
should handle gracefully a project with no source
Buildr::Cobertura cross-project clean
should remove the report directory
should be called when calling global clean
Buildr::Cobertura project with no source
should not define an html report task
should not raise an error when instrumenting
should not add the instrumented directory to the testing classpath
should not add the test coverage tools artifacts to the testing classpath
Buildr::Cobertura project-specific data file
should have a default value
should be overridable
should be created during instrumentation
Buildr::Cobertura project-specific instrumentation
should instrument only included classes
should not instrument excluded classes
should instrument classes that are included but not excluded
Buildr::Application home_dir
should point to ~/.buildr
should point to existing directory
Buildr::Application#run
should execute *_load methods in order
Buildr::Application environment
should return value of BUILDR_ENV
should default to development
should set environment name from -e argument
should be echoed to user
Buildr::Application gems
should return empty array if no gems specified
should return one entry for each gem specified in buildr.yaml
should return a Gem::Specification for each installed gem
should parse Gem name correctly
should find installed version of Gem
Buildr::Application load_gems
should do nothing if no gems specified
should install nothing if specified gems already installed
should fail if required gem not found in remote repository
should fail if need to install gem and not running in interactive mode
should ask permission before installing required gems
should fail if permission not granted to install gem
should install gem if permission granted
should reload gem cache after installing required gems
should load previously installed gems
should load newly installed gems
should default to >=0 version requirement if not specified
should parse exact version requirement
should parse range version requirement
should parse multiple version requirements
Buildr settings user
should be empty hash if no settings.yaml file
should return loaded settings.yaml file
should return loaded settings.yml file
should fail if settings.yaml file is not a hash
should be empty hash if settings.yaml file is empty
Buildr settings configuration
should be empty hash if no build.yaml file
should return loaded build.yaml file
should return loaded build.yml file
should fail if build.yaml file is not a hash
should be empty hash if build.yaml file is empty
Buildr settings profiles
should be empty hash if no profiles.yaml file
should return loaded profiles.yaml file
should return loaded profiles.yml file
should fail if profiles.yaml file is not a hash
should be empty hash if profiles.yaml file is empty
Buildr settings profile
should be empty hash if no profiles.yaml
should be empty hash if no matching profile
should return profile matching environment name
Buildr settings buildfile task
should point to the buildfile
should be a defined task
should ignore any rake namespace
should have the same timestamp as the buildfile
should have the same timestamp as build.yaml if the latter is newer
should have the same timestamp as the buildfile if build.yaml is older
should have the same timestamp as build.rb in home dir if the latter is newer
should include explicitly required files as dependencies
Buildr environment
should be same as Buildr.application.environment
Buildr application
should be same as Rake.application
Buildr settings
should be same as Buildr.application.settings
Buildr::ArtifactNamespace
should be an Enumerable
Buildr::ArtifactNamespace.root
should return the top level namespace
should yield the namespace if a block is given
Buildr::ArtifactNamespace.instance
should return the top level namespace when invoked outside a project definition
should return the namespace for the receiving project
should return the current project namespace when invoked inside a project
should return the root namespace if given :root
should return the namespace for the given name
Buildr::ArtifactNamespace#parent
should be nil for root namespace
should be the parent namespace for nested modules
should be the parent namespace for nested projects
Buildr::ArtifactNamespace#parent=
should reject to set parent for root namespace
should allow to set parent
should allow to set parent to :current
Buildr::ArtifactNamespace#need
should accept an artifact spec
should accept a requirement_spec
should accept a hash :name -> requirement_spec
should take a hash :name -> specs_array
should select best matching version if defined
Buildr::ArtifactNamespace#use
should register the artifact on namespace
should register two artifacts with different version on namespace
should complain if namespace requirement is not satisfied
should be able to register a group
should be able to assign sub namespaces
Buildr::ArtifactNamespace#values
returns the artifacts defined on namespace
Buildr::ArtifactNamespace#values_at
returns the named artifacts
returns first artifacts by their unversioned spec
return first artifact satisfying a dependency
Buildr::ArtifactNamespace#method_missing
should use cool_aid! to create a requirement
should use cool_aid= as shorhand for [:cool_aid]=
should use cool_aid as shorthand for [:cool_aid]
should use cool_aid? to test if artifact has been defined and selected
Buildr::ArtifactNamespace#ns
should create a sub namespace
should take any use arguments
should access sub artifacts using with foo_bar like syntax
should include sub artifacts when calling #values
should reopen a sub-namespace
should fail reopening if not a sub-namespace
should clone artifacts when assigned
should clone parent artifacts by name
Buildr.artifacts
should take ruby symbols and ask the current namespace for them
should take a namespace
Buildr.artifact
should search current namespace if given a symbol
should search current namespace if given a symbol spec
should fail when no artifact by that name is found
Extension using ArtifactNamespace
can register namespace listeners
Buildr::Scala::ScalaTest
should be the default test framework when test cases are in Scala
should be picked if the test language is Scala
should include Scalatest dependencies
should include JMock dependencies
should include Specs dependencies
should include ScalaCheck dependencies
should include public classes extending org.scalatest.FunSuite
should ignore classes not extending org.scalatest.FunSuite
should ignore inner classes
should pass when ScalaTest test case passes
should fail when ScalaTest test case fails
should report failed test names
should report to reports/scalatest/TEST-TestSuiteName.txt
should pass properties to Suite
should set current directory
scalac compiler
should identify itself from source directories
should report the language as :scala
should set the target directory to target/classes
should not override existing target directory
should not change existing list of sources
should include as classpath dependency
should compile a simple .scala file into a .class file
should package .class into a .jar file
scalac compiler options
should set warnings option to false by default
should set wranings option to true when running with --verbose option
should use -nowarn argument when warnings is false
should not use -nowarn argument when warnings is true
should not use -verbose argument by default
should use -verbose argument when running with --trace option
should set debug option to true by default
should set debug option to false based on Buildr.options
should set debug option to false based on debug environment variable
should set debug option to false based on DEBUG environment variable
should use -g argument when debug option is true
should not use -g argument when debug option is false
should set deprecation option to false by default
should use -deprecation argument when deprecation is true
should not use -deprecation argument when deprecation is false
should set optimise option to false by default
should use -optimise argument when deprecation is true
should not use -optimise argument when deprecation is false
should not set target option by default
should use -target:xxx argument if target option set
should not set other option by default
should pass other argument if other option is string
should pass other argument if other option is array
should complain about options it doesn't know
should inherit options from parent
Buildr::Emma project-specific clean
should remove the instrumented directory
should remove the reporting directory
Buildr::Emma project-specific instrumented directory
should have a default value
should be overridable
should be created during instrumentation
Buildr::Emma project-specific instrumentation
should happen after compile
should put classes from compile.target in the instrumented directory
should touch instrumented directory if anything instrumented
should not touch instrumented directory if nothing instrumented
Buildr::Emma project-specific testing classpath
should give priority to instrumented classes over non-instrumented ones
should have the test coverage tools artifacts
Buildr::Emma project-specific html report
should have html files
should contain full source code, including comments
Buildr::Emma cross-project reporting
should have a default target
Buildr::Emma cross-project reporting in html
should be a defined task
should happen after project instrumentation and testing
should have html files
should contain full source code, including comments
should handle gracefully a project with no source
Buildr::Emma cross-project clean
should remove the report directory
should be called when calling global clean
Buildr::Emma project with no source
should not define an html report task
should not raise an error when instrumenting
should not add the instrumented directory to the testing classpath
should not add the test coverage tools artifacts to the testing classpath
Buildr::Emma project-specific metadata file
should have a default value
should be overridable
should be created during instrumentation
Buildr::Emma project-specific coverage file
should have a default value
should be overridable
should be created during test
Buildr::Emma project-specific instrumentation
should instrument only included classes
should not instrument excluded classes
should instrument classes that are included but not excluded
Buildr::Emma project-specific reports in html
should inform the user if no coverage data
Buildr::Emma project-specific reports in xml
should have an xml file
groovyc compiler
should identify itself from groovy source directories
should identify if groovy sources are found on java directories
should identify itself even if groovy and java sources are found
should identify from custom layout
should identify from compile source directories
should report the multi-language as :groovy, :java
should set the target directory to target/classes
should not override existing target directory
should not change existing list of sources
should compile groovy sources
should include as classpath dependency
should cross compile java sources
should cross compile test java sources
should package classes into a jar file
groovyc compiler options
should set warning option to false by default
should set warning option to true when running with --verbose option
should not set verbose option by default
should set verbose option when running with --trace option
should set debug option to false based on Buildr.options
should set debug option to false based on debug environment variable
should set debug option to false based on DEBUG environment variable
should set deprecation option to false by default
should use deprecation argument when deprecation is true
should not use deprecation argument when deprecation is false
should set optimise option to false by default
should use optimize argument when deprecation is true
should not use optimize argument when deprecation is false
Buildr::Project
should be findable
should not exist unless defined
should fail to be defined if its name is already used for a task
should exist once defined
should always return same project for same name
should show up in projects list if defined
should not show up in projects list unless defined
should be findable from within a project
should cease to exist when project list cleared
should be defined only once
should be definable in any order
should detect circular dependency
Buildr::Project property
should be set if passed as argument
should be set if assigned in body
should take precedence when assigned in body
should inherit from parent (for some properties)
should have different value if set in sub-project
Buildr::Project block
should execute once
should execute in describe of project
should execute by passing project
should execute in namespace of project
Buildr::Project#base_dir
should be pwd if not specified
should come from property, if specified
should be expanded path
should be relative to parent project
should be settable only if not read
Buildr::Layout
should expand empty to itself
should expand array of symbols
should expand array of names
should map symbol to path
should map symbols to path
should map strings to path
should ignore nil elements
should return nil if path not mapped
should return path from symbol
should return path from symbol
should do eager mapping
Buildr::Project#layout
should exist by default
should be clone of default layout
should come from property, if specified
should inherit from parent project
should clone when inheriting from parent project
should be settable only if not read
Buildr::Project#path_to
should return absolute paths as is
should resolve empty path to project's base directory
should resolve relative paths
should accept multiple arguments
should handle relative paths
should resolve symbols using layout
should resolve path for sub-project
should be idempotent for relative paths
Buildr::Project#on_define
should be called when project is defined
should be called with project object
should be called with project object and set properties
should execute in namespace of project
should be called before project block
should accept enhancement and call it after project block
should accept enhancement and call it with project
should execute enhancement in namespace of project
Rake::Task recursive
should invoke same task in child project
should invoke in depth-first order
should not invoke task in parent project
Sub-project
should point at parent project
should be defined only within parent project
should have unique name
should be findable from root
should be findable from parent project
should be findable only if exists
should always execute its definition
should execute in order of dependency
should warn of circular dependency
Top-level project
should have no parent
Buildr#project
should raise error if no such project
should return a project if exists
should find a project by its full name
should find a project from any context
should find a project from its parent or sibling project
should fine a project from its parent by proximity
should invoke project before returning it
should fail if called without a project name
should return self if called on a project without a name
should evaluate parent project before returning
Buildr#projects
should only return defined projects
should return all defined projects
should return only named projects
should complain if named project does not exist
should find a project from its parent or sibling project
should fine a project from its parent by proximity
should evaluate all projects before returning
Rake::Task local directory
should execute project in local directory
should execute sub-project in local directory
should do nothing if no project in local directory
should find closest project that matches current directory
Buildr::Project#task
should create a regular task
should return a task defined in the project
should not create task outside project definition
should include project name as prefix
should ignore namespace if starting with color
should accept single dependency
should accept multiple dependencies
should execute task exactly once
should create a file task
should create file task with absolute path
should create file task relative to project base directory
should accept single dependency
should accept multiple dependencies
should accept hash arguments
should return a file task defined in the project
should create file task relative to project definition
should execute task exactly once
Rake::Task buildr:initialize
should evaluate all project definitions
Buildr::TestTask
should respond to :compile and return compile task
should respond to :compile and add sources to compile
should respond to :compile and add action for test:compile
should execute compile tasks first
should respond to :resources and return resources task
should respond to :resources and add prerequisites to test:resources
should respond to :resources and add action for test:resources
should respond to :setup and return setup task
should respond to :setup and add prerequisites to test:setup
should respond to :setup and add action for test:setup
should respond to :teardown and return teardown task
should respond to :teardown and add prerequisites to test:teardown
should respond to :teardown and add action for test:teardown
should respond to :with and return self
should respond to :with and add artifacfs to compile task dependencies
should respond to :with and add artifacfs to task dependencies
should response to :options and return test framework options
should respond to :using and return self
should respond to :using and set value options
should start without pre-selected test framework
should respond to :using and select test framework
should infer test framework from compiled language
should respond to :include and return self
should respond to :include and add inclusion patterns
should respond to :exclude and return self
should respond to :exclude and add exclusion patterns
should execute setup task before running tests
should execute teardown task after running tests
should not execute teardown if setup failed
should use the main compile dependencies
should include the main compile target in its dependencies
should include the main compile target in its dependencies, even when using non standard directories
should include the main resources target in its dependencies
should not use the test compile dependencies
should include the test compile target in its dependencies
should include the test compile target in its dependencies, even when using non standard directories
should add test compile target ahead of regular compile target
should include the test resources target in its dependencies
should add test resource target ahead of regular resource target
should not have a last successful run timestamp before the tests are run
should clean after itself (test files)
should clean after itself (reports)
Buildr::TestTask with no tests
should pass
should report no failed tests
should return no failed tests
should return no passing tests
should execute teardown task
Buildr::TestTask with passing tests
should pass
should report no failed tests
should return passed tests
should return no failed tests
should execute teardown task
should update the last successful run timestamp
Buildr::TestTask with failed test
should fail
should report failed tests
should return failed tests
should return passing tests as well
should not fail if fail_on_failure is false
should report failed tests even if fail_on_failure is false
should return failed tests even if fail_on_failure is false
should execute teardown task
should not update the last successful run timestamp
Buildr::Project#test
should return the project's test task
should accept prerequisites for task
should accept actions for task
should set fail_on_failure true by default
should set fork mode by default
should set properties to empty hash by default
should set environment variables to empty hash by default
should inherit options from parent project
should clone options from parent project when using #using
should clone options from parent project when using #options
should accept to set a test property in the top project
should accept to set a test property in a subproject
should not change options of unrelated projects when using #options
should run from project's build task
Buildr::Project#test.compile
should identify compiler from project
should include identified sources
should compile to target/test/<code>
should use main compile dependencies
should include the main compiled target in its dependencies
should include the test framework dependencies
should clean after itself
Buildr::Project#test.resources
should ignore resources unless they exist
should pick resources from src/test/resources if found
should copy to the resources target directory
should create target directory even if no files to copy
should execute alongside compile task
Buildr::TestTask#invoke
should require dependencies to exist
should run all dependencies as prerequisites
should run tests if they have never run
should not run tests if test option is off
Buildr::TestTask#invoke when there was a successful test run already
should not run tests if nothing changed
should run tests if options.test is :all
should run tests if main compile target changed
should run tests if test compile target changed
should run tests if main resources changed
should run tests if test resources changed
should run tests if compile-dependent project changed
should run tests if test-dependent project changed
should run tests if buildfile changed
Rake::Task test
should be recursive
should be local task
should stop at first failure
should ignore failure if options.test is :all
should ignore failure if environment variable test is 'all'
should ignore failure if environment variable TEST is 'all'
should execute no tests if options.test is false
should execute no tests if environment variable test is 'no'
should execute no tests if environment variable TEST is 'no'
test rule
should execute test task on local project
should reset tasks to specific pattern
should apply *name* pattern
should not apply *name* pattern if asterisks used
should accept multiple tasks separated by commas
should execute only the named tests
should execute the named tests even if the test task is not needed
should not update the last successful test run timestamp
Buildr::Options test
should be true by default
should be false if test environment variable is 'skip'
should be false if test environment variable is 'no'
should be false if test environment variable is 'off'
should be false if test environment variable is 'false'
should be false if TEST environment variable is 'skip'
should be false if TEST environment variable is 'no'
should be false if TEST environment variable is 'off'
should be false if TEST environment variable is 'false'
should be :all if test environment variable is all
should be :all if TEST environment variable is all
should be true and warn for any other value
Buildr integration
should return the same task from all contexts
should respond to :setup and return setup task
should respond to :setup and add prerequisites to integration:setup
should respond to :setup and add action for integration:setup
should respond to :teardown and return teardown task
should respond to :teardown and add prerequisites to integration:teardown
should respond to :teardown and add action for integration:teardown
Rake::Task integration
should be a local task
should be a recursive task
should find nested integration tests
should ignore nested regular tasks
should agree not to run the same tasks as test
should run setup task before any project integration tests
should run teardown task after all project integrations tests
should run test cases marked for integration
should run setup and teardown tasks marked for integration
should run test actions marked for integration
should not fail if test=all
should execute by local package task
should execute by local package task along with unit tests
should not execute by local package task if test=no
integration rule
should execute integration tests on local project
should reset tasks to specific pattern
should apply *name* pattern
should not apply *name* pattern if asterisks used
should accept multiple tasks separated by commas
should execute only the named tests
Buildr::Groovy::EasyB
should apply to a project having EasyB sources
should be selected by :easyb name
should select a java compiler if java sources are found
should include src/spec/groovy/*Behavior.groovy
should include src/spec/groovy/*Story.groovy
URI#download
should download file if found
should fail if file not found
should work the same way from static method with URI
should work the same way from static method with String
should download to a task
should download to a file
URI#upload
should upload file if found
should fail if file not found
should work the same way from static method with URI
should work the same way from static method with String
should upload from a task
should create MD5 hash
should create SHA1 hash
should upload an entire directory
URI::FILE
should complain about file:
should accept file:something as file:///something
should accept file:/ as file:///
should accept file:/something as file:///something
should complain about file://
should accept file://something as file://something/
should accept file:///something
should treat host as path when host name is a Windows drive
URI::FILE#read
should not complain about excessive options
should read the file
should read the file and yield to block
should raise NotFoundError if file doesn't exist
should raise NotFoundError if file is actually a directory
URI::FILE#write
should not complain about excessive options
should write the file from a string
should write the file from a reader
should write the file from a block
should not create file if read fails
URI::HTTP#read
should not use proxy unless proxy is set
should use proxy from environment variable HTTP_PROXY
should not use proxy for hosts from environment variable NO_PROXY
should use proxy for hosts other than those specified by NO_PROXY
should support comma separated list in environment variable NO_PROXY
should support glob pattern in NO_PROXY
should support specific port in NO_PROXY
should not die if content size is zero
should use HTTP Basic authentication
should include the query part when performing HTTP GET
URI::HTTP#write
should open connection to HTTP server
should use HTTP basic authentication
should use HTTPS if applicable
should upload file with PUT request
should set Content-Length header
should set Content-MD5 header
should send entire content
should fail on 4xx response
should fail on 5xx response
URI::SFTP#read
should open connection to SFTP server
should open file for reading
should read contents of file and return it
should read contents of file and pass it to block
URI::SFTP#write
should open connection to SFTP server
should check that path exists on server
should close all opened directories
should create missing paths on server
should create missing directories recursively
should open file for writing
should write contents to file
#<Method: Module#struct>
should be object with key-value pairs
should fail when requesting non-existent key
should return members when requested
should return valued when requested
#<Method: Module#write>
should create path
should write content to file
should retrieve content from block, if block given
should write empty file if no content provided
should return content as a string
should return empty string if no content provided
#<Method: Module#read>
should return contents of named file
should yield to block if block given
should return block response if block given
#<Method: Module#download>
should be a file task
should accept a String and download from that URL
should accept a URI and download from that URL
should accept a path and String and download from that URL
should accept an artifact and String and download from that URL
should accept a path and URI and download from that URL
should create path for download
should fail if resource not found
should fail on any other error
should execute only if file does not already exist
should execute without a proxy if none specified
should pass Buildr proxy options
should set HTTP proxy from HTTP_PROXY environment variable
#<Method: Module#filter>
should return a Filter for the source
should use the source directory
should use the source directories
should accept a file task
Buildr::Filter
should respond to :from and return self
should respond to :from and add source directory
should respond to :from and add source directories
should return source directories as file task
should return source directories as expanded path
should respond to :into and return self
should respond to :into and set target directory
should return target directory as file task
should return target directory as expanded path
should respond to :using and return self
should respond to :using and set mapping from the argument
should respond to :using and set mapping from the block
should respond to :include and return self
should respond to :include and use these inclusion patterns
should respond to :exclude and return self
should respond to :exclude and use these exclusion patterns
should copy files over
should copy dot files over
should copy empty directories as well
should copy files from multiple source directories
should copy files recursively
should apply hash mapping using Maven style
should apply hash mapping using Ant style
should apply hash mapping using Ruby style
should use erb when given a binding
should apply hash mapping using erb
should use an object binding when using erb
should use a given block context when using erb
should using Maven mapper by default
should apply hash mapping using regular expression
should apply proc mapping
should apply proc mapping with relative file name
should apply proc mapping with file content
should make target directory
should touch target directory
should not touch target directory unless running
should run only one new files
should return true when run copies any files
should return false when run does not copy any files
should fail if source directory doesn't exist
should fail is target directory not set
should copy read-only files as writeable
Buildr::Filter::Mapper
should allow plugable mapping types
#<Method: Buildr.options>
should return an Options object
should return an Options object each time
should return the same Options object when called on Object, Buildr or Project
Buildr::Options proxy.exclude
should be an array
should support adding to array
should support resetting array
should use proxy when not excluded
should use proxy unless excluded
should not use proxy if excluded
should support multiple host names
should support glob pattern on host name
Hash ::from_java_properties
should return hash
should ignore comments and empty lines
should allow multiple lines
should handle \t, \r, \n and \f
should ignore whitespace
Hash#to_java_properties
should return name/value pairs
should handle \t, \r, \n and \f
Buildr::Project#group
should default to project name
should be settable
should inherit from parent project
Buildr::Project#version
should default to nil
should be settable
should inherit from parent project
Buildr::Project#id
should be same as project name
should replace colons with dashes
should not be settable
Buildr::Project#package
should default to id from project
should default to composed it for nested projects
should take id from option if specified
should default to group from project
should take group from option if specified
should default to version from project
should take version from option if specified
should accept package type as first argument
should support optional type
should assume :zip package type unless specified
should infer packaging type from compiler
should fail if packaging not supported
should default to no classifier
should accept classifier from option
should return a file task
should return a task that acts as artifact
should create different tasks for each spec
should not create multiple packages for the same spec
should return the same task for subsequent calls
should return a packaging task even if file already exists
should register task as artifact
should create in target path
should create prerequisite for package task
should create task requiring a build
should create a POM artifact in local repository
should create POM artifact ignoring classifier
should create POM artifact that creates its own POM
should not require downloading artifact or POM
Buildr::Project#package file
should be a file task
should not require id, project or version
should not provide project or version
should provide packaging type
should assume packaging type from extension if unspecified
should support different packaging types
should fail if packaging not supported
should create different tasks for each file
should return the same task for subsequent calls
should point to specified file
should create prerequisite for package task
should create task requiring a build
should create specified file during build
should do nothing for installation/upload
Rake::Task package
should be local task
should be recursive task
should create package in target directory
Rake::Task install
should be local task
should be recursive task
should create package in local repository
Rake::Task uninstall
should be local task
should be recursive task
Rake::Task upload
should be local task
should be recursive task
should upload artifact and POM
should upload signatures for artifact and POM
Buildr::Packaging zip
should create artifact of proper type
should create file with proper extension
should always return same task for the same package
should complain if option not known
should respond to with() and return self
should respond to with() and complain if unknown option
should not include META-INF directory
Buildr::Packaging tar
should create artifact of proper type
should create file with proper extension
should always return same task for the same package
should complain if option not known
should respond to with() and return self
should respond to with() and complain if unknown option
Buildr::Packaging tgz
should create artifact of proper type
should create file with proper extension
should always return same task for the same package
should complain if option not known
should respond to with() and return self
should respond to with() and complain if unknown option
Buildr::CompileTask
should respond to from() and return self
should respond to from() and add sources
should respond to with() and return self
should respond to with() and add dependencies
should respond to into() and return self
should respond to into() and create file task
should respond to using() and return self
should respond to using() and set options
should attempt to identify compiler
should only support existing compilers
should only allow setting the compiler once
Buildr::CompileTask#compiler
should be nil if no compiler identifier
should return the selected compiler
should attempt to identify compiler if sources are specified
Buildr::CompileTask#language
should be nil if no compiler identifier
should return the appropriate language
Buildr::CompileTask#sources
should be empty if no sources in default directory
should point to default directory if it contains sources
should be an array
should allow files
should allow directories
should allow tasks
should act as prerequisites
Buildr::CompileTask#dependencies
should be empty
should be an array
should allow files
should allow tasks
should allow artifacts
should allow projects
should be accessible as classpath
Buildr::CompileTask#target
should be a file task
should accept a task
should create dependency in file task when set
Buildr::CompileTask#options
should have getter and setter methods
should have bracket accessors
should map from bracket accessor to get/set accessor
should be independent of parent
Buildr::CompileTask#invoke
should compile into target directory
should compile only once
should compile if there are source files to compile
should not compile unless there are source files to compile
should require source file or directory to exist
should run all source files as prerequisites
should require dependencies to exist
should run all dependencies as prerequisites
should force compilation if no target
should force compilation if target empty
should force compilation if sources newer than compiled
should not force compilation if sources older than compiled
should force compilation if dependencies newer than compiled
should not force compilation if dependencies older than compiled
should timestamp target directory if specified
should touch target if anything compiled
should not touch target if nothing compiled
should not touch target if failed to compile
should complain if source directories and no compiler selected
Buildr::Project#compile
should return a task
should always return the same task
should be unique for the project
should be named after the project
should return a compile task
should accept sources and add to source list
should accept block and enhance task
should execute resources task
should be recursive
should be a local task
should run from build task
should clean after itself
Buildr::Project#resources
should return a task
should always return the same task
should be unique for the project
should be named after the project
should return a resources task
should provide a filter
should include src/main/resources as source directory
should include src/main/resources directory only if it exists
should accept prerequisites
should respond to from and add additional sources
should pass include pattern to filter
should pass exclude pattern to filter
should accept block and enhance task
should set target directory to target/resources
should use provided target directoy
should create file task for target directory
should copy resources to target directory
should not create target directory unless there are resources
should not be recursive
should use current profile for filtering
javac compiler
should identify itself from source directories
should identify from source directories using custom layout
should identify from compile source directories
should report the language as :java
should set the target directory to target/classes
should not override existing target directory
should not change existing list of sources
should include classpath dependencies
should include tools.jar dependency
javac compiler options
should set warnings option to false by default
should set wranings option to true when running with --verbose option
should use -nowarn argument when warnings is false
should not use -nowarn argument when warnings is true
should not use -verbose argument by default
should use -verbose argument when running with --trace option
should set debug option to true by default
should set debug option to false based on Buildr.options
should set debug option to false based on debug environment variable
should set debug option to false based on DEBUG environment variable
should use -g argument when debug option is true
should not use -g argument when debug option is false
should set deprecation option to false by default
should use -deprecation argument when deprecation is true
should not use -deprecation argument when deprecation is false
should not set source option by default
should not set target option by default
should use -source nn argument if source option set
should use -target nn argument if target option set
should set lint option to false by default
should use -lint argument if lint option is true
should use -lint argument with value of option
should use -lint argument with value of option as array
should not set other option by default
should pass other argument if other option is string
should pass other argument if other option is array
should complain about options it doesn't know
should inherit options from parent
Buildr::Project#javadoc
should return the project's Javadoc task
should return a Javadoc task
should set target directory to target/javadoc
should create file task for target directory
should respond to into() and return self
should respond to into() and change target directory
should respond to from() and return self
should respond to from() and add sources
should respond to from() and add file task
should respond to from() and add project's sources and dependencies
should generate javadocs from project
should include compile dependencies
should respond to include() and return self
should respond to include() and add files
should respond to exclude() and return self
should respond to exclude() and ignore files
should respond to using() and return self
should respond to using() and accept options
should pick -windowtitle from project name
should pick -windowtitle from project description
should produce documentation
should fail on error
should be local task
should not recurse
Buildr::Artifact
should act as one
should have an artifact identifier
should have a group identifier
should have a version number
should know if it is a snapshot
should have a file type
should understand classifier
should return hash specification
should return string specification
should have associated POM artifact
should have one artifact for all classifiers
should download file if file does not exist
should not download file if file exists
should handle lack of POM gracefully
should pass if POM provided
should pass if POM not required
should not download file if dry-run
should resolve to path in local repository
should return a list of all registered artifact specifications
Buildr::Repositories local
should default to .m2 path
should be settable
should reset to default
should locate file from string specification
should locate file from hash specification
should load path from settings file
Buildr::Repositories remote
should be empty initially
should be settable
should be settable from array
should add and return repositories in order
should be used to download artifact
should lookup in array order
should fail if artifact not found
should support artifact classifier
should deal well with repositories URL that lack the last slash
should deal well with repositories URL that have the last slash
should resolve m2-style deployed snapshots
should handle missing maven metadata by reporting the artifact unavailable
should handle missing m2 snapshots by reporting the artifact unavailable
should load with all repositories specified in settings file
should load with all repositories specified in build.yaml file
should load with all repositories specified in settings and build.yaml files
Buildr::Repositories release_to
should accept URL as first argument
should accept hash with options
should allow the hash to be manipulated
should load URL from settings file
should load URL, username and password from settings file
Buildr#artifact
should accept hash specification
should reject partial hash specifier
should complain about invalid key
should use JAR type by default
should accept string specification
should reject partial string specifier
should create a task naming the artifact in the local repository
should use from method to install artifact from existing file
should reference artifacts defined on build.yaml by using ruby symbols
Buildr#artifacts
should return a list of artifacts from all its arguments
should accept nested arrays
should accept struct
should ignore duplicates
should accept and return existing tasks
should accept filenames and expand them
should accept filenames and return filenames
should accept project and return all its packaging tasks
should complain about an invalid specification
Buildr#group
should accept list of artifact identifiers
should accept array with artifact identifiers
should accept a type
Buildr#install
should return the install task
should accept artifacts to install
should install artifact when install task is run
should install POM alongside artifact
Buildr#upload
should return the upload task
should accept artifacts to upload
should upload artifact when upload task is run
Buildr::ActsAsArtifact#upload
should be used to upload artifact
should support artifact classifier
should complain without any repository configuration
should accept repositories.upload setting
Rake::Task artifacts
should download all specified artifacts
should fail if failed to download an artifact
should succeed if artifact already exists
Buildr#transitive
should return a list of artifacts from all its arguments
should accept nested arrays
should accept struct
should ignore duplicates
should accept and return existing tasks
should accept filenames and expand them
should accept filenames and return file task
should accept project and return all its packaging tasks
should complain about an invalid specification
should bring artifact and its dependencies
should bring dependencies of POM without artifact itself
should bring artifact and transitive depenencies
Buildr::Project#manifest
should include user name
should include JDK version
should include project comment
should include project name if no comment
should include project version
should not include project version unless specified
should inherit from parent project
Buildr::Project#meta_inf
should by an array
should include LICENSE file if found
should be empty unless LICENSE exists
should inherit from parent project
should expect LICENSE file parent project
Buildr::Packaging jar
should create artifact of proper type
should create file with proper extension
should always return same task for the same package
should complain if option not known
should respond to with() and return self
should respond to with() and complain if unknown option
should include default header when no options specified
should not exist when manifest=false
should map manifest from hash
should end hash manifest with EOL
should break hash manifest lines longer than 72 characters using continuations
should map manifest from array
should end array manifest with EOL
should break array manifest lines longer than 72 characters using continuations
should put Name: at beginning of section
should create manifest from proc
should create manifest from file
should create manifest from task
should respond to with() and accept manifest
should include META-INF directory
should inherit manifest from parent project
should not modify manifest of parent project
should default to LICENSE file
should be empty if no LICENSE file
should include file specified by :meta_inf option
should include files specified by :meta_inf option
should include file task specified by :meta_inf option
should include file tasks specified by :meta_inf option
should complain if cannot find file
should complain if cannot build task
should respond to with() and accept manifest and meta_inf
should use files from compile directory if nothing included
should use files from resources directory if nothing included
should include class directories
should include resource files starting with dot
should include empty resource directories
Buildr::Packaging war
should create artifact of proper type
should create file with proper extension
should always return same task for the same package
should complain if option not known
should respond to with() and return self
should respond to with() and complain if unknown option
should include default header when no options specified
should not exist when manifest=false
should map manifest from hash
should end hash manifest with EOL
should break hash manifest lines longer than 72 characters using continuations
should map manifest from array
should end array manifest with EOL
should break array manifest lines longer than 72 characters using continuations
should put Name: at beginning of section
should create manifest from proc
should create manifest from file
should create manifest from task
should respond to with() and accept manifest
should include META-INF directory
should inherit manifest from parent project
should not modify manifest of parent project
should default to LICENSE file
should be empty if no LICENSE file
should include file specified by :meta_inf option
should include files specified by :meta_inf option
should include file task specified by :meta_inf option
should include file tasks specified by :meta_inf option
should complain if cannot find file
should complain if cannot build task
should respond to with() and accept manifest and meta_inf
should use files from webapp directory if nothing included
should accept files from :classes option
should use files from compile directory if nothing included
should ignore compile directory if no source files to compile
should include only specified classes directories
should use files from resources directory if nothing included
should include empty resource directories
should accept file from :libs option
should accept file from :libs option
should use artifacts from compile classpath if no libs specified
should include only specified libraries
Buildr::Packaging aar
should create artifact of proper type
should create file with proper extension
should always return same task for the same package
should complain if option not known
should respond to with() and return self
should respond to with() and complain if unknown option
should include default header when no options specified
should not exist when manifest=false
should map manifest from hash
should end hash manifest with EOL
should break hash manifest lines longer than 72 characters using continuations
should map manifest from array
should end array manifest with EOL
should break array manifest lines longer than 72 characters using continuations
should put Name: at beginning of section
should create manifest from proc
should create manifest from file
should create manifest from task
should respond to with() and accept manifest
should include META-INF directory
should inherit manifest from parent project
should not modify manifest of parent project
should default to LICENSE file
should be empty if no LICENSE file
should include file specified by :meta_inf option
should include files specified by :meta_inf option
should include file task specified by :meta_inf option
should include file tasks specified by :meta_inf option
should complain if cannot find file
should complain if cannot build task
should respond to with() and accept manifest and meta_inf
should automatically include services.xml and any *.wsdl files under src/main/axis2
should accept files from :include option
should use files from compile directory if nothing included
should use files from resources directory if nothing included
should include empty resource directories
should accept file from :libs option
should accept file from :libs option
should NOT use artifacts from compile classpath if no libs specified
should return all libraries from libs attribute
Buildr::Packaging ear
should create artifact of proper type
should create file with proper extension
should always return same task for the same package
should complain if option not known
should respond to with() and return self
should respond to with() and complain if unknown option
should include default header when no options specified
should not exist when manifest=false
should map manifest from hash
should end hash manifest with EOL
should break hash manifest lines longer than 72 characters using continuations
should map manifest from array
should end array manifest with EOL
should break array manifest lines longer than 72 characters using continuations
should put Name: at beginning of section
should create manifest from proc
should create manifest from file
should create manifest from task
should respond to with() and accept manifest
should include META-INF directory
should inherit manifest from parent project
should not modify manifest of parent project
should default to LICENSE file
should be empty if no LICENSE file
should include file specified by :meta_inf option
should include files specified by :meta_inf option
should include file task specified by :meta_inf option
should include file tasks specified by :meta_inf option
should complain if cannot find file
should complain if cannot build task
should respond to with() and accept manifest and meta_inf
should set display name from project id
should set display name in application.xml
should accept different display name
should map WARs to /war directory
should map EJBs to /ejb directory
should not modify original artifact for its components
should map JARs to /lib directory
should accept component type with :type option
should accept component and its type as type=>artiract
should map typed JARs to /jar directory
should add multiple components at a time using the type=>component style
should add all EAR supported packages when given a project argument
should complain about unknown component type
should allow unknown component types with explicit type
should accept alternative directory name
should accept customization of directory map
should accept customization of directory map with nil paths in application.xml
should accept customization of directory map with nil paths in the classpath
should list WAR components in application.xml
should specify web-uri for WAR components in application.xml
should specify context-root for WAR components in application.xml
should accept context-root for WAR components in application.xml
should allow disabling the context root
should list EJB components in application.xml
should list JAR components in application.xml
should update WAR component classpath to include libraries
should update WAR component classpath but skip internal libraries
should update EJB component classpath to include libraries
should update JAR component classpath to include libraries
should deal with very long classpaths
should generate relative classpaths for top level EJB
should generate relative classpaths for second level EJB
should generate relative classpaths for nested EJB
Buildr::Packaging sources
should create artifact of proper type
should create file with proper extension
should always return same task for the same package
should complain if option not known
should respond to with() and return self
should respond to with() and complain if unknown option
should create package of type :zip and classifier 'sources'
should contain source files
should be a ZipTask
Buildr::Packaging javadoc
should create artifact of proper type
should create file with proper extension
should always return same task for the same package
should complain if option not known
should respond to with() and return self
should respond to with() and complain if unknown option
should create package of type :zip and classifier 'javadoc'
should contain Javadocs
should use project description in window title
should be a ZipTask
package_with_sources
should create package of type zip with classifier
should create package for projects that have source files
should not create package for projects that have no source files
should limit to projects specified by :only
should limit to projects specified by :only array
should ignore project specified by :except
should ignore projects specified by :except array
package_with_javadoc
should create package of type zip with classifier
should create package for projects that have source files
should not create package for projects that have no source files
should limit to projects specified by :only
should limit to projects specified by :only array
should ignore project specified by :except
should ignore projects specified by :except array
Buildr::TarTask
should point to archive file
should create file
should create empty archive if no files included
should create empty archive if called #clean method
should archive all included files
should archive file tasks
should invoke and archive file tasks
should include entry for directory
should not archive any excluded files
should not archive any excluded files in included directories
should not archive any excluded files when using :from/:as
should exclude entire directory and all its children
should not archive any excluded files when pattern is *.ext
should archive files into specified path
should include entry for directory
should archive files into specified path
should archive directories into specified path
should understand . in path
should understand .. in path
should understand leading / in path
should archive file into specified name
should archive file into specified name/path
should archive files starting with dot
should archive directory into specified name
should archive directory into specified name/path
should archive directory contents
should archive directory contents into specified path
should not allow two files with the :as argument
should expand another archive file
should expand another archive file with include pattern
should expand another archive file with exclude pattern
should expand another archive file into path
should expand another archive file into path with :path option
should expand another archive file into path with :path=>'/'
should expand another archive file into path with merge option
should update if one of the files is recent
should do nothing if all files are uptodate
should update if one of the files is recent
should create new archive when updating
should not accept invalid options
Buildr::TarTask gzipped
should point to archive file
should create file
should create empty archive if no files included
should create empty archive if called #clean method
should archive all included files
should archive file tasks
should invoke and archive file tasks
should include entry for directory
should not archive any excluded files
should not archive any excluded files in included directories
should not archive any excluded files when using :from/:as
should exclude entire directory and all its children
should not archive any excluded files when pattern is *.ext
should archive files into specified path
should include entry for directory
should archive files into specified path
should archive directories into specified path
should understand . in path
should understand .. in path
should understand leading / in path
should archive file into specified name
should archive file into specified name/path
should archive files starting with dot
should archive directory into specified name
should archive directory into specified name/path
should archive directory contents
should archive directory contents into specified path
should not allow two files with the :as argument
should expand another archive file
should expand another archive file with include pattern
should expand another archive file with exclude pattern
should expand another archive file into path
should expand another archive file into path with :path option
should expand another archive file into path with :path=>'/'
should expand another archive file into path with merge option
should update if one of the files is recent
should do nothing if all files are uptodate
should update if one of the files is recent
should create new archive when updating
should not accept invalid options
Buildr::ZipTask
should point to archive file
should create file
should create empty archive if no files included
should create empty archive if called #clean method
should archive all included files
should archive file tasks
should invoke and archive file tasks
should include entry for directory
should not archive any excluded files
should not archive any excluded files in included directories
should not archive any excluded files when using :from/:as
should exclude entire directory and all its children
should not archive any excluded files when pattern is *.ext
should archive files into specified path
should include entry for directory
should archive files into specified path
should archive directories into specified path
should understand . in path
should understand .. in path
should understand leading / in path
should archive file into specified name
should archive file into specified name/path
should archive files starting with dot
should archive directory into specified name
should archive directory into specified name/path
should archive directory contents
should archive directory contents into specified path
should not allow two files with the :as argument
should expand another archive file
should expand another archive file with include pattern
should expand another archive file with exclude pattern
should expand another archive file into path
should expand another archive file into path with :path option
should expand another archive file into path with :path=>'/'
should expand another archive file into path with merge option
should update if one of the files is recent
should do nothing if all files are uptodate
should update if one of the files is recent
should create new archive when updating
should not accept invalid options
should work with path object
Buildr::Unzip
should touch target directory
should expand files
should expand all files
should expand only included files
should expand all but excluded files
should include with nested path patterns
should include with relative path
should exclude with relative path
should handle relative paths without any includes or excludes
should return itself from root method
should return target task from target method
should alias from_path as path
Buildr::JUnit
should be the default test framework when test cases are in java
should be picked if the test language is Java
should include JUnit dependencies
should pick JUnit version from junit build settings
should include JMock dependencies
should pick JUnit version from junit build settings
should include public classes extending junit.framework.TestCase
should include public classes with annotated test cases
should include public classes with RunWith annotation
should ignore classes not extending junit.framework.TestCase
should ignore inner classes
should ignore abstract classes
should ignore classes with no tests in them
should pass when JUnit test case passes
should fail when JUnit test case fails
should report failed test names
should report to reports/junit
should pass properties to JVM
should pass environment to JVM
should set current directory
should run all test cases in same VM if fork is once
should run each test case in separate same VM if fork is each
Buildr::JUnit report
should default to the target directory reports/junit
should generate report into the target directory
should clean after itself
should generate a consolidated XML report
should default to generating a report with frames
should generate single page when frames is false
should generate frame page when frames is false
should generate reports from all projects that ran test cases
Buildr::TestNG
should be selectable in project
should be selectable in parent project
should include TestNG dependencies
should include TestNG dependencies
should include classes using TestNG annotations
should ignore classes not using TestNG annotations
should ignore inner classes
should pass when TestNG test case passes
should fail when TestNG test case fails
should report failed test names
should report to reports/testng
should generate reports
Buildr::Generate Generated buildfile
should be a legal buildfile
should not contain NEXT_VERSION because it was removed in buildr 1.3.3
build task
should execute task for project in current directory
should not execute task for projects in other directory
clean task
should execute task for project in current directory
should not execute task for projects in other directory
package task
should execute task for project in current directory
should not execute task for projects in other directory
should execute build task as prerequisite
install task
should execute task for project in current directory
should not execute task for projects in other directory
should execute package task as prerequisite
uninstall task
should execute task for project in current directory
should not execute task for projects in other directory
upload task
should execute task for project in current directory
should not execute task for projects in other directory
should execute package task as prerequisite
Buildr::Project#build
should return the project's build task
should enhance the project's build task
should execute build task for sub-project
should not execute build task of other projects
Buildr::Project#clean
should return the project's clean task
should enhance the project's clean task
should remove target directory
should remove reports directory
should execute clean task for sub-project
should not execute clean task of other projects
Buildr::Project#target
should default to target
should set layout :target
should come from layout :target
Buildr::Project#reports
should default to reports
should set layout :reports
should come from layout :reports
Buildr::Release#make
should tag a release with the release version
should update the buildfile with the next version number
should commit the updated buildfile
Buildr::Release#check
should accept to release from the trunk
should accept to release from a branch
should reject releasing from a tag
should reject a non standard repository layout
should reject an uncommitted file
Buildr::Release#extract_version
should extract VERSION_NUMBER with single quotes
should extract VERSION_NUMBER with double quotes
should extract VERSION_NUMBER without any spaces
should extract THIS_VERSION as an alternative to VERSION_NUMBER
should complain if no current version number
Buildr::Release#tag url
should accept to tag foo/trunk
should accept to tag foo/branches/1.0
should accept to tag trunk/foo
should accept to tag branches/foo/1.0
should use tag specified by tag_name
should use tag returned by tag_name if tag_name is a proc
Buildr::Release#with_release_candidate_version
should yield the name of the release candidate buildfile
should yield a name different from the original buildfile
Buildr::Release#tag_release
should tag the working copy
should remove the tag if it already exists
should accept that the tag does not exist
should inform the user
Buildr::Release#commit_new_snapshot
should update the buildfile with a new version number
should commit the new buildfile on the trunk
should inform the user of the new version
Buildr::Svn#repo_url
should extract the SVN URL from svn info
ENV JAVA_HOME on OS X
should point to default JVM
should use value of environment variable if specified
Java#tools_jar when JAVA_HOME points to a JDK
should return the path to tools.jar
Java#tools_jar when JAVA_HOME points to a JRE inside a JDK
should return the path to tools.jar
Java#tools_jar when there is no tools.jar
should return nil
Buildr::Eclipse eclipse's .project file scala project
should have Scala nature before Java nature
should have Scala build command and no Java build command
Buildr::Eclipse eclipse's .classpath file scala project
should have SCALA_CONTAINER before JRE_CONTAINER
Buildr::Eclipse eclipse's .classpath file source folders main code
should ignore CVS and SVN files
should accept to come from the default directory
should accept to come from a user-defined directory
should accept a file task as a main source folder
should go to the default target directory
Buildr::Eclipse eclipse's .classpath file source folders test code
should ignore CVS and SVN files
should accept to come from the default directory
should accept to come from a user-defined directory
should go to the default target directory
Buildr::Eclipse eclipse's .classpath file source folders main resources
should ignore CVS and SVN files
should accept to come from the default directory
should share a classpath entry if it comes from a directory with code
should go to the default target directory
Buildr::Eclipse eclipse's .classpath file source folders test resources
should ignore CVS and SVN files
should accept to come from the default directory
should share a classpath entry if it comes from a directory with code
should go to the default target directory
Buildr::Eclipse eclipse's .classpath file source folders project depending on another project
should have the underlying project in its classpath
Buildr::VersionRequirement.create
should complain on invalid input
should allow versions using hyphen
should create a single version requirement
should create a composed version requirement
Buildr::VersionRequirement#satisfied_by?
should accept Gem version operators
should accept logic not operator
should accept logic or operator
should accept logic and operator
should assume logic and if missing operator between expressions
should allow combining logic operators
should allow using parens to group logic expressions
Buildr::VersionRequirement#default
should return nil if missing default requirement
should return the last version with a = requirement