endlessruby 0.0.1 → 0.1.0

data/History.txt

@@ -2,3 +2,4 @@
 
 * Alpha:
   * initial release
+  * 0.1.0 release

data/Manifest.txt

@@ -4,10 +4,10 @@ README.rdoc
 Rakefile
 bin/endlessruby
 lib/endlessruby.rb
-lib/endlessruby/extensions.rb
+lib/endlessruby/custom_require.rb
 lib/endlessruby/main.rb
 src/endlessruby.er
-src/endlessruby/extensions.er
+src/endlessruby/custom_require.er
 src/endlessruby/main.er
 src/er.er
 spec/blank_line_spec.rb
@@ -23,6 +23,7 @@ spec/semicolon_spec.rb
 spec/simply_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
+spec/use_end_case_spec.rb
 spec/test_data/er_omission.er
 spec/test_data/file.er
 spec/test_data/rb_omission.rb

data/README.rdoc

@@ -2,9 +2,15 @@
 
 * http://github.com/pasberth/EndlessRuby
 
+== UPDATE:
+EndlessRuby 0.0.1 からのアップデート
+* 正規表現ベースからirbに付属しているRubyLexベースに(かなり安定したと思います)
+* def method; a; end みたいな書式に対応
+* テストしてないけどRubyLexベースなのでたぶんけっこうな数の構文に対応している気がする
+
 == DESCRIPTION:
 
-EndlessRuby は Ruby を end なしで書けるプリプロセッサまたはコンパイラです。
+EndlessRuby は Ruby を end なしで代わりにインデントで書けるプリプロセッサまたはコンパイラです。
 * EndlessRuby で書かれたソースコードを Ruby プログラムから require
 * EndlessRuby で書かれたソースコードを ピュア Ruby にコンパイル
 ができます。
@@ -12,6 +18,9 @@ EndlessRuby は Ruby を end なしで書けるプリプロセッサまたはコ
 基本的にRubyの構文からendを取り除いただけで書けます。endを取り除かなくても実行可能です。
 EndlessRubyの独自な拡張的な構文はありません。
 ただ行単位で処理しているので def method; a; end みたいな書式できません。
+# 0.1.0 からできるようになりました
+
+endを取り除かなくても実行可能なので
 
 コンパイルする場合は
 $ endlessruby -c src/example.er src/more.er -o lib
@@ -21,6 +30,10 @@ src/example.er => lib/example.rb
 src/more.er => lib/more.rb
 として書き出されます。
 
+デコンパイル
+$ endlessruby -d lib/example.rb lib/more.rb -o src
+すべてのendを取り除きます
+
 実行する場合は
 $ endlessruby src/example.er
 
@@ -29,13 +42,23 @@ $ endlessruby src/example.er
 require 'endlessruby'
 require 'example.er'
 
-たぶんバグだらけです
+= BE CAREFUL
 
-== FEATURES/PROBLEMS:
+インデントを合わせる箇所に注意してください。インデントは行頭ではなくてキーワードに合わせてください。
 
-* def method; a; end みたいな書式に対応
+たとえばcaseの場合は
+
+YES:
+res = case x
+      when A then a
+      when B then b
+
+NO:
+res = case x
+when A then a
+when B then b
 
-== SYNOPSIS:
+複数行のブロックを渡す場合は {} ではなくて do end を使ってください。 {} の場合は閉じカッコを省略できません。
 
 = REQUIREMENTs
 

data/bin/endlessruby

@@ -2,4 +2,4 @@
 
 require "endlessruby"
 require "endlessruby/main"
-EndlessRuby::Main.main ARGV
+EndlessRuby::Main.main ARGV

data/lib/endlessruby.rb

@@ -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,207 +36,267 @@ 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+?/, '') == ""
-  end
-
-  # 内部で使用します。インデントを取り除きます
-  def unindent line
-    line  =~ /^\s*?(\S.*?)$/
-    $1
-  end
-  # 内部で使用します。インデントします
-  def indent line, level, indent="  "
-    "#{indent * level}#{line}"
-  end
-
-  # 内部で使用します。インデントの数を数えます。
-  def indent_count line, indent="  "
-    return 0 unless line
-    if line =~ /^#{indent}(.*?)$/
-      1 + (indent_count $1, indent)
-    else
-      0
-    end
-  end
-
-  # 内部で使用します。ブロックを作るキーワード群です。
-  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
   end
 
-  # 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
   end
 
+  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
+  end
 
   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"
+  private
+
+  def merge_options options
 
-    pure = []
-    i = 0
-    while i < endless.length
-      pure << (currently_line = endless[i])
+    opts = {
+      :in => {}, :out => {}
+    }
 
-      if currently_line =~ /(.*)(?:^|(?:(?!\\).))\#(?!\{).*$/
-        currently_line = $1
+    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"
+    end
+
+    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"
       end
+    end
 
-      if blank_line? currently_line
-        i += 1
-        next
+    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"
       end
+    elsif !opts[:out][:io]
+      opts[:out] = { :io => (out_io = Tempfile.new("endlessruby pure temp file")), :ensure => proc { out_io.close } }
+    end
 
-      # ブロックを作らない構文なら単に無視する 
-      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
-          end
-          inner_currently_line = $1
-        elsif blank_line? inner_currently_line
-          comment_count += 1
-        end
+    opts[:out][:any] = nil
+    opts
+  end
 
-        if blank_line? inner_currently_line
-          inner_statements << endless[i + 1]
-          i += 1
-          next
-        end
+  def converting_helper options
+    opts = merge_options options
 
-        just_after_indent_depth = indent_count inner_currently_line
+    io = opts[:in][:io]
 
-        # 次の行がendならば意図のあるものなのでendを持ちあ揚げない
-        if inner_currently_line =~ /^\s*end(?!\w).*$/
-          comment_count = 0
-        end
+    r = RubyLex.new
+    r.set_input io
+    r.skip_space = false
 
-        if base_indent_depth < just_after_indent_depth
-          comment_count = 0
-        end
+    pure = opts[:out][:io]
 
-        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
-          end
-        end
+    indent = []
+    pass = []
+    bol = true
+    last = [0, 0]
+    bol_indent = 0
 
-        if inner_currently_line =~ /^.*?\<\<(\-?)(\w+)(?!\w).*$/
-          in_here_document = [$1, $2]
-        end
+    while t = r.token
 
-        if base_indent_depth > indent_count(inner_currently_line)
-          break
-        end
+      if bol && !(RubyToken::TkSPACE === t) && !(RubyToken::TkNL === t)
 
-        if base_indent_depth == indent_count(inner_currently_line)
-          unless keyword[1..-1].any? { |k| k =~ unindent(inner_currently_line) }
+        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
           end
-        end
 
-        inner_statements << endless[i + 1]
-        i += 1
+          _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
+            end
+            break if pure.pos == 0 || !(["\n", ' '].include?(c))
+            pure.seek pure.pos - 1
+            idt.unshift c
+          end
+          if idt.first == "\n"
+            pure.write idt.shift
+          end
+          pure.write "#{' '*_indent}end\n"
+          pure.write idt.join
+        end
+        bol = false
       end
 
-      # endをコメントより上の行へ持ち上げる
-      if 0 < comment_count
-        comment_count.times do
-          inner_statements.pop
+      case t
+      when RubyToken::TkNL
+        bol = true
+      when RubyToken::TkEND
+        indent.pop
+        pass.pop
+        if opts[:decompile]
+          last[0] += 3
+          last[1] += 3
+          next
         end
-        i -= comment_count
+      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
       end
 
-      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"
-        end
-      else
-        # メソッドチェインは削除しない
-        if endless[i + 1] && endless[i + 1] =~ /^\s*end(?:\s|$)\s*$/
-          i += 1
+
+      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
         end
+        last = [io.pos, r.seek]
       end
 
-      i += 1
+      io.seek pos
     end
-    pure.join "\n"
-  end
 
-  alias to_pure_ruby endless_ruby_to_pure_ruby
-  alias ER2PR endless_ruby_to_pure_ruby
-  alias ER2RB endless_ruby_to_pure_ruby
+    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
+      end
+      if c  == "\n"
+        pure.write "#{' '*_indent}end"
+      else
+        pure.write "\n#{' '*_indent}end"
+      end
+    end
+
+    pure.seek 0
+    ret = pure.read.chomp
+    pure.seek 0
+
+    opts[:out][:ensure] && opts[:out][:ensure].call
+    opts[:in][:ensure] && opts[:in][:ensure].call
+
+    ret
+  end
 end
 
 if __FILE__ == $PROGRAM_NAME