datamapper 0.3.2 → 0.9.3

data/lib/data_mapper/adapters/mysql_adapter.rb

@@ -1,72 +0,0 @@
-require 'data_mapper/adapters/data_object_adapter'
-begin
-  gem 'do_mysql', '<=0.2.4'
-  require 'do_mysql'
-rescue LoadError
-  STDERR.puts <<-EOS
-You must install the DataObjects::Mysql driver.
-  gem install do_mysql
-EOS
-  exit
-end
-
-module DataMapper
-  module Adapters
-    
-    class MysqlAdapter < DataObjectAdapter
-      
-      TRUE_ALIASES << "T".freeze << "\004\bT".freeze
-      FALSE_ALIASES << "F".freeze << "\004\bF".freeze
-      
-      def empty_insert_sql
-        "() VALUES ()"
-      end
-      
-      def create_connection
-        
-        connection_string = ""
-        builder = lambda { |k,v| connection_string << "#{k}=#{@configuration.send(v)} " unless @configuration.send(v).blank? }
-        
-        builder['host', :host]
-        builder['user', :username]
-        builder['password', :password]
-        builder['dbname', :database]
-        builder['socket', :socket]
-        builder['port', :port]
-        
-        logger.debug { connection_string.strip }
-        
-        conn = DataObject::Mysql::Connection.new(connection_string.strip)
-        conn.logger = self.logger
-        conn.open
-        cmd = conn.create_command("SET NAMES UTF8")
-        cmd.execute_non_query
-        return conn
-      end
-      
-      def database_column_name
-        "TABLE_SCHEMA"
-      end
-      
-      module Mappings
-        
-        def to_create_table_sql
-          @to_create_table_sql || @to_create_table_sql = begin
-            "CREATE TABLE #{to_sql} (#{columns.map { |c| c.to_long_form }.join(', ')}) Type=MyISAM CHARACTER SET utf8"
-          end
-        end
-        
-        class Schema
-
-          def database_tables
-            get_database_tables(@adapter.schema.name)
-          end
-
-        end
-
-        
-      end # module Mappings
-    end # class MysqlAdapter
-    
-  end # module Adapters
-end # module DataMapper

data/lib/data_mapper/adapters/postgresql_adapter.rb

@@ -1,258 +0,0 @@
-require 'data_mapper/adapters/data_object_adapter'
-begin
-  gem 'do_postgres', '<=0.2.4'
-  require 'do_postgres'
-rescue LoadError
-  STDERR.puts <<-EOS
-You must install the DataObjects::Postgres driver.
-  gem install do_postgres
-EOS
-  exit
-end
-
-module DataMapper
-  module Adapters
-    
-    class PostgresqlAdapter < DataObjectAdapter
-      
-      def schema_search_path
-        @schema_search_path || @schema_search_path = begin
-          if @configuration.schema_search_path
-            @configuration.schema_search_path.split(',').map do |part|
-              part.blank? ? nil : part.strip.ensure_wrapped_with("'")
-            end.compact
-          else
-            []
-          end
-        end
-      end
-      
-      def create_connection
-        connection_string = ""
-        builder = lambda do |k,v|
-          connection_string << "#{k}=#{@configuration.send(v)} " unless
-            @configuration.send(v).blank?
-        end
-        builder['host', :host]
-        builder['user', :username]
-        builder['password', :password]
-        builder['dbname', :database]
-        builder['socket', :socket]
-        builder['port', :port]
-        conn = DataObject::Postgres::Connection.new(connection_string.strip)
-        conn.logger = self.logger
-        conn.open
-
-        unless schema_search_path.empty?
-          execute("SET search_path TO #{schema_search_path}")
-        end
-
-        return conn
-      end
-      
-      def database_column_name
-        "TABLE_CATALOG"
-      end
-            
-      TABLE_QUOTING_CHARACTER = '"'.freeze
-      COLUMN_QUOTING_CHARACTER = '"'.freeze
-      
-      TYPES.merge!({
-        :integer => 'integer'.freeze,
-        :datetime => 'timestamp with time zone'.freeze
-      })
-        
-      module Mappings
-        class Table
-          def sequence_sql
-            @sequence_sql ||= quote_table("_id_seq").freeze
-          end
-          
-          def to_create_table_sql
-            schema_name = name.index('.') ? name.split('.').first : nil
-            schema_list = @adapter.query('SELECT nspname FROM pg_namespace').join(',')
-          
-            sql = if schema_name and !schema_list.include?(schema_name)
-                "CREATE SCHEMA #{@adapter.quote_table_name(schema_name)}; " 
-            else
-              ''
-            end
-            
-            sql << "CREATE TABLE " << to_sql
-          
-            sql << " (" << columns.map do |column|
-              column.to_long_form
-            end.join(', ') << ")"
-          
-            return sql
-          end
-          
-          # The logic of this comes from AR; it was modified for smarter typecasting
-          def unquote_default(default)
-            # Boolean types
-            return true if default =~ /true/i
-            return false if default =~ /false/i
-
-            # Char/String/Bytea type values
-            return $1 if default =~ /^'(.*)'::(bpchar|text|character varying|bytea)$/
-
-            # Numeric values
-            return value.to_f if default =~ /^-?[0-9]+(\.[0-9]*)/
-            return value.to_i if default =~ /^-?[0-9]+/
-
-            # Fixed dates / times
-            return Date.parse($1) if default =~ /^'(.+)'::date/
-            return DateTime.parse($1) if default =~ /^'(.+)'::timestamp/            
-
-            # Anything else is blank, some user type, or some function
-            # and we can't know the value of that, so return nil.
-            return nil       
-          end
-          
-          # def to_exists_sql
-          #   @to_exists_sql || @to_exists_sql = <<-EOS.compress_lines
-          #     SELECT TABLE_NAME
-          #     FROM INFORMATION_SCHEMA.TABLES
-          #     WHERE TABLE_NAME = ?
-          #       AND TABLE_CATALOG = ?
-          #   EOS
-          # end
-          # 
-          # def to_column_exists_sql
-          #   @to_column_exists_sql || @to_column_exists_sql = <<-EOS.compress_lines
-          #     SELECT TABLE_NAME, COLUMN_NAME
-          #     FROM INFORMATION_SCHEMA.COLUMNS
-          #     WHERE TABLE_NAME = ?
-          #     AND COLUMN_NAME = ?
-          #     AND TABLE_CATALOG = ?
-          #   EOS
-          # end          
-                    
-          private 
-          
-          def quote_table(table_suffix = nil)
-            parts = name.split('.')
-            parts.last << table_suffix if table_suffix
-            parts.map { |part|
-              @adapter.quote_table_name(part) }.join('.')
-          end
-        end # class Table
-        
-        class Schema
-          
-          def database_tables
-            get_database_tables("public")
-          end
-          
-        end
-        
-        class Column
-          def serial_declaration
-            "SERIAL"
-          end
-          
-          def check_declaration
-          	"CHECK (" << check << ")"
-          end
-          
-          def to_alter_sql
-            "ALTER TABLE " <<  table.to_sql << " ALTER COLUMN " << to_alter_form
-          end
-          
-          def alter!
-            result = super
-            reset_alter_state!
-            result
-          end
-          
-          def reset_alter_state!
-            @type_changed = false
-            @default_changed = false
-          end
-          
-          def default=(value)
-            @default_changed = true
-            super
-          end
-          
-          def type=(value)
-            @type_changed = true
-            super
-          end
-          
-          def to_alter_form
-            sql = to_sql.dup
-            
-            changes = 0
-            
-            if @type_changed
-              changes += 1
-              sql << " TYPE " << type_declaration
-              case self.type
-              when :integer then sql << " USING #{to_sql}::integer"
-              when :datetime then
-                sql << " USING timestamp with time zone"
-              end
-            end
-            
-            if @default_changed
-              sql << ", " if changes += 1 > 1
-              
-              if default.blank? || default_declaration.blank?
-                sql << " DROP DEFAULT"
-              else
-                sql << " " << default_declaration
-              end
-            end
-            
-            sql
-          end
-          
-          def to_long_form
-            @to_long_form || begin
-              @to_long_form = "#{to_sql}"
-              
-              if serial? && !serial_declaration.blank?
-                @to_long_form << " #{serial_declaration}"
-                if key? && !primary_key_declaration.blank?
-                  @to_long_form << " #{primary_key_declaration}"
-                end
-              else
-                @to_long_form << " #{type_declaration}"
-                
-                unless nullable? || not_null_declaration.blank?
-                  @to_long_form << " #{not_null_declaration}"
-                end
-                
-                if default && !default_declaration.blank?
-                  @to_long_form << " #{default_declaration}"
-                end
-                
-                if unique? && !unique_declaration.blank?
-                  @to_long_form << " #{unique_declaration}"
-                end
-                
-                if check && !check_declaration.blank?
-                  @to_long_form << " #{check_declaration}"
-                end
-              end
-                      
-              @to_long_form
-            end
-          end
-          
-          # size is still required, as length in postgres behaves slightly differently
-          def size
-            case self.type
-            #strings in postgres can be unlimited length
-            when :string then return (@options.has_key?(:length) || @options.has_key?(:size) ? @size : nil)
-            else nil
-            end
-          end
-        end # class Column
-      end # module Mappings
-      
-    end # class PostgresqlAdapter
-    
-  end # module Adapters
-end # module DataMapper

data/lib/data_mapper/adapters/sql/coersion.rb

@@ -1,134 +0,0 @@
-require 'bigdecimal' 
-require 'bigdecimal/util'
-
-module DataMapper
-  module Adapters
-    module Sql
-      # Coersion is a mixin that allows for coercing database values to Ruby Types.
-      #
-      # DESIGN: Probably should handle the opposite scenario here too. I believe that's
-      # currently in DataMapper::Database, which is obviously not a very good spot for
-      # it.
-      module Coersion
-        
-        class CoersionError < StandardError
-        end
-        
-        TRUE_ALIASES = ['true'.freeze, 'TRUE'.freeze, '1'.freeze, 1]
-        FALSE_ALIASES = [nil, '0'.freeze, 0]
-        
-        def self.included(base)
-          base.const_set('TRUE_ALIASES', TRUE_ALIASES.dup)
-          base.const_set('FALSE_ALIASES', FALSE_ALIASES.dup)
-        end
-        
-        def type_cast_boolean(raw_value)
-          return nil if raw_value.nil? || (raw_value.respond_to?(:empty?) && raw_value.empty?)
-          case raw_value
-            when TrueClass, FalseClass then raw_value
-            when *self::class::TRUE_ALIASES then true
-            when *self::class::FALSE_ALIASES then false
-            else raise CoersionError.new("Can't type-cast #{raw_value.inspect} to a boolean")
-          end
-        end
-        
-        def type_cast_string(raw_value)
-          return nil if raw_value.blank?
-          # type-cast values should be immutable for memory conservation
-          raw_value
-        end
-        
-        def type_cast_text(raw_value)
-          return nil if raw_value.blank?
-          # type-cast values should be immutable for memory conservation
-          raw_value
-        end
-        
-        def type_cast_class(raw_value)
-          return nil if raw_value.blank?
-          Object::recursive_const_get(raw_value)
-        end
-        
-        def type_cast_integer(raw_value)
-          return nil if raw_value.blank?
-          raw_value.to_i
-        rescue ArgumentError
-          nil
-        end
-        
-        def type_cast_decimal(raw_value)
-          return nil if raw_value.blank?
-          raw_value.to_d
-        rescue ArgumentError 
-          nil 
-        end
-                
-        def type_cast_float(raw_value)
-          return nil if raw_value.blank?
-          case raw_value
-            when Float then raw_value
-            when Numeric, String then raw_value.to_f
-            else CoersionError.new("Can't type-cast #{raw_value.inspect} to a float")
-          end
-        end
-        
-        def type_cast_datetime(raw_value)
-          return nil if raw_value.blank?
-          
-          case raw_value
-            when "0000-00-00 00:00:00" then nil
-            when DateTime then raw_value
-            when Date then DateTime.new(raw_value) rescue nil
-            when String then DateTime::parse(raw_value) rescue nil
-            else raise CoersionError.new("Can't type-cast #{raw_value.inspect} to a datetime")
-          end
-        end
-        
-        def type_cast_date(raw_value)
-          return nil if raw_value.blank?
-          
-          case raw_value
-            when Date then raw_value
-            when DateTime, Time then Date::civil(raw_value.year, raw_value.month, raw_value.day)
-            when String then Date::parse(raw_value)
-            else raise CoersionError.new("Can't type-cast #{raw_value.inspect} to a date")
-          end
-        end
-        
-        def type_cast_object(raw_value)
-          return nil if raw_value.blank?
-
-          begin
-            YAML.load(raw_value)
-          rescue
-            raise CoersionError.new("Can't type-cast #{raw_value.inspect} to an object")
-          end
-        end
-        
-        def type_cast_value(type, raw_value)
-          return nil if raw_value.blank?
-          
-          case type
-          when :string then type_cast_string(raw_value)
-          when :text then type_cast_text(raw_value)
-          when :boolean then type_cast_boolean(raw_value)
-          when :class then type_cast_class(raw_value)
-          when :integer then type_cast_integer(raw_value)
-          when :decimal then type_cast_decimal(raw_value)
-          when :float then type_cast_float(raw_value)
-          when :datetime then type_cast_datetime(raw_value)
-          when :date then type_cast_date(raw_value)
-          when :object then type_cast_object(raw_value)
-          else
-            if respond_to?("type_cast_#{type}")
-              send("type_cast_#{type}", raw_value)
-            else
-              raise "Don't know how to type-cast #{{ type => raw_value }.inspect }"
-            end
-          end
-        end
-
-      end # module Coersion
-    end
-  end  
-end