sherlock 0.1.1 → 0.1.2

data/lib/collection.rb

@@ -1,8 +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
-
+#!/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/collection/base.rb

@@ -1,76 +1,75 @@
-#!/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
+#!/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
+      
+      # Filters the collection, if the first argument is an Array, Regexp, String or Hash.
+      def [](value, *args)
+        case value
+        when String, Regexp, Array, Hash
+          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?(obj, string_or_regexp_or_array)
+        [string_or_regexp_or_array].flatten.detect { |pattern| obj.match(pattern) }
+      end
+    
+      def new(*args)
+        self.class.new(*args)
+      end
+    end
+  end
+end

data/lib/collection/files.rb

@@ -1,62 +1,77 @@
-#!/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
-      alias lines 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
+#!/usr/bin/env ruby -wKU
+
+module Sherlock
+  module Collection
+    class Files < Base
+  
+      def initialize(glob_or_regex, opts = {})
+        case glob_or_regex
+        when Hash
+          opts = glob_or_regex
+        when Array
+          opts[:arr] = glob_or_regex
+        when String
+          opts[:glob] = glob_or_regex
+        when Symbol
+          opts[:glob] = "**/*.#{glob_or_regex}"
+        when 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)
+        arr = opts[:arr] || Dir[opts[:glob]]
+        super(arr, opts)
+      end
+  
+      # Returns a Lines collection with all lines containing the
+      # given content / 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 lines collect_lines_matching
+      
+      def not_blank_lines
+        lines(/\S+/)
+      end
+      
+      def blank_lines
+        lines(/^\s+$/)
+      end
+      
+      # Returns a Files collection with all files containing the
+      # given content / matching the given pattern.
+      def select_files_containing(pattern)
+        select_files(pattern, :select)
+      end
+      alias containing select_files_containing
+
+      # Returns a Files collection with all files not containing the
+      # given content / matching the given pattern.
+      def select_files_not_containing(pattern)
+        select_files(pattern, :reject)
+      end
+      alias not_containing select_files_not_containing
+
+      private
+
+      def select_files(pattern, method)
+        pattern = [pattern].flatten
+        arr = send(method) { |f| matching?(File.read(f), pattern) }
+        new(arr)
+      end
+    end
+  end
+end

data/lib/collection/lines.rb

@@ -1,33 +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
+#!/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

@@ -1,57 +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
+#!/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