ronin-sql 0.1.1 → 0.2.0

data/lib/ronin/code/sql/program.rb

@@ -3,7 +3,7 @@
 # Ronin SQL - A Ronin library providing support for SQL related security
 # tasks.
 #
-# Copyright (c) 2007-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -21,56 +21,203 @@
 #++
 #
 
-require 'ronin/code/sql/style'
-require 'ronin/code/sql/builder'
+require 'ronin/code/sql/dialect'
+require 'ronin/code/sql/common_dialect'
+require 'ronin/chars/char_set'
 
 module Ronin
   module Code
     module SQL
       class Program
 
+        # Name of the dialect
+        attr_reader :dialect
+
+        # Use single-line or multi-line style
+        attr_accessor :multiline
+
+        # Use lowercase style
+        attr_accessor :lowercase
+
+        # Compile with less parenthesis
+        attr_accessor :less_parenthesis
+
+        # Space string
+        attr_accessor :space
+
+        # New-line string
+        attr_accessor :newline
+
         def initialize(options={},&block)
-          @builder = Builder.new(Style.new(options),&block)
+          options[:dialect] ||= :common
+          options[:symbols] ||= {}
+
+          if options.has_key?(:multiline)
+            @multiline = options[:multiline]
+          else
+            @multiline = true
+          end
+
+          if options.has_key?(:lowercase)
+            @lowercase = options[:lowercase]
+          else
+            @lowercase = false
+          end
+
+          if options.has_key?(:less_parens)
+            @less_parens = options[:less_parens]
+          else
+            @less_parens = false
+          end
+
+          @space = Chars::CharSet.new(options[:space] || ' ')
+          @newline = Chars::CharSet.new(options[:newline] || "\n")
+
+          @dialect = Dialect.get(options[:dialect]).new(options[:symbols])
+
+          instance_eval(&block) if block
         end
 
-        def style
-          @builder.style
+        def self.compile(options={},&block)
+          self.new(options,&block).compile
         end
 
-        def dialect
-          @builder.style.dialect.name
+        def symbols
+          @dialect.symbols
+        end
+
+        def select(*arguments,&block)
+          @dialect.statement(:select,*arguments,&block)
         end
 
         def compile
-          @builder.compile
+          sql = []
+          stmt = ['']
+          prev = nil
+
+          each_string do |current|
+            if current == ';'
+              sql << stmt
+              stmt = ['']
+            elsif current == '('
+              next if @less_parens
+
+              stmt << current
+            elsif current == ')'
+              next if @less_parens
+
+              stmt.last << current
+            elsif (current == ',' || prev == '(')
+              stmt.last << current
+            elsif prev == ','
+              if @less_parens
+                stmt.last << current
+              else
+                stmt << current
+              end
+            else
+              stmt << current
+            end
+
+            prev = current
+          end
+
+          sql_string = ''
+
+          sql.each_with_index do |stmt,stmt_index|
+            stmt_string = ''
+
+            stmt.each_with_index do |token,token_index|
+              unless token.empty?
+                sql_string << token
+
+                unless token_index == (stmt.length - 1)
+                  sql_string << space_token
+                end
+              end
+            end
+
+            sql_string << stmt_string
+
+            unless stmt_index == (sql.length - 1)
+              if @multiline
+                sql_string << newline_token
+              else
+                sql_string << ';'
+                sql_string << space_token
+              end
+            end
+          end
+
+          return sql_string
         end
 
-        def to_s
-          compile
+        alias to_s compile
+
+        protected
+
+        def space_token
+          @space.random_char
         end
 
-        def self.compile(options={},&block)
-          self.new(options,&block).compile
+        def newline_token
+          @newline.random_char
         end
 
-        def uri_encode
-          compile.uri_encode
+        def format_string(data)
+         "'" + data.to_s.sub("'","''") + "'"
         end
 
-        def uri_escape
-          compile.uri_escape
+        def format_token(token)
+          token = token.to_s
+
+          if @lowercase
+            token.downcase!
+          else
+            token.upcase!
+          end
+
+          return token
         end
 
-        def html_encode
-          compile.html_encode
+        def format(token)
+          if token.kind_of?(Token)
+            return format_token(token)
+          elsif token.kind_of?(String)
+            return format_string(token)
+          else
+            return token.to_s
+          end
         end
 
-        def format_html(options={})
-          compile.format_html(options)
+        def each_token(&block)
+          @dialect.each_token do |token|
+            block.call(token)
+          end
+
+          return self
         end
 
-        def base64_encode
-          compile.base64_encode
+        def each_string(&block)
+          each_token do |token|
+            block.call(format(token))
+          end
+
+          return self
+        end
+
+        def method_missing(name,*arguments,&block)
+          if @dialect.has_statement?(name)
+            return @dialect.enqueue_statement(name,*arguments,&block)
+          elsif @dialect.methods.include?(name.to_s)
+            return @dialect.send(name,*arguments,&block)
+          elsif (arguments.empty? && block.nil?)
+            if @dialect.symbols.has_symbol?(name)
+              return @dialect.symbols[name]
+            end
+          end
+
+          raise(NoMethodError,name.id2name)
         end
 
       end

data/lib/ronin/code/sql/rename_to_clause.rb

@@ -0,0 +1,44 @@
+#
+#--
+# Ronin SQL - A Ronin library providing support for SQL related security
+# tasks.
+#
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+#
+
+require 'ronin/code/sql/clause'
+
+module Ronin
+  module Code
+    module SQL
+      class RenameToClause < Clause
+
+        attr_accessor :table
+
+        def initialize(table)
+          @table = table
+        end
+
+        def emit
+          emit_token('RENAME TO') + emit_value(@table)
+        end
+
+      end
+    end
+  end
+end

data/lib/ronin/code/sql/replace.rb

@@ -3,7 +3,7 @@
 # Ronin SQL - A Ronin library providing support for SQL related security
 # tasks.
 #
-# Copyright (c) 2007-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -22,34 +22,32 @@
 #
 
 require 'ronin/code/sql/statement'
+require 'ronin/code/sql/fields_clause'
+require 'ronin/code/sql/values_clause'
+require 'ronin/code/sql/default_values_clause'
 
 module Ronin
   module Code
     module SQL
       class Replace < Statement
 
-        def initialize(style,table=nil,values=nil,from=nil,&block)
-          @table = table
-          @values = values
-          @from = from
+        clause :fields, FieldsClause
+        clause :default_values, DefaultValuesClause
+        clause :values, ValuesClause
 
-          super(style,&block)
-        end
+        def initialize(dialect,options={},&block)
+          @table = options[:table]
 
-        def values(data)
-          @values = data
+          super(dialect,options,&block)
         end
 
-        def from(expr)
-          @from = expr
+        def table(name)
+          @table = name
+          return value
         end
 
-        def compile
-          if @values.kind_of?(Hash)
-            return compile_expr('REPLACE INTO',@table,compile_list(@values.keys),'VALUES',compile_datalist(@values.values))
-          elsif @from.kind_of?(Select)
-            return compile_expr('REPLACE INTO',@table,compile_list(@values),@from)
-          end
+        def emit
+          emit_token('REPLACE INTO') + emit_value(@table) + super
         end
 
       end

data/lib/ronin/code/sql/select.rb

@@ -3,7 +3,7 @@
 # Ronin SQL - A Ronin library providing support for SQL related security
 # tasks.
 #
-# Copyright (c) 2007-2008 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -22,163 +22,68 @@
 #
 
 require 'ronin/code/sql/statement'
+require 'ronin/code/sql/fields_clause'
+require 'ronin/code/sql/from_clause'
+require 'ronin/code/sql/join_clause'
+require 'ronin/code/sql/where_clause'
+require 'ronin/code/sql/group_by_clause'
+require 'ronin/code/sql/having_clause'
+require 'ronin/code/sql/order_by_clause'
+require 'ronin/code/sql/limit_clause'
+require 'ronin/code/sql/offset_clause'
+require 'ronin/code/sql/union_clause'
+require 'ronin/code/sql/union_all_clause'
 
 module Ronin
   module Code
     module SQL
       class Select < Statement
 
-        option_list :rows, [:all, :distinct]
-
-        def initialize(style,tables=nil,options={:fields => nil, :where => nil},&block)
-          @fields = options[:fields] || all
-          @tables = tables
-          @where = options[:where]
-
-          super(style,&block)
-        end
-
-        def fields(*exprs)
-          @fields = exprs
-          return self
-        end
-
-        def tables(*expr)
-          @tables = expr
-          return self
-        end
-
-        def where(expr)
-          @where = expr
-          return self
-        end
-
-        def group_by(*fields)
-          @group_by = fields
-          return self
-        end
-
-        def having(expr)
-          @having = expr
-          return self
-        end
-
-        def order_by(*exprs)
-          @order_by = exprs
-          return self
-        end
-
-        def limit(value)
-          @limit = value
-        end
+        clause :fields, FieldsClause
+        clause :from, FromClause
+        clause :join, JoinClause
+        clause :where, WhereClause
+        clause :group_by, GroupByClause
+        clause :having, HavingClause
+        clause :order_by, OrderByClause
+        clause :limit, LimitClause
+        clause :offset, OffsetClause
+        clause :union, UnionClause
+        clause :union_all, UnionAllClause
+
+        def initialize(dialect,options={},&block)
+          @distinct_rows = options[:distinct_rows]
+          @all_rows = options[:all_rows]
+
+          super(dialect,options)
+
+          unless options[:fields]
+            fields(all)
+          end
 
-        def offset(value)
-          @limit = value
+          instance_eval(&block) if block
         end
 
-        def union(table,opts={:fields => [], :where => nil},&block)
-          @union = Select.new(@style,table,opts,&block)
+        def all_rows
+          @all_rows = true
           return self
         end
 
-        def union_all(table,opts={:fields => [], :where => nil},&block)
-          @union_all = Select.new(@style,table,opts,&block)
+        def distinct_rows
+          @distinct_rows = true
           return self
         end
 
-        def join(table,on_expr)
-          @join_type = :outer
-          @join_table = table
-          @join_on = on_expr
-        end
-
-        def inner_join(table,on_expr)
-          @join_type = :inner
-          @join_table = table
-          @join_on = on_expr
-        end
-
-        def left_join(table,on_expr)
-          @join_type = :left
-          @join_table = table
-          @join_on = on_expr
-        end
-
-        def right_join(table,on_expr)
-          @join_type = :right
-          @join_table = table
-          @join_on = on_expr
-        end
-
-        def compile
-          compile_expr(keyword_select,
-                       rows?,
-                       fields?,
-                       keyword_from,
-                       compile_list(@tables),
-                       where?,
-                       order_by?,
-                       having_by?,
-                       order_by?,
-                       limit?,
-                       unioned?)
-        end
-
-        protected
-
-        keyword :select
-        keyword :from
-        keyword :where
-        keyword :union
-        keyword :union_all
-        keyword :group_by, 'GROUP BY'
-        keyword :having
-        keyword :order_by, 'ORDER BY'
-        keyword :limit
-        keyword :offset
-
-        def fields?
-          if @fields.kind_of?(Array)
-            unless @fields.empty?
-              return compile_row(@fields)
-            else
-              return all.to_s
-            end
-          else
-            return @fields.to_s
-          end
-        end
-
-        def where?
-          compile_expr(keyword_where,@where) if @where
-        end
-
-        def group_by?
-          compile_expr(keyword_group_by,compile_row(@group_by)) if @group_by
-        end
-
-        def having_by?
-          compile_expr(keyword_having,@having) if @having
-        end
-
-        def order_by?
-          compile_expr(keyword_order_by,@order_by) if @order_by
-        end
-
-        def limit?
-          compile_expr(keyword_limit,@limit,offset?) if @limit
-        end
-
-        def offset?
-          compile_expr(keyword_offset,@offset) if @offset
-        end
+        def emit
+          tokens = emit_token('SELECT')
 
-        def unioned?
-          if @union_all
-            return compile_expr(keyword_union_all,@union_all)
-          elsif @union
-            return compile_expr(keyword_union,@union)
+          if @distinct_rows
+            tokens += emit_token('DISTINCT')
+          elsif @all_rows
+            tokens += emit_token('ALL')
           end
+          
+          return tokens + super
         end
 
       end

data/lib/ronin/code/sql/set_clause.rb

@@ -0,0 +1,44 @@
+#
+#--
+# Ronin SQL - A Ronin library providing support for SQL related security
+# tasks.
+#
+# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+#
+
+require 'ronin/code/sql/clause'
+
+module Ronin
+  module Code
+    module SQL
+      class SetClause < Clause
+
+        attr_accessor :values
+
+        def initialize(*values)
+          @values = values
+        end
+
+        def emit
+          emit_token('WHERE') + emit_row(@values)
+        end
+
+      end
+    end
+  end
+end