Class: Buildr::ArchiveTask::Path

Inherits:
Object
  • Object
show all
Defined in:
lib/buildr/packaging/archive.rb

Overview

Which files go where. All the rules for including, excluding and merging files are handled by this object.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(root, path) ⇒ Path

Returns a new instance of Path.



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/buildr/packaging/archive.rb', line 29

def initialize(root, path)
  @root = root
  @path = path.empty? ? path : "#{path}/"
  @includes = FileList[]
  @excludes = []
  # Expand source files added to this path.
  expand_src = proc { @includes.map{ |file| file.to_s }.uniq }
  @sources = [ expand_src ]
  # Add files and directories added to this path.
  @actions = [] << proc do |file_map|
    expand_src.call.each do |path|
      unless excluded?(path)
        if File.directory?(path)
          in_directory path do |file, rel_path|
            dest = "#{@path}#{rel_path}"
            trace "Adding #{dest}"
            file_map[dest] = file
          end
        else
          trace "Adding #{@path}#{File.basename(path)}"
          file_map["#{@path}#{File.basename(path)}"] = path
        end
      end
    end
  end
end

Instance Attribute Details

#root ⇒ Object (readonly)

Returns the archive from this path.



27
28
29
 
# File 'lib/buildr/packaging/archive.rb', line 27

def root
  @root
end

Instance Method Details

#add_files(file_map) ⇒ Object

:nodoc:



129
130
131
 
# File 'lib/buildr/packaging/archive.rb', line 129

def add_files(file_map) #:nodoc:
  @actions.each { |action| action.call(file_map) }
end

#contain?(*files) ⇒ Boolean

:call-seq:

contain(file*) => boolean

Returns true if this ZIP file path contains all the specified files. You can use relative file names and glob patterns (using *, **, etc).

Returns:

  • (Boolean) 


155
156
157
 
# File 'lib/buildr/packaging/archive.rb', line 155

def contain?(*files)
  files.all? { |file| entries.detect { |entry| File.fnmatch(file, entry.to_s, File::FNM_PATHNAME) } }
end

#empty? ⇒ Boolean

:call-seq:

empty? => boolean

Returns true if this path is empty (has no other entries inside).

Returns:

  • (Boolean) 


146
147
148
 
# File 'lib/buildr/packaging/archive.rb', line 146

def empty?
  entries.all? { |entry| entry.empty? }
end

#entry(name) ⇒ Object

:call-seq:

entry(name) => ZipEntry

Returns a ZIP file entry. You can use this to check if the entry exists and its contents, for example:

package(:jar).path("META-INF").entry("LICENSE").should contain(/Apache Software License/)



165
166
167
 
# File 'lib/buildr/packaging/archive.rb', line 165

def entry(name)
  root.entry("#{@path}#{name}")
end

#exclude(*files) ⇒ Object

:call-seq:

exclude(*files) => self



92
93
94
95
96
97
 
# File 'lib/buildr/packaging/archive.rb', line 92

def exclude(*files)
  files = files.flatten.map(&:to_s) 
  @excludes |= files
  @excludes |= files.reject { |f| f =~ /\*$/ }.map { |f| "#{f}/*" }
  self
end

#exist? ⇒ Boolean

:call-seq:

exist => boolean

Returns true if this path exists. This only works if the path has any entries in it, so exist on path happens to be the opposite of empty.

Returns:

  • (Boolean) 


138
139
140
 
# File 'lib/buildr/packaging/archive.rb', line 138

def exist?
  !entries.empty?
end

#include(*args) ⇒ Object Also known as: add, <<

:call-seq:

include(*files) => self
include(*files, :path=>path) => self
include(file, :as=>name) => self
include(:from=>path) => self
include(*files, :merge=>true) => self



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/buildr/packaging/archive.rb', line 62

def include(*args)
  options = args.pop if Hash === args.last
  files = args.flatten

  if options.nil? || options.empty?
    @includes.include *files.flatten
  elsif options[:path]
    sans_path = options.reject { |k,v| k == :path }
    path(options[:path]).include *files + [sans_path]
  elsif options[:as]
    raise 'You can only use the :as option in combination with the :path option' unless options.size == 1
    raise 'You can only use one file with the :as option' unless files.size == 1
    include_as files.first.to_s, options[:as]
  elsif options[:from]
    raise 'You can only use the :from option in combination with the :path option' unless options.size == 1
    raise 'You canont use the :from option with file names' unless files.empty?
    [options[:from]].flatten.each { |path| include_as path.to_s, '.' }
  elsif options[:merge]
    raise 'You can only use the :merge option in combination with the :path option' unless options.size == 1
    files.each { |file| merge file }
  else
    raise "Unrecognized option #{options.keys.join(', ')}"
  end
  self
end

#merge(*args) ⇒ Object

:call-seq:

merge(*files) => Merge
merge(*files, :path=>name) => Merge

Raises:

  • (ArgumentError) 


102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/buildr/packaging/archive.rb', line 102

def merge(*args)
  options = Hash === args.last ? args.pop : {}
  files = args.flatten
  rake_check_options options, :path
  raise ArgumentError, "Expected at least one file to merge" if files.empty?
  path = options[:path] || @path
  expanders = files.collect do |file|
    @sources << proc { file.to_s }
    expander = ZipExpander.new(file)
    @actions << proc { |file_map| expander.expand(file_map, path) }
    expander
  end
  Merge.new(expanders)
end

#path(path) ⇒ Object

Returns a Path relative to this one.



118
119
120
121
122
 
# File 'lib/buildr/packaging/archive.rb', line 118

def path(path)
  return self if path.nil?
  return root.path(path[1..-1]) if path[0] == ?/
  root.path("#{@path}#{path}")
end

#sources ⇒ Object

Returns all the source files.



125
126
127
 
# File 'lib/buildr/packaging/archive.rb', line 125

def sources #:nodoc:
  @sources.map{ |source| source.call }.flatten
end

#to_s ⇒ Object 



169
170
171
 
# File 'lib/buildr/packaging/archive.rb', line 169

def to_s
  @path
end