rfs 0.1

data/lib/innate/file.rb

@@ -0,0 +1,5 @@
+class File
+  def self.absolute_path? name
+    name if /^(\.|[A-Za-z]:|\/)/ =~ name
+  end
+end

data/lib/innate/filelines.rb

@@ -0,0 +1,148 @@
+
+# load is not currently thread safe.
+class FileLines < Array
+  def initialize(fn)
+    @fn = fn
+    @init = false
+    @loaded_all = false
+  end
+
+  alias_method :at_before_file_lines, :[]
+
+  def at(i)
+    load i
+    super
+  end
+
+  def [](r)
+    load r
+    super
+  end
+
+  def []=(i, v)
+    super
+  end
+
+  def length
+    init
+    super
+  end
+
+  def size
+    init
+    super
+  end
+
+  def values_at(*a)
+    load(*a)
+    super
+  end
+
+  def each
+    load_all
+    super
+  end
+
+  def first
+    at 0
+  end
+
+  def last
+    at length - 1
+  end
+
+  def collect
+    load_all
+    super
+  end
+  
+private
+  def init
+    return if @init
+    @init = true
+    if @fn
+      begin
+        File.open @fn do |f|
+          p = 1
+          pos = 0
+          crlf = 0
+          self[0] = 0
+          f.each_line do |l|
+            if p == 2
+              f.seek pos, IO::SEEK_SET
+              if f.readline == l
+                crlf = 1
+              else
+                crlf = 0
+              end
+              break
+            end
+            p += 1
+            pos += l.length + 1  
+          end
+          p = 1
+          pos = 0
+          f.rewind
+          f.each_line do |l|
+            self[p] = pos += l.length + crlf
+            p += 1
+          end
+        end 
+        pop
+      rescue 
+      end
+    end
+  end
+
+  def load_all
+    return if @loaded_all
+    load 0...length
+    @loaded_all = true
+  end
+
+  def load(*v)
+    return if @loading or !@fn
+    begin
+      @loading = true
+      init
+      range = nil
+      return if @loaded_all
+      begin
+        File.open @fn do |f|
+          v.each do |i|
+            range = make_range i
+
+            # could add support for neg. indexes...
+            # but don't need it now.
+            range.each do |line_num|
+              val = at line_num
+              if val.is_a? Fixnum
+                f.seek val, IO::SEEK_SET
+                self[line_num] = f.readline
+              end
+            end
+          end
+        end
+      end
+    rescue
+      v.collect do |i|
+        make_range(i).collect {nil}
+      end.flatten
+    end
+  ensure
+    @loading = false
+  end
+  
+  def make_range i
+    if i.is_a? Range
+      if i.last < 0
+        Range.new i.first, length + i.last, i.exclude_end?
+      else
+        i
+      end
+    else
+      i..i
+    end
+  end
+end    
+

data/lib/innate/kernel.rb

@@ -0,0 +1,41 @@
+require 'innate/file'
+
+def find_in_path f
+  (['.'] + $:).each do |p|
+    ['', '.rb', '.rbw'].each do |ext|
+      fn = File.expand_path File.join(p, f + ext)
+      if File.exists? fn and !File.directory? fn
+        return fn
+      end
+    end
+  end
+  nil
+end
+
+def each_loaded_file
+  ($").each do |f|
+    if File.exists? f
+      yield f
+    else
+      fn = File.absolute_path?(f) ? f : find_in_path(f)
+      if fn
+        yield fn
+      else
+        raise "file not found: #{f}" unless found
+      end
+    end
+  end
+end
+
+def each_caller
+  caller.each do |c|
+    m = /^(.+):(\d+)(:in `(.*)')?$/.match c
+    yield m[1].gsub('\\', '/'), m[2] ? m[2].to_i : 0, m[4]
+  end
+end
+
+def each_lfoc
+  each_loaded_file {|fn| yield fn}
+  each_caller {|fn, l, f| yield fn}
+end
+

data/lib/innate/metaid.rb

@@ -0,0 +1,30 @@
+
+# From http://www.whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+
+class Object
+  
+  # The hidden singleton lurks behind everyone
+  def metaclass
+    class << self
+      self
+    end
+  end
+
+  def meta_eval &blk
+    metaclass.instance_eval(&blk)
+  end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+
+  def class_undef name
+    class_eval { undef_method name }
+  end
+end

data/lib/innate/mkdirs.rb

@@ -0,0 +1,12 @@
+class File
+  def self.mkdirs(d)
+    return true if File.directory? d
+    return false if File.exist? d
+    p = File.split d
+    return false if p[1] == '\\'
+    Dir.mkdir(d) if mkdirs p[0]
+    true
+  end
+end
+
+                             

data/lib/innate/regexp.rb

@@ -0,0 +1,80 @@
+class Regexp
+  def interpolate replace, new_pattern
+    r = /^\(\?([imx]*)(-[imx]+)?:(.*?)#{Regexp.escape replace}(.*)\)$/
+    m = r.match self.to_s
+    if m
+      s = "#{m[3]}#{new_pattern}#{m[4]}"
+      o = m[1] || ''
+      self.class.new(s, 
+                 (o.include?(?i) ? Regexp::IGNORECASE : 0) |
+                 (o.include?(?m) ? Regexp::MULTILINE : 0) |
+                 (o.include?(?x) ? Regexp::EXTENDED : 0))
+    else
+      self
+    end
+  end
+end
+
+class MatchData
+  def replace_capture(c, s)
+    string[0, offset(c)[0]] + (s || '') + string[offset(c)[1]..-1]
+  end
+
+  def display(first = 0, last = nil, open = '(', close = ')') 
+    s = pre_match
+    p = s.length
+    e = []
+    (first...(last || length)).each do |o|
+      next if offset(o) == [nil, nil]
+      while e.last and e.last <= offset(o).first
+        s << string[p...e.last] + close
+        p = e.pop
+      end
+      s << string[p...offset(o).first] + open
+      p = offset(o).first
+      e << offset(o).last
+    end
+    while e.last
+      s << string[p...e.last] + close
+      p = e.pop
+    end
+    s << string[p..-1]
+    return s
+  end
+
+  def breakdown
+    s = []
+    length.times do |o|
+      if offset(o) == [nil, nil]
+        s << ''
+      else
+        s << (' ' * offset(o).first) + self[o] + (' ' * (string.length - offset(o).last))
+      end
+    end 
+    s
+  end
+
+  def display_breakdown
+    r = "S: |#{string}|"
+    breakdown.each_with_index do |s, i|
+      r += "\n#{i}: |#{s}|"
+    end
+    r
+  end
+  
+  # Replace the matching part of the string with match interpolation.
+  #
+  # If there are any captures, replaces the first one,
+  # otherwise replaces the whole match.
+  # 
+  # Interpolates %n to the corresponding capture.
+  def sub(repl, capture_num = 1)
+    cn = capture_num || 1
+    t = repl.clone
+    to_a[1..-1].each_with_index do |m, i|
+      t.gsub!("%#{i + 1}", m ? m : '')
+    end
+    replace_capture self[cn] ? cn : 0, t
+  end
+end
+

data/lib/innate/reload.rb

@@ -0,0 +1,11 @@
+def reload s
+  unless $".delete s
+    if /\.rb$/ =~ s
+      require s
+    else
+      reload s + '.rb'
+    end
+  else
+    require s
+  end
+end

data/lib/innate/roman.rb

@@ -0,0 +1,72 @@
+require 'innate/regexp'
+
+class Regexp
+  # All groups are non-capturing!
+  def self.ROMAN_PATTERN
+    '(?:M{0,4})(?:C[DM]|D?C{0,3})(?:X[LC]|L?X{0,3})(?:I[VX]|V?I{0,3})'
+  end
+
+  def self.ROMAN
+    Regexp.new("^#{self.ROMAN_PATTERN}$", 'i')
+  end
+  
+  def interpolate_roman
+    #     r = /\?([imx]*-[imx]*:[^(]\()roman(\).*)/
+    interpolate '(roman)', "(#{Regexp.ROMAN_PATTERN})"
+  end
+end
+
+
+
+class String
+  def roman_numeral?
+    self =~ Regexp.ROMAN ? self : nil
+  end
+
+  def toggle_roman
+    if Regexp.ROMAN =~ self
+      roman_to_i.to_s
+    else
+      to_i.roman
+    end
+  end
+  
+  def roman_to_i
+    raise "#{self} is not a valid roman numeral." unless roman_numeral?
+    s = upcase
+    values = { ?M => 1000, ?D => 500, ?C => 100, ?L => 50, ?X => 10, ?V => 5, ?I => 1 }
+    value = result = 0
+    upcase.each_byte do |b|
+      result -= value *2 if values[b] > value
+      result += (value = values[b])
+    end
+    result
+  end
+end
+
+
+class Fixnum
+  def roman
+    raise 'There is no Roman representation for numbers below 1.' if self < 1
+    raise 'There is no Roman representation for numbers above 4999.' if self > 4999
+    elements = {1000 => 'M',500 => 'D',100 => 'C',50 => 'L',10 => 'X',5 => 'V',1 => 'I'}
+    values = [1000, 500, 100, 50, 10, 5, 1]
+    r = ''
+    int = self
+    values.each do |v|
+      while int >= v
+        r += elements[v]
+        int -= v
+      end
+      if v > 1
+        v.to_s[0,1] == '5' ? t = v / 5 : t = v / 10
+        if int >= v - t
+          r += elements[t] + elements[v]
+          int -= v - t
+        end
+      end
+    end
+    return r
+  end
+end
+

data/lib/innate/scriptlines.rb

@@ -0,0 +1,60 @@
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+
+require 'innate/filelines'
+require 'innate/kernel'
+
+module ScriptLines
+  def handle_odd_paths
+    SCRIPT_LINES__.select {|k,v| v.is_a? Array}.each do |k, v|
+      x = SCRIPT_LINES__[File.expand_path(k)]
+      unless x and x.is_a? FileLines
+        x = FileLines.new(k)
+      end
+      SCRIPT_LINES__[k] = x     
+    end
+  end
+  module_function :handle_odd_paths
+
+  def display
+    SCRIPT_LINES__.collect.sort.each {|k,v| puts "#{v.class} #{k}"}
+    SCRIPT_LINES__.length
+  end
+  module_function :display    
+end
+
+each_lfoc do |fn|
+  unless SCRIPT_LINES__[fn].is_a? FileLines
+    if fn =~ /\.rbw?/
+      SCRIPT_LINES__[fn] = FileLines.new fn
+    end
+  end
+end
+ScriptLines.handle_odd_paths
+
+class Object
+  alias :require_before_laziness :require unless respond_to? :require_before_laziness
+  def require *files
+    r = require_before_laziness(*files)
+    if r
+      files.each do |f|
+        fn = find_in_path f
+        if fn
+          fl = FileLines.new fn
+          SCRIPT_LINES__[fn] = fl 
+          SCRIPT_LINES__[f] = fl if f[0] == ?.
+        end
+      end
+      ScriptLines.handle_odd_paths
+    end
+    return r
+  end
+
+  #alias :require_gem_before_laziness :require_gem unless respond_to? :require_gem_before_laziness if 
+  #def require_gem *files
+    #r = require_gem_before_laziness(*files)
+    #if r
+      #ScriptLines.handle_odd_paths
+    #end
+    #r
+  #end
+end