lazibi 0.1.13 → 0.1.14

data/config/lazibi_config_template.rb

@@ -0,0 +1,15 @@
+module Lazibi
+  class Config
+    def filter_order
+      [:syntax_guard, :beautify, :optional_end, :optional_do]
+    end
+
+    def exclude
+      ['^vendor']
+    end
+
+    def filters
+      {:optional_do => ['^spec'], :optional_end => ['']}
+    end
+  end
+end

data/lib/core/beautify_engine.rb

@@ -0,0 +1,10 @@
+require 'engine_base'
+
+module Lazibi
+  class BeautifyEngine < EngineBase
+    def initialize
+      super
+      go_up :syntax_guard, :beautify
+    end
+  end
+end

data/lib/core/default_engine.rb

@@ -0,0 +1,11 @@
+require 'beautify_engine'
+
+module Lazibi
+  class DefaultEngine < BeautifyEngine
+    def initialize
+      super
+      go_up :optional_end, :optional_do
+      go_down :optional_do, :optional_end
+    end
+  end
+end

data/lib/core/engine_base.rb

@@ -0,0 +1,74 @@
+$:.unshift(File.dirname(__FILE__) + '/../filter')
+$:.unshift(File.dirname(__FILE__) + '/../helper')
+
+require 'rubygems'
+require 'active_support'
+require 'application_helper'
+
+module Lazibi
+  class EngineBase
+    include Helper::ApplicationHelper
+    
+    attr :up_path
+    attr :down_path
+    attr :filters
+    
+    def initialize
+      @filters = []
+      @up_path = []
+      @down_path = []
+      filter_dir = File.dirname(__FILE__) + '/../filter'
+
+      Dir.open(filter_dir).each do |fn|
+        next unless fn =~ /[.]rb$/
+        require fn
+        @filters << fn.scan(/(.*)[.]/).to_s.to_sym
+      end
+    end
+        
+        
+    def go_up(*paths)
+      @up_path += Array(paths)
+    end
+  
+    def go_down(*paths)
+      @down_path += Array(paths)
+    end
+  
+    def up(source)
+      return source if source.blank?
+      transcript = source
+      valid = true
+      @up_path.each do |step|
+        class_name = step.to_s.camelize
+        filter = Filter.const_get(class_name).new
+        transcript = filter.up(transcript)
+        unless transcript
+          valid = false
+          break
+        end
+      end
+      
+      valid ? transcript : skip_notice + "\n" + source
+    end
+  
+    def down(source)
+      return source if source.blank?
+      transcript = source
+      if transcript.split("\n").first == skip_notice
+        return source.split("\n")[1..-1].join("\n")
+      end
+      
+      @down_path.each do |step|
+        class_name = step.to_s.camelize
+        filter = Filter.const_get(class_name).new
+        transcript = filter.down(transcript)
+      end
+      transcript
+    end
+      
+    def to_s
+      'up_path: ' + @up_path.to_s + "\n" + 'down_path: ' + @down_path.to_s
+    end
+  end
+end

data/lib/filter/beautify_filter.rb

@@ -0,0 +1,148 @@
+# 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 filter by Jinjing
+
+require 'filter_base'
+require 'beautify_filter_helper'
+
+module Lazibi
+  module Filter
+    class Beautify < FilterBase
+      include Helper::BeautifyFilterHelper
+      
+      def make_tab(tab)
+        return (tab < 0) ? "": tab_str * tab_size * tab
+      end
+
+      def add_line(line,tab)
+        line.strip!
+        line = make_tab(tab)+line if line.length > 0
+        return line + "\n"
+      end
+
+      def 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 up( 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
+              tline = clean_line(tline)
+              outdent_exp.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 += add_line(ml,tab)
+                  first_line = false
+                elsif ml.strip =~ /^unless/ || ml.strip =~ /^if/
+                  dest = dest.chop.rstrip.chop.rstrip + ' ' + ml.strip + "\n"
+                else
+                  dest += add_line(ml,tab)
+                end
+              end
+              multiLineArray.clear
+              multiLineStr = ""
+            else
+              dest += add_line(line,tab)
+            end
+            if(!commentLine)
+              indent_exp.each do |re|
+                if(tline =~ re) && !(tline =~ /\s+end\s*$/)
+                  tab += 1
+                  break
+                end
+              end
+            end
+          end
+          if(tline =~ /^=end/)
+            commentBlock = false
+          end
+        end
+        dest
+      end
+    end
+  end
+end

data/lib/filter/filter_base.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__) + '/../helper')
+require 'filter_helper'
+
+
+module Lazibi
+  module Filter
+    class FilterBase
+      include Helper::FilterHelper
+      
+      def up(source)
+        source
+      end
+      
+      def down(source)
+        source
+      end
+    end
+  end
+end

data/lib/filter/optional_do_filter.rb

@@ -0,0 +1,66 @@
+require 'filter_base'
+
+module Lazibi
+  module Filter
+    class OptionalDo < FilterBase
+      def up(source)
+        lines = source.split("\n")
+        lines.each_index do |index|
+          l = lines[index]
+          l = optional_do_filter_to_py( lines, index )
+          lines[index] = l
+        end
+        lines.join "\n"
+      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
+        
+    
+      def down(source)
+        lines = source.split("\n")
+        lines.each_index do |index|
+          l = lines[index]
+          l = optional_do_filter_to_rb(lines, index)
+          lines[index] = l
+        end
+        lines.join "\n"
+      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
+        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
+    end
+  end
+end

data/lib/filter/optional_end_filter.rb

@@ -0,0 +1,124 @@
+require 'filter_base'
+
+module Lazibi
+  module Filter
+    class OptionalEnd < FilterBase
+      
+      def up( source )
+        rb = source
+        py = []
+        lines = rb.split("\n")
+        lines.each_index do |index|
+          l = lines[index]
+          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 down( source )
+        content = source
+        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
+      end
+      
+      def insert_end( content )
+        @lines = content.split("\n")
+        progress = 0
+        while progress < @lines.size
+          lines = @lines[progress..-1]
+          lines.each_index do |index|
+            l = lines[index]
+            safe_l = clean_block(clean_line(get_rest(l)))
+            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
+    end
+  end
+end