vorax 0.1.0pre

data/lib/vorax/parser/body_split.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+require 'strscan'
+
+module Vorax
+
+  module Parser
+
+    class SubProgram
+
+      attr_accessor :start_pos, :declare_pos, :end_pos, :text, :level
+      attr_reader :name, :type
+      
+      def initialize(name, type, start_pos)
+        @name = name
+        @type = type
+        @start_pos = start_pos
+        @declare_pos = nil
+        @end_pos = nil
+        @text = ''
+        @level = 0
+      end
+
+    end
+
+    class BodySplit
+
+      PLSQL_SPEC = '(?:\bpackage\b|\btype\b)'
+      SUBPROG = '(?:\bfunction\b|\bprocedure\b)'
+      BEGIN_MODULE = '(?:\bbegin\b)'
+      END_MODULE = '(?:\bend\b)'
+
+      def initialize
+        spots = [BEGIN_ML_COMMENT, BEGIN_SL_COMMENT,
+                BEGIN_PLSQL_SPECIAL_QUOTING, BEGIN_QUOTING,
+                PLSQL_SPEC, SUBPROG, BEGIN_MODULE, END_MODULE]
+        @marks = Regexp.new(spots.join('|'), Regexp::IGNORECASE)
+        @level = 0
+      end
+
+      def split(text)
+        @blocks = []
+        @ss = StringScanner.new(text)
+        @level = 0
+        @crr_block = nil
+        while !@ss.eos?
+          Parser::consume(@ss, :scan_until, @marks)
+          process_ml_comment
+          process_sl_comment
+          process_double_quotes
+          process_plsql_quoting
+          process_single_quotes
+          process_plsql_spec
+          process_subprog
+          process_begin
+          process_end
+        end
+        return @blocks
+      end
+
+      private
+
+      def process_ml_comment
+        scan_until(/\*\/\s*/) if @ss.matched =~ /#{BEGIN_ML_COMMENT}/
+      end
+
+      def process_sl_comment
+        scan_until(/\n/) if @ss.matched =~ /#{BEGIN_SL_COMMENT}/
+      end
+
+      def process_double_quotes
+        scan_until(/"/) if @ss.matched == '"'
+      end
+
+      def process_plsql_quoting
+        if @ss.matched =~ /q'\[/
+          scan_until(/\]'/) 
+        elsif @ss.matched =~ /q'[{]/
+          scan_until(/[}]'/) 
+        elsif @ss.matched =~ /q'[(]/
+          scan_until(/[)]'/) 
+        elsif @ss.matched =~ /q'[<]/
+          scan_until(/[>]'/) 
+        end
+      end
+
+      def process_single_quotes
+        if @ss.matched == "'" 
+          begin
+            scan_until(/\'+/) 
+          end while (@ss.matched != "'" && !@ss.eos?)
+        end
+      end
+
+      def process_plsql_spec
+        if @ss.matched =~ /#{PLSQL_SPEC}/i
+          meta_data = Parser.plsql_spec("#{@ss.matched}#{@ss.rest}")
+          if meta_data[:end_def] > 0
+            spec = SubProgram.new(meta_data[:name], 'spec', @ss.pos)
+            spec.declare_pos = @ss.pos + meta_data[:end_def]
+            scan_until(/#{SLASH_TERMINATOR}/)
+            spec.end_pos = @ss.pos
+            spec.text = @ss.string[(spec.start_pos..spec.end_pos)]
+            @blocks << spec
+          end
+        end
+      end
+
+      def process_subprog
+        if @ss.matched =~ /#{SUBPROG}/i
+          subprog_name = @ss.peek(32)[/(?:"[^"]+")|(?:[A-Z0-9$_#]+)/i]
+          if @ss.matched =~ /function/i
+            subprog_type = 'function'
+          elsif @ss.matched =~ /procedure/i
+            subprog_type = 'procedure'
+          end
+          start_pos = @ss.pos - @ss.matched.length
+          @crr_block = SubProgram.new(subprog_name, subprog_type, start_pos)
+        end
+      end
+
+      def process_begin
+        if @ss.matched =~ /#{BEGIN_MODULE}/i && @crr_block
+          @level += 1
+          @crr_block.declare_pos = @ss.pos 
+          @crr_block.level = @level
+        end
+      end
+
+      def process_end
+        if @ss.matched =~ /#{END_MODULE}/i
+          # we have an "end" match. first of all check if it's not part
+          # of an conditional compiling "$end" definition
+          char_behind = @ss.string[@ss.pos - @ss.matched.length - 1, 1]
+          if char_behind != '$'
+            finish = Parser.end_subprog("#{@ss.matched}#{@ss.rest}")
+            if finish > 0
+              if @level == 1
+                if @crr_block
+                  @crr_block.end_pos = (@ss.pos - 1) + (finish - 1)
+                  @crr_block.text = @ss.string[(@crr_block.start_pos..@crr_block.end_pos)]
+                  @blocks << @crr_block.clone
+                  @crr_block = nil
+                end
+              end
+              @level -= 1
+            end
+          end
+        end
+      end
+
+      def scan_until(regexp, skip = false)
+        if skip
+          @ss.skip_until(regexp)
+        else
+          segment = @ss.scan_until(regexp)
+          if !segment
+            @ss.terminate
+          end
+        end
+      end
+
+    end
+
+  end
+
+end
+
+

data/lib/vorax/parser/conn_string.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+require 'strscan'
+
+module Vorax
+
+  module Parser
+
+    # A class used to parse a connection string.
+    class ConnString
+
+      # Parse the given connection string.
+      #
+      # @return [Hash] a hash with the following keys:
+      #
+      # :user => the username,
+      # :password => the password,
+      # :db => the target database,
+      # :role => sysdba, sysasm or sysoper (if that's the case),
+      # :prompt_for => when some pieces are missing (e.g. password), the corresponding keys from above is put here
+      def parse(cstr)
+        # well known connection strings:
+        #   - user => just the password will be prompted
+        #   - user/pwd
+        #   - user@db => just the password will be prompted
+        #   - user/pwd@db [as sysdba|sysoper|sysasm]
+        #   - /
+        #   - / [as sysdba|sysoper|sysasm}
+        #   - /@db => use wallet
+        Vorax::debug("parse connection string #{cstr.inspect}")
+        result = {:user => '', :password => '', :db => '', :role => '', :prompt_for => nil}
+        input = cstr.strip
+        scanner = StringScanner.new(input)
+        result[:user] = unquoted_scan(scanner, /[@\/]/)
+        has_pwd_slash = false
+
+        if scanner.matched?
+          # we have a @ or a / in our connection string
+          result[:user].chop!
+          if scanner.matched == "/"
+            has_pwd_slash = true
+            result[:password] = unquoted_scan(scanner, /@/)
+            if scanner.matched?
+              # there is a "@" so we know where to stop to extract the pwd
+              result[:password].chop!
+              extract_db(scanner, result)
+            else
+              # there's no "@" so assume everything to be the password
+              # except for the role
+              result[:password] = scanner.scan_until(/\z/)
+              extract_role(result, :password)
+            end
+          elsif scanner.matched == "@"
+            extract_db(scanner, result)
+          end
+        else
+          # we don't have a @ or a / in our connection string
+          result[:user] = input
+        end
+        result[:user] = strip_quotes(result[:user])
+        result[:password] = strip_quotes(result[:password])
+        if result[:user].empty? && result[:password].empty? && has_pwd_slash
+          # assume OS authentication
+          result[:prompt_for] = nil
+        else
+          if result[:user].empty?
+            result[:prompt_for] = :user
+          elsif (not result[:user].empty?) && result[:password].empty?
+            result[:prompt_for] = :password
+          end
+        end
+        result
+      end
+
+      private
+
+      def strip_quotes(text)
+        text.gsub(/\A"|"\z/, '')
+      end
+
+      def extract_db(scanner, cstr_hash)
+        cstr_hash[:db] = scanner.scan_until(/\z/)
+        extract_role(cstr_hash, :db)
+      end
+
+      def extract_role(cstr_hash, from_attr)
+        cstr_hash[from_attr].sub!(/\s+as\s+(sysdba|sysoper|sysasm)\z/i, '')
+        cstr_hash[:role] = $1.downcase if $1
+      end
+
+      def unquoted_scan(scanner, pattern)
+        result = ''
+        begin
+          fragment = scanner.scan_until(pattern)
+          result << fragment if fragment
+        end while fragment && result.count('"').odd? # go on if between quotes
+        result
+      end
+
+    end
+
+  end
+
+end