sherlock 0.1.0

data/lib/collection/base.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby -wKU
+
+module Sherlock
+  module Collection
+    class Base < Array
+      def initialize(arr = [], opts = {})
+        super(0)
+        self.concat filter_array_by_options(arr, opts)
+      end
+      
+      # Returns the first value of the collection (matching the value, if given).
+      def first(*value)
+        item = if value.empty?
+          super
+        else
+          filter(value)[0]
+        end
+        new([item])
+      end
+    
+      # Returns a collection with all files matching the
+      # given pattern.
+      def select_items_matching(*pattern)
+        opts = pattern.last.is_a?(Hash) ? pattern.pop : {}
+        pattern = [pattern].flatten
+        arr = select { |f| pattern.empty? || matching?(f, pattern) }
+        arr = filter_array_by_options(arr, opts)
+        new(arr, opts)
+      end
+      alias filter select_items_matching
+  
+      def [](value, *args)
+        if [String, Regexp, Array, Hash].include?(value.class) #value.is_a?(Regexp)
+          filter(value, *args)
+        else
+          super(value)
+        end
+      end
+    
+      def -(other)
+        new(super)
+      end
+    
+      def +(other)
+        new(super.uniq)
+      end
+    
+      def &(other)
+        new(super)
+      end
+    
+      def |(other)
+        new(super)
+      end
+    
+      private
+
+      def filter_array_by_options(arr, opts = {})
+        arr = arr.select { |f| matching?(f, opts[:only]) } if opts[:only]
+        arr = arr.reject { |f| matching?(f, opts[:except]) } if opts[:except]
+        arr
+      end
+
+      def matching?(str, string_or_regexp_or_array)
+        [string_or_regexp_or_array].flatten.each { |pattern|
+          return true if str.match(pattern)
+        }
+        false
+      end
+    
+      def new(*args)
+        self.class.new(*args)
+      end
+    end
+  end
+end

data/lib/collection/files.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby -wKU
+
+module Sherlock
+  module Collection
+    class Files < Base
+  
+      def initialize(glob_or_regex, opts = {})
+        if glob_or_regex.is_a?(Hash)
+          opts = glob_or_regex
+        elsif glob_or_regex.is_a?(Array)
+          opts[:arr] = glob_or_regex
+        elsif glob_or_regex.is_a?(String)
+          opts[:glob] = glob_or_regex
+        elsif glob_or_regex.is_a?(Regexp)
+          if opts[:only]
+            raise "Cannot use regexp and :only-option at the same time."
+          else
+            opts[:only] = glob_or_regex
+          end
+        end
+        opts = {:glob => '*'}.merge(opts)
+        super(opts[:arr] || Dir[opts[:glob]], opts)
+      end
+  
+      # Returns all the lines matching the given pattern.
+      def collect_lines_matching(pattern, &block)
+        pattern = [pattern].flatten
+        lines = Lines.new
+        self.each { |f|
+          io = File.open(f)
+          io.each { |line|
+            if matching?(line, pattern)
+              lines << MatchedLine.new(line, :file => f, :line_number => io.lineno, :pattern => pattern)
+            end
+          }
+        }
+        lines
+      end
+      alias old_collect collect
+      alias collect collect_lines_matching
+      
+      # Returns a FileCollection with all files containing the
+      # given content / matching the given pattern.
+      def select_files_containing(pattern)
+        pattern = [pattern].flatten
+        arr = select { |f| matching?(File.read(f), pattern) }
+        new(arr)
+      end
+      alias containing select_files_containing
+
+      # Returns a FileCollection with all files not containing the
+      # given content / matching the given pattern.
+      def select_files_not_containing(pattern)
+        pattern = [pattern].flatten
+        arr = select { |f| !matching?(File.read(f), pattern) }
+        new(arr)
+      end
+      alias not_containing select_files_not_containing
+    end
+  end
+end

data/lib/collection/lines.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby -wKU
+
+module Sherlock
+  module Collection
+    class Lines < Base
+      # Executes gsub on all lines in the collection and returns
+      # the modified collection.
+      def gsub(*args, &block)
+        arr = map { |line| line.gsub(*args, &block) }
+        new(arr)
+      end
+    
+      # Returns an array of the lines' match_data objects without the 
+      # 'overall' match (the first element of the MatchData object).
+      def matches
+        map { |line| line.match_data[1..line.match_data.length-1] }
+      end
+      
+      def new(arr, opts = {}) # :nodoc:
+        self.class.new(arr)
+      end
+      
+      def save!
+        sort_by { |line| line.line_number }.reverse.each(&:save!)
+      end
+      
+      def to_s
+        map { |line| (line.changed? ? '[C] ' : '[ ] ') + line.inspect }.join("\n")
+      end
+      alias inspect to_s
+    end
+  end
+end

data/lib/collection/matched_line.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby -wKU
+
+module Sherlock
+  module Collection
+    
+    # ==== Attributes
+    # 
+    # * <tt>:file</tt>
+    # * <tt>:line_number</tt>
+    # * <tt>:pattern</tt>
+    #
+    class MatchedLine < String
+      attr_accessor :attributes
+
+      def initialize(line, _attributes = {})
+        super(line)
+        self.attributes = {:original => line}.merge(_attributes)
+      end
+      
+      def changed?
+        attributes[:original] != self
+      end
+      
+      def gsub(*args, &block)
+        self.class.new(super, attributes)
+      end
+      
+      def match_data
+        attributes[:pattern].each do |p|
+          if m = self.match(p)
+            return m
+          end
+        end
+        nil
+      end
+      
+      def method_missing(m)
+        if attributes && value = attributes[m.to_s.intern]
+          value
+        else
+          super
+        end
+      end
+      
+      def save!
+        all_lines = File.open(file, 'r') { |f| f.readlines }
+        index = line_number - 1
+        if original == all_lines[index]
+          all_lines[index] = self.to_s
+        else
+          raise "File seems modified: #{file}"
+        end
+        File.open(file, 'w') {|f| f.write(all_lines) }
+      end
+    end
+  end
+end

data/lib/collection.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby -wKU
+
+sub_dir = File.basename(__FILE__, '.rb')
+all_files = Dir[File.join(File.dirname(__FILE__), sub_dir, '*.rb')]
+all_files.sort.map { |f| File.basename(f, '.rb') }.each do |_module|
+  require File.join(File.dirname(__FILE__), sub_dir, _module)
+end
+

data/lib/core_ext.rb

@@ -0,0 +1,42 @@
+
+class ::Object
+  #:call-seq:
+  #   obj.full?
+  #   obj.full? { |f| ... }
+  #
+  # Returns wheter or not the given obj is not blank?.
+  # If a block is given and the obj is full?, the obj is yielded to that block.
+  # 
+  #   salary = nil
+  #   salary.full? # => nil
+  #   salary.full? { |s| "#{s} $" } # => nil
+  #   salary = 100
+  #   salary.full? { |s| "#{s} $" } # => "100 $"
+  # 
+  # With ActiveSupport's implementation of Symbol#to_proc it is possible to write:
+  # 
+  #   current_user.full?(&:name) # => "Dave"
+  def full?
+    f = blank? ? nil : self
+    if block_given? and f
+      yield f
+    else
+      f
+    end
+  end
+end
+
+class ::Symbol
+  # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
+  #
+  #   # The same as people.collect { |p| p.name }
+  #   people.collect(&:name)
+  #
+  #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
+  #   people.select(&:manager?).collect(&:salary)
+  #
+  # (borrowed from ActiveSupport)
+  def to_proc
+    Proc.new { |*args| args.shift.__send__(self, *args) }
+  end
+end

data/lib/latex.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby -wKU
+
+module Sherlock
+  module LaTex
+    class << self
+      def included(base)
+        base.__send__(:include, InstanceMethods)
+        Sherlock::Collection::Files.__send__(:include, Collection::Files::InstanceMethods)
+      end
+    end
+    
+    module InstanceMethods
+      def tex_files(opts = {})
+        investigate('**/*.tex', opts)
+      end
+    end
+    
+    module Collection
+      module Files
+        module InstanceMethods
+          def collect_macros(pattern)
+            collect(/\\(#{pattern})(\{([^\}]+)\})*/)
+          end
+          alias macros collect_macros
+      
+          def inputs(opts = {})
+            macros(:input).filter(opts)
+          end
+      
+          def tagged(with_tag)
+            tag_prefix = "%%!!"
+            arr = [with_tag].flatten.map { |tag| "#{tag_prefix} #{tag}" }
+            containing(arr)
+          end
+    
+          def not_tagged(with_tag)
+            tag_prefix = "%%!!"
+            arr = [with_tag].flatten.map { |tag| "#{tag_prefix} #{tag}" }
+            not_containing(arr)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sherlock.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby -wKU
+
+# TODO: Output-Methoden für File- und Line-Collections, Tabellen, success & failure inkl. optionaler Colorierung.
+# TODO: vielleicht LaTex shortcuts à la tex_files.inputs(:only => 'generated/schema')
+
+%w(collection core_ext latex).each do |_module|
+  require File.join(File.dirname(__FILE__), _module)
+end
+
+module Sherlock
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    BUILD = 0
+
+    STRING = [MAJOR, MINOR, BUILD].join('.').freeze
+  end
+  
+  module InstanceMethods
+    def collect_files_matching(*args)
+      Sherlock::Collection::Files.new(*args)
+    end
+    alias investigate collect_files_matching
+  end
+  
+  class << self
+    def included(base)
+      base.__send__(:include, InstanceMethods)
+    end
+    include InstanceMethods
+    alias [] collect_files_matching
+  end
+end

data/spec/collection/base_spec.rb

@@ -0,0 +1,142 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Sherlock::Collection::Base do
+  def new_collection(arr = nil, opts = {})
+    arr ||= %w(eins zwei drei vier fünf)
+    Sherlock::Collection::Base.new(arr, opts)
+  end
+  
+  def filter_arguments
+    [
+      [['ei']],
+      [[/ei/]],
+      [['sieben', 'sechs', 'fünf', 'vier']],
+      [[/ei/, 'fünf'], {:only => /ei$/, :except => 'zwei'}],
+      [{:only => /ei$/, :except => 'zwei'}],
+    ]
+  end
+  
+  describe "#initialize" do
+    it "creates an empty collection without arguments" do
+      empty_collection = Sherlock::Collection::Base.new
+      empty_collection.should be_empty
+    end
+    it "creates a full collection for a given array" do
+      collection = new_collection([:foo, :bar])
+      collection.should_not be_empty
+    end
+    it "creates a full collection for a given collection" do
+      collection = new_collection(new_collection)
+      collection.should_not be_empty
+    end
+  end
+  
+  describe "#first" do
+    it "should give a collection with the first matching element for a string" do
+      collection = new_collection.first('ei')
+      collection.should == new_collection(%w(eins))
+    end
+    it "should give a collection with the first matching element for a regexp" do
+      collection = new_collection.first(/ei/)
+      collection.should == new_collection(%w(eins))
+    end
+    it "should give a collection with the first matching element for an array of strings" do
+      collection = new_collection.first(%w(sieben sechs fünf))
+      collection.should == new_collection(%w(fünf))
+    end
+    it "should give a collection with the first matching element for an array of regexps" do
+      collection = new_collection.first([/sieben/, /sechs/, /fünf/])
+      collection.should == new_collection(%w(fünf))
+    end
+    it "should give a collection with the first matching element for an array of strings and regexps" do
+      collection = new_collection.first([/sieben/, /sechs/, 'fünf'])
+      collection.should == new_collection(%w(fünf))
+    end
+  end
+  
+  describe "#filter" do
+    # without real arguments
+    it "should give the same collection without arguments" do
+      collection = new_collection.filter
+      collection.should == new_collection
+    end
+    it "should give the same collection with empty arguments" do
+      collection = new_collection.filter([], {})
+      collection.should == new_collection
+    end
+    
+    # without options
+    it "should give a collection with the matching elements for a string" do
+      collection = new_collection.filter('ei')
+      collection.should == new_collection(%w(eins zwei drei))
+    end
+    it "should give a collection with the matching elements for a regexp" do
+      collection = new_collection.filter(/ei/)
+      collection.should == new_collection(%w(eins zwei drei))
+    end
+    it "should give a collection with the matching elements for an array of strings" do
+      collection = new_collection.filter(%w(sieben sechs fünf vier))
+      collection.should == new_collection(%w(vier fünf))
+    end
+    it "should give a collection with the matching elements for an array of regexps" do
+      collection = new_collection.filter([/ei/, /sechs/, /fünf/])
+      collection.should == new_collection(%w(eins zwei drei fünf))
+    end
+    it "should give a collection with the matching elements for an array of strings and regexps" do
+      collection = new_collection.filter([/ei/, 'fünf'])
+      collection.should == new_collection(%w(eins zwei drei fünf))
+    end
+    
+    # with options
+    it "should accept options as only argument" do
+      collection = new_collection.filter(:except => 'zwei')
+      collection.should == new_collection(%w(eins drei vier fünf))
+    end
+    it "should accept options as only argument (chained)" do
+      collection = new_collection.filter([/ei/, 'fünf']).filter(:except => 'zwei')
+      collection.should == new_collection(%w(eins drei fünf))
+    end
+    it "should filter results with :except option" do
+      collection = new_collection.filter([/ei/, 'fünf'], :except => 'zwei')
+      collection.should == new_collection(%w(eins drei fünf))
+    end
+    it "should filter results with :only option" do
+      collection = new_collection.filter([/ei/, 'fünf'], :only => /ei$/)
+      collection.should == new_collection(%w(zwei drei))
+    end
+    it "should filter results with :only option first and :except option afterwards" do
+      collection = new_collection.filter([/ei/, 'fünf'], :only => /ei$/, :except => 'zwei')
+      collection.should == new_collection(%w(drei))
+    end
+  end
+  
+  describe "#[]" do
+    it "should be a shortcut for 'filter'" do
+      filter_arguments.each do |args|
+        new_collection[*args].should == new_collection.filter(*args)
+      end
+    end
+  end
+  
+  describe "#+" do
+    it "should combine two collections" do
+      collection1 = new_collection(nil, :only => 'eins')
+      collection2 = new_collection(nil, :only => 'zwei')
+      result = collection1 + collection2
+      result.should == new_collection(%w(eins zwei))
+    end
+  end
+  
+  describe "#-" do
+    it "should reduce two collections" do
+      collection1 = new_collection(nil, :only => /ei/)
+      collection2 = new_collection(nil, :only => 'zwei')
+      result = collection1 - collection2
+      result.should == new_collection(%w(eins drei))
+    end
+  end
+  
+  # TODO: tests für #& und #| schreiben
+  # TODO: testen, dass filter(), und first() und containing und so alle String, Regexp sowie [String/Regexp] nehmen
+  
+end

data/spec/collection/files_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Sherlock::Collection::Files do
+  def filtered_by_initialize(filter = {:only => /lines/})
+    text_files(filter)
+  end
+  
+  describe "#initialize" do
+    it "creates an collection of all text files" do
+      files = text_files
+      files.should_not be_empty
+    end
+    
+    it "filters text files by name" do
+      filtered_by_method = text_files.filter(:only => /lines/)
+      filtered_by_initialize.should == filtered_by_method
+    end
+  end
+  
+  describe "#collect" do
+    it "collects all lines beginning with a number and a dot." do
+      lines = text_files(:only => /lines/).collect(/^\d+\./)
+      lines.should_not be_empty
+    end
+    
+    it "tries to collect all lines beginning with a number and a dot." do
+      lines = text_files(:except => /lines/).collect(/^\d+\./)
+      lines.should be_empty
+    end
+  end
+  
+  describe "#select_files_containing" do
+    it "selects all text files containing numbered lists" do
+      files = text_files.containing(/^.*\d+\./)
+      files.should_not be_empty
+      files.should == text_files(:only => 'lines.txt')
+    end
+  end
+
+  describe "#select_files_not_containing" do
+    it "selects all text files not containing numbered lists" do
+      files = text_files.not_containing(/^.*\d+\./)
+      files.should_not be_empty
+      files.should == text_files(:except => 'lines.txt')
+    end
+  end
+end

data/spec/collection/lines_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Sherlock::Collection::Files do
+  def numbered_lines
+    text_files(:only => /lines/).collect(/^.*(\d+\.)(.+)/)
+  end
+  
+  describe "#initialize" do
+    it "creates an collection of lines looking like numbered lists" do
+      lines = numbered_lines
+      lines.should_not be_empty
+    end
+  end
+  
+  describe "#filter" do
+    it "filters a collection of lines" do
+      lines = numbered_lines
+      new_lines = lines.filter(:except => /^\d\./)
+      lines.count.should be > new_lines.count
+    end
+  end
+  
+  describe "#gsub" do
+    it "modifies a collection of lines" do
+      lines = numbered_lines
+      new_lines = lines.gsub(/^(.*)(\d+)(\..+)/) do |match|
+        "X #{match}"
+      end
+      new_lines.each do |line|
+        line.changed?.should == true
+      end
+    end
+  end
+  
+end

data/spec/collection/matched_line_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Sherlock::Collection::Files do
+  def some_line
+    lines = text_files.collect('Zeile')
+    lines[0]
+  end
+  
+  describe "#initialize" do
+    it "should be an unchanged line" do
+      some_line.changed?.should == false
+    end
+  end
+  
+  describe "#gsub" do
+    it "modifies a line" do
+      line = some_line
+      new_line = line.gsub(/^(.*)/, 'X \1')
+      new_line[0..0].should == 'X'
+      new_line.changed?.should == true
+      new_line[0..0].should != 'X'
+      line.changed?.should == false
+    end
+  end
+  
+end

data/spec/detective_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Sherlock do
+  describe "#investigate" do
+    it "creates a collection of all text files" do
+      files = Sherlock.investigate('**/*.txt')
+      files.should_not be_empty
+    end
+    
+    it "creates an empty collection" do
+      files = Sherlock.investigate('**/not-there')
+      files.should be_empty
+    end
+  end
+end

data/spec/fixtures/simple/lines.txt

@@ -0,0 +1,5 @@
+1. Eine Zeile
+2. Eine weitere Zeile
+3. Noch eine Zeile
+4. Die vierte Zeile
+5. Alle fuenf Zeilen

data/spec/fixtures/simple/lorem.txt

@@ -0,0 +1,19 @@
+Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. 
+
+Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. 
+
+Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. 
+
+Nam liber tempor cum soluta nobis eleifend option congue nihil imperdiet doming id quod mazim placerat facer possim assum. Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. 
+
+Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis. 
+
+At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, At accusam aliquyam diam diam dolore dolores duo eirmod eos erat, et nonumy sed tempor et et invidunt justo labore Stet clita ea et gubergren, kasd magna no rebum. sanctus sea sed takimata ut vero voluptua. est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat. 
+
+Consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus. 
+
+Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. 
+
+Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. 
+
+Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. 

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby -wKU
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'sherlock'
+
+require 'rubygems'
+require 'rspec'
+
+require 'fileutils'
+
+def text_files(opts = {})
+  Sherlock::Collection::Files.new('**/*.txt', opts)
+end
+
+def rebuild_test_data_dir!
+  FileUtils.rm_rf(test_data_dir)
+  FileUtils.mkdir_p(test_data_dir)
+  FileUtils.cp_r(original_test_data_dir, tmp_dir)
+end
+
+def original_test_data_dir
+  File.join(File.dirname(__FILE__), 'fixtures')
+end
+
+def test_data_dir
+  File.join(tmp_dir, 'fixtures')
+end
+
+def tmp_dir
+  File.join(File.dirname(__FILE__), '..', 'tmp')
+end
+
+RSpec.configure do |config|
+  config.before(:each) {
+    rebuild_test_data_dir!
+    Dir.chdir(test_data_dir)
+  }
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: sherlock
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- "Ren\xC3\xA9 F\xC3\xB6hring"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-10 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :runtime
+  version_requirements: *id001
+description: A library for filtering lists of files and performing actions on their content.
+email: rf@bamaru.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/collection/base.rb
+- lib/collection/files.rb
+- lib/collection/lines.rb
+- lib/collection/matched_line.rb
+- lib/collection.rb
+- lib/core_ext.rb
+- lib/latex.rb
+- lib/sherlock.rb
+- spec/collection/base_spec.rb
+- spec/collection/files_spec.rb
+- spec/collection/lines_spec.rb
+- spec/collection/matched_line_spec.rb
+- spec/detective_spec.rb
+- spec/fixtures/simple/lines.txt
+- spec/fixtures/simple/lorem.txt
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://bamaru.com
+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: 
+- none
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A library for filtering lists of files and performing actions on their content.
+test_files: []
+