=begin
endless.rb is a pre-processor for ruby which allows you to use python-ish 
indentation to delimit scopes, instead of having to type 'end' every time.
 
Basically, this makes the end keyword optional. If you leave off the
end, the preprocessor inserts an end for you at the next line indented
at or below the level of indentation of the line which started the scope.
 
End is optional, so you can still write things like this:
  begin
    do_something
  end until done?
(However, you'd better make damn sure you get the end indented to the 
right level!)
 
This script uses RubyLexer to extract a stream of tokens and modify 
it, then turn those tokens back into ruby code. Since RubyLexer is a 
complete stand-alone lexer, this should be a very thorough solution,
free of insoluable little problems due to the script's inability to 
follow where comments and strings start and stop. (That said, I'm sure
there will be some problems with it, as it's pretty raw code.)
 
As different programs have a variety of interpretations as to the
width of a tab character, tabs for indentation are absolutely 
forbidden by endless.rb.
 
There is a similar script, pyruby.rb, or pyrb.rb floating around which 
examines a source file line by line and assumes lines ending in a colon 
are the start of a block. Since pyrb.rb does not tokenize the input, 
pyruby.rb can be fooled by a colon in a string or comment:
 
  p "a:
     b"
  p "a" #:
 
It's basically impossible to get this kind of thing right without actually
tokenizing the input. Also, unlike python (and pyruby.rb), endless.rb needs
no extra colon to start an indented block. (I don't like python's colons 
much.)
 
Code written without ends must be pulled into the interpreter via special
versions of the #load or #eval builtin methods. Eventually, there should
be a version of #require as well, but for now you must get along with #load.
The special versions are contained in the Endless module, so to load up 
source code without ends in it, use 
  Endless.load 'filename'
instead of 
  require 'filename' 
or
  load 'filename'
 
For examples, see the end of the file.
 
=end
 
require 'rubygems'
require 'rubylexer'
require 'tempfile'
 
class EndlessRubyLexer<RubyLexer
  def initialize *args
    @old_indent_levels=[]
    super
  end
 
  def old_indent_level
    @old_indent_levels.last
  end
 
 
  DONT_END=/^( *)(end|when|else|elsif|rescue|ensure)(?!#{LETTER_DIGIT}|[?!])/o
 
  def start_of_line_directives
    super
 
    if @file.check /^( *)(.)/ #(?!end(?!#{LETTER_DIGIT}|[?!]).)(.)/m
      lm=@file.last_match
      @indent_level=lm[1].size if lm[1]
      if /\A(?![ ])[\s\v]\Z/===lm[2]
        @indent_level=:invalid
      end
 
 
      if !(@parsestack.last.respond_to? :in_body and !@parsestack.last.in_body) and
         (!@moretokens[-2] or NewlineToken===@moretokens[-2])
        #auto-terminate previous same or more indented want-end contexts
        pos=input_position
        while WantsEndContext===@parsestack.last and 
              @parsestack.last.indent_level > @indent_level
          insert_implicit_end pos
        end
        while WantsEndContext===@parsestack.last and 
              @parsestack.last.indent_level == @indent_level
          insert_implicit_end pos
        end unless @file.check DONT_END
      end
    end
  end
 
  def insert_implicit_end pos
    #emit implicit end token
    @moretokens.push WsToken.new(' ',pos), 
                     KeywordToken.new('end',pos), 
                     KeywordToken.new(';',pos)
    @parsestack.pop
  end   
 
  def indent_level
    if Integer===@indent_level
      @indent_level
    else
      raise "invalid indentation: must use only spaces" 
    end
  end
 
  def endoffile_detected(str='')
    result=super
    pos=input_position
    while WantsEndContext===@parsestack.last
      insert_implicit_end pos
    end
    @moretokens.push result
    return @moretokens.shift
  end
 
  def keyword_for(str,offset,result)
    result=super
    @parsestack[-2].indent_level=indent_level
    return result
  end
 
  def keyword_def(str,offset,result)
    fail unless @indent_level
    @old_indent_levels.push @indent_level
    result=super
    @old_indent_levels.pop
 
    return result
  end
 
  eval %w[module class begin case].map{|w| 
    "
     def keyword_#{w}(str,offset,result)
       result=super
       @parsestack.last.indent_level=indent_level
       return result
     end
    "
  }.join
 
  eval %w[while until if unless].map{|w|
    "
     def keyword_#{w}(str,offset,result)
       result=super
       if @parsestack[-2].respond_to? :indent_level=
         @parsestack[-2].indent_level||=indent_level 
       end
       return result
     end
    "
  }.join
 
  def keyword_do(str,offset,result)
    return super if ExpectDoOrNlContext===@parsestack.last
    result=super
    ctx=@parsestack[-1]
    ctx=@parsestack[-2] if BlockParamListLhsContext===ctx
    ctx.indent_level=indent_level
    return result
  end
end
 
class RubyLexer::NestedContexts::WantsEndContext
  attr_accessor :indent_level
end
 
class RubyLexer::NestedContexts::DefContext
  alias endful_see see
  def see(lxr,msg)
    if :semi==msg
      fail unless lxr.parsestack.last.equal? self
      @indent_level||=lxr.old_indent_level
    end
    endful_see lxr, msg
  end
end
 
module Endless
  VERSIOn="0.0.2"
 
  class<<self
    def require(name)
      raise NotImplementedError
      huh load
    end
 
    def load(filename,wrap=false)
      [''].concat($:).each{|pre|
        pre+="/" unless %r{(\A|/)\Z}===pre
        if File.exist? finally=pre+filename
          code=File.open(finally){|fd| fd.read }
          f=Tempfile.new filename 
          begin
            preprocess code,filename,f
            f.rewind
            return ::Kernel::load(f.path, wrap)
          ensure f.close
          end
        end
      }
      raise LoadError, "no such file to load -- "+filename
    end
 
    def eval(code,file="(eval)",line=1,binding=nil)
      #binding should default to Binding.of_caller, not nil......
      eval(preprocess(code,file),file,line,binding)
    end
 
    def preprocess(code,filename,output='')
      lexer=EndlessRubyLexer.new(filename,code)
      printer=RubyLexer::KeepWsTokenPrinter.new
 
      begin
        tok=lexer.get1token
        output << printer.aprint(tok)
      end until RubyLexer::EoiToken===tok
 
      return output
    end
 
    def main
      fn=ARGV.first
      if fn=='-e'
        fn=ARGV[1..-1].join ' '
        f=fn
      elsif fn=='test'
        f=DATA
      else
        f=open fn if fn
      end
      preprocess f||$stdin.read, fn||'-', $stdout
    end
 
  end
end
 
Endless.main if __FILE__==$0
 
__END__
 
#test data follows
 
begin
  a
  
  b
 
begin
  a
  b
 
begin \
  a
  b
 
begin
  a
 
  b
 
 
begin
  a
  a2
 
 
rescue  
  b
 
begin
  a
  a2
 
ensure  
  b
 
begin
  a
  a2
 
else  
  b
 
begin
  a
  a2
  
rescue
  b
else
  d
ensure 
  c
 
x
case ARGV[0]
when /^\d*$/
          p "That's an integer!"
when /^[A-Za-z]*$/
          p "That's a word!"
else
          p "That's something that's not an integer or a word..."
end
 
case ARGV[0]
when /^\d*$/
          p "That's an integer!"
when /^[A-Za-z]*$/
          p "That's a word!"
else
          p "That's something that's not an integer or a word..."
 
case 
  ARGV[0]
when /^\d*$/
          p "That's an integer!"
when /^[A-Za-z]*$/
          p "That's a word!"
else
          p "That's something that's not an integer or a word..."
 
case ARGV[0]
        when /^\d*$/
          p "That's an integer!"
        when /^[A-Za-z]*$/
          p "That's a word!"
        else
          p "That's something that's not an integer or a word..."
case ARGV[0]
        when /^\d*$/
          p "That's an integer!"
        when /^[A-Za-z]*$/
          p "That's a word!"
        else
          p "That's something that's not an integer or a word..."
end
case ARGV[0]
        when /^\d*$/
          p "That's an integer!"
        when /^[A-Za-z]*$/
          p "That's a word!"
        else
          p "That's something that's not an integer or a word..."
end if ARGV[0]
result = case ARGV[0]
        when /^\d*$/
          p "That's an integer!"
        when /^[A-Za-z]*$/
          p "That's a word!"
        else
          p "That's something that's not an integer or a word..."
        end if ARGV[0]
result = case ARGV[0]
        when /^\d*$/
          p "That's an integer!"
        when /^[A-Za-z]*$/
          p "That's a word!"
        else
          p "That's something that's not an integer or a word..."
end if ARGV[0]
class A
  class B
    class C
      module D
        foo
  end
 
class A
  class B
    class C
      module D
        foo
end
 
 
 
class A <
  Ay; foo
  bar
 
class B \
  ; foo
  bar
 
module C include
  Cy; foo
  bar
 
module C \
  ; foo
  bar
def a(b)
  c
  d
 
def a#(b)
  c
  d
 
def a
  c
  d
 
def a()
  c
  d
 
def a b
  c
  d
 
def a b
  c
end
 
def a b
 
end
 
def a b
end
 
  def keo()
    retun sup
 
  def keo()
    retun sup
  end
 
def goo
xxx
 
def goo
  xxx
 
def fooo x,
         y,
         z
 some code
 
   really_important_code!
   fantastically_critical_code!
 
 more code
 
 
def foo big,
        list,
        of,
        args
 
 some.stuff
 some.stuff
 some.stuff
 
  something.more.important!
  look.at.me!
 
 more.stuff=boring
 
#i don't know why this works, but it does
baz.
  foo(bar, :a=>1, :b=>2,
             :c=>3, :d=>4) do
  do_stuff!
 
xxx
 
#i don't know why this works, but it does
foo(bar, :a=>1, :b=>2,
             :c=>3, :d=>4) do
  do_stuff!
 
xxx
 
def foo(bar, a=1, b=2,
             c=3, d=4)
  do_stuff!
 
xxx
 
 
n = 2 * -[1,2,3,4,5].inject(0) do |a, b|
 c = a * 2
 a * c + b
result = 8 * -if n > 0
 -n += 10000
else
 n + 500000
puts result
for i in 1..10 do
  p i
  pp i
 
for i in 1..10
  p i
  pp i
 
#for i 
#  in 1..10 do
#  p i
#  pp i
 
#for i 
#  in 1..10
#  p i
#  pp i
 
for 
  i in 1..10 do
  p i
  pp i
 
for 
  i in 1..10
  p i
  pp i
 
for i in 
  1..10 do
  p i
  pp i
 
for i in 
  1..10
  p i
  pp i
 
for i in 1..10 do \
  p i
  pp i
 
if a
  b
else
  c
class RubyLexer
  class WantsEndContext
    def initialize(a,b)
    end
  end
end
 
class RubyLexer
  WantsEndContext.new 1,2
  class WantsEndContext
    attr_accessor :indent_level
  end
  WantsEndContext.new
end