ronin-code-sql 2.0.0.beta1

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+#
+# ronin-code-sql - A Ruby DSL for crafting SQL Injections.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-sql is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-sql 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-sql.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/sql/operators'
+require 'ronin/code/sql/emittable'
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Represents a binary expression in SQL.
+      #
+      # @api semipublic
+      #
+      class BinaryExpr < Struct.new(:left,:operator,:right)
+
+        include Operators
+        include Emittable
+
+        #
+        # Converts the binary expression to SQL.
+        #
+        # @param [Hash{Symbol => Object}] kwargs
+        #   Additional keyword arguments for {Emitter#initialize}.
+        #
+        # @return [String]
+        #   The emitted SQL expression.
+        #
+        def to_sql(**kwargs)
+          emitter(**kwargs).emit_expression(self)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+#
+# ronin-code-sql - A Ruby DSL for crafting SQL Injections.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-sql is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-sql 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-sql.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/sql/literals'
+require 'ronin/code/sql/fields'
+require 'ronin/code/sql/functions'
+require 'ronin/code/sql/statement'
+require 'ronin/code/sql/statements'
+require 'ronin/code/sql/emittable'
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Represents a SQL Clause.
+      #
+      # @api semipublic
+      #
+      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
+end

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

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+#
+# ronin-code-sql - A Ruby DSL for crafting SQL Injections.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-sql is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-sql 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-sql.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Methods for creating common SQL {Clause Clauses}.
+      #
+      # @api public
+      #
+      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 `UNION ALL` clause.
+        #
+        # @return [self]
+        #
+        # @since 1.1.0
+        #
+        def union_all(&block)
+          clause([:UNION, :ALL],&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
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+#
+# ronin-code-sql - A Ruby DSL for crafting SQL Injections.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-sql is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-sql 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-sql.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/sql/emitter'
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Allows an object to be converted to raw SQL.
+      #
+      # @api public
+      #
+      module Emittable
+        #
+        # Creates a new emitter.
+        #
+        # @param [Hash{Symbol => Object}] kwargs
+        #   Additional keyword arguments for {Emitter#initialize}.
+        #
+        # @api private
+        #   
+        def emitter(**kwargs)
+          Emitter.new(**kwargs)
+        end
+
+        #
+        # The default `to_sql` method.
+        #
+        # @param [Hash{Symbol => Object}] kwargs
+        #   Additional keyword arguments for {Emitter#initialize}.
+        #
+        # @option kwargs [:lower, :upper, :random, nil] :case
+        #   Case for keywords.
+        #
+        # @option kwargs [String] :space (' ')
+        #   String to use for white-space.
+        #
+        # @option kwargs [:single, :double] :quotes (:single)
+        #   Type of quotes to use for Strings.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        # @raise [ArgumentError]
+        #   Could not emit an unknown SQL object.
+        #
+        def to_sql(**kwargs)
+          emitter(**kwargs).emit(self)
+        end
+
+        #
+        # @see #to_sql
+        #
+        def to_s
+          to_sql
+        end
+
+        #
+        # Inspects the object.
+        #
+        # @return [String]
+        #   The inspected object.
+        #
+        def inspect
+          "#<#{self.class}: #{to_sql}>"
+        end
+      end
+    end
+  end
+end