filelist 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jakub Stastny aka Botanicus
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+GEM_NAME = "filelist"
+AUTHOR = "Jakub Stastny aka Botanicus"
+EMAIL = "knava.bestvinensis@gmail.com"
+HOMEPAGE = "http://101Ideas.cz/"
+SUMMARY = "FileList from Rake"
+GEM_VERSION = "0.0.1"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.textile", "LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README.textile Rakefile) + Dir.glob("{lib,spec}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Create a gemspec file"
+task :gemspec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+def sudo_gem(cmd)
+  sh "#{SUDO} #{RUBY} -S gem #{cmd}", :verbose => false
+end
+
+desc "Install #{GEM_NAME} #{GEM_VERSION}"
+task :install => [ :package ] do
+  sudo_gem "install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources"
+end
+
+desc "Uninstall #{GEM_NAME} #{GEM_VERSION}"
+task :uninstall => [ :clobber ] do
+  sudo_gem "uninstall #{GEM_NAME} -v#{GEM_VERSION} -Ix"
+end
+
+require 'spec/rake/spectask'
+desc 'Default: run spec examples'
+task :default => 'spec'

data/TODO

@@ -0,0 +1,2 @@
+- find another useful stuff in rake, not just filelist
+- cp filelist's tests

data/filelist.gemspec

@@ -0,0 +1,23 @@
+#!/usr/bin/env gem build
+# coding: utf-8
+
+begin
+  require "rubygems/specification"
+rescue SecurityError
+  # http://gems.github.com
+end
+
+VERSION  = "0.0.1"
+SPECIFICATION = ::Gem::Specification.new do |s|
+  s.name = "filelist"
+  s.version = VERSION
+  s.authors = ["Jakub Šťastný aka Botanicus"]
+  s.homepage = "http://github.com/botanicus/filelist"
+  s.summary = "FileList is taken from Rake"
+  s.description = "" # TODO: long description
+  s.cert_chain = nil
+  s.email = ["knava.bestvinensis", "gmail.com"].join("@")
+  s.files = Dir.glob("**/*") - Dir.glob("pkg/*")
+  s.require_paths = ["lib"]
+  # s.required_ruby_version = ::Gem::Requirement.new(">= 1.9.1")
+end

data/lib/filelist.rb

@@ -0,0 +1,396 @@
+# stolen directly from rake
+module Cloneable
+  # Clone an object by making a new object and setting all the instance
+  # variables to the same values.
+  def dup
+    sibling = self.class.new
+    instance_variables.each do |ivar|
+      value = self.instance_variable_get(ivar)
+      new_value = value.clone rescue value
+      sibling.instance_variable_set(ivar, new_value)
+    end
+    sibling.taint if tainted?
+    sibling
+  end
+
+  def clone
+    sibling = dup
+    sibling.freeze if frozen?
+    sibling
+  end
+end
+
+class FileList
+
+  include Cloneable
+
+  # == Method Delegation
+  #
+  # The lazy evaluation magic of FileLists happens by implementing all the
+  # array specific methods to call +resolve+ before delegating the heavy
+  # lifting to an embedded array object (@items).
+  #
+  # In addition, there are two kinds of delegation calls.  The regular kind
+  # delegates to the @items array and returns the result directly.  Well,
+  # almost directly.  It checks if the returned value is the @items object
+  # itself, and if so will return the FileList object instead.
+  #
+  # The second kind of delegation call is used in methods that normally
+  # return a new Array object.  We want to capture the return value of these
+  # methods and wrap them in a new FileList object.  We enumerate these
+  # methods in the +SPECIAL_RETURN+ list below.
+
+  # List of array methods (that are not in +Object+) that need to be
+  # delegated.
+  ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).map { |n| n.to_s }
+
+  # List of additional methods that must be delegated.
+  MUST_DEFINE = %w[to_a inspect]
+
+  # List of methods that should not be delegated here (we define special
+  # versions of them explicitly below).
+  MUST_NOT_DEFINE = %w[to_a to_ary partition *]
+
+  # List of delegated methods that return new array values which need
+  # wrapping.
+  SPECIAL_RETURN = %w[
+    map collect sort sort_by select find_all reject grep
+    compact flatten uniq values_at
+    + - & |
+  ]
+
+  DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).collect{ |s| s.to_s }.sort.uniq
+
+  # Now do the delegation.
+  DELEGATING_METHODS.each_with_index do |sym, i|
+    if SPECIAL_RETURN.include?(sym)
+      ln = __LINE__+1
+      class_eval %{
+        def #{sym}(*args, &block)
+          resolve
+          result = @items.send(:#{sym}, *args, &block)
+          FileList.new.import(result)
+        end
+      }, __FILE__, ln
+    else
+      ln = __LINE__+1
+      class_eval %{
+        def #{sym}(*args, &block)
+          resolve
+          result = @items.send(:#{sym}, *args, &block)
+          result.object_id == @items.object_id ? self : result
+        end
+      }, __FILE__, ln
+    end
+  end
+
+  # Create a file list from the globbable patterns given.  If you wish to
+  # perform multiple includes or excludes at object build time, use the
+  # "yield self" pattern.
+  #
+  # Example:
+  #   file_list = FileList.new('lib/**/*.rb', 'test/test*.rb')
+  #
+  #   pkg_files = FileList.new('lib/**/*') do |fl|
+  #     fl.exclude(/\bCVS\b/)
+  #   end
+  #
+  def initialize(*patterns)
+    @pending_add = []
+    @pending = false
+    @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+    @exclude_procs = DEFAULT_IGNORE_PROCS.dup
+    @exclude_re = nil
+    @items = []
+    patterns.each { |pattern| include(pattern) }
+    yield self if block_given?
+  end
+
+  # Add file names defined by glob patterns to the file list.  If an array
+  # is given, add each element of the array.
+  #
+  # Example:
+  #   file_list.include("*.java", "*.cfg")
+  #   file_list.include %w( math.c lib.h *.o )
+  #
+  def include(*filenames)
+    # TODO: check for pending
+    filenames.each do |fn|
+      if fn.respond_to? :to_ary
+        include(*fn.to_ary)
+      else
+        @pending_add << fn
+      end
+    end
+    @pending = true
+    self
+  end
+  alias :add :include
+
+  # Register a list of file name patterns that should be excluded from the
+  # list.  Patterns may be regular expressions, glob patterns or regular
+  # strings.  In addition, a block given to exclude will remove entries that
+  # return true when given to the block.
+  #
+  # Note that glob patterns are expanded against the file system. If a file
+  # is explicitly added to a file list, but does not exist in the file
+  # system, then an glob pattern in the exclude list will not exclude the
+  # file.
+  #
+  # Examples:
+  #   FileList['a.c', 'b.c'].exclude("a.c") => ['b.c']
+  #   FileList['a.c', 'b.c'].exclude(/^a/)  => ['b.c']
+  #
+  # If "a.c" is a file, then ...
+  #   FileList['a.c', 'b.c'].exclude("a.*") => ['b.c']
+  #
+  # If "a.c" is not a file, then ...
+  #   FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c']
+  #
+  def exclude(*patterns, &block)
+    patterns.each do |pat|
+      @exclude_patterns << pat
+    end
+    if block_given?
+      @exclude_procs << block
+    end
+    resolve_exclude if ! @pending
+    self
+  end
+
+
+  # Clear all the exclude patterns so that we exclude nothing.
+  def clear_exclude
+    @exclude_patterns = []
+    @exclude_procs = []
+    calculate_exclude_regexp if ! @pending
+    self
+  end
+
+  # Define equality.
+  def ==(array)
+    to_ary == array
+  end
+
+  # Return the internal array object.
+  def to_a
+    resolve
+    @items
+  end
+
+  # Return the internal array object.
+  def to_ary
+    to_a
+  end
+
+  # Lie about our class.
+  def is_a?(klass)
+    klass == Array || super(klass)
+  end
+  alias kind_of? is_a?
+
+  # Redefine * to return either a string or a new file list.
+  def *(other)
+    result = @items * other
+    case result
+    when Array
+      FileList.new.import(result)
+    else
+      result
+    end
+  end
+
+  # Resolve all the pending adds now.
+  def resolve
+    if @pending
+      @pending = false
+      @pending_add.each do |fn| resolve_add(fn) end
+      @pending_add = []
+      resolve_exclude
+    end
+    self
+  end
+
+  def calculate_exclude_regexp
+    ignores = []
+    @exclude_patterns.each do |pat|
+      case pat
+      when Regexp
+        ignores << pat
+      when /[*?]/
+        Dir[pat].each do |p| ignores << p end
+      else
+        ignores << Regexp.quote(pat)
+      end
+    end
+    if ignores.empty?
+      @exclude_re = /^$/
+    else
+      re_str = ignores.collect { |p| "(" + p.to_s + ")" }.join("|")
+      @exclude_re = Regexp.new(re_str)
+    end
+  end
+
+  def resolve_add(fn)
+    case fn
+    when %r{[*?\[\{]}
+      add_matching(fn)
+    else
+      self << fn
+    end
+  end
+  private :resolve_add
+
+  def resolve_exclude
+    calculate_exclude_regexp
+    reject! { |fn| exclude?(fn) }
+    self
+  end
+  private :resolve_exclude
+
+  # Return a new FileList with the results of running +sub+ against each
+  # element of the oringal list.
+  #
+  # Example:
+  #   FileList['a.c', 'b.c'].sub(/\.c$/, '.o')  => ['a.o', 'b.o']
+  #
+  def sub(pat, rep)
+    inject(FileList.new) { |res, fn| res << fn.sub(pat,rep) }
+  end
+
+  # Return a new FileList with the results of running +gsub+ against each
+  # element of the original list.
+  #
+  # Example:
+  #   FileList['lib/test/file', 'x/y'].gsub(/\//, "\\")
+  #      => ['lib\\test\\file', 'x\\y']
+  #
+  def gsub(pat, rep)
+    inject(FileList.new) { |res, fn| res << fn.gsub(pat,rep) }
+  end
+
+  # Same as +sub+ except that the oringal file list is modified.
+  def sub!(pat, rep)
+    each_with_index { |fn, i| self[i] = fn.sub(pat,rep) }
+    self
+  end
+
+  # Same as +gsub+ except that the original file list is modified.
+  def gsub!(pat, rep)
+    each_with_index { |fn, i| self[i] = fn.gsub(pat,rep) }
+    self
+  end
+
+  # Apply the pathmap spec to each of the included file names, returning a
+  # new file list with the modified paths.  (See String#pathmap for
+  # details.)
+  def pathmap(spec=nil)
+    collect { |fn| fn.pathmap(spec) }
+  end
+
+  # Return a new array with <tt>String#ext</tt> method applied to each
+  # member of the array.
+  #
+  # This method is a shortcut for:
+  #
+  #    array.collect { |item| item.ext(newext) }
+  #
+  # +ext+ is a user added method for the Array class.
+  def ext(newext='')
+    collect { |fn| fn.ext(newext) }
+  end
+
+
+  # Grep each of the files in the filelist using the given pattern. If a
+  # block is given, call the block on each matching line, passing the file
+  # name, line number, and the matching line of text.  If no block is given,
+  # a standard emac style file:linenumber:line message will be printed to
+  # standard out.
+  def egrep(pattern)
+    each do |fn|
+      open(fn) do |inf|
+        count = 0
+        inf.each do |line|
+          count += 1
+          if pattern.match(line)
+            if block_given?
+              yield fn, count, line
+            else
+              puts "#{fn}:#{count}:#{line}"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # Return a new file list that only contains file names from the current
+  # file list that exist on the file system.
+  def existing
+    select { |fn| File.exist?(fn) }
+  end
+
+  # Modify the current file list so that it contains only file name that
+  # exist on the file system.
+  def existing!
+    resolve
+    @items = @items.select { |fn| File.exist?(fn) }
+    self
+  end
+
+  # FileList version of partition.  Needed because the nested arrays should
+  # be FileLists in this version.
+  def partition(&block)       # :nodoc:
+    resolve
+    result = @items.partition(&block)
+    [
+      FileList.new.import(result[0]),
+      FileList.new.import(result[1]),
+    ]
+  end
+
+  # Convert a FileList to a string by joining all elements with a space.
+  def to_s
+    resolve
+    self.join(' ')
+  end
+
+  # Add matching glob patterns.
+  def add_matching(pattern)
+    Dir[pattern].each do |fn|
+      self << fn unless exclude?(fn)
+    end
+  end
+  private :add_matching
+
+  # Should the given file name be excluded?
+  def exclude?(fn)
+    calculate_exclude_regexp unless @exclude_re
+    fn =~ @exclude_re || @exclude_procs.any? { |p| p.call(fn) }
+  end
+
+  DEFAULT_IGNORE_PATTERNS = [
+    /(^|[\/\\])CVS([\/\\]|$)/,
+    /(^|[\/\\])\.svn([\/\\]|$)/,
+    /\.bak$/,
+    /~$/
+  ]
+  DEFAULT_IGNORE_PROCS = [
+    proc { |fn| fn =~ /(^|[\/\\])core$/ && ! File.directory?(fn) }
+  ]
+#    @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup
+
+  def import(array)
+    @items = array
+    self
+  end
+
+  class << self
+    # Create a new file list including the files listed. Similar to:
+    #
+    #   FileList.new(*args)
+    def [](*args)
+      new(*args)
+    end
+  end
+end # FileList

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: filelist
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Jakub \xC5\xA0\xC5\xA5astn\xC3\xBD aka Botanicus"
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2009-12-31 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: knava.bestvinensis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- filelist.gemspec
+- lib/filelist.rb
+- LICENSE
+- Rakefile
+- README.textile
+- TODO
+has_rdoc: true
+homepage: http://github.com/botanicus/filelist
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: FileList is taken from Rake
+test_files: []
+