endlessruby 0.0.1 → 0.1.0

data/lib/endlessruby/{extensions.rb → custom_require.rb}

@@ -13,62 +13,49 @@ module Kernel
   # pathが./または/で以外で始まる場合は$LOAD_PATHと$:をそれぞれ参照してpathを探します。
   # もしpathがそれらで始まる場合はそれぞれ参照しません。(つまり通常のrequireの動作と同じです)
   def require path
-    at = caller
     endlessruby_original_require path
   rescue SyntaxError, LoadError
-    case path
-    when /^\.\/.*?$/, /^\/.*?$/
-      unless File.exist? path
-        if File.exist? "#{path}.er"
-          path = "#{path}.er"
+
+    load = lambda do |path, abspath|
+
+      if !File.exist?(abspath) || File.directory?(abspath)
+        if File.exist? "#{abspath}.er"
+          abspath = "#{abspath}.er"
         else
-          $@ = at
           raise LoadError, "no such file to load -- #{path}"
         end
       end
 
-      if File.directory? path
-        $@ = at
+      return false if $".include? abspath
+
+      if File.directory? abspath
         raise LoadError, "Is a directory - #{path}"
       end
 
-      open(path) do |file|
-        begin
-          EndlessRuby.ereval file.read, TOPLEVEL_BINDING, path
-        rescue Exception => e
-          $@ = at
-          raise e
-        end
+      open(abspath) do |file|
+        EndlessRuby.ereval file.read, TOPLEVEL_BINDING, abspath
+        $" << abspath
         return true
       end
+    end
+
+    case path
+    when /^\~(.*?)$/
+      load.call path, File.join(ENV['HOME'], $1)
+    when /^\.\/.*?$/, /^\/.*?$/
+      load.call path, path
     else
       is_that_dir = false
-      ($LOAD_PATH | $:).each do |load_path|
-        real_path = File.join load_path, path
-        unless File.exist? real_path
-          if File.exist? "#{real_path}.er"
-            real_path = "#{real_path}.er"
-          else
-            next
-          end
-        end
-
-        next is_that_dir = true if File.directory? real_path
-        open(real_path) do |file|
-          begin
-            EndlessRuby.ereval file.read, TOPLEVEL_BINDING, real_path
-          rescue Exception => e
-            $@ = at
-            raise e
-          end
+      $:.each do |load_path|
+        abspath = File.join load_path, path
+        begin
+          return load.call path, abspath
+        rescue SyntaxError => e
+          $stderr.puts "*ENDLESSRUBY BUG*"
+          raise e
+        rescue LoadError => e
+          raise e if load_path == $:.last
         end
-        return true
-      end
-      $@ = at
-      if is_that_dir
-        raise LoadError, "Is a directory - #{path}"
-      else
-        raise LoadError, "no such file to load -- #{path}"
       end
     end
   end

data/lib/endlessruby/main.rb

@@ -9,23 +9,14 @@ module EndlessRuby::Main
 
   # er ファイルから読み込みそれをピュアなRubyにコンパイルしてrbに書き出します
   def compile er, rb
-    open(er) do |erfile|
-      open(rb, "w") do |rbfile|
-        rbfile.write ER2PR(erfile.read)
-      end
-    end
+    ER2PR({ :in => { :any => er }, :out => { :any => rb } })
   end
 
   # rbファイルを読み込みそれからすべてのendを取り除きます。
   def decompile rb, er
-    open(rb) do |rbfile|
-      open(er, "w") do |erfile|
-        erfile.write PR2ER(rbfile.read)
-      end
-    end
+    PR2ER({ :in => { :any => rb }, :out => { :any => er } })
   end
 
-
   # EndlessRuby::Main.main と同じ動作をします。このモジュールをincludeした場合に使用します。
   def endlessruby argv
     EndlessRuby::Main.main argv
@@ -48,19 +39,22 @@ module EndlessRuby::Main
     }
 
     parser = OptionParser.new do |opts|
-      opts.on '-o OUT' do |out|
+
+      opts.version = EndlessRuby::VERSION
+
+      opts.on '-o OUT', 'appoint output directory.' do |out|
         options[:out] = out
       end
 
-      opts.on '-c', '--compile' do |c|
+      opts.on '-c', '--compile', 'compile endlessruby source code to pure ruby' do |c|
         options[:compile] = true
       end
 
-      opts.on '-d', '--decompile' do |d|
+      opts.on '-d', '--decompile', 'decompile pure ruby source code to endless ruby' do |d|
         options[:decompile] = true
       end
 
-      opts.on '-r' do |r|
+      opts.on '-r', 'unimplemented' do |r|
         options[:recursive] = true
       end
     end

data/spec/build_self_spec.rb

@@ -12,8 +12,8 @@ describe EndlessRuby, "must can compile self" do
     "#{lib}/endlessruby.rb",
    "#{src}/endlessruby/main.er",
    "#{lib}/endlessruby/main.rb",
-   "#{src}/endlessruby/extensions.er",
-   "#{lib}/endlessruby/extensions.rb",
+   "#{src}/endlessruby/custom_require.er",
+   "#{lib}/endlessruby/custom_require.rb",
    "#{src}/er.er",
    "#{bin}/endlessruby",
   ]

data/spec/endlessruby_spec.rb

@@ -8,3 +8,5 @@ require "require_spec"
 require "build_self_spec"
 require "concrete_examples_spec"
 require "semicolon_spec"
+require "block_expr_spec"
+require "use_end_case_spec"

data/spec/require_spec.rb

@@ -26,4 +26,12 @@ describe "require" do
     TestData.test_data.should == "ruby script"
   end
 
+  it "require ellipsis of 'er' and exist same name directory" do
+
+    require 'test_data/exist_same_name_directory'
+
+    $test_data.should == "exist same name directory"
+    TestData.test_data.should == "exist same name directory"
+  end
+
 end

data/spec/semicolon_spec.rb

@@ -7,8 +7,17 @@ describe "split with semicolon lines is inner lines" do
 def method; statements; end
 DEFINE
   <<DEFINE.chomp!
-def method
-  statements
+def method; statements; end
+DEFINE
+
+  end
+
+  it "example" do
+    ER2RB(<<DEFINE).should == 
+def method; statements
+DEFINE
+  <<DEFINE.chomp!
+def method; statements
 end
 DEFINE
 

data/spec/simply_spec.rb

@@ -461,6 +461,22 @@ DEFINE
 
 end
 
+describe "for expression case" do
+
+  it "for" do
+    ER2RB(<<DEFINE).should == 
+for i in enu
+  pass
+DEFINE
+    <<DEFINE.chomp!
+for i in enu
+  pass
+end
+DEFINE
+  end
+
+end
+
 describe "exception expression case" do
 
   it "try only" do

data/spec/use_end_case_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe "use end case" do
+
+  it "example" do
+    ER2RB(<<DEFINE).should == 
+def m
+  if true
+    case a
+    when b then 1
+    end
+  else
+  end
+DEFINE
+  <<DEFINE.chomp!
+def m
+  if true
+    case a
+    when b then 1
+    end
+  else
+  end
+end
+DEFINE
+
+  end
+end

data/src/endlessruby.er

@@ -4,7 +4,9 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-require 'endlessruby/extensions'
+require 'endlessruby/custom_require'
+require "tempfile"
+require "irb"
 
 # EndlessRubyはRubyをendを取り除いて書けます。
 #
@@ -34,179 +36,243 @@ require 'endlessruby/extensions'
 module EndlessRuby
 
   # EndlessRuby のバージョンです
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 
   extend self
 
-  private
-
-  # 内部で使用します。空業かどうか判定します。
-  def blank_line? line
-    return true unless line
-    (line.chomp.gsub /\s+?/, '') == ""
-
-  # 内部で使用します。インデントを取り除きます
-  def unindent line
-    line  =~ /^\s*?(\S.*?)$/
-    $1
-  # 内部で使用します。インデントします
-  def indent line, level, indent="  "
-    "#{indent * level}#{line}"
-
-  # 内部で使用します。インデントの数を数えます。
-  def indent_count line, indent="  "
-    return 0 unless line
-    if line =~ /^#{indent}(.*?)$/
-      1 + (indent_count $1, indent)
-    else
-      0
-
-  # 内部で使用します。ブロックを作るキーワード群です。
-  BLOCK_KEYWORDS = [
-    [/^if(:?\s|\().*?$/, /^elsif(:?\s|\().*?$/, /^else(?:$|\s+)/],
-    [/^unless(:?\s|\().*?$/, /^elsif(:?\s|\().*?$/, /^else(?:$|\s+)/],
-    [/^while(:?\s|\().*?$/],
-    [/^until(:?\s|\().*?$/],
-    [/^case(:?\s|\().*?$/, /^when(:?\s|\().*?$/, /^else(?:$|\s+)/],
-    [/^def\s.*?$/, /^rescue(:?$|\s|\().*?$/, /^else(?:$|\s+)/, /^ensure(?:$|\s+)/],
-    [/^class\s.*?$/],
-    [/^module\s.*?$/],
-    [/^begin(?:$|\s+)/, /^rescue(:?$|\s|\().*?$/, /^else(?:$|\s+)/, /^ensure(?:$|\s+)/],
-    [/^.*?\s+do(:?$|\s|\|)/]
-  ]
-
   public
 
   # 文字列をEndlessRubyの構文として実行します。引数の意味はKernel#evalと同じです
   def ereval(src, binding=TOPLEVEL_BINDING, filename=__FILE__, lineno=1)
-    at = caller
     eval(ER2PR(src), binding, filename, lineno)
-  rescue Exception => e
-    $@ = at
-    raise e
 
-  # Rubyの構文をEndlessRubyの構文に変換します。
-  def pure_ruby_to_endless_ruby src
-    @decompile = true
-    s = ER2RB(src)
-    @decompile = nil
-    s
+  # EndlessRubyの構文をピュアなRubyの構文に変換します。<br />
+  # options: オプションを表すHashまたはto_hashを実装したオブジェクト、構文を読み出すIOまたはto_ioを実装したオブジェクト、EndlessRubyの構文を表すStringまたはto_strを実装したオブジェクト、またはファイルのパス<br />
+  # optionsが文字列ならばそれをピュアなRubyの構文にします。それがIOならばIOから読み出してそれをピュアなRubyの構文にします。<br />
+  # ファイルのパスならばそのファイルかあ読み込みます
+  # それがHashならばそれはオプションです。それぞれHashを指定します。<br />
+  # options: {
+  #   in: {
+  #     io: optionsにIOを指定した場合と同じです
+  #      any: それが存在するファイルのパスを表す文字列ならばそのファイルから読み出します。この場合のanyはoptionsにそのような文字列を指定するのと同じ意味です。
+  #           そうでない文字列ならばそれ自体をEndlessRubyの構文として読み出します。この場合のanyはoptionsに文字列を指定するのと同じ意味です。
+  #           それがIOならばそのIOから読み出します。この場合のany はin.ioを直接指定するのと同じです。
+  #   }
+  #   out: {
+  #     io: このIOに結果を書き出します。
+  #     any: ファイルのパスかIOです。ファイルのパスならばそのファイルに書き出します。IOならばそのIOに書き出します。
+  #   }
+  #   decompile: trueならばコンパイルではなくてでコンパイルします。
+  # }    
+  #
+  # opts[:out][:io] には書き出すioを指定します。<br />
+  # from a file on disk:<br />
+  #     EndlessRuby.ER2RB("filename.er")
+  # <br />
+  # from string that is source code:<br />
+  #     EndlessRuby.ER2RB(<<DEFINE)
+  #       # endlessruby syntax
+  #     DEFINE
+  # <br />
+  # from IO:<br />
+  #     file = open 'filename.er'
+  #     EndlessRuby.ER2RB(file)
+  #
+  # appoint input file and output file:
+  #     ER2PR({ :in => { :any => 'filename.er' }, :out => { :any => 'filename.rb' } })
+  #     ER2PR({ :in => { :io => in_io }, :out => { :io => out_io } })
+  def endless_ruby_to_pure_ruby options
+    converting_helper options
+
+  alias to_pure_ruby endless_ruby_to_pure_ruby
+  alias ER2PR endless_ruby_to_pure_ruby
+  alias ER2RB endless_ruby_to_pure_ruby
 
+  # Rubyの構文をEndlessRubyの構文に変換します。optionsはendlessruby_to_pure_rubyと同じです。
+  def pure_ruby_to_endless_ruby options
+    options = merge_options options
+    options[:decompile] = true
+    converting_helper options
 
   alias RB2ER pure_ruby_to_endless_ruby
   alias PR2ER pure_ruby_to_endless_ruby
 
-  # EndlessRubyの構文をピュアなRubyの構文に変換します。
-  def endless_ruby_to_pure_ruby src
-    endless = src.split "\n"
-
-    pure = []
-    i = 0
-    while i < endless.length
-      pure << (currently_line = endless[i])
-
-      if currently_line =~ /(.*)(?:^|(?:(?!\\).))\#(?!\{).*$/
-        currently_line = $1
-
-      if blank_line? currently_line
-        i += 1
-        next
-
-      # ブロックを作らない構文なら単に無視する 
-      next i += 1 unless BLOCK_KEYWORDS.any? { |k| k[0] =~ unindent(currently_line)  }
-
-      # ブロックに入る
-      keyword = BLOCK_KEYWORDS.each { |k| break k if k[0] =~ unindent(currently_line)  }
-
-      currently_indent_depth = indent_count currently_line
-      base_indent_depth = currently_indent_depth
-
-      inner_statements = []
-      # def method1
-      #   statemetns
-      # # document of method2
-      # def method2
-      #   statements
-      # のような場合にコメントの部分はmethod1内に含まないようにする。
-      # def method1
-      #   statemetns
-      # # comment
-      #   return
-      # のような場合と区別するため。
-      comment_count = 0
-      in_here_document = nil
-      while i < endless.length
-
-        inner_currently_line = endless[i + 1]
-
-        if inner_currently_line =~ /(.*)(?:^|(?:(?!\\).))\#(?!\{).*$/
-          if blank_line?($1) && currently_indent_depth >= indent_count(inner_currently_line)
-            comment_count += 1
-          inner_currently_line = $1
-        elsif blank_line? inner_currently_line
-          comment_count += 1
-
-        if blank_line? inner_currently_line
-          inner_statements << endless[i + 1]
-          i += 1
-          next
+  private
+
+  def merge_options options
+
+    opts = {
+      :in => {}, :out => {}
+    }
 
-        just_after_indent_depth = indent_count inner_currently_line
+    if options.respond_to? :to_hash
+      opts = opts.merge options.to_hash
+    elsif options.respond_to?(:to_io) || options.respond_to?(:to_str)
+      opts[:in][:any] = options
+    else
+      raise ArgumentError, "options is IO, String, or Hash"
+
+    if opts[:in][:any]
+      if opts[:in][:any].respond_to?(:to_str) && File.exist?(opts[:in][:any].to_str) # from a file on the disk.
+        opts[:in] = {
+          :io => (in_io = open opts[:in][:any].to_str),
+          :ensure => proc { in_io.close }
+        }
+      elsif opts[:in][:any].respond_to? :to_io # from IO that can read source code.
+        opts[:in] = {
+          :io => options.to_io,
+          :ensure => proc {}
+        }
+      elsif opts[:in][:any].respond_to? :to_str # from String that is source code.
+        in_io = Tempfile.new "endlessruby from temp file"
+        in_io.write options.to_str
+        in_io.seek 0
+        opts[:in] = {
+          :io => in_io,
+          :ensure => proc { in_io.close }
+        }
+      else
+        raise ArgumentError, "options[:in][:any] is IO, String which is path, or String which is source code"
+
+    opts[:in][:any] = nil
+
+    if opts[:out][:any]
+      if opts[:out][:any].respond_to?(:to_str) # to a file on the disk.
+        opts[:out] = {
+          :io => (out_io = open opts[:out][:any].to_str, "w+"),
+          :ensure => proc { out_io.close }
+        }
+      elsif opts[:out][:any].respond_to? :to_io # to IO that can read source code.
+        opts[:out] = {
+          :io => options.to_io,
+          :ensure => proc {}
+        }
+      else
+        raise ArgumentError, "options[:out][:any] is IO, or String which is Path"
+    elsif !opts[:out][:io]
+      opts[:out] = { :io => (out_io = Tempfile.new("endlessruby pure temp file")), :ensure => proc { out_io.close } }
 
-        # 次の行がendならば意図のあるものなのでendを持ちあ揚げない
-        if inner_currently_line =~ /^\s*end(?!\w).*$/
-          comment_count = 0
+    opts[:out][:any] = nil
+    opts
 
-        if base_indent_depth < just_after_indent_depth
-          comment_count = 0
+  def converting_helper options
+    opts = merge_options options
 
-        if in_here_document
-          if (in_here_document[0] == '' && inner_currently_line =~ /^#{in_here_document[1]}\s*$/) || # <<DEFINE case
-              (in_here_document[0] == '-' && inner_currently_line =~ /^\s*#{in_here_document[1]}\s*$/) # <<-DEFINE case
-            in_here_document = nil
-            inner_statements << endless[i + 1]
-            i += 1
-            next
-          else
-            inner_statements << endless[i + 1]
-            i += 1
-            next
+    io = opts[:in][:io]
 
-        if inner_currently_line =~ /^.*?\<\<(\-?)(\w+)(?!\w).*$/
-          in_here_document = [$1, $2]
+    r = RubyLex.new
+    r.set_input io
+    r.skip_space = false
 
-        if base_indent_depth > indent_count(inner_currently_line)
-          break
+    pure = opts[:out][:io]
 
-        if base_indent_depth == indent_count(inner_currently_line)
-          unless keyword[1..-1].any? { |k| k =~ unindent(inner_currently_line) }
-            break
+    indent = []
+    pass = []
+    bol = true
+    last = [0, 0]
+    bol_indent = 0
+
+    while t = r.token
 
-        inner_statements << endless[i + 1]
-        i += 1
+      if bol && !(RubyToken::TkSPACE === t) && !(RubyToken::TkNL === t)
 
-      # endをコメントより上の行へ持ち上げる
-      if 0 < comment_count
-        comment_count.times do
-          inner_statements.pop
-        i -= comment_count
+        bol_indent = this_indent = t.char_no
+        while (indent.last && pass.last) && ((this_indent < indent.last) || (this_indent <= indent.last && !pass.last.include?(t.class)))
+          if RubyToken::TkEND === t && this_indent == indent.last
+            break
 
-      pure += ER2PR(inner_statements.join("\n")).split "\n"
-      # 次の行がendならばendを補完しない(ワンライナーのため)
-      unless @decompile
-        unless endless[i + 1] && endless[i + 1] =~ /^\s*end(?!\w).*$/
-          pure << "#{'  '*currently_indent_depth}end"
+          _indent = indent.pop
+          pass.pop
+          idt = []
+          loop do
+            pure.seek pure.pos - 1
+            if RUBY_VERSION < "1.9" # 1.8
+              c = pure.read(1)
+            else
+              c = pure.getc
+            break if pure.pos == 0 || !(["\n", ' '].include?(c))
+            pure.seek pure.pos - 1
+            idt.unshift c
+          if idt.first == "\n"
+            pure.write idt.shift
+          pure.write "#{' '*_indent}end\n"
+          pure.write idt.join
+        bol = false
+
+      case t
+      when RubyToken::TkNL
+        bol = true
+      when RubyToken::TkEND
+        indent.pop
+        pass.pop
+        if opts[:decompile]
+          last[0] += 3
+          last[1] += 3
+          next
+      when RubyToken::TkIF, RubyToken::TkUNLESS
+        pass << [RubyToken::TkELSE, RubyToken::TkELSIF]
+        indent << t.char_no
+      when RubyToken::TkFOR
+        pass << []
+        indent << t.char_no
+      when RubyToken::TkWHILE, RubyToken::TkUNTIL
+        pass << []
+        indent << t.char_no
+      when RubyToken::TkBEGIN
+        pass << [RubyToken::TkRESCUE, RubyToken::TkELSE, RubyToken::TkENSURE]
+        indent << t.char_no
+      when RubyToken::TkDEF
+        pass << [RubyToken::TkRESCUE, RubyToken::TkELSE, RubyToken::TkENSURE]
+        indent << t.char_no
+      when RubyToken::TkCLASS, RubyToken::TkMODULE
+        pass << []
+        indent << t.char_no
+      when RubyToken::TkCASE
+        pass << [RubyToken::TkWHEN, RubyToken::TkELSE]
+        indent << t.char_no
+      when RubyToken::TkDO
+        pass << []
+        indent << bol_indent
+      when RubyToken::TkSPACE
+
+
+      pos = io.pos
+      io.seek pos
+
+      pos = io.pos
+
+      if RUBY_VERSION < "1.9" # 1.8
+        io.seek t.seek
+        pure.write io.read(r.seek - t.seek)
+      else # 1.9
+        io.seek last[0]
+        (r.seek - last[1]).times do
+          pure.write io.getc
+        last = [io.pos, r.seek]
+
+      io.seek pos
+
+    until opts[:decompile] || (indent.empty? && pass.empty?)
+      _indent = indent.pop
+      pass.pop
+      pure.seek pure.pos - 1
+      if RUBY_VERSION < "1.9" # 1.8
+        c = pure.read 1
+      else
+        c = pure.getc
+      if c  == "\n"
+        pure.write "#{' '*_indent}end"
       else
-        # メソッドチェインは削除しない
-        if endless[i + 1] && endless[i + 1] =~ /^\s*end(?:\s|$)\s*$/
-          i += 1
+        pure.write "\n#{' '*_indent}end"
 
-      i += 1
-    pure.join "\n"
+    pure.seek 0
+    ret = pure.read.chomp
+    pure.seek 0
 
-  alias to_pure_ruby endless_ruby_to_pure_ruby
-  alias ER2PR endless_ruby_to_pure_ruby
-  alias ER2RB endless_ruby_to_pure_ruby
+    opts[:out][:ensure] && opts[:out][:ensure].call
+    opts[:in][:ensure] && opts[:in][:ensure].call
+
+    ret
 
 if __FILE__ == $PROGRAM_NAME
   require 'endlessruby/main'