rfs 0.1

data/lib/innate/test/testreload.rb

@@ -0,0 +1,61 @@
+def copy(a, b)
+  File.open(b, 'w') do |f|
+    f.write File.read(a)
+  end
+end
+
+require 'test/unit'
+require 'innate/reload'
+require 'innate/scriptlines'
+
+class TestReload < Test::Unit::TestCase
+
+  def t
+    begin
+      copy 'files/reloadtarget1.rb', 'files/reloadtarget.rb'
+      require 'files/reloadtarget'
+      yield :original
+      copy 'files/reloadtarget2.rb', 'files/reloadtarget.rb'
+      reload 'files/reloadtarget'    
+      yield :reloaded
+    ensure
+      # I don't delete anymore because it messes up the tests
+      # for scriptlines
+      #File.delete 'files/reloadtarget.rb' rescue nil
+    end
+  end
+
+
+  #targetfn sleeps for 2 seconds.. more than enough time to have an overlap
+  def test_reload
+    thread = nil
+    t do |step|
+      if step == :original
+        thread = Thread.new do 
+          assert_equal 'function1', targetfn {|v| assert_equal 'start 1', v }
+        end 
+      elsif step == :reloaded
+        assert_equal 'function2', targetfn {|v| assert_equal 'start 2', v }
+        thread.join
+      end
+    end
+  end
+
+  def test_reload_scriptlines
+    orig = nil
+    fn = nil
+    t do |step|
+      if step == :original
+        fn = find_in_path 'files/reloadtarget'
+        orig = SCRIPT_LINES__[fn].collect
+      elsif step == :reloaded
+        r = SCRIPT_LINES__[fn]
+        assert_not_nil orig.first
+        assert_equal orig.first, r.first
+        assert_equal orig.last, r.last
+        assert_equal orig[1..-2].collect {|l| l.tr('12', '21') }, r[1..-2]
+        assert_equal orig.collect {|l| l.tr('12', '21') }, r.collect
+      end
+    end
+  end 
+end

data/lib/innate/test/testroman.rb

@@ -0,0 +1,54 @@
+require 'innate/roman'
+require 'test/unit'
+
+class TestRoman < Test::Unit::TestCase
+  # Since it works already I don't really need more 
+  # detailed tests.  If it breaks, break this down.
+  def test_full_range
+    r = (1..4999).inject(['']) { |lon, v|
+      lon.unshift v.roman if v.roman.length > lon.first.length
+      lon
+    }.delete_if {|v| v == ''}.reverse.collect {|v| [v, v.roman_to_i] }
+    assert_equal([["I", 1],
+                  ["II", 2],
+                  ["III", 3],
+                  ["VIII", 8],
+                  ["XVIII", 18],
+                  ["XXVIII", 28],
+                  ["XXXVIII", 38],
+                  ["LXXXVIII", 88],
+                  ["CLXXXVIII", 188],
+                  ["CCLXXXVIII", 288],
+                  ["CCCLXXXVIII", 388],
+                  ["DCCCLXXXVIII", 888],
+                  ["MDCCCLXXXVIII", 1888],
+                  ["MMDCCCLXXXVIII", 2888],
+                  ["MMMDCCCLXXXVIII", 3888],
+                  ["MMMMDCCCLXXXVIII", 4888]],
+                 r)
+  end
+
+  def test_lower_case
+    assert_equal 1914, 'mcmxiv'.roman_to_i
+  end
+
+  def test_toggle1
+    assert_equal '1914', '1914'.toggle_roman.toggle_roman
+  end
+
+  def test_toggle2
+    assert_equal 'MCMXLIV', 'mcmxliv'.toggle_roman.toggle_roman
+  end 
+
+  def test_interpolate_regexp
+    assert_equal('(?-mix:valiant(' + Regexp.ROMAN_PATTERN + ')soldier)',
+                 (/valiant(roman)soldier/).interpolate_roman.to_s)
+  end
+
+  def test_interpolate_regexp2
+    assert_equal('(?i-mx:valiant(' + Regexp.ROMAN_PATTERN + ')soldier)',
+                 (/valiant(roman)soldier/i).interpolate_roman.to_s)
+  end
+
+end
+

data/lib/innate/test/testscriptlines.rb

@@ -0,0 +1,39 @@
+require 'test/unit'
+require 'innate/scriptlines'
+require 'cursor/indexed'
+require 'timeout'
+
+class TestScriptLines < Test::Unit::TestCase
+  def test_defined
+    assert defined?(SCRIPT_LINES__)
+  end
+
+  def test_types
+    assert SCRIPT_LINES__.length > 0
+    SCRIPT_LINES__.each do |name, file|
+      assert File.exists?(name)
+      assert_kind_of FileLines, file
+    end
+  end
+
+  def test_contents
+    locked = 0
+    begin
+      Timeout::timeout(30) do
+        SCRIPT_LINES__.each do |name, file|
+          begin
+            lines = File.open(name) {|f| f.readlines }.to_cursor
+            file.each do |line|
+              assert_equal lines.read1next, line
+            end
+          rescue Errno::EACCES
+            locked += 1
+          end
+        end
+        assert locked <= 3, 'too many locked files...??'
+      end
+    rescue Timeout::Error
+    end
+  end
+
+end

data/lib/innate/test/teststring.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require 'innate/string'
+require 'cursor/indexed'
+
+class TestString < Test::Unit::TestCase
+  def test_starts_with?
+    assert_nil 'o\'hare'.starts_with?('Mc', 'Mac', 'O\'')
+    assert_equal 'O\'', 'O\'hare'.starts_with?('Mc', 'Mac', 'O\'')
+    assert_nil 'mcdonald'.starts_with?('Mc', 'Mac', 'O\'')
+    assert_equal 'Mc', 'Mcdonald'.starts_with?('Mc', 'Mac', 'O\'')
+    assert_nil 'normal'.starts_with?('Mc', 'Mac', 'O\'')
+  end
+
+  def test_starts_with_i?
+    assert_equal 'O\'', 'o\'hare'.starts_with_i?('Mc', 'Mac', 'O\'')
+    assert_equal 'O\'', 'O\'hare'.starts_with_i?('Mc', 'Mac', 'O\'')
+    assert_equal 'Mc', 'mcdonald'.starts_with_i?('Mc', 'Mac', 'O\'')
+    assert_nil 'normal'.starts_with_i?('Mc', 'Mac', 'O\'')
+  end
+
+  def test_prefix_to?
+    assert_equal 'spud', 's'.prefix_to?('blog', 'roil', 'spud', 'star')
+    assert_equal 'star', 'st'.prefix_to?('blog', 'roil', 'spud', 'star')
+    assert_nil 'S'.prefix_to?('blog', 'roil', 'spud', 'star')
+    assert_nil 'xz'.prefix_to?('blog', 'roil', 'spud', 'star')
+  end
+
+  def test_prefix_to?
+    assert_equal 'Spud', 's'.prefix_to_i?('Blog', 'Roil', 'Spud', 'star')
+    assert_equal 'star', 'St'.prefix_to_i?('blog', 'roil', 'spud', 'star')
+    assert_nil 'xz'.prefix_to_i?('blog', 'roil', 'spud', 'star')
+  end
+
+  def test_split_with_separator
+    assert_equal([[nil, 'hello'], [', ', 'is darrick there'], ['? ', 'no'], ['.', '']],
+                  'hello, is darrick there? no.'.split_with_separator(/[.,?]\s*/))
+  end
+
+  def test_split_with_separator2
+    count = 0
+    c = [[nil, 'hello'], [', ', 'is darrick there'], ['? ', 'no'], ['.', '']].to_cursor
+    'hello, is darrick there? no.'.split_with_separator(/[.,?]\s*/) do |s, text|
+      cs, ctext = c.read1next
+      assert_equal cs, s
+      assert_equal ctext, text
+      count += 1
+    end
+    assert_equal 4, count
+  end
+  
+      
+end

data/lib/innate/test/testtitlecase.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'innate/titlecase'
+require 'cursor/indexed'
+
+class TestTitleCase < Test::Unit::TestCase
+  def test_s
+    s = ['this sentence should be capitalized',
+       'here is another one. the best is to see what will happen! is it good?',
+       'how many more do i need here?  a few.',
+       "i'll have to get this done soon, it may get boring..."]
+    t = ['This Sentence Should Be Capitalized',
+       'Here is Another One. The Best is to See What Will Happen! Is it Good?',
+       'How Many More Do I Need Here?  A Few.',
+       "I'll Have to Get This Done Soon, it May Get Boring..."].to_cursor
+    s.each do |string|
+      assert_equal t.read1next, string.title_case
+    end
+  end
+end
+

data/lib/innate/titlecase.rb

@@ -0,0 +1,64 @@
+require 'innate/roman'
+require 'innate/string'
+require 'innate/array'
+
+class String
+  # lower even if it occurs after punctuation.
+  def self.ALWAYS_LOWER
+    []
+  end
+
+  def self.LOWER
+    %w{ as of in the and at or a to it is on by for with an from }
+  end
+
+  # good for names with a second capital.
+  # this is prefixes rather than words, so it 
+  # doesn't use +Array#match?+
+  def self.DOUBLE_CAP
+    %w{ mac mc o' d' }
+  end
+
+  # which punctuation causes :lower words to be capitalized after all
+  def self.CAP_AFTER
+    %w{ . ! ? ( � : ; } << ' - '
+  end
+
+  def self.SPLIT_PATTERN
+    /('?[ .!?:;""()\-\n\r\t�_]'?)+/
+  end
+
+  def self.UPPER
+    [Regexp.ROMAN]
+  end
+  
+  def title_case(opts = {})
+    opts[:always_lower] ||= String.ALWAYS_LOWER
+    opts[:lower] ||= String.LOWER
+    opts[:double_cap] ||=  String.DOUBLE_CAP
+    opts[:cap_after] ||= String.CAP_AFTER  
+    opts[:split_pattern] ||= String.SPLIT_PATTERN
+    opts[:upper] ||= String.UPPER
+    
+    res = split_with_separator(opts[:split_pattern]) do |s, w|
+      w.downcase!
+      s.to_s + if opts[:always_lower].match? w
+        w
+      elsif opts[:lower].match? w
+        if !s or opts[:cap_after].match?(s.rstrip[-1, 1]) or opts[:cap_after].match?(s)
+          w.capitalize
+        else
+          w
+        end
+      elsif opts[:upper].match? w
+        w.upcase
+      elsif (t = w.starts_with?(opts[:double_cap]))
+        t.capitalize + w[t.length...w.length].capitalize
+      else
+        w.capitalize
+      end
+    end
+    res.join
+  end
+end
+

data/lib/innate/tracerequire.rb

@@ -0,0 +1,22 @@
+class Object
+  alias :require_before_tracerequire :require unless respond_to? :require_before_tracerequire
+  @@__require_depth = 0
+  @@__require_count = 0
+    
+  def require(s)
+    @@__require_count += 1
+    rc = @@__require_count
+    print "\n#{'  ' * @@__require_depth}require '#{s}'"
+    @@__require_depth += 1
+    r = require_before_tracerequire(s)
+    @@__require_depth -= 1
+    s = "=> #{r.to_s}"
+    if rc == @@__require_count
+      print " " + s
+    else
+      print "\n#{'  ' * @@__require_depth}" + s
+    end
+    puts if @@__require_depth == 0
+    return r
+  end 
+end 

data/lib/namesource.rb

@@ -0,0 +1,53 @@
+class NameSource
+  def name(file, md, path)
+    file
+  end
+
+  def close
+  end
+end
+
+
+class NameStreamSource < NameSource
+  def initialize(stream)
+    @stream = stream
+  end
+
+  def name(file, md, path)
+    @stream.readline.chomp
+  end
+end
+
+
+class NameFileSource < NameSource
+  def initialize(file_name)
+    @file_name = file_name
+  end
+  
+  def name(file, md, path)
+    unless @file and @path == path
+      @file.close if @file
+      @path = path
+      fn = File.join(path, @file_name)
+      if File.exists? fn
+        @file = File.open(fn)
+      else
+        @file = File.open(@file_name)
+      end
+    end
+    @file.readline.chomp
+  end
+
+  def close
+    @file.close if @file 
+  end
+end
+
+
+class NamePromptSource < NameSource
+  def name(file, md, path)
+    print "Rename #{File.join(path, file)}\n#[captures: #{md.display} ] to:\n>>> "
+    STDIN.gets.chomp
+  end
+end
+

data/lib/options.rb

@@ -0,0 +1,64 @@
+class OptionError < RenamerError
+end
+
+class MissingOptionError < OptionError
+  attr_reader :missing_opt
+  def initialize missing_opt
+    @missing_opt = missing_opt
+    super "The required option #{missing_opt} was not present."
+  end
+end
+
+class BadOptionValueError < OptionError
+  attr_reader :opt, :klass, :klass_expected
+  def initialize opt, klass, klass_expected
+    @opt = opt
+    @klass = klass
+    @klass_expected = klass_expected
+    super "#{opt} was expected to be one of #{klass_expected.to_a.flatten.join ', '} but was #{klass}."
+  end
+end
+
+
+module Options
+
+
+  attr_accessor :options
+
+  def opt(sym, *types)
+    v = @options[sym]
+    if v
+      unless types.empty?
+        if types.find {|t| v.is_a? t}
+          if block_given?
+            yield v
+          else
+            v
+          end
+        else
+          raise BadOptionValueError.new(sym, v.class, types)
+        end
+      else
+        if block_given?
+          yield v
+        else
+          v
+        end
+      end
+    elsif !types.include? NilClass
+      raise MissingOptionError.new(sym)
+    end
+  end
+
+  def opt_if(sym, *types)
+    begin
+      v = opt sym, *types
+    rescue OptionError
+    end
+    if block_given?
+      yield v if v
+    else
+      v
+    end
+  end
+end

data/lib/providers.rb

@@ -0,0 +1,93 @@
+
+module Provider
+  module Folder
+    class Tree
+      def initialize(tree)
+        @tree = tree
+      end
+
+      def each(&block)
+        traverse_list @tree, nil, &block
+      end
+
+      protected
+      def traverse_list branch, path, &block
+        branch.each do |i|
+          if i.selected?
+            yield @tree.itemPathname(i)
+          end
+          traverse_list(i, p, &block) if i.expanded?
+        end
+      end
+    end
+  end
+
+
+  module File
+    class Base
+      def initialize(folder_provider)
+        @folders = folder_provider
+        @iterator = :each
+      end
+
+      def reverse
+        @iterator = :reverse_each
+      end
+    end
+    
+        
+    class NonRecursive < Base
+      def each
+        @folders.each do |folder|
+          dir = Dir.new(folder)
+          dir.collect.send(@iterator) do |file|
+            unless file =~ /^\.+$/
+              yield folder, file
+            end
+          end
+        end
+      end
+    end
+    
+
+    class Recursive < Base
+      def each(&block)
+        @folders.each do |folder|
+          recursive_each(folder, &block)
+        end
+      end
+
+      private
+      def recursive_each(folder, &block)
+        dir = Dir.new(folder) rescue return
+        dir.collect.send(@iterator) do |file|
+          j = ::File.join(folder, file)
+          unless file =~ /^\.+$/
+            if ::File.directory? j 
+              recursive_each j, &block
+            end
+            yield folder, file
+          end
+        end
+      end
+    end
+
+    class Array < Base
+      attr_accessor :files
+
+      def initialize(files)
+        super nil
+        @files = files
+      end
+
+      def each
+        @files.send(@iterator) do |file|
+          p, f = ::File.split file
+          yield p, f
+        end
+      end
+    end
+  end
+end
+
+