endlessruby 0.0.1

data/src/endlessruby/main.er

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+module EndlessRuby::Main
+
+  extend self
+  extend EndlessRuby
+  include EndlessRuby
+
+  # er ファイルから読み込みそれをピュアなRubyにコンパイルしてrbに書き出します
+  def compile er, rb
+    open(er) do |erfile|
+      open(rb, "w") do |rbfile|
+        rbfile.write ER2PR(erfile.read)
+
+  # rbファイルを読み込みそれからすべてのendを取り除きます。
+  def decompile rb, er
+    open(rb) do |rbfile|
+      open(er, "w") do |erfile|
+        erfile.write PR2ER(rbfile.read)
+
+
+  # EndlessRuby::Main.main と同じ動作をします。このモジュールをincludeした場合に使用します。
+  def endlessruby argv
+    EndlessRuby::Main.main argv
+
+  # $ endlessruby.rb args とまったく同じ動作をします。argvはARGVと同じ形式でなければなりません。
+  def self.main argv
+
+    if argv.first && File.exist?(argv.first)
+      $PROGRAM_NAME = argv.shift
+      open $PROGRAM_NAME do |file|
+        EndlessRuby.ereval file.read, TOPLEVEL_BINDING, $PROGRAM_NAME
+      return true
+
+    require 'optparse'
+
+    options = {
+    }
+
+    parser = OptionParser.new do |opts|
+      opts.on '-o OUT' do |out|
+        options[:out] = out
+
+      opts.on '-c', '--compile' do |c|
+        options[:compile] = true
+
+      opts.on '-d', '--decompile' do |d|
+        options[:decompile] = true
+
+      opts.on '-r' do |r|
+        options[:recursive] = true
+
+    parser.parse! argv
+
+    if options[:compile]
+      out = options[:out] || '.'
+
+      argv.each do |er|
+        unless File.exist? er
+          puts "no such file to load -- #{er}"
+          next
+
+        if File.directory? er
+          unless options[:recursive]
+            puts "Is a directory - #{er}"
+            next
+          # Unimolementation
+          next
+
+        rb = er
+        if er =~ /^(.*)\.er$/
+          rb = $1
+        rb = File.split(rb)[1]
+        rb = File.join(out, "#{rb}.rb")
+        compile er, rb
+    elsif options[:decompile]
+      out = options[:out] || '.'
+
+      argv.each do |rb|
+        unless File.exist? rb
+          puts "no such file to load -- #{rb}"
+          next
+
+        if File.directory? rb
+          unless options[:recursive]
+            puts "Is a directory - #{rb}"
+            next
+          # Unimolementation
+          next
+
+        er = rb
+        if rb =~ /^(.*)\.rb$/
+          er = $1
+        er = File.split(er)[1]
+        er = File.join(out, "#{er}.er")
+        decompile rb, er

data/src/endlessruby.er

@@ -0,0 +1,213 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'endlessruby/extensions'
+
+# EndlessRubyはRubyをendを取り除いて書けます。
+#
+# erファイルをrequire
+#   require 'homuhomu.er' | require 'homuhomu'
+#
+# erファイルを実行
+#   $ path/to/endlessruby.rb homuhomu.er
+#
+# erファイルをコンパイル
+#   $ path/to/endlessruby.rb -c src/homuhomu.er -o lib
+#   # => src/homuhomu.er をコンパイルして lib/homuhomu.rb を書き出します。
+#   #  -o が省略された場合はカレントディレクトリに書き出します。
+#
+# Example:
+#   class EndlessRubyWorld
+#
+#     def self.hello!
+#       puts "hello!"
+#
+#
+#   [-2, -1, 0, 1, 2].reject do |x|
+#     x < 0
+#   end.each do |n|
+#     puts n
+#
+module EndlessRuby
+
+  # EndlessRuby のバージョンです
+  VERSION = "0.0.1"
+
+  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
+
+
+  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
+
+        just_after_indent_depth = indent_count inner_currently_line
+
+        # 次の行がendならば意図のあるものなのでendを持ちあ揚げない
+        if inner_currently_line =~ /^\s*end(?!\w).*$/
+          comment_count = 0
+
+        if base_indent_depth < just_after_indent_depth
+          comment_count = 0
+
+        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
+
+        if inner_currently_line =~ /^.*?\<\<(\-?)(\w+)(?!\w).*$/
+          in_here_document = [$1, $2]
+
+        if base_indent_depth > indent_count(inner_currently_line)
+          break
+
+        if base_indent_depth == indent_count(inner_currently_line)
+          unless keyword[1..-1].any? { |k| k =~ unindent(inner_currently_line) }
+            break
+
+        inner_statements << endless[i + 1]
+        i += 1
+
+      # endをコメントより上の行へ持ち上げる
+      if 0 < comment_count
+        comment_count.times do
+          inner_statements.pop
+        i -= comment_count
+
+      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"
+      else
+        # メソッドチェインは削除しない
+        if endless[i + 1] && endless[i + 1] =~ /^\s*end(?:\s|$)\s*$/
+          i += 1
+
+      i += 1
+    pure.join "\n"
+
+  alias to_pure_ruby endless_ruby_to_pure_ruby
+  alias ER2PR endless_ruby_to_pure_ruby
+  alias ER2RB endless_ruby_to_pure_ruby
+
+if __FILE__ == $PROGRAM_NAME
+  require 'endlessruby/main'
+  EndlessRuby::Main.main ARGV

data/src/er.er

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "endlessruby"
+require "endlessruby/main"
+EndlessRuby::Main.main ARGV

data/tasks/rspec.rake

@@ -0,0 +1,11 @@
+begin
+  require 'rspec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'rspec'
+end
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ['--options', "spec/spec.opts"]
+  t.pattern = 'spec/*_spec.rb'
+end

data/test/test_helpers.rb

@@ -0,0 +1,12 @@
+class TestEndlessRuby
+  
+  def test_blank_line
+    assert_equal true, (blank_line? "        ")
+  end
+
+  def test_not_blank_line
+    assert_equal false, (blank_line? "        pass")
+  end
+
+
+end

data/test/test_require.rb

@@ -0,0 +1,31 @@
+class TestEndlessRuby
+
+  def test_require_without_er
+    require "#{ROOT}/test/homu"
+    assert_equal "hello", Homu.hello
+  end
+  
+  def test_require
+    require "#{ROOT}/test/foo.er"
+    assert_equal "hello", Foo.hello
+  end
+
+  def test_load_path
+    $LOAD_PATH << "#{ROOT}/test"
+    require "bar.er"
+    assert_equal "hello", Bar.hello
+  end
+
+  def test_is_a_dir
+    assert_raise(LoadError) {
+      require "#{ROOT}/test/is_a_dir"
+    }  
+  end
+
+  def test_no_such_file
+    assert_raise(LoadError) {
+      require "#{ROOT}/test/no_such_file"
+    }
+  end
+
+end

data/test/test_simply.rb

@@ -0,0 +1,173 @@
+class TestEndlessRuby
+  
+  def test_1
+    er2rb_right_output?(<<DEFINE.chomp!,
+def test
+  test
+end
+DEFINE
+    <<DEFINE)
+def test
+  test
+DEFINE
+  end
+
+  def test_2
+    er2rb_right_output?(<<DEFINE.chomp!,
+class Test
+  def test
+    proc do |args|
+      pass
+    end
+    proc do |args|
+      pass
+    end
+  end
+end
+DEFINE
+    <<DEFINE)
+class Test
+  def test
+    proc do |args|
+      pass
+    proc do |args|
+      pass
+DEFINE
+  end
+
+  def test_3
+    er2rb_right_output?(<<DEFINE.chomp!,
+def test
+  if false
+    pass
+  elsif true
+    pass
+  else
+    pass
+  end
+end
+DEFINE
+    <<DEFINE)
+def test
+  if false
+    pass
+  elsif true
+    pass
+  else
+    pass
+DEFINE
+  end
+
+  def test_nest_keywords
+    er2rb_right_output?(<<DEFINE.chomp!,
+def test
+  if false
+    pass
+  elsif true
+    if true
+      pass
+    elsif false
+      pass
+    else
+      pass
+    end
+  else
+    pass
+  end
+end
+DEFINE
+    <<DEFINE)
+def test
+  if false
+    pass
+  elsif true
+    if true
+      pass
+    elsif false
+      pass
+    else
+      pass
+  else
+    pass
+DEFINE
+  end
+
+  def test_4
+    er2rb_right_output?(<<DEFINE.chomp!,
+def test
+  if_nantoka
+end
+DEFINE
+    <<DEFINE)
+def test
+  if_nantoka
+DEFINE
+  end
+
+
+  def test_here_document
+    er2rb_right_output?(<<DEFINE.chomp!,
+def method
+  src = <<SRC
+hello world
+SRC
+end
+DEFINE
+    <<DEFINE)
+def method
+  src = <<SRC
+hello world
+SRC
+DEFINE
+  end
+
+  def test_here_document2
+    er2rb_right_output?(<<DEFINE.chomp!,
+def method
+  src = <<-SRC
+hello world
+  SRC
+end
+DEFINE
+    <<DEFINE)
+def method
+  src = <<-SRC
+hello world
+  SRC
+DEFINE
+  end
+
+
+  def test_commentout
+    er2rb_right_output?(<<DEFINE.chomp!,
+def method
+  #TODO:
+  # proc do
+  #   statements 
+end
+DEFINE
+    <<DEFINE)
+def method
+  #TODO:
+  # proc do
+  #   statements 
+DEFINE
+  end
+
+  def test_commentout
+    er2rb_right_output?(<<DEFINE.chomp!,
+def method
+  statements #TODO:
+  statements # proc do
+  statements #   statements 
+end
+DEFINE
+    <<DEFINE)
+def method
+  statements #TODO:
+  statements # proc do
+  statements #   statements 
+DEFINE
+  end
+
+end

data/test/test_use_end_case.rb

@@ -0,0 +1,81 @@
+class TestEndlessRuby
+  
+
+  def test_method_chain_case
+
+    er2rb_right_output?(<<DEFINE.chomp!,
+def test
+  self.map do |item|
+    pass
+  end.each do |item|
+    pass
+  end
+end
+DEFINE
+    <<DEFINE)
+def test
+  self.map do |item|
+    pass
+  end.each do |item|
+    pass
+DEFINE
+
+  end
+
+  def test_method_chain_and_nest_case
+
+    er2rb_right_output?(<<DEFINE.chomp!,
+def test
+  self.map do |item|
+    self.map do |item2|
+      pass
+    end
+  end.each do |item|
+    pass
+  end
+end
+DEFINE
+    <<DEFINE)
+def test
+  self.map do |item|
+    self.map do |item2|
+      pass
+  end.each do |item|
+    pass
+DEFINE
+
+  end
+
+  def test_use_end_case
+    er2rb_right_output?(<<DEFINE.chomp!,
+def test
+  self.map do |item|
+  end
+end
+DEFINE
+    <<DEFINE)
+def test
+  self.map do |item|
+  end
+end
+DEFINE
+  end
+
+  def test_beggining_of_the_end_function
+    er2rb_right_output?(<<DEFINE.chomp!,
+def test
+  self.each do |item|
+    pass
+  end
+  endlessruby src
+end
+DEFINE
+    <<DEFINE)
+def test
+  self.each do |item|
+    pass
+  endlessruby src
+DEFINE
+  end
+
+end