datamapper 0.1.1 → 0.2.0

data/plugins/can_has_sphinx/scripts/sphinx.sh

@@ -0,0 +1,47 @@
+#!/bin/sh
+#
+# start/stop searchd server.
+
+if ! [ -x /usr/local/bin/searchd ]; then
+        exit 0
+fi
+
+case "$1" in
+    start)
+        echo -n "Starting sphinx searchd server:"
+        echo -n " searchd" ; 
+        /sbin/start-stop-daemon --start --quiet --pidfile /var/run/searchd.pid --chdir /etc --exec /usr/local/bin/searchd
+        echo "."
+        ;;
+    stop)
+        echo -n "Stopping sphinx searchd server:"
+        echo -n " searchd" ; 
+        /sbin/start-stop-daemon --stop --quiet --oknodo --pidfile /var/run/searchd.pid --exec /usr/local/bin/searchd
+        echo "."
+        ;;
+    reload)
+        echo -n "Reloading sphinx searchd server:"
+        echo -n " searchd"
+        /sbin/start-stop-daemon --stop --quiet --oknodo --pidfile /var/run/searchd.pid --signal 1
+        echo "."
+        ;;
+    force-reload)
+        $0 reload
+        ;;
+    reindex)
+        cd /etc
+        /usr/local/bin/indexer --rotate --quiet --all
+        ;;
+    restart)
+        echo -n "Restarting sphinx searchd server:"
+        echo -n " searchd"
+        /sbin/start-stop-daemon --stop --quiet --oknodo --pidfile /var/run/searchd.pid --exec /usr/local/bin/searchd
+        /sbin/start-stop-daemon --start --quiet --pidfile /var/run/searchd.pid --chdir /etc --exec  /usr/local/bin/searchd
+        echo "."
+        ;;
+    *)
+        echo "Usage: /etc/init.d/searchd {start|stop|reload|restart|reindex}"
+        exit 1
+        ;;
+esac
+exit 0

data/plugins/can_has_sphinx/tasks/acts_as_sphinx_tasks.rake

@@ -0,0 +1,41 @@
+namespace :sphinx do
+  desc "Run indexer"
+  task :index do
+    cd 'config' do
+      system 'indexer --all'
+    end
+  end
+
+  desc "Rotate idendexes and restart searchd server"
+  task :rotate do
+    cd 'config' do
+      system 'indexer --rotate --all'
+    end
+  end
+  
+  desc "Start searchd server"
+  task :start do
+    if File.exists?('/var/run/searchd.pid')
+      puts 'Sphinx searchd server is already started.'
+    else
+      cd 'config' do
+        system 'searchd'
+        puts 'Sphinx searchd server started.'
+      end
+    end
+  end
+  
+  desc "Stop searchd server"
+  task :stop do
+    unless File.exists?('/var/run/searchd.pid')
+      puts 'Sphinx searchd server is not running.'
+    else
+      pid = File.read('/var/run/searchd.pid').chomp
+      system "kill #{pid}"
+      puts 'Sphinx searchd server stopped.'
+    end
+  end
+  
+  desc "Restart searchd server"
+  task :restart => [:stop, :start]
+end

data/plugins/dataobjects/REVISION

@@ -0,0 +1 @@
+18

data/plugins/dataobjects/Rakefile

@@ -0,0 +1,7 @@
+require 'spec/rake/spectask'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('specs') do |t|
+  t.spec_opts = ["--format", "specdoc", "--colour"]
+  t.spec_files = Dir['spec/*_spec.rb'].sort
+end

data/plugins/dataobjects/do.rb

@@ -0,0 +1,246 @@
+require 'date'
+
+# Thanks http://www.rubyweeklynews.org/20051120
+class DateTime
+ def to_time
+   Time.mktime(year, mon, day, hour, min, sec)
+ end
+ 
+ def to_date
+   Date.new(year, mon, day)
+ end
+end
+
+class Time
+  def to_datetime
+    DateTime.civil(year, mon, day, hour, min, sec)
+  end
+  
+  def to_s_db
+    strftime("%Y-%m-%d %X")
+  end
+end
+
+module DataObject
+  STATE_OPEN   = 0
+  STATE_CLOSED = 1
+
+  class Connection
+
+    attr_reader :timeout, :database, :datasource, :server_version, :state
+    
+    def initialize(connection_string)
+    end
+    
+    def begin_transaction
+      # TODO: Hook this up
+      Transaction.new
+    end
+    
+    def change_database(database_name)
+      raise NotImplementedError
+    end
+    
+    def open
+      raise NotImplementedError
+    end
+    
+    def close
+      raise NotImplementedError
+    end
+    
+    def create_command(text)
+      Command.new(self, text)
+    end
+    
+    def closed?
+      @state == STATE_CLOSED
+    end
+    
+  end
+  
+  class Transaction
+    
+    attr_reader :connection
+    
+    def initialize(conn)
+      @connection = conn
+    end
+    
+    # Commits the transaction
+    def commit
+      raise NotImplementedError
+    end
+    
+    # Rolls back the transaction
+    def rollback(savepoint = nil)
+      raise NotImplementedError
+    end
+    
+    # Creates a savepoint for rolling back later (not commonly supported)
+    def save(name)
+      raise NotImplementedError
+    end
+    
+  end
+  
+  class Reader
+    include Enumerable
+    
+    attr_reader :field_count, :has_rows, :records_affected, :fields
+    alias_method :has_rows?, :has_rows
+    
+    def each
+      return nil unless has_rows
+      while(true) do
+        yield
+        break unless self.next
+      end
+    end
+    
+    def current_row
+      ret = []
+      field_count.times do |i|
+        ret[i] = item(i)
+      end
+      ret
+    end
+    
+    def close
+      raise NotImplementedError
+    end
+    
+    # retrieves the Ruby data type for a particular column number
+    def data_type_name(col)
+      raise ReaderClosed, "You cannot ask for metadata once the reader is closed" if state_closed?      
+    end
+    
+    # retrieves the name of a particular column number
+    def name(col)
+      raise ReaderClosed, "You cannot ask for metadata once the reader is closed" if state_closed?      
+    end
+    
+    # retrives the index of the column with a particular name
+    def get_index(name)
+      raise ReaderClosed, "You cannot ask for metadata once the reader is closed" if state_closed?
+    end
+    
+    def item(idx)
+      raise ReaderClosed, "You cannot ask for information once the reader is closed" if state_closed?
+    end
+
+    # returns an array of hashes containing the following information
+    #            
+    # name:         the column name
+    # index:        the index of the column
+    # max_size:     the maximum allowed size of the data in the column
+    # precision:    the precision (for column types that support it)
+    # scale:        the scale (for column types that support it)
+    # unique:       boolean specifying whether the values must be unique
+    # key:          boolean specifying whether this column is, or is part
+    #               of, the primary key
+    # catalog:      the name of the database this column is part of
+    # base_name:    the original name of the column (if AS was used,
+    #               this will provide the original name)
+    # schema:       the name of the schema (if supported)
+    # table:        the name of the table this column is part of
+    # data_type:    the name of the Ruby data type used
+    # allow_null:   boolean specifying whether nulls are allowed
+    # db_type:      the type specified by the DB
+    # aliased:      boolean specifying whether the column has been
+    #               renamed using AS
+    # calculated:   boolean specifying whether the field is calculated
+    # serial:       boolean specifying whether the field is a serial
+    #               column
+    # blob:         boolean specifying whether the field is a BLOB
+    # readonly:     boolean specifying whether the field is readonly
+    def get_schema
+      raise ReaderClosed, "You cannot ask for metadata once the reader is closed" if state_closed?
+    end
+    
+    # specifies whether the column identified by the passed in index
+    # is null.
+    def null?(idx)
+      raise ReaderClosed, "You cannot ask for column information once the reader is closed" if state_closed?
+    end
+    
+    # Consumes the next result. Returns true if a result is consumed and
+    # false if none is
+    def next
+      raise ReaderClosed, "You cannot increment the cursor once the reader is closed" if state_closed?
+    end
+    
+    protected
+    def state_closed?
+      @state == STATE_CLOSED
+    end
+    
+    def native_type
+      raise ReaderClosed, "You cannot check the type of a column once the reader is closed" if state_closed?
+    end
+    
+  end
+  
+  class ResultData
+    
+    def initialize(conn, affected_rows, last_insert_row = nil)
+      @conn, @affected_rows, @last_insert_row = conn, affected_rows, last_insert_row
+    end
+  
+    attr_reader :affected_rows, :last_insert_row
+    alias_method :to_i, :affected_rows
+    
+  end
+  
+  class Schema < Array
+    
+  end
+  
+  class Command
+    
+    attr_reader :text, :timeout, :connection
+    
+    # initialize creates a new Command object
+    def initialize(connection, text)
+      @connection, @text = connection, text
+    end
+    
+    def execute_non_query
+      raise LostConnectionError, "the connection to the database has been lost" if @connection.closed?
+    end
+    
+    def execute_reader
+      raise LostConnectionError, "the connection to the database has been lost" if @connection.closed?
+    end
+    
+    def prepare
+      raise NotImplementedError
+    end
+    
+  end
+  
+  class NotImplementedError < StandardError
+  end
+  
+  class ConnectionFailed < StandardError
+  end
+  
+  class ReaderClosed < StandardError
+  end
+  
+  class ReaderError < StandardError
+  end
+  
+  class QueryError < StandardError
+  end
+  
+  class NoInsertError < StandardError
+  end
+  
+  class LostConnectionError < StandardError
+  end
+  
+  class UnknownError < StandardError
+  end
+  
+end

data/plugins/dataobjects/do_mysql.rb

@@ -0,0 +1,179 @@
+require 'mysql_c'
+require 'do'
+
+module DataObject
+  module Mysql
+    TYPES = Hash[*Mysql_c.constants.select {|x| x.include?("MYSQL_TYPE")}.map {|x| [Mysql_c.const_get(x), x.gsub(/^MYSQL_TYPE_/, "")]}.flatten]    
+    
+    QUOTE_STRING = "\""
+    QUOTE_COLUMN = "`"
+    
+    class Connection < DataObject::Connection
+      attr_reader :db
+      
+      def initialize(connection_string)
+        @state = STATE_CLOSED
+        @connection_string = connection_string
+        opts = connection_string.split(" ")
+        opts.each do |opt|
+          k, v = opt.split("=")
+          raise ArgumentError, "you specified an invalid connection component: #{opt}" unless k && v
+          instance_variable_set("@#{k}", v)
+        end
+      end
+      
+      def change_database(database_name)
+        @dbname = database_name
+        @connection_string.gsub(/db_name=[^ ]*/, "db_name=#{database_name}")
+      end
+      
+      def open
+        @db = Mysql_c.mysql_init(nil)
+        raise ConnectionFailed, "could not allocate a MySQL connection" unless @db
+        conn = Mysql_c.mysql_real_connect(@db, @host, @user, @password, @dbname, @port || 0, @socket, @flags || 0)
+        raise ConnectionFailed, "The connection with connection string #{@connection_string} failed\n#{Mysql_c.mysql_error(@db)}" unless conn
+        @state = STATE_OPEN
+        true
+      end
+      
+      def close
+        if @state == STATE_OPEN
+          Mysql_c.mysql_close(@db)
+          @state = STATE_CLOSED        
+          true
+        else
+          false
+        end
+      end
+      
+      def create_command(text)
+        Command.new(self, text)
+      end
+      
+    end
+    
+    class Reader < DataObject::Reader
+    
+      def initialize(db, reader)
+        @reader = reader
+        unless @reader
+          if Mysql_c.mysql_field_count(db) == 0
+            @records_affected = Mysql_c.mysql_affected_rows(db)
+            close
+          else
+            raise UnknownError, "An unknown error has occured while trying to process a MySQL query.\n#{Mysql_c.mysql_error(db)}"
+          end
+        else
+          @field_count = Mysql_c.mysql_num_fields(@reader)
+          @state = STATE_OPEN
+          self.next
+          fields = Mysql_c.mysql_fetch_fields(@reader)
+          @native_fields = fields
+          raise UnknownError, "An unknown error has occured while trying to process a MySQL query. There were no fields in the resultset\n#{Mysql_c.mysql_error(db)}" unless fields
+          @fields = fields.map {|field| field.name}
+          @rows = Mysql_c.mysql_num_rows(@reader)
+          @has_rows = @rows > 0
+        end
+      end
+      
+      def close
+        if @state != STATE_CLOSED
+          Mysql_c.mysql_free_result(@reader)
+          @state = STATE_CLOSED
+          true
+        else
+          false
+        end
+      end
+      
+      def name(col)
+        super
+        @fields[col]
+      end
+      
+      def get_index(name)
+        super
+        @fields.index(name)
+      end
+      
+      def null?(idx)
+        super
+        @row[idx] == nil
+      end
+      
+      def item(idx)
+        super
+        typecast(@row[idx], idx)
+      end
+      
+      def next
+        super
+        @row = Mysql_c.mysql_fetch_row(@reader)
+        close if @row.nil?
+        @row ? true : nil
+      end
+      
+      protected
+      def native_type(col)
+        super
+        TYPES[@native_fields[col].type]
+      end
+      
+      def typecast(val, idx)
+        return nil if val.nil?
+        field = @native_fields[idx]
+        case TYPES[field.type]
+          when "TINY"
+            if field.max_length == 1
+              val != "0"
+            else
+              val.to_i
+            end
+          when "BIT"
+            val.to_i(2)
+          when "SHORT", "LONG", "INT24", "LONGLONG"
+            val.to_i
+          when "DECIMAL", "NEWDECIMAL", "FLOAT", "DOUBLE", "YEAR"
+            val.to_f
+          when "TIMESTAMP", "DATETIME"
+            DateTime.parse(val) rescue nil
+          when "TIME"
+            DateTime.parse(val).to_time rescue nil
+          when "DATE"
+            Date.parse(val) rescue nil
+          when "NULL"
+            nil
+          else
+            val
+        end
+      end
+      
+      
+    end
+    
+    class Command < DataObject::Command
+      
+      def execute_reader
+        super
+        result = Mysql_c.mysql_query(@connection.db, @text)
+        # TODO: Real Error
+        raise QueryError, "Your query failed.\n#{Mysql_c.mysql_error(@connection.db)}\n#{@text}" unless result == 0 
+        reader = Mysql_c.mysql_store_result(@connection.db)
+        Reader.new(@connection.db, reader)
+      end
+      
+      def execute_non_query
+        super
+        result = Mysql_c.mysql_query(@connection.db, @text)
+        raise QueryError, "Your query failed.\n#{Mysql_c.mysql_error(@connection.db)}\n#{@text}" unless result == 0         
+        reader = Mysql_c.mysql_store_result(@connection.db)
+        raise QueryError, "You called execute_non_query on a query: #{@text}" if reader
+        rows_affected = Mysql_c.mysql_affected_rows(@connection.db)
+        Mysql_c.mysql_free_result(reader)
+        return ResultData.new(@connection, rows_affected, Mysql_c.mysql_insert_id(@connection.db))
+      end
+      
+    end
+    
+  end
+end