Class: Buildr::Unzip

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

Overview

An object for unzipping a file into a target directory. You can tell it to include or exclude only specific files and directories, and also to map files from particular paths inside the zip file into the target directory. Once ready, call #extract.

Usually it is more convenient to create a file task for extracting the zip file (see #unzip) and pass this object as a prerequisite to other tasks.

See Buildr#unzip.

Defined Under Namespace

Classes: FromPath

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(args) ⇒ Unzip

Initialize with hash argument of the form target=>zip_file.



519
520
521
522
 
# File 'lib/buildr/packaging/zip.rb', line 519

def initialize(args)
  @target, arg_names, @zip_file = Buildr.application.resolve_args([args])
  @paths = {}
end

Instance Attribute Details

#target ⇒ Object

The target directory to extract to.



516
517
518
 
# File 'lib/buildr/packaging/zip.rb', line 516

def target
  @target
end

#zip_file ⇒ Object

The zip file to extract.



514
515
516
 
# File 'lib/buildr/packaging/zip.rb', line 514

def zip_file
  @zip_file
end

Instance Method Details

#exclude(*files) ⇒ Object

:call-seq:

exclude(*files) => self

Exclude all files that match the patterns and return self.

Use exclude to unzip all files except those that match the pattern. You can use #exclude in combination with #include.



586
587
588
589
590
591
592
593
 
# File 'lib/buildr/packaging/zip.rb', line 586

def exclude(*files)
  if Hash === files.last
    from_path(files.pop[:path]).exclude *files
  else
    from_path(nil).exclude *files
  end
  self
end

#extract ⇒ Object

:call-seq:

extract()

Extract the zip file into the target directory.

You can call this method directly. However, if you are using the #unzip method, it creates a file task for the target directory: use that task instead as a prerequisite. For example:

build unzip(dir=>zip_file)

Or:

unzip(dir=>zip_file).target.invoke



535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
 
# File 'lib/buildr/packaging/zip.rb', line 535

def extract()
  # If no paths specified, then no include/exclude patterns
  # specified. Nothing will happen unless we include all files.
  if @paths.empty?
    @paths[nil] = FromPath.new(self, nil)
  end

  # Otherwise, empty unzip creates target as a file when touching.
  mkpath target.to_s, :verbose=>false
  Zip::ZipFile.open(zip_file.to_s) do |zip|
    entries = zip.collect
    @paths.each do |path, patterns|
      patterns.map(entries).each do |dest, entry|
        next if entry.directory?
        dest = File.expand_path(dest, target.to_s)
        trace "Extracting #{dest}"
        mkpath File.dirname(dest), :verbose=>false rescue nil
        entry.extract(dest) { true }
      end
    end
  end
  # Let other tasks know we updated the target directory.
  touch target.to_s, :verbose=>false
end

#from_path(name) ⇒ Object Also known as: path

:call-seq:

from_path(name) => Path

Allows you to unzip from a path. Returns an object you can use to specify which files to include/exclude relative to that path. Expands the file relative to that path.

For example:

unzip(Dir.pwd=>'test.jar').from_path('etc').include('LICENSE')

will unzip etc/LICENSE into ./LICENSE.

This is different from:

unzip(Dir.pwd=>'test.jar').include('etc/LICENSE')

which unzips etc/LICENSE into ./etc/LICENSE.



609
610
611
 
# File 'lib/buildr/packaging/zip.rb', line 609

def from_path(name)
  @paths[name] ||= FromPath.new(self, name)
end

#include(*files) ⇒ Object Also known as: add

:call-seq:

include(*files) => self
include(*files, :path=>name) => self

Include all files that match the patterns and returns self.

Use include if you only want to unzip some of the files, by specifying them instead of using exclusion. You can use #include in combination with #exclude.



569
570
571
572
573
574
575
576
 
# File 'lib/buildr/packaging/zip.rb', line 569

def include(*files)
  if Hash === files.last
    from_path(files.pop[:path]).include *files
  else
    from_path(nil).include *files
  end
  self
end

#root ⇒ Object

:call-seq:

root() => Unzip

Returns the root path, essentially the Unzip object itself. In case you are wondering down paths and want to go back.



619
620
621
 
# File 'lib/buildr/packaging/zip.rb', line 619

def root()
  self
end

#to_s ⇒ Object

Returns the path to the target directory.



624
625
626
 
# File 'lib/buildr/packaging/zip.rb', line 624

def to_s()
  target.to_s
end