vorax 0.1.0pre

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+*.rbc
+.config
+.yardoc
+_yardoc
+doc/
+spec/reports

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Alexandru Tica
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# Ruby::Vorax
+
+Provides the logic required by Vorax, an Oracle IDE for geeks. Even
+the main goal of this gem is to support Vorax, it can also be used
+as it is to interact with a hidden SqlPLUS process or to parse 
+SQL/PLSQL code.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ruby-vorax'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby-vorax
+
+## Usage
+
+To create a SqlPLUS connection and execute something:
+    
+    sp = Sqlplus.new('sqlplus')
+    sp.exec('select table_name from all_tables;')
+    print sp.read_output(32767) while sp.busy?
+    sp.terminate
+
+To get the structure of a PLSQL code:
+
+    text = File.open('spec/sql/test.pkg', 'rb') { |file| file.read }
+    structure = Parser::PlsqlStructure.new(text)
+    structure.print_tree
+
+See the "YARD" generated documentation for additional info.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,30 @@
+require_relative 'spec/spec_helper.rb'
+require 'rspec/core/rake_task'
+require 'yard'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new
+
+desc "Generate documentation"
+YARD::Rake::YardocTask.new
+
+desc 'Builds the gem'
+task :build do
+  sh "gem build vorax.gemspec"
+end
+
+desc 'Builds and installs the gem'
+task :install => :build do
+  sh "gem install vorax-#{Vorax::VERSION}"
+end
+
+desc 'Tags version, pushes to remote, and pushes gem'
+task :release => :build do
+  sh "git tag v#{Vorax::VERSION}"
+  sh "git push origin master"
+  sh "git push origin v#{Vorax::VERSION}"
+  sh "gem push vorax-#{Vorax::VERSION}.gem"
+end

data/lib/vorax/base_funnel.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require 'nokogiri'
+
+module Vorax
+
+  # A funnel is an abstraction for the idea of formatting text. You
+  # write some text into the funnel and then you read it formatted. It's
+  # up to every subclass to implement the transformation logic.
+  class BaseFunnel
+
+    # Write the text to be converted into the funnel. By default, this
+    # method does nothing, since it is intended to be overwritten by
+    # subclasses.
+    #
+    # @param text [String] the text to be formatted.
+    def write(text)
+      # do nothing: subclass responsability
+    end
+
+    # Read the converted text. By default, this method does nothing. It is
+    # intended to be overridden in subclasses.
+    def read
+      # do nothing: subclass responsability
+    end
+
+  end
+
+end
+

data/lib/vorax/output/html_convertor.rb

@@ -0,0 +1,120 @@
+# encoding: UTF-8
+
+module Vorax
+  module Output
+
+    # An abstraction for converting an XML/HTML to something else. The idea is that
+    # sqlplus may be configured to spit HTML output so that we can easily parse
+    # it and transform it to something else. The io attribute is the pipe used to
+    # push HTML content and fetch the formatted text.
+    class HTMLConvertor < Nokogiri::XML::SAX::Document
+
+      attr_reader :io, :text
+
+      # Creates a new convertor.
+      def initialize()
+        super()
+        @io = StringIO.new("")
+        @tags_chain = []
+        @text = ''
+      end
+
+      # This callback must be defined in every subclass. It is
+      # invoked as soon as a new tag is detected.
+      #
+      # @param name [String] the detected tag name
+      # @param attrs [Array] an array with all defined attributes for
+      #   the detected tag.
+      def start_hook name, attrs = []
+        # this should be implemented in sub-classes
+      end
+
+      # This callback must be defined in every subclass. It is
+      # invoked as soon as a end tag definition is detected.
+      #
+      # @param name [String] the name of the endding tag
+      def end_hook name
+        # this should be implemented in sub-classes
+      end
+
+      # Indent every line from the provided text with the given pad
+      # size.
+      #
+      # @param text [String] the multiline text to be indented
+      # @param pad_size [int] the padding size
+      #
+      # @return the indented text
+      def self.ml_indent(text, pad_size)
+        text.gsub(/\r?\n/, "\n#{' '*pad_size}")
+      end
+
+      # Get the N-th line from the provided multiline text.
+      #
+      # @param text [String] the multiline text
+      # @param lineno [int] the line number
+      # @return the N-th line
+      def self.ml_segment(text, lineno)
+        text.split(/\r?\n/)[lineno] || ""
+      end
+
+      # Get the size of the largest line from a multiline text.
+      #
+      # @param text [String] the multiline text.
+      # @return the size of the largest line
+      def self.ml_width(text)
+        text.split(/\r?\n/).inject(0) { |counter, elem| [elem.length, counter].max }
+      end
+
+      # Get the number of lines from a multiline text.
+      #
+      # @param text [String] the multiline text.
+      # @return the number of lines
+      def self.ml_count(text)
+        text.scan(/\r?\n/).size
+      end
+
+      # Get the HTML tag to be used to ping the Nokogiri parser.
+      # @return the ping tag
+      def self.ping_tag
+        "s"
+      end
+
+      # Whenever or not the convertor should spit plain text which is directly
+      # under <body> tag.
+      def should_spit_text?
+        @tags_chain.size > 0 && 
+          #(not @text.empty?) &&
+          ["body", "p", "br", HTMLConvertor.ping_tag].include?(@tags_chain.last[:name])
+      end
+
+      # The text accumulated within the current tag. This is automatically
+      # called from the Nokogiri engine.
+      def characters(str)
+        @text << str if str && !str.empty?
+      end
+
+      private
+
+      def start_element name, attrs = []
+        @tags_chain.push({:name => name.downcase, :attrs => attrs})
+        if should_spit_text?
+          chunk = @text
+          chunk.strip! unless @tags_chain.last[:name] == 'pre'
+          @io << chunk unless chunk.empty?
+          @text.clear
+        end
+        start_hook(name, attrs)
+      end
+
+      def end_element name
+        if name == 'pre'
+          @io << @text
+        end
+        end_hook(name.downcase)
+        @tags_chain.pop
+      end
+
+    end
+
+  end
+end

data/lib/vorax/output/html_funnel.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+
+require 'nokogiri'
+
+module Vorax
+
+  # A namespace for everything related to the sqlplus output processing.
+  module Output
+
+    # A special type of funnel to work with HTML convertors.
+    class HTMLFunnel < BaseFunnel
+
+      # Creates a new HTML funnel.
+      #
+      # @param convertor [HTMLConvertor] the convertor to be used
+      #   to transform the HTML content.
+      def initialize(convertor)
+        @tail = ''
+        @parser = Nokogiri::HTML::SAX::PushParser.new(convertor)
+      end
+
+      # Put the html content into the funnel.
+      #
+      # @param text [String] a chunk of HTML text
+      def write(text)
+        if text && !text.empty?
+          @parser.write text
+          if @parser.document.should_spit_text?
+            @tail << text
+            # just to be sure we don't have stale text after
+            # the last end tag
+            ping
+          end
+        end
+      end
+
+      # Get the formatted text from the funnel, as it is transformed
+      # by the buddy convertor.
+      #
+      # @return the formatted text
+      def read
+        @parser.document.io.rewind
+        chunk = @parser.document.io.read
+        @parser.document.io.truncate(0)
+        @parser.document.io.seek(0)
+        return chunk
+      end
+
+      private
+
+      # This is a workaround. The Nokogiri pull parser doesn't spit anything
+      # if there's no endding tag. For example, if "<p>Text" is given, "Text" will not
+      # be spit because the end "</p>" is missing. In sqlplus this is common
+      # especially for "prompt" or "accept" commands which spit output without
+      # enclosing the text in any tags. The main problem is ACCEPT, where VoraX
+      # will wait for users input, but the prompt will not be shown which will 
+      # make the poor user confused. The solution is to force a random tag into
+      # the HTML input stream so that the parser to move along.
+      def ping
+        unless @tail.empty?
+          # be carefull not to ping into incomplete tags
+          last_open_tag_position = (@tail.rindex('<') || -1)
+          last_close_tag_position = (@tail.rindex('>') || -1)
+          last_open_entity_position = (@tail.rindex('&') || -1)
+          last_close_entity_position = (@tail.rindex(';') || -1)
+          hwm = [last_close_tag_position, last_close_entity_position].max
+          @tail = @tail[hwm + 1 .. -1] if hwm >= 0
+          if last_close_tag_position >= last_open_tag_position && 
+             last_close_entity_position >= last_open_entity_position
+            @parser << "<#{HTMLConvertor.ping_tag}/>" 
+          end
+        end
+      end
+
+    end
+
+  end 
+
+end

data/lib/vorax/output/pagezip_convertor.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+module Vorax
+  module Output
+
+    # A convertor used to compress every page returned by sqlplus when executing
+    # a query.
+    class PagezipConvertor < ZipConvertor
+
+      # @see ZipConvertor.should_spit?
+      def should_spit?(end_tag)
+        ("table" == end_tag) ||
+          ("th" == end_tag && rows.size > 0)
+      end
+
+    end
+
+  end
+end
+

data/lib/vorax/output/tablezip_convertor.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+module Vorax
+  
+  module Output
+
+    # A convertor used to compress every HTML TABLE from the
+    # sqlplus output.
+    class TablezipConvertor < ZipConvertor
+
+      # see ZipConvertor.should_spit?
+      def should_spit?(current_tag)
+        current_tag == "table"
+      end
+
+    end
+
+  end
+
+end
+
+

data/lib/vorax/output/vertical_convertor.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+module Vorax
+  module Output
+
+    class VerticalConvertor < HTMLConvertor
+
+      def initialize()
+        super()
+        reset_props()
+      end
+
+      def end_element name
+        super(name)
+        @io << "\n" if ['br', 'p'].include?(name)
+        if "th" == name and @collect_columns
+          column = @text.strip
+          @columns << column
+          @th_length = [column.length, @th_length].max
+        end
+        @values << @text.strip if "td" == name
+        if "tr" == name && (not @values.empty?)
+          @columns = Array.new(@values.size, "") if @columns.empty?
+          @columns.each_with_index do |column, i|
+            value = HTMLConvertor.ml_indent(@values[i], @th_length + 3)
+            @io.print("#{column.ljust(@th_length)} : #{value}\n")
+          end
+          @values.clear
+          @collect_columns = false
+          print_row_separator
+        end
+        @text.clear unless HTMLConvertor.ping_tag == name
+        reset_props() if name == "table"
+      end
+
+      def print_row_separator
+        @separator ||= '-' * 60
+        @io.print("#{'-' * 60}\n")
+      end
+
+      private
+
+      def reset_props
+        @columns = []
+        @values = []
+        @th_length = 0
+        @text = ""
+        @collect_columns = true
+      end
+
+    end
+
+  end
+end

data/lib/vorax/output/zip_convertor.rb

@@ -0,0 +1,117 @@
+# encoding: UTF-8
+
+module Vorax
+
+  module Output
+
+    # A special type of HTML convertor used for compressing HTML tables. This is an
+    # abstract class and every convertor which needs compressing utilities must
+    # inherit from this class.
+    class ZipConvertor < HTMLConvertor
+
+      attr_reader :rows, :last_close_tag, :last_open_tag
+
+      # Create a new ZipConvertor.
+      def initialize()
+        super()
+        reset_props()
+      end
+
+      # @see HTMLConvertor.start_hook
+      def start_hook name, attrs = []
+        @last_open_tag[:name] = name
+        @last_open_tag[:attrs] = attrs
+      end
+
+      # @see HTMLConvertor.end_hook
+      def end_hook name
+        @io << "\n" if ['br', 'p'].include?(name)
+        @record << {:text => text.strip, 
+                    :is_column => ("th" == name), 
+                    :align => get_align(@last_open_tag)} if ["td", "th"].include?(name)
+        if "tr" == name
+          @rows << @record.dup
+          @record.clear
+        end
+        if should_spit?(name)
+          spit
+          @rows.clear
+        end
+        text.clear unless HTMLConvertor.ping_tag == name
+        @last_close_tag.clear
+        @last_close_tag << name
+        reset_props() if "table" == name
+      end
+
+      # A method which tells if the accumulated compressed text should
+      # be spit or not. This is the only method which must be implemented
+      # into subclasses.
+      #
+      # @param name [String] the end HTML tag
+      def should_spit?(name)
+        raise RuntimeError.new "Implement me"
+      end
+
+      private
+
+      def columns_layout
+        layout = []
+        (0..@rows.first.size-1).each do |i|
+          width = @rows.inject(0) do |result, element| 
+            [result, HTMLConvertor.ml_width(element[i][:text])].max
+          end
+          first_data_row = @rows.detect { |row| row[i][:is_column] == false }
+          align = first_data_row[i][:align] if first_data_row
+          layout << {:width => width, :align => (align && align == "right" ? "rjust" : "ljust")}
+        end
+        layout
+      end
+
+      def separator(layout)
+        # spit separator
+        layout.each_with_index do |column, i|
+          @io << "-" * column[:width]
+          @io << (i == layout.size - 1 ? "\n" : " ")
+        end
+      end
+
+      def spit
+        layout = columns_layout
+        # spit records
+        @rows.each do |record|
+          max_height = record.inject(0) { |result, element| [result, HTMLConvertor.ml_count(element[:text])].max }
+          (0..max_height).each do |j|
+            layout.length.times do |i|
+              @io << "\n" if record[i][:is_column] && i == 0 && @first_spit == false
+              @first_spit = false
+              @io << HTMLConvertor.ml_segment(record[i][:text], j).send(layout[i][:align], layout[i][:width])
+              @io << (i == layout.size - 1 ? "\n" : " ")
+              separator(layout) if i == layout.size - 1 && record[i][:is_column]
+            end
+          end
+        end
+      end
+
+      def get_align(tag)
+        attrs = tag[:attrs]
+        if attrs
+          align_pair = attrs.find { |pair| pair[0] == "align" }
+          return align_pair[1] if align_pair
+        end
+      end
+
+      def reset_props
+        @record = []
+        @rows = []
+        @last_open_tag = {:name => '', :attrs => []}
+        @last_close_tag = ''
+        @first_spit = true
+      end
+
+    end
+
+  end
+
+end
+
+

data/lib/vorax/parser/argument.rb~

@@ -0,0 +1,125 @@
+# encoding: utf-8
+
+module Vorax
+
+  module Parser
+
+    # Given a statement and a position we want to see if on that position we should
+    # provide code completion for an argument
+    class Argument
+
+      def initialize(statement)
+        @stmt = statement
+        # interesting points to search within statement
+        @marks = [BEGIN_PLSQL_SPECIAL_QUOTING, BEGIN_QUOTING,
+          CLOSE_PARAN, OPEN_PARAN, ANY]
+        # level referes to open/close brackets
+        @level = 0
+      end
+
+      # the function/procedure which owns the argument at the
+      # provided position
+      def belongs_to(position = @stmt.length)
+        @belongs_to = ''
+        stmt = @stmt[(0...position)]
+        # remove all comments
+        stmt = Parser::Comment.new.remove_all(stmt)
+        stmt.reverse!
+        @ss = StringScanner.new(stmt)
+        consume
+        return @belongs_to
+      end
+
+      private
+
+      def consume
+        while !@ss.eos?
+          @ss.skip_until(/#{@marks.join('|')}/im)
+
+          process_plsql_quoting
+          process_double_quotes
+          process_single_quotes
+          process_close_paran
+          process_open_paran
+
+          p @ss.rest
+          gets
+        end
+      end
+
+      def process_plsql_quoting
+        # pay attention, is reveresed
+        if @ss.matched =~ /'\]/
+          @ss.skip_until(/\['q/) 
+          p 'a intrat'          
+        end
+        #@ss.skip_until(/\{'q/) if @ss.matched =~ /'\}/
+        #@ss.skip_until(/\('q/) if @ss.matched =~ /'\)/
+        #@ss.skip_until(/\>'q/) if @ss.matched =~ /'\</
+      end
+
+      def process_double_quotes
+        @ss.skip_until(/"/) if @ss.matched == '"'
+      end
+
+      def process_single_quotes
+        if @ss.matched == "'" 
+          begin
+            @ss.skip_until(/\'+/) 
+          end while (@ss.matched != "'" && !@ss.eos?)
+        end
+      end
+
+      def process_close_paran
+        if @ss.matched =~ /#{CLOSE_PARAN}/
+          @level += 1 
+        end
+      end
+
+      def process_open_paran
+        if @ss.matched =~ /#{OPEN_PARAN}/
+          if @level == 0
+            extract_module
+          else
+            @level -= 1
+            @ss.terminate if @level < 0 #give up, it's an invalid statement
+          end
+        end
+      end
+
+      def extract_module
+        while !@ss.eos?
+          # consume leading whitspaces
+          @ss.scan(/\s*/)
+          if @ss.check(/"/) == '"'
+            # we have a quoted identifier
+            @belongs_to << @ss.scan(/"/)
+            @belongs_to << @ss.scan_until(/"/)
+          else
+            # unquoted identifier
+            @belongs_to << @ss.scan(/\S+/)
+          end
+          # consume trailing whitespaces
+          @ss.scan(/\s*/)
+
+          # might be a dblink
+          if @ss.check(/@/) == '@' 
+            @belongs_to << @ss.scan(/@/)
+            next
+          end
+
+          # might be package or a owner
+          if @ss.check(/\./) == '.' 
+            @belongs_to << @ss.scan(/\./)
+            next
+          end
+          @ss.terminate
+        end
+        @belongs_to.reverse!
+      end
+
+    end
+
+  end
+
+end