ronin-sql 0.2.4 → 1.0.0

data/lib/ronin/formatting/sql.rb

@@ -1,8 +1,9 @@
 #
-# Ronin SQL - A Ronin library providing support for SQL related security
-# tasks.
+# Ronin SQL - A Ruby DSL for crafting SQL Injections.
 #
-# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2013 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin SQL.
 #
 # 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

data/lib/ronin/sql.rb

@@ -1,8 +1,9 @@
 #
-# Ronin SQL - A Ronin library providing support for SQL related security
-# tasks.
+# Ronin SQL - A Ruby DSL for crafting SQL Injections.
 #
-# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2013 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin SQL.
 #
 # 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
@@ -19,12 +20,4 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #
 
-require 'ronin/sql/extensions'
-require 'ronin/sql/error'
-require 'ronin/sql/injection'
-require 'ronin/sql/version'
-require 'ronin/config'
-
-module Ronin
-  Config.load :sql
-end
+require 'ronin/sql/sql'

data/lib/ronin/{code/sql/create_index.rb → sql/binary_expr.rb}

@@ -1,8 +1,9 @@
 #
-# Ronin SQL - A Ronin library providing support for SQL related security
-# tasks.
+# Ronin SQL - A Ruby DSL for crafting SQL Injections.
 #
-# Copyright (c) 2007-2009 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2007-2013 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin SQL.
 #
 # 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
@@ -19,26 +20,32 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #
 
-require 'ronin/code/sql/create'
-require 'ronin/code/sql/on_clause'
+require 'ronin/sql/operators'
+require 'ronin/sql/emittable'
 
 module Ronin
-  module Code
-    module SQL
-      class CreateIndex < Create
-
-        clause :on, OnClause
+  module SQL
+    #
+    # Represents a binary expression in SQL.
+    #
+    class BinaryExpr < Struct.new(:left,:operator,:right)
 
-        def initialize(dialect,index=nil,options={},&block)
-          super(dialect,'INDEX',index,options,&block)
-        end
-
-        def index(name=nil)
-          @name = name if name
-          return @name
-        end
+      include Operators
+      include Emittable
 
+      #
+      # Converts the binary expression to SQL.
+      #
+      # @param [Hash] options
+      #   Additional options for {Emitter#initialize}.
+      #
+      # @return [String]
+      #   The emitted SQL expression.
+      #
+      def to_sql(options={})
+        emitter(options).emit_expression(self)
       end
+
     end
   end
 end

data/lib/ronin/sql/clause.rb

@@ -0,0 +1,72 @@
+#
+# Ronin SQL - A Ruby DSL for crafting SQL Injections.
+#
+# Copyright (c) 2007-2013 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin SQL.
+#
+# 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/sql/literals'
+require 'ronin/sql/fields'
+require 'ronin/sql/functions'
+require 'ronin/sql/statement'
+require 'ronin/sql/statements'
+require 'ronin/sql/emittable'
+
+module Ronin
+  module SQL
+    #
+    # Represents a SQL Clause.
+    #
+    class Clause < Struct.new(:keyword,:argument)
+
+      include Literals
+      include Fields
+      include Functions
+      include Statements
+      include Emittable
+
+      #
+      # Initializes the SQL clause.
+      #
+      # @param [Symbol] keyword
+      #   The name of the clause.
+      #
+      # @param [Object] argument
+      #   Additional argument for the clause.
+      #
+      # @yield [(clause)]
+      #   If a block is given, the return value will be used as the argument.
+      #
+      # @yieldparam [Clause] clause
+      #   If the block accepts an argument, it will be passed the new clause.
+      #   Otherwise the block will be evaluated within the clause.
+      #
+      def initialize(keyword,argument=nil,&block)
+        super(keyword,argument)
+
+        if block
+          self.argument = case block.arity
+                          when 0 then instance_eval(&block)
+                          else        block.call(self)
+                          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ronin/sql/clauses.rb

@@ -0,0 +1,297 @@
+#
+# Ronin SQL - A Ruby DSL for crafting SQL Injections.
+#
+# Copyright (c) 2007-2013 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# This file is part of Ronin SQL.
+#
+# 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
+#
+
+module Ronin
+  module SQL
+    #
+    # Methods for creating common SQL {Clause Clauses}.
+    #
+    module Clauses
+      #
+      # The defined clauses of the statement.
+      #
+      # @return [Array<Clause>]
+      #   The clauses defined thus far.
+      #
+      def clauses
+        @clauses ||= []
+      end
+
+      #
+      # Appends an arbitrary clause.
+      #
+      # @param [Symbol] keyword
+      #   The name of the clause.
+      #
+      # @param [Object] argument
+      #   Additional argument for the clause.
+      #
+      # @yield [(clause)]
+      #   If a block is given, the return value will be used as the argument.
+      #
+      # @yieldparam [Clause] clause
+      #   If the block accepts an argument, it will be passed the new clause.
+      #   Otherwise the block will be evaluated within the clause.
+      #
+      # @return [self]
+      #
+      def clause(keyword,argument=nil,&block)
+        clauses << Clause.new(keyword,argument,&block)
+        return self
+      end
+
+      #
+      # Appends a `FROM` clause.
+      #
+      # @param [Field, Symbol] table
+      #   The table to select from.
+      #
+      # @return [self]
+      #
+      def from(table=nil,&block)
+        clause(:FROM,table,&block)
+      end
+
+      #
+      # Appends an `INTO` clause.
+      #
+      # @param [Field, Symbol] table
+      #   The table to insert into.
+      #
+      # @return [self]
+      #
+      def into(table=nil,&block)
+        clause(:INTO,table,&block)
+      end
+
+      #
+      # Appends a `WHERE` clause.
+      #
+      # @return [self]
+      #
+      def where(&block)
+        clause(:WHERE,&block)
+      end
+
+      #
+      # Appends a `JOIN` clause.
+      #
+      # @param [Field, Symbol] table
+      #   The table to join.
+      #
+      # @return [self]
+      #
+      def join(table=nil,&block)
+        clause(:JOIN,table,&block)
+      end
+
+      #
+      # Appends a `INNER JOIN` clause.
+      #
+      # @param [Field, Symbol] table
+      #   The table to join.
+      #
+      # @return [self]
+      #
+      def inner_join(table=nil,&block)
+        clause([:INNER, :JOIN],table,&block)
+      end
+
+      #
+      # Appends a `LEFT JOIN` clause.
+      #
+      # @param [Field, Symbol] table
+      #   The table to join.
+      #
+      # @return [self]
+      #
+      def left_join(table=nil,&block)
+        clause([:LEFT, :JOIN],table,&block)
+      end
+
+      #
+      # Appends a `RIGHT JOIN` clause.
+      #
+      # @param [Field, Symbol] table
+      #   The table to join.
+      #
+      # @return [self]
+      #
+      def right_join(table=nil,&block)
+        clause([:RIGHT, :JOIN],table,&block)
+      end
+
+      #
+      # Appends a `FULL JOIN` clause.
+      #
+      # @param [Field, Symbol] table
+      #   The table to join.
+      #
+      # @return [self]
+      #
+      def full_join(table=nil,&block)
+        clause([:FULL, :JOIN],table,&block)
+      end
+
+      #
+      # Appends a `ON` clause.
+      #
+      # @return [self]
+      #
+      def on(&block)
+        clause(:ON,&block)
+      end
+
+      #
+      # Appends a `UNION` clause.
+      #
+      # @return [self]
+      #
+      def union(&block)
+        clause(:UNION,&block)
+      end
+
+      #
+      # Appends a `GROUP BY` clause.
+      #
+      # @param [Array<Field, Symbol>] columns
+      #   The columns for `GROUP BY`.
+      #
+      # @return [self]
+      #
+      def group_by(*columns,&block)
+        clause([:GROUP, :BY],columns,&block)
+      end
+
+      #
+      # Appends a `HAVING` clause.
+      #
+      # @return [self]
+      #
+      def having(&block)
+        clause(:HAVING,&block)
+      end
+
+      #
+      # Appends a `LIMIT` clause.
+      #
+      # @param [Integer] value
+      #   The maximum number of rows to select.
+      #
+      # @return [self]
+      #
+      def limit(value,&block)
+        clause(:LIMIT,value,&block)
+      end
+
+      #
+      # Appends a `OFFSET` clause.
+      #
+      # @param [Integer] value
+      #   The index to start selecting at within the result set.
+      #
+      # @return [self]
+      #
+      def offset(value,&block)
+        clause(:OFFSET,value,&block)
+      end
+
+      #
+      # Appends a `TOP` clause.
+      #
+      # @param [Integer] value
+      #   The number of top rows to select. 
+      #
+      # @return [self]
+      #
+      def top(value,&block)
+        clause(:TOP,value,&block)
+      end
+
+      #
+      # Appends a `INTO` clause.
+      #
+      # @param [Field, Symbol] table
+      #   The table to insert/replace into.
+      #
+      # @return [self]
+      #
+      def into(table)
+        clause(:INTO,table)
+      end
+
+      #
+      # Appends a `VALUES` clause.
+      #
+      # @param [Array] values
+      #   The values to insert.
+      #
+      # @return [self]
+      #
+      def values(*values)
+        clause(:VALUES,values)
+      end
+
+      #
+      # Appends a `DEFAULT VALUES` clause.
+      #
+      # @return [self]
+      #
+      def default_values
+        clause([:DEFAULT, :VALUES])
+      end
+
+      #
+      # Appends a `SET` clause.
+      #
+      # @param [Hash{Field,Symbol => Object}] values
+      #   The columns and values to update.
+      #
+      # @return [self]
+      #
+      def set(values={})
+        clause(:SET,values)
+      end
+
+      #
+      # Appends a `INDEXED BY` clause.
+      #
+      # @param [Field, Symbol] name
+      #   The name of the index.
+      #
+      # @return [self]
+      #
+      def indexed_by(name,&block)
+        clause([:INDEXED, :BY],name,&block)
+      end
+
+      #
+      # Appends a `NOT INDEXED` clause.
+      #
+      # @return [self]
+      #
+      def not_indexed
+        clause([:NOT, :INDEXED])
+      end
+    end
+  end
+end