lazibi 0.1.13 → 0.1.14

data/lib/helper/parser_helper.rb

@@ -1,92 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../vendor')
-
-require 'beautifier'
-
-module Lazibi
-  module ParserHelper
-    SKIP = "#skip_parse"
-
-    def get_indent( line )
-      line =~ /( *)/
-      $1.size
-    end
-
-    def get_rest( line )
-      line =~/( *)/
-      $'
-    end
-
-    def begin_keys
-      [
-        /^module\b/,
-        /(=\s*|^|<<\s*)if\b/,
-        /(=\s*|^|<<\s*)until\b/,
-        /(=\s*|^|<<\s*)for\b/,
-        /(=\s*|^|<<\s*)unless\b/,
-        /(=\s*|^|<<\s*)while\b/,
-        /(=\s*|^|<<\s*)begin\b/,
-        /(=\s*|^|<<\s*)loop\b\s*do/,
-        /\bcase\b/,
-        /^class\b/,
-        /^def\b/,
-        /\bdo\b/,
-      ]
-    end
-
-    def middle_keys
-      [
-        /^then\b/,
-        /^else\b/,
-        /^elsif\b/,
-        /^ensure\b/,
-        /^rescue\b/,
-        /^when\b/
-      ]
-    end
-
-
-    def end_keys
-      /^end\b/
-    end
-
-    def start_anchor?( str )
-      return false if str =~ /^#/
-      str = clean_line str
-      group_match str, begin_keys
-    end
-
-    def middle_anchor?( str )
-      str = clean_line str
-      group_match str, middle_keys
-    end
-
-
-    def group_match(str, patterns)
-      for pattern in patterns
-        return true if str =~ pattern
-      end
-      false
-    end
-
-    def end_anchor?(str)
-      str =~ end_keys
-    end
-
-    def clean_line(line, leave_comment = false)
-      Beautifier::clean_line line, leave_comment
-    end
-
-    # why?
-    def nasty_line?(line)
-      return false
-      s = %w! \/ ' " \( \{ \[ !
-      p = Regexp.new(s.join('|'))
-      return line =~ p
-    end
-
-    def comment_at_end(line)
-      return false if line.strip ==''
-      clean_line(line, true) =~ /#/
-    end
-  end
-end

data/lib/parser.rb

@@ -1,194 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/helper')
-
-require 'parser_helper'
-
-module Lazibi
-  module Parser
-    include ParserHelper
-
-    def to_py( rb, filters = [] )
-      py = []
-      lines = rb.split("\n")
-      lines.each_index do |index|
-        l = filter_for_to_py(lines, index, filters)
-        if l.strip =~ /^end$/
-          next
-        end
-        l = remove_colon_at_end(l)
-
-        s = l
-        if comment_at_end(l)
-          s = s.sub(/(\s*;\s*end*\s*)(#.*)/, ' \2')
-          s = s.sub(/(\s+end*\s*)(#.*)/, ' \2')
-        else
-          s = s.sub(/\s+end\s*$/, '')
-          s = remove_colon_at_end(s)
-        end
-
-        py << s
-      end
-
-      py.join("\n")
-    end
-
-
-    def remove_colon_at_end(l)
-      if comment_at_end(l)
-        l.sub /(\s*;\s*)(#.*)/, ' \2'
-      else
-        l.sub /;*$/, ''
-      end
-    end
-
-    def to_rb( content, filters = [] )
-      return '' if content.strip == ''
-      lines = content.split("\n")
-      first_line = lines.first.strip
-      return lines[1..-1].join("\n") if first_line == '#skip_parse'
-      insert_end content, filters
-    end
-
-
-    # private
-
-    def insert_end( content, filters )
-      @lines = content.split("\n")
-      progress = 0
-      while progress < @lines.size
-        lines = @lines[progress..-1]
-        lines.each_index do |index|
-          # run through filters
-          # destructively
-          l = filter_for_to_rb(lines, index, filters)
-          @lines[progress] = l
-          safe_l = clean_block(clean_line(get_rest(l)))
-          if l =~ /dependencies/
-            puts l, safe_l, clean_line(get_rest(l))
-          end
-          if start_anchor? safe_l
-            relative_index_for_end = find_end( lines[index..-1], get_indent(l))
-            unless relative_index_for_end
-              progress += 1
-              break
-            end
-            index_for_end = relative_index_for_end + index
-
-            if relative_index_for_end == 0 && !comment_at_end(l)
-              #l = lines[index_for_end]
-              lines[index_for_end] = lines[index_for_end].rstrip + '; end'
-            else
-              lines[index_for_end] = lines[index_for_end] + "\n" +  ' ' * get_indent(l) + "end"
-            end
-            head = @lines[0...progress]
-            tail = lines[index..-1].join("\n").split("\n")
-
-            @lines = head + tail
-
-
-            progress += 1
-            break
-          end
-          progress += 1
-        end
-      end
-
-      result = @lines.join("\n")
-    end
-
-    def find_end( lines, indent )
-      return 0 if lines.size == 1
-
-      anchor = 0
-
-      lines = lines[1..-1]
-      lines.each_index do |i|
-        l = lines[i]
-        next if l.strip == ''
-        if l.strip =~ /^#/
-          if get_indent(l) > indent
-            anchor = i + 1
-          end
-          next
-        end
-        return anchor if get_indent(l) < indent
-        if get_indent(l) == indent
-          rest = get_rest l
-          if start_anchor? rest
-            return anchor
-          elsif end_anchor? rest
-            return false
-          elsif middle_anchor? rest
-            anchor = i + 1
-            next
-          else
-            return anchor
-          end
-        end
-        anchor =  i + 1
-      end
-      return anchor
-    end
-
-    def filter_for_to_rb(lines, index, filters)
-      l = lines[index]
-      if filters.include?( :optional_do )
-        l = optional_do_filter_to_rb(lines, index)
-      end
-      # destructive behaviour
-      lines[index] = l
-      l
-    end
-
-    def optional_do_filter_to_rb(lines, index)
-      l = lines[index]
-      return l if l.strip == ''
-      return l if l =~ /[\{\[]\s*$/
-      rest = get_rest(l)
-      return l if start_anchor?(rest) || middle_anchor?(rest) || end_anchor?(rest)
-
-      l_check = clean_line l
-      # bad code
-      # return l if nasty_line?(l_check)
-      next_line = ''
-      if index + 1 < lines.size
-        lines[index+1..-1].each_index do |i|
-          abs_i = index + 1 + i
-          next if lines[abs_i].strip == ''
-          next_line = lines[abs_i]
-          break
-        end
-      else
-        return l
-      end
-      if get_indent(next_line) > get_indent(l)
-        return l.rstrip + ' do'
-      else
-        return l
-      end
-    end
-
-
-    def filter_for_to_py(lines, index, filters)
-      l = lines[index]
-      if filters.include?( :optional_do )
-        l = optional_do_filter_to_py( lines, index )
-      end
-
-      # destructive behaviour
-      lines[index] = l
-      l
-    end
-
-    def optional_do_filter_to_py(lines, index)
-      l = lines[index]
-      return l if l.strip == ''
-      return l if l.strip[0..0] == '#'
-      l_check = clean_line(l).strip
-      if l_check.size > 2 && l.strip[-3..-1] == ' do' && !nasty_line?(l_check)
-        l = l.rstrip[0...-3].rstrip
-        return l
-      end
-      return l
-    end
-  end
-end

data/lib/vendor/beautifier.rb

@@ -1,278 +0,0 @@
-# Ruby beautifier, version 1.3, 04/03/2006
-# Copyright (c) 2006, P. Lutus
-# TextMate modifications by T. Burks
-# Released under the GPL
-# Modified for lazibi by Jinjing
-
-module Beautifier
-
-  $tabSize = 2
-  $tabStr = " "
-
-  # indent regexp tests
-
-  $indentExp = [
-    /^module\b/,
-    /(=\s*|^|<<\s*)if\b/,
-    /(=\s*|^|<<\s*)until\b/,
-    /(=\s*|^|<<\s*)for\b/,
-    /(=\s*|^|<<\s*)unless\b/,
-    /(=\s*|^|<<\s*)while\b/,
-    /(=\s*|^|<<\s*)begin\b/,
-    /(=\s*|^|<<\s*)loop\b/,
-    #    /\bthen\b/,
-    /\bcase\b/,
-    /^class\b/,
-    /^rescue\b/,
-    /^def\b/,
-    /\bdo\b/,
-    /^else\b/,
-    /^elsif\b/,
-    /^ensure\b/,
-    /\bwhen\b/,
-    /\{[^\}]*$/,
-    /\[[^\]]*$/
-  ]
-
-  # outdent regexp tests
-
-  $outdentExp = [
-    /^rescue\b/,
-    /^ensure\b/,
-    /^elsif\b/,
-    #    /\bthen\b/,
-    /^end\b/,
-    /^else\b/,
-    /\bwhen\b/,
-    /^[^\{]*\}/,
-    /^[^\[]*\]/
-  ]
-
-
-
-  def self.makeTab(tab)
-    return (tab < 0) ? "":$tabStr * $tabSize * tab
-  end
-
-  def self.addLine(line,tab)
-    line.strip!
-    line = makeTab(tab)+line if line.length > 0
-    return line + "\n"
-  end
-
-  def self.clean_line( line, leave_comment = false )
-
-    # throw out sequences that will
-    # only sow confusion
-    # " \"" << "#{base}/#{path}".gsub(/["?<>\*]/, '') << "\""
-    tline = line.dup.sub /[;]*$/, ''
-
-
-
-
-    tline.gsub!(/#\{.*?\}/,"")
-    tline.gsub!(/\\\"/,"'")
-
-    # deal with nested syntax
-
-    tline.gsub!(/"\/*?"/,"\"\"")
-    tline.gsub!(/\/.*?[^\\]\//,"//")
-
-    # again
-    tline.gsub!(/".*?"/,"\"\"")
-    tline.gsub!(/'.*?'/,"''")
-    tline.gsub!(/`.*?`/,"''")
-
-    # more ..
-    tline.gsub!(/%[qwsrx]\{.*?\}/, "''")
-    tline.gsub!(/%[qwsrx]\(.*?\)/, "''")
-    tline.gsub!(/%[qwsrx]\[.*?\]/, "''")
-    tline.gsub!(/%[qwsrx](.).*?\1/, "''")
-
-    tline.gsub!(/#.*$/, '') unless leave_comment
-
-    tline
-  end
-
-  def self.split_end( source )
-    lines = source.split("\n")
-    new_lines = []
-    for line in lines
-      if line =~ /^\s*#/
-        new_lines << line
-      else
-        new_lines << line.gsub( /\send\./, "\nend." )
-      end
-    end
-
-    new_lines.join("\n")
-  end
-
-  def self.join_sep_line( source )
-    lines = source.split("\n")
-    continue = false
-    buffer = ''
-    new_lines = []
-    for line in lines
-      if clean_line(line, true).strip =~ /#/
-        if continue
-          new_lines << buffer
-          new_lines << line
-          buffer = ''
-        else
-          new_lines << line
-        end
-        next
-      end
-
-      if continue
-        if line.strip == ''
-          continue = false
-          new_lines << buffer
-          new_lines << line
-          buffer = ''
-        elsif line.strip[-1..-1] == "\\"
-          continue = true
-          buffer += ' ' + line.strip[0...-1].strip
-        else
-          continue = false
-          buffer += ' ' + line.lstrip
-          new_lines << buffer
-          buffer = ''
-        end
-      else
-        if line.strip == ''
-          new_lines << line
-        elsif line.strip[-1..-1] == "\\"
-          continue = true
-          buffer += line.rstrip[0...-1].strip
-        else
-          new_lines << line
-        end
-      end
-    end
-
-    new_lines.join("\n")
-  end
-
-
-  def self.valid?( line )
-    not_supported = using_eval?(line) || here_doc?(line) || special_syntax(line)
-    return !not_supported
-  end
-
-  def self.using_eval?( line )
-    line =~ /\b(class|module|instance)_eval\b/
-  end
-
-  def self.here_doc?( line )
-    line =~ /(=\s*<<)|(<<-)/
-  end
-
-  def self.special_syntax( line )
-    patterns = [
-      /:\[\]=/,
-      /\beval\b/,
-      /javascript_cdata/
-    ]
-    for p in patterns
-      return true if line =~ p
-    end
-
-    false
-  end
-
-  def self.valid_before_clean?( line )
-    r = line =~ /#\{[^\{]*#\{.*\}.*\}/
-    r.nil?
-  end
-
-
-  def self.ruby( source )
-    invalid = false
-    #source = join_sep_line(split_end(source))
-    source = split_end(source)
-    commentBlock = false
-    multiLineArray = Array.new
-    multiLineStr = ""
-    tab = 0
-    dest = ""
-    source.split("\n").each do |line|
-      # combine continuing lines
-      if(!(clean_line(line, true) =~ /\s*#/) && line =~ /[^\\]\\\s*$/)
-        multiLineArray.push line
-        multiLineStr += line.sub(/^(.*)\\\s*$/,"\\1")
-        next
-      end
-
-      # add final line
-      if(multiLineStr.length > 0)
-        multiLineArray.push line
-        multiLineStr += line.sub(/^(.*)\\\s*$/,"\\1")
-      end
-
-      tline = ((multiLineStr.length > 0)?multiLineStr:line).strip
-      if(tline =~ /^=begin/)
-        commentBlock = true
-      end
-      if(commentBlock)
-        # add the line unchanged
-        dest += line + "\n"
-      else
-        commentLine = (tline =~ /^#/)
-        if(!commentLine)
-          # throw out sequences that will
-          # only sow confusion
-          valid_before = valid_before_clean?( tline )
-          tline = clean_line(tline)
-          unless ( valid?(tline) && valid_before )
-            puts '- ' + tline
-            invalid = true
-            break
-          end
-          $outdentExp.each do |re|
-            if(tline =~ re)
-              tab -= 1
-              break
-            end
-          end
-        end
-        if (multiLineArray.length > 0)
-          first_line = true
-          multiLineArray.each do |ml|
-            if first_line
-              dest += addLine(ml,tab)
-              first_line = false
-            elsif ml.strip =~ /^unless/ || ml.strip =~ /^if/
-              dest = dest.chop.rstrip.chop.rstrip + ' ' + ml.strip + "\n"
-            else
-              dest += addLine(ml,tab)
-            end
-          end
-          multiLineArray.clear
-          multiLineStr = ""
-        else
-          dest += addLine(line,tab)
-        end
-        if(!commentLine)
-          $indentExp.each do |re|
-            if(tline =~ re) && !(tline =~ /\s+end\s*$/)
-              tab += 1
-              break
-            end
-          end
-        end
-      end
-      if(tline =~ /^=end/)
-        commentBlock = false
-      end
-    end
-    # STDOUT.write(dest)
-    # uncomment this to complain about mismatched blocks
-    # if(tab != 0)
-    #   STDERR.puts "Indentation error: #{tab}"
-    #
-    return false if invalid
-    dest
-  end
-end