capistrano-filter 0.2

data/lib/capistrano/ext/filter.rb

@@ -0,0 +1,8 @@
+unless Capistrano::Configuration.respond_to?(:instance)
+  abort "capistrano/ext/filter requires Capistrano 2"
+end
+
+Capistrano::Configuration.instance.load do
+    require 'capistrano/recipes/deploy/strategy/copy_and_filter'
+    require 'capistrano/recipes/deploy/strategy/filter'
+end

data/lib/capistrano/recipes/deploy/strategy/copy_and_filter.rb

@@ -0,0 +1,232 @@
+require 'capistrano/recipes/deploy/strategy/base'
+require 'fileutils'
+require 'tempfile'  # Dir.tmpdir
+#require 'filter.rb'
+
+module Capistrano
+  module Deploy
+    module Strategy
+
+      # This class implements the strategy for deployments which work
+      # by preparing the source code locally, compressing it, copying the
+      # file to each target host, and uncompressing it to the deployment
+      # directory.
+      #
+      # By default, the SCM checkout command is used to obtain the local copy
+      # of the source code. If you would rather use the export operation,
+      # you can set the :copy_strategy variable to :export.
+      #
+      #   set :copy_strategy, :export
+      #
+      # For even faster deployments, you can set the :copy_cache variable to
+      # true. This will cause deployments to do a new checkout of your
+      # repository to a new directory, and then copy that checkout. Subsequent
+      # deploys will just resync that copy, rather than doing an entirely new
+      # checkout. Additionally, you can specify file patterns to exclude from
+      # the copy when using :copy_cache; just set the :copy_exclude variable
+      # to a file glob (or an array of globs).
+      #
+      #   set :copy_cache, true
+      #   set :copy_exclude, ".git/*"
+      #
+      # Note that :copy_strategy is ignored when :copy_cache is set. Also, if
+      # you want the copy cache put somewhere specific, you can set the variable
+      # to the path you want, instead of merely 'true':
+      #
+      #   set :copy_cache, "/tmp/caches/myapp"
+      #
+      # This deployment strategy also supports a special variable,
+      # :copy_compression, which must be one of :gzip, :bz2, or
+      # :zip, and which specifies how the source should be compressed for
+      # transmission to each host.
+      class CopyAndFilter < Base
+        # Obtains a copy of the source code locally (via the #command method),
+        # compresses it to a single file, copies that file to all target
+        # servers, and uncompresses it on each of them into the deployment
+        # directory.
+        def deploy!
+          if copy_cache
+            if File.exists?(copy_cache)
+              logger.debug "refreshing local cache to revision #{revision} at #{copy_cache}"
+              system(source.sync(revision, copy_cache))
+            else
+              logger.debug "preparing local cache at #{copy_cache}"
+              system(source.checkout(revision, copy_cache))
+            end
+
+            # Check the return code of last system command and rollback if not 0
+            unless $? == 0
+              raise Capistrano::Error, "shell command failed with return code #{$?}"
+            end
+
+            logger.debug "copying cache to deployment staging area #{destination}"
+            Dir.chdir(copy_cache) do
+              FileUtils.mkdir_p(destination)
+              queue = Dir.glob("*", File::FNM_DOTMATCH)
+              while queue.any?
+                item = queue.shift
+                name = File.basename(item)
+
+                next if name == "." || name == ".."
+                next if copy_exclude.any? { |pattern| File.fnmatch(pattern, item) }
+
+                if File.symlink?(item)
+                  FileUtils.ln_s(File.readlink(File.join(copy_cache, item)), File.join(destination, item))
+                elsif File.directory?(item)
+                  queue += Dir.glob("#{item}/*", File::FNM_DOTMATCH)
+                  FileUtils.mkdir(File.join(destination, item))
+                else
+                  FileUtils.ln(File.join(copy_cache, item), File.join(destination, item))
+                end
+              end
+            end
+          else
+            logger.debug "getting (via #{copy_strategy}) revision #{revision} to #{destination}"
+            system(command)
+
+            if copy_exclude.any?
+              logger.debug "processing exclusions..."
+              if copy_exclude.any?
+                copy_exclude.each do |pattern| 
+                  delete_list = Dir.glob(File.join(destination, pattern), File::FNM_DOTMATCH)
+                  # avoid the /.. trap that deletes the parent directories
+                  delete_list.delete_if { |dir| dir =~ /\/\.\.$/ }
+                  FileUtils.rm_rf(delete_list.compact)
+                end
+              end
+            end
+          end
+          
+          if filtering_props and not filtering_props.empty? then
+            #_cset(:filtering_files, "*") unless filtering_files
+            #filtering_files = [*filtering_files]
+            _filter_using = filtering_using #FIXME Valor default?  ? filtering_using : :ruby
+            _filter_files = [*filtering_files]
+            logger.info "filtering files #{destination} with pattern #{_filter_files.join(',')}"
+            _filter_criteria = filter.from(destination).force().using(_filter_using, filtering_props)
+            _filter_files.each do |file|
+                _filter_criteria.include(file)
+            end
+            _filter_criteria.into(destination).run()
+          end
+
+          File.open(File.join(destination, "REVISION"), "w") { |f| f.puts(revision) }
+
+          logger.trace "compressing #{destination} to #{filename}"
+          Dir.chdir(tmpdir) { system(compress(File.basename(destination), File.basename(filename)).join(" ")) }
+
+          upload(filename, remote_filename)
+          run "cd #{configuration[:releases_path]} && #{decompress(remote_filename).join(" ")} && rm #{remote_filename}"
+        ensure
+          FileUtils.rm filename rescue nil
+          FileUtils.rm_rf destination rescue nil
+        end
+
+        def check!
+          super.check do |d|
+            d.local.command(source.local.command) if source.local.command
+            d.local.command(compress(nil, nil).first)
+            d.remote.command(decompress(nil).first)
+          end
+        end
+
+        # Returns the location of the local copy cache, if the strategy should
+        # use a local cache + copy instead of a new checkout/export every
+        # time. Returns +nil+ unless :copy_cache has been set. If :copy_cache
+        # is +true+, a default cache location will be returned.
+        def copy_cache
+          @copy_cache ||= configuration[:copy_cache] == true ?
+            File.join(Dir.tmpdir, configuration[:application]) :
+            configuration[:copy_cache]
+        end
+
+        private
+
+          # Specify patterns to exclude from the copy. This is only valid
+          # when using a local cache.
+          def copy_exclude
+            @copy_exclude ||= Array(configuration.fetch(:copy_exclude, []))
+          end
+
+          # Returns the basename of the release_path, which will be used to
+          # name the local copy and archive file.
+          def destination
+            @destination ||= File.join(tmpdir, File.basename(configuration[:release_path]))
+          end
+
+          # Returns the value of the :copy_strategy variable, defaulting to
+          # :checkout if it has not been set.
+          def copy_strategy
+            @copy_strategy ||= configuration.fetch(:copy_strategy, :checkout)
+          end
+
+          # Should return the command(s) necessary to obtain the source code
+          # locally.
+          def command
+            @command ||= case copy_strategy
+            when :checkout
+              source.checkout(revision, destination)
+            when :export
+              source.export(revision, destination)
+            end
+          end
+
+          # Returns the name of the file that the source code will be
+          # compressed to.
+          def filename
+            @filename ||= File.join(tmpdir, "#{File.basename(destination)}.#{compression.extension}")
+          end
+
+          # The directory to which the copy should be checked out
+          def tmpdir
+            @tmpdir ||= configuration[:copy_dir] || Dir.tmpdir
+          end
+
+          # The directory on the remote server to which the archive should be
+          # copied
+          def remote_dir
+            @remote_dir ||= configuration[:copy_remote_dir] || "/tmp"
+          end
+
+          # The location on the remote server where the file should be
+          # temporarily stored.
+          def remote_filename
+            @remote_filename ||= File.join(remote_dir, File.basename(filename))
+          end
+
+          # A struct for representing the specifics of a compression type.
+          # Commands are arrays, where the first element is the utility to be
+          # used to perform the compression or decompression.
+          Compression = Struct.new(:extension, :compress_command, :decompress_command)
+          
+          # The compression method to use, defaults to :gzip.
+          def compression
+            remote_tar = configuration[:copy_remote_tar] || 'tar'
+            local_tar = configuration[:copy_local_tar] || 'tar'
+            
+            type = configuration[:copy_compression] || :gzip
+            case type
+            when :gzip, :gz   then Compression.new("tar.gz",  [local_tar, 'czf'], [remote_tar, 'xzf'])
+            when :bzip2, :bz2 then Compression.new("tar.bz2", [local_tar, 'cjf'], [remote_tar, 'xjf'])
+            when :zip         then Compression.new("zip",     %w(zip -qr), %w(unzip -q))
+            else raise ArgumentError, "invalid compression type #{type.inspect}"
+            end
+          end
+          
+          # Returns the command necessary to compress the given directory
+          # into the given file.
+          def compress(directory, file)
+            compression.compress_command + [file, directory]
+          end
+
+          # Returns the command necessary to decompress the given file,
+          # relative to the current working directory. It must also
+          # preserve the directory structure in the file.
+          def decompress(file)
+            compression.decompress_command + [file]
+          end
+      end
+
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/strategy/filter.rb

@@ -0,0 +1,423 @@
+# 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.
+
+
+require 'erb'
+require 'rake'
+
+  # A filter knows how to copy files from one directory to another, applying mappings to the
+  # contents of these files.
+  #
+  # You can specify the mapping using a Hash, and it will map ${key} fields found in each source
+  # file into the appropriate value in the target file. For example:
+  #
+  #   filter.using 'version'=>'1.2', 'build'=>Time.now
+  #
+  # will replace all occurrences of <tt>${version}</tt> with <tt>1.2</tt>, and <tt>${build}</tt>
+  # with the current date/time.
+  #
+  # You can also specify the mapping by passing a proc or a method, that will be called for
+  # each source file, with the file name and content, returning the modified content.
+  #
+  # Without any mapping, the filter simply copies files from the source directory into the target
+  # directory.
+  #
+  # A filter has one target directory, but you can specify any number of source directories,
+  # either when creating the filter or calling #from. Include/exclude patterns are specified
+  # relative to the source directories, so:
+  #   filter.include '*.png'
+  # will only include PNG files from any of the source directories.
+  # In the same way, you can use regular expressions, so:
+  #   filter.include /picture_.*\.png/
+  # will only include PNG files starting with picture_ from any of the sources directories.
+  #
+  # See Buildr#filter.
+  class Filter
+
+    def initialize #:nodoc:
+      clear
+      @force = true
+    end
+
+    # Returns the list of source directories (each being a file task).
+    attr_reader :sources
+
+    # :call-seq:
+    #   clear => self
+    #
+    # Clear filter sources and include/exclude patterns
+    def clear
+      @include = []
+      @exclude = []
+      @sources = Rake::FileList[]
+      @mapper = Mapper.new
+      self
+    end
+    
+    def force
+        @force = true
+        self
+    end
+    
+    def noforce
+        @force = false
+        self
+    end
+
+    # :call-seq:
+    #   from(*sources) => self
+    #
+    # Adds additional directories from which to copy resources.
+    #
+    # For example:
+    #   filter.from('src').into('target').using('build'=>Time.now)
+    def from(*sources)
+      @sources |= sources.flatten.map { |dir| file(File.expand_path(dir.to_s)) }
+      self
+    end
+
+    # The target directory as a file task.
+    def target
+      return nil unless @target_dir
+      unless @target
+        @target = file(File.expand_path(@target_dir)) { |task| run if @target == task }
+        @target.enhance @include.select {|f| f.is_a?(Rake::FileTask)}
+        @target.enhance @exclude.select {|f| f.is_a?(Rake::FileTask)}
+        @target.enhance copy_map.values
+      end
+      @target
+    end
+
+    # :call-seq:
+    #   into(dir) => self
+    #
+    # Sets the target directory into which files are copied and returns self.
+    #
+    # For example:
+    #   filter.from('src').into('target').using('build'=>Time.now)
+    def into(dir)
+      @target_dir = dir.to_s
+      @target = nil
+      self
+    end
+
+    # :call-seq:
+    #   include(*files) => self
+    #
+    # Specifies files to include and returns self. See FileList#include.
+    #
+    # By default all files are included. You can use this method to only include specific
+    # files from the source directory.
+    def include(*files)
+      @include += files.flatten
+      self
+    end
+    alias :add :include
+
+    # :call-seq:
+    #   exclude(*files) => self
+    #
+    # Specifies files to exclude and returns self. See FileList#exclude.
+    def exclude(*files)
+      @exclude += files.flatten
+      self
+    end
+
+    # The mapping. See #using.
+    def mapping #:nodoc:
+      @mapper.config
+    end
+
+    # The mapper to use. See #using.
+    def mapper #:nodoc:
+      @mapper.mapper_type
+    end
+
+    # :call-seq:
+    #   using(mapping) => self
+    #   using { |file_name, contents| ... } => self
+    #
+    # Specifies the mapping to use and returns self.
+    #
+    # The most typical mapping uses a Hash, and the default mapping uses the Maven style, so
+    # <code>${key}</code> are mapped to the values. You can change that by passing a different
+    # format as the first argument. Currently supports:
+    # * :ant -- Map <code>@key@</code>.
+    # * :maven -- Map <code>${key}</code> (default).
+    # * :ruby -- Map <code>#{key}</code>.
+    # * :erb -- Map <code><%= key %></code>.
+    # * Regexp -- Maps the matched data (e.g. <code>/=(.*?)=/</code>
+    #
+    # For example:
+    #   filter.using 'version'=>'1.2'
+    # Is the same as:
+    #   filter.using :maven, 'version'=>'1.2'
+    #
+    # You can also pass a proc or method. It will be called with the file name and content,
+    # to return the mapped content.
+    #
+    # Without any mapping, all files are copied as is.
+    #
+    # To register new mapping type see the Mapper class.
+    def using(*args, &block)
+      @mapper.using(*args, &block)
+      self
+    end
+
+    def recursive_with_dot_files(*dirs)
+      FileList[dirs.map { |dir| File.join(dir, '/**/{*,.*}') }].reject { |file| File.basename(file) =~ /^[.]{1,2}$/ }
+    end
+
+    def relative_path(to, from = '.')
+      to = Pathname.new(to).cleanpath
+      return to.to_s if from.nil?
+      to_path = Pathname.new(File.expand_path(to.to_s, "/"))
+      from_path = Pathname.new(File.expand_path(from.to_s, "/"))
+      to_path.relative_path_from(from_path).to_s
+    end
+
+    # :call-seq:
+    #    run => boolean
+    #
+    # Runs the filter.
+    def run
+      copy_map = copy_map()
+
+      mkpath target.to_s
+      return false if copy_map.empty?
+
+      copy_map.each do |path, source|
+        dest = File.expand_path(path, target.to_s)
+        if File.directory?(source)
+          mkpath dest
+        else
+          mkpath File.dirname(dest)
+          if @mapper.mapper_type
+            mapped = @mapper.transform(File.open(source, 'rb') { |file| file.read }, path)
+            File.open(dest, 'wb') { |file| file.write mapped }
+          else # no mapping
+            cp source, dest
+          end
+        end
+        File.chmod(File.stat(source).mode | 0200, dest)
+      end
+      touch target.to_s
+      true
+    end
+
+    # Returns the target directory.
+    def to_s
+      target.to_s
+    end
+
+  protected
+  
+    # :call-seq:
+    #   pattern_match(file, pattern) => boolean
+    # 
+    # This method returns true if the file name matches the pattern.
+    # The pattern may be a String, a Regexp or a Proc.
+    #
+    def pattern_match(file, pattern)
+      case
+      when pattern.is_a?(Regexp)
+        return file.match(pattern)
+      when pattern.is_a?(String)
+        return File.fnmatch(pattern, file)
+      when pattern.is_a?(Proc)
+        return pattern.call(file)
+      when pattern.is_a?(Rake::FileTask)
+        return pattern.to_s.match(file)
+      else
+        raise "Cannot interpret pattern #{pattern}"
+      end
+    end
+
+  private
+    def copy_map
+      sources.each { |source| raise "Source directory #{source} doesn't exist" unless File.exist?(source.to_s) }
+      raise 'No target directory specified, where am I going to copy the files to?' if target.nil?
+
+      sources.flatten.map(&:to_s).inject({}) do |map, source|
+        files = recursive_with_dot_files(source).
+          map { |file| relative_path(file, source) }.
+          select { |file| @include.empty? || @include.any? { |pattern| pattern_match(file, pattern) } }.
+          reject { |file| @exclude.any? { |pattern| pattern_match(file, pattern) } }
+        files.each do |file|
+          src, dest = File.expand_path(file, source), File.expand_path(file, target.to_s)
+          map[file] = src if !File.exist?(dest) || File.stat(src).mtime >= File.stat(dest).mtime || @force
+        end
+        map
+      end
+    end
+
+    # This class implements content replacement logic for Filter.
+    #
+    # To register a new template engine @:foo@, extend this class with a method like:
+    #
+    #   def foo_transform(content, path = nil)
+    #      # if this method yields a key, the value comes from the mapping hash
+    #      content.gsub(/world/) { |str| yield :bar }
+    #   end
+    #
+    # Then you can use :foo mapping type on a Filter
+    #
+    #   filter.using :foo, :bar => :baz
+    #
+    # Or all by your own, simply
+    #
+    #   Mapper.new(:foo, :bar => :baz).transform("Hello world") # => "Hello baz"
+    #
+    # You can handle configuration arguments by providing a @*_config@ method like:
+    #
+    #   # The return value of this method is available with the :config accessor.
+    #   def moo_config(*args, &block)
+    #      raise ArgumentError, "Expected moo block" unless block_given?
+    #      { :moos => args, :callback => block }
+    #   end
+    #
+    #   def moo_transform(content, path = nil)
+    #      content.gsub(/moo+/i) do |str|
+    #        moos = yield :moos # same than config[:moos]
+    #        moo = moos[str.size - 3] || str
+    #        config[:callback].call(moo)
+    #      end
+    #   end
+    #
+    # Usage for the @:moo@ mapper would be something like:
+    #
+    #   mapper = Mapper.new(:moo, 'ooone', 'twoo') do |str|
+    #     i = nil; str.capitalize.gsub(/\w/) { |s| s.send( (i = !i) ? 'upcase' : 'downcase' ) }
+    #   end
+    #   mapper.transform('Moo cow, mooo cows singing mooooo') # => 'OoOnE cow, TwOo cows singing MoOoOo'
+    class Mapper
+
+      attr_reader :mapper_type, :config
+
+      def initialize(*args, &block) #:nodoc:
+        using(*args, &block)
+      end
+
+      def using(*args, &block)
+        case args.first
+        when Hash # Maven hash mapping
+          using :maven, *args
+        when Binding # Erb binding
+          using :erb, *args
+        when Symbol # Mapping from a method
+          raise ArgumentError, "Unknown mapping type: #{args.first}" unless respond_to?("#{args.first}_transform", true)
+          configure(*args, &block)
+        when Regexp # Mapping using a regular expression
+          raise ArgumentError, 'Expected regular expression followed by mapping hash' unless args.size == 2 && Hash === args[1]
+          @mapper_type, @config = *args
+        else
+          unless args.empty? && block.nil?
+            raise ArgumentError, 'Expected proc, method or a block' if args.size > 1 || (args.first && block)
+            @mapper_type = :callback
+            config = args.first || block
+            raise ArgumentError, 'Expected proc, method or callable' unless config.respond_to?(:call)
+            @config = config
+          end
+        end
+        self
+      end
+
+      def transform(content, path = nil)
+        type = Regexp === mapper_type ? :regexp : mapper_type
+        raise ArgumentError, "Invalid mapper type: #{type.inspect}" unless respond_to?("#{type}_transform", true)
+        self.__send__("#{type}_transform", content, path) { |key| config[key] || config[key.to_s.to_sym] }
+      end
+
+     private
+      def configure(mapper_type, *args, &block)
+        configurer = method("#{mapper_type}_config") rescue nil
+        if configurer
+          @config = configurer.call(*args, &block)
+        else
+          raise ArgumentError, "Missing hash argument after :#{mapper_type}" unless args.size == 1 && Hash === args[0]
+          @config = {} unless Hash === @config
+          args.first.each_pair { |k, v| @config[k] = v.to_s }
+        end
+        @mapper_type = mapper_type
+      end
+
+      def maven_transform(content, path = nil)
+        content.gsub(/\$\{.*?\}/) { |str| yield(str[2..-2]) || str }
+      end
+
+      def ant_transform(content, path = nil)
+        content.gsub(/@.*?@/) { |str| yield(str[1..-2]) || str }
+      end
+
+      def ruby_transform(content, path = nil)
+        content.gsub(/#\{.*?\}/) { |str| yield(str[2..-2]) || str }
+      end
+
+      def regexp_transform(content, path = nil)
+        content.gsub(mapper_type) { |str| yield(str.scan(mapper_type).join) || str }
+      end
+
+      def callback_transform(content, path = nil)
+        config.call(path, content)
+      end
+
+      def erb_transform(content, path = nil)
+        case config
+        when Binding
+          bnd = config
+        when Hash
+          bnd = OpenStruct.new
+          table = config.inject({}) { |h, e| h[e.first.to_sym] = e.last; h }
+          bnd.instance_variable_set(:@table, table)
+          bnd = bnd.instance_eval { binding }
+        else
+          bnd = config.instance_eval { binding }
+        end
+        require 'erb'
+        ERB.new(content).result(bnd)
+      end
+
+      def erb_config(*args, &block)
+        if block_given?
+          raise ArgumentError, "Expected block or single argument, but both given." unless args.empty?
+          block
+        elsif args.size > 1
+          raise ArgumentError, "Expected block or single argument."
+        else
+          args.first
+        end
+      end
+
+    end # class Mapper
+
+  end
+
+  # :call-seq:
+  #   filter(*source) => Filter
+  #
+  # Creates a filter that will copy files from the source directory(ies) into the target directory.
+  # You can extend the filter to modify files by mapping <tt>${key}</tt> into values in each
+  # of the copied files, and by including or excluding specific files.
+  #
+  # A filter is not a task, you must call the Filter#run method to execute it.
+  #
+  # For example, to copy all files from one directory to another:
+  #   filter('src/files').into('target/classes').run
+  # To include only the text files, and replace each instance of <tt>${build}</tt> with the current
+  # date/time:
+  #   filter('src/files').into('target/classes').include('*.txt').using('build'=>Time.now).run
+  def filter(*sources)
+    Filter.new.from(*sources)
+  end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: capistrano-filter
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  version: "0.2"
+platform: ruby
+authors: 
+- "@"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-13 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 2
+        - 5
+        - 19
+        version: 2.5.19
+  type: :runtime
+  version_requirements: *id001
+description: ops
+email: 
+- "@"
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/capistrano/ext/filter.rb
+- lib/capistrano/recipes/deploy/strategy/filter.rb
+- lib/capistrano/recipes/deploy/strategy/copy_and_filter.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: capistrano-filter
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: possibilita o uso de filtro no deploy pelo capistrano
+test_files: []
+