m4dbi 0.5.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+## 0.5.0
+
+First official public release.

data/HIM

@@ -0,0 +1,50 @@
+== M4DBI - Models (and more) For DBI
+
+http://purepistos.net/m4dbi
+
+M4DBI is a Ruby library that provides ORM modelling to the Ruby DBI package
+( http://ruby-dbi.rubyforge.org/ ).
+
+=== Dependencies
+
+  - dbi (of course) http://ruby-dbi.rubyforge.org/
+    - DBDs for your choice of DBs
+  - metaid (gem install metaid)
+  - bacon (optional, for running tests; gem install bacon)
+    
+=== Installation
+
+==== Nightly Gem
+
+  wget http://rome.purepistos.net/m4dbi/m4dbi-nightly.gem
+  gem install m4dbi-nightly.gem
+  
+==== Repository
+
+To use the repository version, you need Subversion (http://subversion.tigris.org).
+Chances are, there is a Subversion package for your Linux/UNIX flavour.
+
+  cd /where/you/want/m4dbi
+  svn co http://rome.purepistos.net/svn/m4dbi
+  
+Change the following to whatever the equivalent paths are for your system:
+
+  cd /usr/lib/ruby/site_ruby/1.8
+  ln -s /path/to/checked/out/m4dbi/trunk/lib/m4dbi
+  ln -s /path/to/checked/out/m4dbi/trunk/lib/m4dbi.rb
+
+=== Usage
+
+See http://rome.purepistos.net/m4dbi/examples/ .  These are automatically
+generated from the spec files under the spec/ dir.
+
+=== Source Code
+
+Browse source at http://rome.purepistos.net/issues/m4dbi/browser/trunk .
+See coverage at http://rome.purepistos.net/m4dbi/rcov .
+Very limited rdocs at http://rome.purepistos.net/m4dbi/rdoc .
+
+=== Feedback and Support
+
+On IRC: irc.freenode.net ##mathetes or ##ramaze .
+Use http://mibbit.com if you don't have an IRC client.

data/READHIM

@@ -0,0 +1 @@
+Don't read ME; read HIM!

data/lib/m4dbi/collection.rb

@@ -0,0 +1,69 @@
+module DBI
+  class Collection
+    def initialize( the_one, the_many_model, the_one_fk )
+      @the_one = the_one
+      @the_many_model = the_many_model
+      @the_one_fk = the_one_fk
+    end
+    
+    def elements
+      @the_many_model.where( @the_one_fk => @the_one.pk )
+    end
+    alias copy elements
+    
+    def method_missing( method, *args, &blk )
+      elements.send( method, *args, &blk )
+    end
+    
+    def push( new_item_hash )
+      new_item_hash[ @the_one_fk ] = @the_one.pk
+      @the_many_model.create( new_item_hash )
+    end
+    alias << push
+    alias add push
+    
+    def delete( arg )
+      case arg
+        when @the_many_model
+          result = @the_many_model.dbh.do(
+            %{
+              DELETE FROM #{@the_many_model.table}
+              WHERE
+                #{@the_one_fk} = ?
+                AND #{@the_many_model.pk} = ?
+            },
+            @the_one.pk,
+            arg.pk
+          )
+          result > 0
+        when Hash
+          hash = arg
+          keys = hash.keys
+          where_subclause = keys.map { |k|
+            "#{k} = ?"
+          }.join( " AND " )
+          @the_many_model.dbh.do(
+            %{
+              DELETE FROM #{@the_many_model.table}
+              WHERE
+                #{@the_one_fk} = ?
+                AND #{where_subclause}
+            },
+            @the_one.pk,
+            *( keys.map { |k| hash[ k ] } )
+          )
+      end
+    end
+    
+    # Returns the number of records deleted
+    def clear
+      @the_many_model.dbh.do(
+        %{
+          DELETE FROM #{@the_many_model.table}
+          WHERE #{@the_one_fk} = ?
+        },
+        @the_one.pk
+      )
+    end
+  end
+end

data/lib/m4dbi/database-handle.rb

@@ -0,0 +1,86 @@
+require 'dbi'
+require 'thread'
+
+module DBI
+  
+  # Here, we engage in some hackery to get database handles to provide us
+  # with the name of the database connected to.  For mystical reasons, this
+  # is hidden in normal DBI.
+  # Retrieve the database name with DatabaseHandle#dbname.
+  module DBD; module Pg
+    module ConnectionDatabaseNameAccessor
+      def dbname
+        @connection.db
+      end
+    end
+    module DatabaseNameAccessor
+      def dbname
+        @handle.dbname
+      end
+    end
+  end; end
+  
+  class DatabaseHandle
+    alias old_initialize initialize
+    def initialize( handle )
+      DBI::DatabaseHandle.last_handle = self
+      handle = old_initialize( handle )
+      @mutex = Mutex.new
+      
+      # Hackery to expose dbname.
+      if defined?( DBI::DBD::Pg::Database ) and ( DBI::DBD::Pg::Database === @handle )
+        @handle.extend DBI::DBD::Pg::ConnectionDatabaseNameAccessor
+        extend DBI::DBD::Pg::DatabaseNameAccessor
+      end
+      # TODO: more DBDs
+      
+      handle
+    end
+    
+    # Atomically disable autocommit, do transaction, and reenable.
+    # Used for a single transaction when autocommit is normally left on.
+    # Only one thread can execute one_transaction at a time,
+    # since we need to thread protect the AutoCommit property of the
+    # database handle.
+    def one_transaction
+      @mutex.synchronize do
+        auto_commit = self[ 'AutoCommit' ]
+        self[ 'AutoCommit' ] = false
+        result = transaction do
+          yield self
+        end
+        self[ 'AutoCommit' ] = auto_commit
+        result
+      end
+    end
+    
+    def select_column( statement, *bindvars )
+      row = select_one( statement, *bindvars )
+      if row
+        row[ 0 ]
+      end
+    end
+    
+    alias s select_all
+    alias s1 select_one
+    alias sc select_column
+    alias u do
+    alias i do
+    alias d do
+    
+    class << self
+      def last_handle
+        @handle# ||= create_handle
+      end
+      
+      def last_handle=( handle )
+        @handle = handle
+      end
+    end
+    
+  end
+end
+
+
+
+

data/lib/m4dbi/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  def to_clause( join_string )
+    # The clause items and the values have to be in the same order.
+    keys_ = keys
+    clause = keys_.map { |field|
+      "#{field} = ?"
+    }.join( join_string )
+    values_ = keys_.map { |key|
+      self[ key ]
+    }
+    [ clause, values_ ]
+  end
+  
+  def to_where_clause
+    to_clause( " AND " )
+  end
+  
+  def to_set_clause
+    to_clause( ", " )
+  end
+end

data/lib/m4dbi/model.rb

@@ -0,0 +1,372 @@
+require 'dbi'
+require 'metaid'
+
+module DBI
+  class Model
+    #attr_reader :row
+    ancestral_trait_reader :dbh, :table
+    ancestral_trait_class_reader :dbh, :table, :pk, :columns
+    
+    M4DBI_UNASSIGNED = '__m4dbi_unassigned__'
+    
+    extend Enumerable
+    
+    def self.[]( hash_or_pk_value )
+      case hash_or_pk_value
+        when Hash
+          clause, values = hash_or_pk_value.to_where_clause
+          row = dbh.select_one(
+            "SELECT * FROM #{table} WHERE #{clause}",
+            *values
+          )
+        else
+          row = dbh.select_one(
+            "SELECT * FROM #{table} WHERE #{pk} = ?",
+            hash_or_pk_value
+          )
+      end
+      
+      if row
+        self.new( row )
+      end
+    end
+    
+    def self.from_rows( rows )
+      rows.map { |r| self.new( r ) }
+    end
+    
+    def self.where( conditions, *args )
+      case conditions
+        when String
+          sql = "SELECT * FROM #{table} WHERE #{conditions}"
+          params = args
+        when Hash
+          cond, params = conditions.to_where_clause
+          sql = "SELECT * FROM #{table} WHERE #{cond}"
+      end
+      
+      self.from_rows(
+        dbh.select_all( sql, *params )
+      )
+    end
+    
+    def self.one_where( conditions, *args )
+      case conditions
+        when String
+          sql = "SELECT * FROM #{table} WHERE #{conditions} LIMIT 1"
+          params = args
+        when Hash
+          cond, params = conditions.to_where_clause
+          sql = "SELECT * FROM #{table} WHERE #{cond} LIMIT 1"
+      end
+      
+      row = dbh.select_one( sql, *params )
+      if row
+        self.new( row )
+      end
+    end
+    
+    def self.all
+      self.from_rows(
+        dbh.select_all( "SELECT * FROM #{table}" )
+      )
+    end
+    
+    # TODO: Perhaps we'll use cursors for Model#each.
+    def self.each( &block )
+      self.all.each( &block )
+    end
+    
+    def self.one
+      row = dbh.select_one( "SELECT * FROM #{table} LIMIT 1" )
+      if row
+        self.new( row )
+      end
+    end
+    
+    def self.count
+      dbh.select_column( "SELECT COUNT(*) FROM #{table}" )
+    end
+    
+    def self.create( hash = {} )
+      if block_given?
+        row = DBI::Row.new(
+          columns.collect { |c| c[ 'name' ] },
+          [ M4DBI_UNASSIGNED ] * columns.size
+        )
+        yield row
+        hash = row.to_h
+        hash.to_a.each do |key,value|
+          if value == M4DBI_UNASSIGNED
+            hash.delete( key )
+          end
+        end
+      end
+      
+      keys = hash.keys
+      cols = keys.join( ',' )
+      values = keys.map { |key| hash[ key ] }
+      value_placeholders = values.map { |v| '?' }.join( ',' )
+      rec = nil
+      
+      dbh.one_transaction do |dbh_|
+        num_inserted = dbh_.do(
+          "INSERT INTO #{table} ( #{cols} ) VALUES ( #{value_placeholders} )",
+          *values
+        )
+        if num_inserted > 0
+          pk_value = hash[ self.pk.to_sym ] || hash[ self.pk.to_s ]
+          if pk_value
+            rec = self.one_where( self.pk => pk_value )
+          else
+            begin
+              rec = last_record( dbh_ )
+            rescue NoMethodError => e
+              # ignore
+              #puts "not implemented: #{e.message}"
+            end
+          end
+        end
+      end
+      
+      rec
+    end
+    
+    def self.find_or_create( hash = nil )
+      item = nil
+      error = nil
+      item = self.one_where( hash )
+      if item.nil?
+        item =
+          begin
+            self.create( hash )
+          rescue => error
+            self.one_where( hash )
+          end
+      end
+      if item
+        item
+      else
+        raise error
+      end
+    end
+    
+    def self.select_all( *args )
+      self.from_rows(
+        dbh.select_all( *args )
+      )
+    end
+    
+    def self.select_one( *args )
+      row = dbh.select_one( *args )
+      if row
+        self.new( row )
+      end
+    end
+    
+    class << self
+      alias s select_all
+      alias s1 select_one
+    end
+    
+    def self.update( where_hash_or_clause, set_hash )
+      where_clause = nil
+      set_clause = nil
+      where_params = nil
+      
+      if where_hash_or_clause.respond_to? :keys
+        where_clause, where_params = where_hash_or_clause.to_where_clause
+      else
+        where_clause = where_hash_or_clause
+        where_params = []
+      end
+      
+      set_clause, set_params = set_hash.to_set_clause
+      params = set_params + where_params
+      dbh.do(
+        "UPDATE #{table} SET #{set_clause} WHERE #{where_clause}",
+        *params
+      )
+    end
+    
+    def self.update_one( pk_value, set_hash )
+      set_clause, set_params = set_hash.to_set_clause
+      params = set_params + [ pk_value ]
+      dbh.do(
+        "UPDATE #{table} SET #{set_clause} WHERE #{pk} = ?",
+        *params
+      )
+    end
+    
+    # Example:
+    #   DBI::Model.one_to_many( Author, :posts, Post, :author, :author_id )
+    #   her_posts = some_author.posts
+    #   the_author = some_post.author
+    def self.one_to_many( the_one, the_many, many_as, one_as, the_one_fk )
+      the_one.class_def( many_as.to_sym ) do
+        DBI::Collection.new( self, the_many, the_one_fk )
+      end
+      the_many.class_def( one_as.to_sym ) do
+        the_one[ @row[ the_one_fk ] ]
+      end
+      the_many.class_def( "#{one_as}=".to_sym ) do |new_one|
+        send( "#{the_one_fk}=".to_sym, new_one.pk )
+      end
+    end
+    
+    # Example:
+    #   DBI::Model.many_to_many(
+    #     @m_author, @m_fan, :authors_liked, :fans, :authors_fans, :author_id, :fan_id
+    #   )
+    #   her_fans = some_author.fans
+    #   favourite_authors = fan.authors_liked
+    def self.many_to_many( model1, model2, m1_as, m2_as, join_table, m1_fk, m2_fk )
+      model1.class_def( m2_as.to_sym ) do
+        model2.select_all(
+          %{
+            SELECT
+              m2.*
+            FROM
+              #{model2.table} m2,
+              #{join_table} j
+            WHERE
+              j.#{m1_fk} = ?
+              AND m2.id = j.#{m2_fk}
+          },
+          pk
+        )
+      end
+      
+      model2.class_def( m1_as.to_sym ) do
+        model1.select_all(
+          %{
+            SELECT
+              m1.*
+            FROM
+              #{model1.table} m1,
+              #{join_table} j
+            WHERE
+              j.#{m2_fk} = ?
+              AND m1.id = j.#{m1_fk}
+          },
+          pk
+        )
+      end
+    end
+    
+    # ------------------- :nodoc:
+    
+    def initialize( row )
+      if not row.respond_to?( "[]".to_sym ) or not row.respond_to?( "[]=".to_sym )
+        raise DBI::Error.new( "Attempted to instantiate DBI::Model with an invalid argument (#{row.inspect}).  (Expecting DBI::Row.)" )
+      end
+      if caller[ 1 ] !~ %r{/m4dbi/model\.rb:}
+        warn "Do not call DBI::Model#new directly; use DBI::Model#create instead."
+      end
+      @row = row
+    end
+    
+    def method_missing( method, *args )
+      @row.send( method, *args )
+    end
+    
+    def pk
+      @row[ self.class.pk ]
+    end
+    
+    def pk_column
+      self.class.pk
+    end
+    
+    def ==( other )
+      other and ( pk == other.pk )
+    end
+    
+    def hash
+      "#{self.class.hash}#{pk}".to_i
+    end
+    
+    def eql?( other )
+      hash == other.hash
+    end
+    
+    def set( hash )
+      set_clause, set_params = hash.to_set_clause
+      set_params << pk
+      dbh.do(
+        "UPDATE #{table} SET #{set_clause} WHERE #{pk_column} = ?",
+        *set_params
+      )
+    end
+    
+    # Returns true iff the record and only the record was successfully deleted.
+    def delete
+      num_deleted = dbh.do(
+        "DELETE FROM #{table} WHERE #{pk_column} = ?",
+        pk
+      )
+      num_deleted == 1
+    end
+    
+    # save does nothing.  It exists to provide compatibility with other ORMs.
+    def save
+      nil
+    end
+  end
+  
+  # Define a new DBI::Model like this:
+  #   class Post < DBI::Model( :posts ); end
+  # You can specify the primary key column like so:
+  #   class Author < DBI::Model( :authors, 'id' ); end
+  def self.Model( table, pk_ = 'id' )
+    h = DBI::DatabaseHandle.last_handle
+    if h.nil? or not h.connected?
+      raise DBI::Error.new( "Attempted to create a Model class without first connecting to a database." )
+    end
+    
+    model_key =
+      if defined?( DBI::DBD::Pg::Database ) and DBI::DBD::Pg::Database === h.handle
+        "#{h.dbname}::#{table}"
+      # TODO: more DBDs
+      else
+        table
+      end
+    
+    @models ||= Hash.new
+    @models[ model_key ] ||= Class.new( DBI::Model ) do |klass|
+      klass.trait( {
+        :dbh => h,
+        :table => table,
+        :pk => pk_,
+        :columns => h.columns( table.to_s ),
+      } )
+      
+      if defined?( DBI::DBD::Pg::Database ) and DBI::DBD::Pg::Database === h.handle
+        meta_def( "last_record".to_sym ) do |dbh_|
+          self.s1 "SELECT * FROM #{table} WHERE #{pk} = currval( '#{table}_#{pk}_seq' );" 
+        end
+      # TODO: more DBDs
+      end
+      
+      klass.trait[ :columns ].each do |col|
+        colname = col[ 'name' ]
+        
+        class_def( colname.to_sym ) do
+          @row[ colname ]
+        end
+        
+        class_def( "#{colname}=".to_sym ) do |new_value|
+          num_changed = dbh.do(
+            "UPDATE #{table} SET #{colname} = ? WHERE #{pk_column} = ?",
+            new_value,
+            pk
+          )
+          if num_changed > 0
+            @row[ colname ] = new_value
+          end
+        end
+      end
+    end
+  end
+  
+end

data/lib/m4dbi/row.rb

@@ -0,0 +1,35 @@
+require 'dbi'
+
+module DBI
+  class Row
+    def method_missing( method, *args )
+      if method.to_s =~ /^(.+)=$/
+        field = $1
+        if not @column_names.include?( field )
+          field = convert_alternate_fieldname( field )
+        end
+        if @column_names.include?( field )
+          self[ field ] = *args
+        else
+          super
+        end
+      else
+        field = method.to_s
+        # We shouldn't use by_field directly and test for nil,
+        # because nil may be a valid value for the column.
+        if not @column_names.include?( field )
+          field = convert_alternate_fieldname( field )
+        end
+        if @column_names.include?( field )
+          by_field field
+        else
+          super
+        end
+      end
+    end
+    
+    def convert_alternate_fieldname( field )
+      field.gsub( /(^_)|(_$)/ , '' )
+    end
+  end
+end