shoesgem 0.1480.0 → 0.1514.0

data/shoes/ruby/gems/1.9.1/gems/sqlite3-ruby-1.3.0/lib/sqlite3/resultset.rb

@@ -1,126 +1,126 @@
-require 'sqlite3/constants'
-require 'sqlite3/errors'
-
-module SQLite3
-
-  # The ResultSet object encapsulates the enumerability of a query's output.
-  # It is a simple cursor over the data that the query returns. It will
-  # very rarely (if ever) be instantiated directly. Instead, client's should
-  # obtain a ResultSet instance via Statement#execute.
-  class ResultSet
-    include Enumerable
-
-    # The class of which we return an object in case we want an Array as
-    # result. (ArrayFields is installed.)
-    class ArrayWithTypes < Array
-      attr_accessor :types
-    end
-
-    # The class of which we return an object in case we want an Array as
-    # result. (ArrayFields is not installed.)
-    class ArrayWithTypesAndFields < Array
-      attr_accessor :types
-      attr_accessor :fields
-    end
-
-    # The class of which we return an object in case we want a Hash as
-    # result.
-    class HashWithTypes < Hash
-      attr_accessor :types
-    end
-
-    # Create a new ResultSet attached to the given database, using the
-    # given sql text.
-    def initialize db, stmt
-      @db   = db
-      @stmt = stmt
-    end
-
-    # Reset the cursor, so that a result set which has reached end-of-file
-    # can be rewound and reiterated.
-    def reset( *bind_params )
-      @stmt.reset!
-      @stmt.bind_params( *bind_params )
-      @eof = false
-    end
-
-    # Query whether the cursor has reached the end of the result set or not.
-    def eof?
-      @stmt.done?
-    end
-
-    # Obtain the next row from the cursor. If there are no more rows to be
-    # had, this will return +nil+. If type translation is active on the
-    # corresponding database, the values in the row will be translated
-    # according to their types.
-    #
-    # The returned value will be an array, unless Database#results_as_hash has
-    # been set to +true+, in which case the returned value will be a hash.
-    #
-    # For arrays, the column names are accessible via the +fields+ property,
-    # and the column types are accessible via the +types+ property.
-    #
-    # For hashes, the column names are the keys of the hash, and the column
-    # types are accessible via the +types+ property.
-    def next
-      row = @stmt.step
-      return nil if @stmt.done?
-
-      if @db.type_translation
-        row = @stmt.types.zip(row).map do |type, value|
-          @db.translator.translate( type, value )
-        end
-      end
-
-      if @db.results_as_hash
-        new_row = HashWithTypes[*@stmt.columns.zip(row).flatten]
-        row.each_with_index { |value,idx|
-          new_row[idx] = value
-        }
-        row = new_row
-      else
-        if row.respond_to?(:fields)
-          row = ArrayWithTypes.new(row)
-        else
-          row = ArrayWithTypesAndFields.new(row)
-        end
-        row.fields = @stmt.columns
-      end
-
-      row.types = @stmt.types
-      row
-    end
-
-    # Required by the Enumerable mixin. Provides an internal iterator over the
-    # rows of the result set.
-    def each( &block )
-      while node = self.next
-        yield node
-      end
-    end
-
-    # Closes the statement that spawned this result set.
-    # <em>Use with caution!</em> Closing a result set will automatically
-    # close any other result sets that were spawned from the same statement.
-    def close
-      @stmt.close
-    end
-
-    # Queries whether the underlying statement has been closed or not.
-    def closed?
-      @stmt.closed?
-    end
-
-    # Returns the types of the columns returned by this result set.
-    def types
-      @stmt.types
-    end
-
-    # Returns the names of the columns returned by this result set.
-    def columns
-      @stmt.columns
-    end
-
-  end
-
-end
+require 'sqlite3/constants'
+require 'sqlite3/errors'
+
+module SQLite3
+
+  # The ResultSet object encapsulates the enumerability of a query's output.
+  # It is a simple cursor over the data that the query returns. It will
+  # very rarely (if ever) be instantiated directly. Instead, client's should
+  # obtain a ResultSet instance via Statement#execute.
+  class ResultSet
+    include Enumerable
+
+    # The class of which we return an object in case we want an Array as
+    # result. (ArrayFields is installed.)
+    class ArrayWithTypes < Array
+      attr_accessor :types
+    end
+
+    # The class of which we return an object in case we want an Array as
+    # result. (ArrayFields is not installed.)
+    class ArrayWithTypesAndFields < Array
+      attr_accessor :types
+      attr_accessor :fields
+    end
+
+    # The class of which we return an object in case we want a Hash as
+    # result.
+    class HashWithTypes < Hash
+      attr_accessor :types
+    end
+
+    # Create a new ResultSet attached to the given database, using the
+    # given sql text.
+    def initialize db, stmt
+      @db   = db
+      @stmt = stmt
+    end
+
+    # Reset the cursor, so that a result set which has reached end-of-file
+    # can be rewound and reiterated.
+    def reset( *bind_params )
+      @stmt.reset!
+      @stmt.bind_params( *bind_params )
+      @eof = false
+    end
+
+    # Query whether the cursor has reached the end of the result set or not.
+    def eof?
+      @stmt.done?
+    end
+
+    # Obtain the next row from the cursor. If there are no more rows to be
+    # had, this will return +nil+. If type translation is active on the
+    # corresponding database, the values in the row will be translated
+    # according to their types.
+    #
+    # The returned value will be an array, unless Database#results_as_hash has
+    # been set to +true+, in which case the returned value will be a hash.
+    #
+    # For arrays, the column names are accessible via the +fields+ property,
+    # and the column types are accessible via the +types+ property.
+    #
+    # For hashes, the column names are the keys of the hash, and the column
+    # types are accessible via the +types+ property.
+    def next
+      row = @stmt.step
+      return nil if @stmt.done?
+
+      if @db.type_translation
+        row = @stmt.types.zip(row).map do |type, value|
+          @db.translator.translate( type, value )
+        end
+      end
+
+      if @db.results_as_hash
+        new_row = HashWithTypes[*@stmt.columns.zip(row).flatten]
+        row.each_with_index { |value,idx|
+          new_row[idx] = value
+        }
+        row = new_row
+      else
+        if row.respond_to?(:fields)
+          row = ArrayWithTypes.new(row)
+        else
+          row = ArrayWithTypesAndFields.new(row)
+        end
+        row.fields = @stmt.columns
+      end
+
+      row.types = @stmt.types
+      row
+    end
+
+    # Required by the Enumerable mixin. Provides an internal iterator over the
+    # rows of the result set.
+    def each( &block )
+      while node = self.next
+        yield node
+      end
+    end
+
+    # Closes the statement that spawned this result set.
+    # <em>Use with caution!</em> Closing a result set will automatically
+    # close any other result sets that were spawned from the same statement.
+    def close
+      @stmt.close
+    end
+
+    # Queries whether the underlying statement has been closed or not.
+    def closed?
+      @stmt.closed?
+    end
+
+    # Returns the types of the columns returned by this result set.
+    def types
+      @stmt.types
+    end
+
+    # Returns the names of the columns returned by this result set.
+    def columns
+      @stmt.columns
+    end
+
+  end
+
+end

data/shoes/ruby/gems/1.9.1/gems/sqlite3-ruby-1.3.0/lib/sqlite3/statement.rb

@@ -1,146 +1,146 @@
-require 'sqlite3/errors'
-require 'sqlite3/resultset'
-
-class String
-  def to_blob
-    SQLite3::Blob.new( self )
-  end
-end
-
-module SQLite3
-  # A statement represents a prepared-but-unexecuted SQL query. It will rarely
-  # (if ever) be instantiated directly by a client, and is most often obtained
-  # via the Database#prepare method.
-  class Statement
-    include Enumerable
-
-    # This is any text that followed the first valid SQL statement in the text
-    # with which the statement was initialized. If there was no trailing text,
-    # this will be the empty string.
-    attr_reader :remainder
-
-    # Binds the given variables to the corresponding placeholders in the SQL
-    # text.
-    #
-    # See Database#execute for a description of the valid placeholder
-    # syntaxes.
-    #
-    # Example:
-    #
-    #   stmt = db.prepare( "select * from table where a=? and b=?" )
-    #   stmt.bind_params( 15, "hello" )
-    #
-    # See also #execute, #bind_param, Statement#bind_param, and
-    # Statement#bind_params.
-    def bind_params( *bind_vars )
-      index = 1
-      bind_vars.flatten.each do |var|
-        if Hash === var
-          var.each { |key, val| bind_param key, val }
-        else
-          bind_param index, var
-          index += 1
-        end
-      end
-    end
-
-    # Execute the statement. This creates a new ResultSet object for the
-    # statement's virtual machine. If a block was given, the new ResultSet will
-    # be yielded to it; otherwise, the ResultSet will be returned.
-    #
-    # Any parameters will be bound to the statement using #bind_params.
-    #
-    # Example:
-    #
-    #   stmt = db.prepare( "select * from table" )
-    #   stmt.execute do |result|
-    #     ...
-    #   end
-    #
-    # See also #bind_params, #execute!.
-    def execute( *bind_vars )
-      reset! if active? || done?
-
-      bind_params(*bind_vars) unless bind_vars.empty?
-      @results = ResultSet.new(@connection, self)
-
-      yield @results if block_given?
-      @results
-    end
-
-    # Execute the statement. If no block was given, this returns an array of
-    # rows returned by executing the statement. Otherwise, each row will be
-    # yielded to the block.
-    #
-    # Any parameters will be bound to the statement using #bind_params.
-    #
-    # Example:
-    #
-    #   stmt = db.prepare( "select * from table" )
-    #   stmt.execute! do |row|
-    #     ...
-    #   end
-    #
-    # See also #bind_params, #execute.
-    def execute!( *bind_vars, &block )
-      execute(*bind_vars)
-      block_given? ? each(&block) : to_a
-    end
-
-    # Returns true if the statement is currently active, meaning it has an
-    # open result set.
-    def active?
-      !done?
-    end
-
-    # Return an array of the column names for this statement. Note that this
-    # may execute the statement in order to obtain the metadata; this makes it
-    # a (potentially) expensive operation.
-    def columns
-      get_metadata unless @columns
-      return @columns
-    end
-
-    def each
-      loop do
-        val = step
-        break self if done?
-        yield val
-      end
-    end
-
-    # Return an array of the data types for each column in this statement. Note
-    # that this may execute the statement in order to obtain the metadata; this
-    # makes it a (potentially) expensive operation.
-    def types
-      must_be_open!
-      get_metadata unless @types
-      @types
-    end
-
-    # A convenience method for obtaining the metadata about the query. Note
-    # that this will actually execute the SQL, which means it can be a
-    # (potentially) expensive operation.
-    def get_metadata
-      @columns = []
-      @types = []
-
-      column_count.times do |column|
-        @columns << column_name(column)
-        @types << column_decltype(column)
-      end
-
-      @columns.freeze
-      @types.freeze
-    end
-    private :get_metadata
-
-    # Performs a sanity check to ensure that the statement is not
-    # closed. If it is, an exception is raised.
-    def must_be_open! # :nodoc:
-      if closed?
-        raise SQLite3::Exception, "cannot use a closed statement"
-      end
-    end
-  end
-end
+require 'sqlite3/errors'
+require 'sqlite3/resultset'
+
+class String
+  def to_blob
+    SQLite3::Blob.new( self )
+  end
+end
+
+module SQLite3
+  # A statement represents a prepared-but-unexecuted SQL query. It will rarely
+  # (if ever) be instantiated directly by a client, and is most often obtained
+  # via the Database#prepare method.
+  class Statement
+    include Enumerable
+
+    # This is any text that followed the first valid SQL statement in the text
+    # with which the statement was initialized. If there was no trailing text,
+    # this will be the empty string.
+    attr_reader :remainder
+
+    # Binds the given variables to the corresponding placeholders in the SQL
+    # text.
+    #
+    # See Database#execute for a description of the valid placeholder
+    # syntaxes.
+    #
+    # Example:
+    #
+    #   stmt = db.prepare( "select * from table where a=? and b=?" )
+    #   stmt.bind_params( 15, "hello" )
+    #
+    # See also #execute, #bind_param, Statement#bind_param, and
+    # Statement#bind_params.
+    def bind_params( *bind_vars )
+      index = 1
+      bind_vars.flatten.each do |var|
+        if Hash === var
+          var.each { |key, val| bind_param key, val }
+        else
+          bind_param index, var
+          index += 1
+        end
+      end
+    end
+
+    # Execute the statement. This creates a new ResultSet object for the
+    # statement's virtual machine. If a block was given, the new ResultSet will
+    # be yielded to it; otherwise, the ResultSet will be returned.
+    #
+    # Any parameters will be bound to the statement using #bind_params.
+    #
+    # Example:
+    #
+    #   stmt = db.prepare( "select * from table" )
+    #   stmt.execute do |result|
+    #     ...
+    #   end
+    #
+    # See also #bind_params, #execute!.
+    def execute( *bind_vars )
+      reset! if active? || done?
+
+      bind_params(*bind_vars) unless bind_vars.empty?
+      @results = ResultSet.new(@connection, self)
+
+      yield @results if block_given?
+      @results
+    end
+
+    # Execute the statement. If no block was given, this returns an array of
+    # rows returned by executing the statement. Otherwise, each row will be
+    # yielded to the block.
+    #
+    # Any parameters will be bound to the statement using #bind_params.
+    #
+    # Example:
+    #
+    #   stmt = db.prepare( "select * from table" )
+    #   stmt.execute! do |row|
+    #     ...
+    #   end
+    #
+    # See also #bind_params, #execute.
+    def execute!( *bind_vars, &block )
+      execute(*bind_vars)
+      block_given? ? each(&block) : to_a
+    end
+
+    # Returns true if the statement is currently active, meaning it has an
+    # open result set.
+    def active?
+      !done?
+    end
+
+    # Return an array of the column names for this statement. Note that this
+    # may execute the statement in order to obtain the metadata; this makes it
+    # a (potentially) expensive operation.
+    def columns
+      get_metadata unless @columns
+      return @columns
+    end
+
+    def each
+      loop do
+        val = step
+        break self if done?
+        yield val
+      end
+    end
+
+    # Return an array of the data types for each column in this statement. Note
+    # that this may execute the statement in order to obtain the metadata; this
+    # makes it a (potentially) expensive operation.
+    def types
+      must_be_open!
+      get_metadata unless @types
+      @types
+    end
+
+    # A convenience method for obtaining the metadata about the query. Note
+    # that this will actually execute the SQL, which means it can be a
+    # (potentially) expensive operation.
+    def get_metadata
+      @columns = []
+      @types = []
+
+      column_count.times do |column|
+        @columns << column_name(column)
+        @types << column_decltype(column)
+      end
+
+      @columns.freeze
+      @types.freeze
+    end
+    private :get_metadata
+
+    # Performs a sanity check to ensure that the statement is not
+    # closed. If it is, an exception is raised.
+    def must_be_open! # :nodoc:
+      if closed?
+        raise SQLite3::Exception, "cannot use a closed statement"
+      end
+    end
+  end
+end