asana2flowdock 1.0.0 → 1.1.0

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/adapters/ado/mssql.rb

@@ -1,69 +0,0 @@
-Sequel.require 'adapters/shared/mssql'
-
-module Sequel
-  module ADO
-    # Database and Dataset instance methods for MSSQL specific
-    # support via ADO.
-    module MSSQL
-      module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
-        include Sequel::MSSQL::DatabaseMethods
-        # Query to use to get the number of rows affected by an update or
-        # delete query.
-        ROWS_AFFECTED = "SELECT @@ROWCOUNT AS AffectedRows"
-        
-        # Issue a separate query to get the rows modified.  ADO appears to
-        # use pass by reference with an integer variable, which is obviously
-        # not supported directly in ruby, and I'm not aware of a workaround.
-        def execute_dui(sql, opts=OPTS)
-          return super unless @opts[:provider]
-          synchronize(opts[:server]) do |conn|
-            begin
-              log_yield(sql){conn.Execute(sql)}
-              res = log_yield(ROWS_AFFECTED){conn.Execute(ROWS_AFFECTED)}
-              res.getRows.transpose.each{|r| return r.shift}
-            rescue ::WIN32OLERuntimeError => e
-              raise_error(e)
-            end
-          end
-        end
-
-        private
-
-        # The ADO adapter's default provider doesn't support transactions, since it 
-        # creates a new native connection for each query.  So Sequel only attempts
-        # to use transactions if an explicit :provider is given.
-        def begin_transaction(conn, opts=OPTS)
-          super if @opts[:provider]
-        end
-
-        def commit_transaction(conn, opts=OPTS)
-          super if @opts[:provider]
-        end
-
-        def rollback_transaction(conn, opts=OPTS)
-          super if @opts[:provider]
-        end
-      end
-      
-      class Dataset < ADO::Dataset
-        include Sequel::MSSQL::DatasetMethods
-
-        # Use a nasty hack of multiple SQL statements in the same call and
-        # having the last one return the most recently inserted id.  This
-        # is necessary as ADO's default :provider uses a separate native
-        # connection for each query.
-        def insert(*values)
-          return super if @opts[:sql]
-          with_sql("SET NOCOUNT ON; #{insert_sql(*values)}; SELECT CAST(SCOPE_IDENTITY() AS INTEGER)").single_value
-        end
-        
-        # If you use a better :provider option for the database, you can get an
-        # accurate number of rows matched.
-        def provides_accurate_rows_matched?
-          !!db.opts[:provider]
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/adapters/amalgalite.rb

@@ -1,179 +0,0 @@
-require 'amalgalite'
-Sequel.require 'adapters/shared/sqlite'
-
-module Sequel
-  # Top level module for holding all Amalgalite-related modules and classes
-  # for Sequel.
-  module Amalgalite
-    # Type conversion map class for Sequel's use of Amalgamite
-    class SequelTypeMap < ::Amalgalite::TypeMaps::DefaultMap
-      methods_handling_sql_types.delete('string')
-      methods_handling_sql_types.merge!(
-        'datetime' => %w'datetime timestamp',
-        'time' => %w'time',
-        'float' => ['float', 'double', 'real', 'double precision'],
-        'decimal' => %w'numeric decimal money'
-      )
-
-      # Store the related database object, in order to be able to correctly
-      # handle the database timezone.
-      def initialize(db)
-        @db = db
-      end
-      
-      # Return blobs as instances of Sequel::SQL::Blob instead of
-      # Amalgamite::Blob
-      def blob(s)
-        SQL::Blob.new(s)
-      end
-      
-      # Return numeric/decimal types as instances of BigDecimal
-      # instead of Float
-      def decimal(s)
-        BigDecimal.new(s)
-      end
-      
-      # Return datetime types as instances of Sequel.datetime_class
-      def datetime(s)
-        @db.to_application_timestamp(s)
-      end
-
-      def time(s)
-        Sequel.string_to_time(s)
-      end
-      
-      # Don't raise an error if the value is a string and the declared
-      # type doesn't match a known type, just return the value.
-      def result_value_of(declared_type, value)
-        if value.is_a?(::Amalgalite::Blob)
-          SQL::Blob.new(value.to_s)
-        elsif value.is_a?(String) && declared_type
-          (meth = self.class.sql_to_method(declared_type.downcase)) ? send(meth, value) : value
-        else
-          super
-        end
-      end
-    end
-    
-    # Database class for SQLite databases used with Sequel and the
-    # amalgalite driver.
-    class Database < Sequel::Database
-      include ::Sequel::SQLite::DatabaseMethods
-      
-      set_adapter_scheme :amalgalite
-      
-      # Mimic the file:// uri, by having 2 preceding slashes specify a relative
-      # path, and 3 preceding slashes specify an absolute path.
-      def self.uri_to_options(uri) # :nodoc:
-        { :database => (uri.host.nil? && uri.path == '/') ? nil : "#{uri.host}#{uri.path}" }
-      end
-      private_class_method :uri_to_options
-      
-      # Connect to the database.  Since SQLite is a file based database,
-      # the only options available are :database (to specify the database
-      # name), and :timeout, to specify how long to wait for the database to
-      # be available if it is locked, given in milliseconds (default is 5000).
-      def connect(server)
-        opts = server_opts(server)
-        opts[:database] = ':memory:' if blank_object?(opts[:database])
-        db = ::Amalgalite::Database.new(opts[:database])
-        db.busy_handler(::Amalgalite::BusyTimeout.new(opts.fetch(:timeout, 5000)/50, 50))
-        db.type_map = SequelTypeMap.new(self)
-        connection_pragmas.each{|s| log_yield(s){db.execute_batch(s)}}
-        db
-      end
-      
-      # Amalgalite is just the SQLite database without a separate SQLite installation.
-      def database_type
-        :sqlite
-      end
-
-      # Run the given SQL with the given arguments. Returns nil.
-      def execute_ddl(sql, opts=OPTS)
-        _execute(sql, opts){|conn| log_yield(sql){conn.execute_batch(sql)}}
-        nil
-      end
-      
-      # Run the given SQL with the given arguments and return the number of changed rows.
-      def execute_dui(sql, opts=OPTS)
-        _execute(sql, opts){|conn| log_yield(sql){conn.execute_batch(sql)}; conn.row_changes}
-      end
-      
-      # Run the given SQL with the given arguments and return the last inserted row id.
-      def execute_insert(sql, opts=OPTS)
-        _execute(sql, opts){|conn| log_yield(sql){conn.execute_batch(sql)}; conn.last_insert_rowid}
-      end
-      
-      # Run the given SQL with the given arguments and yield each row.
-      def execute(sql, opts=OPTS)
-        _execute(sql, opts) do |conn|
-          begin
-            yield(stmt = log_yield(sql){conn.prepare(sql)})
-          ensure
-            stmt.close if stmt
-          end
-        end
-      end
-      
-      # Run the given SQL with the given arguments and return the first value of the first row.
-      def single_value(sql, opts=OPTS)
-        _execute(sql, opts){|conn| log_yield(sql){conn.first_value_from(sql)}}
-      end
-      
-      private
-      
-      # Yield an available connection.  Rescue
-      # any Amalgalite::Errors and turn them into DatabaseErrors.
-      def _execute(sql, opts)
-        begin
-          synchronize(opts[:server]){|conn| yield conn}
-        rescue ::Amalgalite::Error, ::Amalgalite::SQLite3::Error => e
-          raise_error(e)
-        end
-      end
-      
-      # The Amagalite adapter does not need the pool to convert exceptions.
-      # Also, force the max connections to 1 if a memory database is being
-      # used, as otherwise each connection gets a separate database.
-      def connection_pool_default_options
-        o = super.dup
-        # Default to only a single connection if a memory database is used,
-        # because otherwise each connection will get a separate database
-        o[:max_connections] = 1 if @opts[:database] == ':memory:' || blank_object?(@opts[:database])
-        o
-      end
-      
-      # Both main error classes that Amalgalite raises
-      def database_error_classes
-        [::Amalgalite::Error, ::Amalgalite::SQLite3::Error]
-      end
-    end
-    
-    # Dataset class for SQLite datasets that use the amalgalite driver.
-    class Dataset < Sequel::Dataset
-      include ::Sequel::SQLite::DatasetMethods
-
-      Database::DatasetClass = self
-      
-      # Yield a hash for each row in the dataset.
-      def fetch_rows(sql)
-        execute(sql) do |stmt|
-          @columns = cols = stmt.result_fields.map{|c| output_identifier(c)}
-          col_count = cols.size
-          stmt.each do |result|
-            row = {}
-            col_count.times{|i| row[cols[i]] = result[i]}
-            yield row
-          end
-        end
-      end
-
-      private
-      
-      # Quote the string using the adapter instance method.
-      def literal_string_append(sql, v)
-        db.synchronize(@opts[:server]){|c| sql << c.quote(v)}
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/adapters/cubrid.rb

@@ -1,143 +0,0 @@
-require 'cubrid'
-Sequel.require 'adapters/shared/cubrid'
-
-module Sequel
-  module Cubrid
-     CUBRID_TYPE_PROCS = {
-       ::Cubrid::DATE => lambda{|t| Date.new(t.year, t.month, t.day)},
-       ::Cubrid::TIME => lambda{|t| SQLTime.create(t.hour, t.min, t.sec)},
-       21 => lambda{|s| s.to_i}
-     }
-
-    class Database < Sequel::Database
-      include Sequel::Cubrid::DatabaseMethods
-
-      ROW_COUNT = "SELECT ROW_COUNT()".freeze
-      LAST_INSERT_ID = "SELECT LAST_INSERT_ID()".freeze
-
-      set_adapter_scheme :cubrid
-      
-      def connect(server)
-        opts = server_opts(server)
-        conn = ::Cubrid.connect(
-          opts[:database],
-          opts[:host] || 'localhost',
-          opts[:port] || 30000,
-          opts[:user] || 'public',
-          opts[:password] || ''
-        )
-        conn.auto_commit = true
-        conn
-      end
-
-      def server_version
-        @server_version ||= synchronize{|c| c.server_version}
-      end
-      
-      def execute(sql, opts=OPTS)
-        synchronize(opts[:server]) do |conn|
-          r = log_yield(sql) do
-            begin
-              conn.query(sql)
-            rescue => e
-              raise_error(e)
-            end
-          end
-          if block_given?
-            yield(r)
-          else
-            begin
-              case opts[:type]
-              when :dui
-                # This is cubrid's API, but it appears to be completely broken,
-                # giving StandardError: ERROR: CCI, -18, Invalid request handle
-                #r.affected_rows
-
-                # Work around bugs by using the ROW_COUNT function.
-                begin
-                  r2 = conn.query(ROW_COUNT)
-                  r2.each{|a| return a.first.to_i}
-                ensure
-                  r2.close if r2
-                end
-              when :insert
-                begin
-                  r2 = conn.query(LAST_INSERT_ID)
-                  r2.each{|a| return a.first.to_i}
-                ensure
-                  r2.close if r2
-                end
-              end
-            ensure
-              r.close
-            end
-          end
-        end
-      end
-
-      def execute_ddl(sql, opts=OPTS)
-        execute(sql, opts.merge(:type=>:ddl))
-      end
-
-      def execute_dui(sql, opts=OPTS)
-        execute(sql, opts.merge(:type=>:dui))
-      end
-
-      def execute_insert(sql, opts=OPTS)
-        execute(sql, opts.merge(:type=>:insert))
-      end
-
-      private
-
-      def begin_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_BEGIN){conn.auto_commit = false}
-      end
-      
-      def commit_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_COMMIT){conn.commit}
-      end
-
-      def database_error_classes
-        [StandardError]
-      end
-
-      def remove_transaction(conn, committed)
-        conn.auto_commit = true
-      ensure
-        super
-      end
-      
-      # This doesn't actually work, as the cubrid ruby driver
-      # does not implement transactions correctly.
-      def rollback_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
-      end
-    end
-    
-    class Dataset < Sequel::Dataset
-      include Sequel::Cubrid::DatasetMethods
-      COLUMN_INFO_NAME = "name".freeze
-      COLUMN_INFO_TYPE = "type_name".freeze
-
-      Database::DatasetClass = self
-      
-      def fetch_rows(sql)
-        execute(sql) do |stmt|
-          begin
-            procs = 
-            cols = stmt.column_info.map{|c| [output_identifier(c[COLUMN_INFO_NAME]), CUBRID_TYPE_PROCS[c[COLUMN_INFO_TYPE]]]}
-            @columns = cols.map{|c| c.first}
-            stmt.each do |r|
-              row = {}
-              cols.zip(r).each{|(k, p), v| row[k] = (v && p) ? p.call(v) : v}
-              yield row
-            end
-          ensure
-            stmt.close
-          end
-        end
-        self
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/1.9.1/gems/sequel-4.15.0/lib/sequel/adapters/db2.rb

@@ -1,229 +0,0 @@
-require 'db2/db2cli'
-Sequel.require %w'shared/db2', 'adapters'
-
-module Sequel
-  module DB2
-
-    @convert_smallint_to_bool = true
-
-    # Underlying error raised by Sequel, since ruby-db2 doesn't
-    # use exceptions.
-    class DB2Error < StandardError
-    end
-
-    class << self
-      # Whether to convert smallint values to bool, true by default.
-      # Can also be overridden per dataset.
-      attr_accessor :convert_smallint_to_bool
-    end
-
-    tt = Class.new do
-      def boolean(s) !s.to_i.zero? end
-      def date(s) Date.new(s.year, s.month, s.day) end
-      def time(s) Sequel::SQLTime.create(s.hour, s.minute, s.second) end
-    end.new
-
-    # Hash holding type translation methods, used by Dataset#fetch_rows.
-    DB2_TYPES = {
-      :boolean  => tt.method(:boolean),
-      DB2CLI::SQL_BLOB => ::Sequel::SQL::Blob.method(:new),
-      DB2CLI::SQL_TYPE_DATE => tt.method(:date),
-      DB2CLI::SQL_TYPE_TIME => tt.method(:time),
-      DB2CLI::SQL_DECIMAL => ::BigDecimal.method(:new)
-    }
-
-    class Database < Sequel::Database
-      include DatabaseMethods
-
-      set_adapter_scheme :db2
-
-      TEMPORARY = 'GLOBAL TEMPORARY '.freeze
-      rc, NullHandle = DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_ENV, DB2CLI::SQL_NULL_HANDLE)
-      
-      # Hash of connection procs for converting
-      attr_reader :conversion_procs
-
-      def connect(server)
-        opts = server_opts(server)
-        dbc = checked_error("Could not allocate database connection"){DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_DBC, NullHandle)}
-        checked_error("Could not connect to database"){DB2CLI.SQLConnect(dbc, opts[:database], opts[:user], opts[:password])}
-        dbc
-      end
-      
-      def disconnect_connection(conn)
-        DB2CLI.SQLDisconnect(conn)
-        DB2CLI.SQLFreeHandle(DB2CLI::SQL_HANDLE_DBC, conn)
-      end
-
-      def execute(sql, opts=OPTS, &block)
-        synchronize(opts[:server]){|conn| log_connection_execute(conn, sql, &block)}
-      end
-
-      def execute_insert(sql, opts=OPTS)
-        synchronize(opts[:server]) do |conn|
-          log_connection_execute(conn, sql)
-          sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
-          log_connection_execute(conn, sql) do |sth|
-            name, buflen, datatype, size, digits, nullable = checked_error("Could not describe column"){DB2CLI.SQLDescribeCol(sth, 1, 256)}
-            if DB2CLI.SQLFetch(sth) != DB2CLI::SQL_NO_DATA_FOUND
-              v, _ = checked_error("Could not get data"){DB2CLI.SQLGetData(sth, 1, datatype, size)}
-              if v.is_a?(String) 
-                return v.to_i
-              else
-                return nil
-              end
-            end
-          end
-        end
-      end
-      
-      ERROR_MAP = {}
-      %w'SQL_INVALID_HANDLE SQL_STILL_EXECUTING SQL_ERROR'.each do |s|
-        ERROR_MAP[DB2CLI.const_get(s)] = s
-      end
-      def check_error(rc, msg)
-        case rc
-        when DB2CLI::SQL_SUCCESS, DB2CLI::SQL_SUCCESS_WITH_INFO, DB2CLI::SQL_NO_DATA_FOUND
-          nil
-        when DB2CLI::SQL_INVALID_HANDLE, DB2CLI::SQL_STILL_EXECUTING
-          e = DB2Error.new("#{ERROR_MAP[rc]}: #{msg}")
-          e.set_backtrace(caller)
-          raise_error(e, :disconnect=>true)
-        else
-          e = DB2Error.new("#{ERROR_MAP[rc] || "Error code #{rc}"}: #{msg}")
-          e.set_backtrace(caller)
-          raise_error(e, :disconnect=>true)
-        end
-      end
-
-      def checked_error(msg)
-        rc, *ary= yield
-        check_error(rc, msg)
-        ary.length <= 1 ? ary.first : ary
-      end
-
-      def to_application_timestamp_db2(v)
-        to_application_timestamp(v.to_s)
-      end
-
-      private
-
-      def adapter_initialize
-        @conversion_procs = DB2_TYPES.dup
-        @conversion_procs[DB2CLI::SQL_TYPE_TIMESTAMP] = method(:to_application_timestamp_db2)
-      end
-
-      def database_error_classes
-        [DB2Error]
-      end
-
-      def begin_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_BEGIN){DB2CLI.SQLSetConnectAttr(conn, DB2CLI::SQL_ATTR_AUTOCOMMIT, DB2CLI::SQL_AUTOCOMMIT_OFF)}
-        set_transaction_isolation(conn, opts)
-      end
-
-      def remove_transaction(conn, committed)
-        DB2CLI.SQLSetConnectAttr(conn, DB2CLI::SQL_ATTR_AUTOCOMMIT, DB2CLI::SQL_AUTOCOMMIT_ON)
-      ensure
-        super
-      end
-
-      def rollback_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_ROLLBACK){DB2CLI.SQLEndTran(DB2CLI::SQL_HANDLE_DBC, conn, DB2CLI::SQL_ROLLBACK)}
-      end
-
-      def commit_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_COMMIT){DB2CLI.SQLEndTran(DB2CLI::SQL_HANDLE_DBC, conn, DB2CLI::SQL_COMMIT)}
-      end
-    
-      def log_connection_execute(conn, sql)
-        sth = checked_error("Could not allocate statement"){DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_STMT, conn)}
-
-        begin
-          checked_error("Could not execute statement: #{sql}"){log_yield(sql){DB2CLI.SQLExecDirect(sth, sql)}}
-          
-          if block_given?
-            yield(sth)
-          else
-            checked_error("Could not get RPC"){DB2CLI.SQLRowCount(sth)}
-          end
-        ensure
-          checked_error("Could not free statement"){DB2CLI.SQLFreeHandle(DB2CLI::SQL_HANDLE_STMT, sth)}
-        end
-      end
-
-      # Convert smallint type to boolean if convert_smallint_to_bool is true
-      def schema_column_type(db_type)
-        if DB2.convert_smallint_to_bool && db_type =~ /smallint/i 
-          :boolean
-        else
-          super
-        end
-      end
-    end
-    
-    class Dataset < Sequel::Dataset
-      include DatasetMethods
-
-      Database::DatasetClass = self
-      MAX_COL_SIZE = 256
-      
-      # Whether to convert smallint to boolean arguments for this dataset.
-      # Defaults to the DB2 module setting.
-      def convert_smallint_to_bool
-        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = DB2.convert_smallint_to_bool)
-      end
-
-      # Override the default DB2.convert_smallint_to_bool setting for this dataset.
-      attr_writer :convert_smallint_to_bool
-
-      def fetch_rows(sql)
-        execute(sql) do |sth|
-          db = @db
-          i = 1
-          column_info = get_column_info(sth)
-          cols = column_info.map{|c| c.at(1)}
-          @columns = cols
-          errors = [DB2CLI::SQL_NO_DATA_FOUND, DB2CLI::SQL_ERROR]
-          until errors.include?(rc = DB2CLI.SQLFetch(sth))
-            db.check_error(rc, "Could not fetch row")
-            row = {}
-            column_info.each do |i, c, t, s, pr|
-              v, _ = db.checked_error("Could not get data"){DB2CLI.SQLGetData(sth, i, t, s)}
-              row[c] = if v == DB2CLI::Null
-                nil
-              elsif pr
-                pr.call(v)
-              else
-                v
-              end
-            end
-            yield row
-          end
-        end
-        self
-      end
-      
-      private
-
-      def get_column_info(sth)
-        db = @db
-        column_count = db.checked_error("Could not get number of result columns"){DB2CLI.SQLNumResultCols(sth)}
-        convert = convert_smallint_to_bool
-        cps = db.conversion_procs
-
-        (1..column_count).map do |i| 
-          name, buflen, datatype, size, digits, nullable = db.checked_error("Could not describe column"){DB2CLI.SQLDescribeCol(sth, i, MAX_COL_SIZE)}
-          pr = if datatype == DB2CLI::SQL_SMALLINT && convert && size <= 5 && digits <= 1
-            cps[:boolean]
-          elsif datatype == DB2CLI::SQL_CLOB && Sequel::DB2.use_clob_as_blob
-            cps[DB2CLI::SQL_BLOB]
-          else
-            cps[datatype]
-          end
-          [i, output_identifier(name), datatype, size, pr]
-        end 
-      end
-    end
-  end
-end