gdonald-railsdb 0.2

data/app/models/driver.rb

@@ -0,0 +1,8 @@
+class Driver < ActiveRecord::Base
+  
+  has_many :databases
+  
+  validates_presence_of :name,
+                        :message => 'name required'
+
+end

data/app/models/field.rb

@@ -0,0 +1,117 @@
+class Field
+  
+  include Comparable
+  include Switch
+  
+  attr_accessor :database
+  attr_accessor :table
+  attr_accessor :attributes
+  
+  #
+  # This method assigns the database and table this field appears in,
+  # along with all the attributes, no matter how useless they may be.
+  #
+  def initialize( table, attributes )
+    self.table      = table
+    self.attributes = attributes
+    self.database   = self.table.database
+  end
+  
+  #
+  # This is our obligation to Comparable.  Order by column id
+  # (which is faked for some databases).
+  #
+  def <=>( other ) 
+    self.cid <=> other.cid 
+  end
+  
+  #
+  # Update the field using the parameters passed.  This first
+  # checks the name for an update then operates on the actual
+  # field attributes.
+  #
+  def update( params )
+    switch( self.database ) do
+      if params['field'] !=  params['fields']['1']['name']
+        ActiveRecord::Base.connection.rename_column( self.table.name.to_sym,
+                                                     params['field'].to_sym,
+                                                     params['fields']['1']['name'].to_sym )
+      end
+      ActiveRecord::Base.connection.change_column( self.table.name.to_sym,
+                                                   params['fields']['1']['name'].to_sym,
+                                                   params['fields']['1']['type'].to_sym,
+                                                   mangle_column_options( params, '1' ) )
+    end
+  end
+  
+  #
+  # name mapping
+  #
+  def name
+    self.attributes[:name]
+  end
+  
+  #
+  # column id mapping
+  #
+  def cid
+    self.attributes[:cid]
+  end
+
+  #
+  # not all databases send this
+  #
+  def sql_type
+    self.attributes[:sql_type]
+  end
+
+  #
+  # field type mapping
+  #
+  def type
+    self.attributes[:type]
+  end
+  
+  #
+  # limit mapping
+  #
+  def limit
+    self.attributes[:limit]
+  end
+
+  #
+  # precision mapping
+  #
+  def precision
+    self.attributes[:precision]
+  end
+
+  #
+  # scale mapping
+  #
+  def scale
+    self.attributes[:scale]
+  end
+
+  #
+  # inconsistant on some databases
+  #
+  def primary
+    self.attributes[:primary]
+  end
+  
+  #
+  # is null mapping
+  #
+  def null
+    self.attributes[:null]
+  end
+  
+  #
+  # default value mapping
+  #
+  def default
+    self.attributes[:default]
+  end
+  
+end

data/app/models/group.rb

@@ -0,0 +1,12 @@
+class Group < ActiveRecord::Base
+  
+  has_many :user_groups
+  has_many :users, :through => :user_groups
+
+  has_many :group_permissions
+  has_many :permissions, :through => :group_permissions
+
+  validates_presence_of   :name,
+                          :message => 'group name required'
+
+end

data/app/models/group_permission.rb

@@ -0,0 +1,6 @@
+class GroupPermission < ActiveRecord::Base
+  
+  belongs_to :group
+  belongs_to :permission
+  
+end

data/app/models/permission.rb

@@ -0,0 +1,9 @@
+class Permission < ActiveRecord::Base
+  
+  has_many :group_permissions
+  has_many :permissions, :through => :group_permissions
+
+  validates_presence_of   :name,
+                          :message => 'permission name required'
+  
+end

data/app/models/row.rb

@@ -0,0 +1,26 @@
+class Row < ActiveRecord::Base
+  
+  include Comparable
+  include Switch
+  
+  attr_accessor :database
+  attr_accessor :table
+  attr_accessor :id
+  
+  #
+  # This method assigns the table, id, and database attributes
+  #
+  def initialize( table, id )
+    self.table    = table
+    self.id       = id
+    self.database = self.table.database
+  end
+  
+  #
+  # This is our obligation to Comparable.  Order by id for now
+  #
+  def <=>( other )
+    self.id <=> other.id
+  end
+  
+end

data/app/models/switch.rb

@@ -0,0 +1,85 @@
+#
+# This is a mixin used by any other models that need to do
+# work with non- RailsDB application databases.
+#
+module Switch
+
+  #
+  # Switch RailsDB's database connection to a different database.
+  #
+  # (Add newly discovered broken table names in config/environment.rb.)
+  #
+  # This is magic:
+  #
+  def switch_ar( database, name )
+    switch( database ) do
+      begin
+        c = name.singularize.camelize.constantize
+      rescue NameError
+        klass = Class.new ActiveRecord::Base
+        Object.const_set name.singularize.camelize, klass
+        klass.set_table_name name
+        begin
+          c = name.singularize.camelize.constantize
+        rescue NameError
+          raise "NameError: Cannot constantize #{ name }"
+        end
+      end
+      klass = Class.new ActiveRecord::Base
+      class_name = ALT_TABLE_NAMES.include?( name ) ? ALT_TABLE_NAMES[ name ] : name
+      Object.const_set class_name.singularize.camelize, klass
+      klass.set_table_name name
+      yield class_name.singularize.camelize.constantize
+    end
+  end
+
+  #
+  # This method wraps work done to alternate databases
+  #
+  def switch( database )
+    switch_db( database )
+    begin
+      yield
+    rescue  ArgumentError
+      raise "Argument error: #{ $!.to_s }"
+    rescue ActiveRecord::StatementInvalid
+      raise "#{ $!.to_s }"
+    rescue  Mysql::Error, PGError, TypeError
+      raise "Database Error: #{ $!.to_s }"
+    ensure
+      switch_back
+    end
+  end
+
+  #
+  # This method establishes a new ActiveRecord connection using
+  # the database passed.  If you call this you need to finish by
+  # calling switch_back.
+  #
+  def switch_db( database )
+    options = { :adapter  => database.driver.name }
+    case database.driver.name
+      when  'sqlite3'
+        options[:database] = database.path
+      when  'mysql',
+            'postgresql',
+            'oracle'
+        options[:database] = database.name
+        options[:host]     = database.host
+        options[:username] = database.username
+        options[:password] = database.password
+      else
+        raise "#{ database.driver.name } driver not available"
+    end
+    ActiveRecord::Base.establish_connection( options )
+  end
+
+  #
+  # This method is used to re-establish the RailsDB application
+  # database.  It's usually called after a call to switch_db.
+  #
+  def switch_back
+    ActiveRecord::Base.establish_connection( RAILS_ENV.to_sym )
+  end
+
+end

data/app/models/table.rb

@@ -0,0 +1,155 @@
+class Table
+  
+  include Switch
+  
+  attr_accessor :database
+  attr_accessor :name
+  attr_accessor :driver
+  
+  #
+  # Assign the database this table belongs to and it's name
+  #
+  def initialize( database, name )
+    self.database = database
+    self.name     = name
+    self.driver   = self.database.driver
+  end
+
+  #
+  # This method switches ActiveRecord's connection to the actual
+  # database this database model represents, deletes the field,
+  # then switches back to the RailsDB database.
+  #
+  def del_field( name )
+    switch( self.database ) do
+      ActiveRecord::Base.connection.remove_column( self.name.to_sym, name.to_sym )
+    end
+  end
+
+  #
+  # This method switches ActiveRecord's connection to the actual
+  # database this database model represents, adds the new field,
+  # then switches back to the RailsDB database.
+  #
+  def add_field( name, type, options )
+    switch( self.database ) do
+      ActiveRecord::Base.connection.add_column( self.name.to_sym, name.to_sym, type.to_sym, options )
+    end
+  end
+
+  #
+  # This method adds fields from the params from a form.
+  #
+  def add_fields( params )
+    1.upto( params[:fields].size ) do |x|
+      if params[:fields][x.to_s] && !params[:fields][x.to_s][:name].empty?
+        unless self.has_field?( params[:fields][x.to_s][:name] )
+          self.add_field( params[:fields][x.to_s][:name],
+                          params[:fields][x.to_s][:type],
+                          mangle_column_options( params, x.to_s ) )
+        end
+      end
+    end
+  end
+
+  #
+  # This calls ActiveRecord's create method on the given model class
+  #
+  def create( args )
+    switch_ar( self.database, self.name ) do |c|
+      params = {}
+      args.collect { |a| { a[0].to_sym => args[ a[0] ] } }.each do |b|
+        params[ b.keys.first.to_sym ] = b[ b.keys.first.to_sym ]
+      end
+      o = c.create( params )
+    end
+  end
+
+  #
+  # This calls ActiveRecord's find method on the given model class
+  #
+  def find( *args )
+    switch_ar( self.database, self.name ) { |c| o = c.find( *args ).collect{ |r| r.attributes } }
+  end
+  
+  #
+  # This method gets the row count for this table.
+  #
+  def row_count
+    switch_ar( self.database, self.name ) { |c| o = c.count }
+  end
+
+  #
+  # Just the field names, sorted
+  #
+  def field_names
+    self.fields.collect { |f| f.name }.sort
+  end
+  
+  #
+  # Does this table contain a filed with passed name?
+  #
+  def has_field?( name )
+    self.field_names.each { |f| return true if f == name }
+    false
+  end
+  
+  #
+  # How many fields in this table
+  #
+  def field_count
+    self.fields.size
+  end
+  
+  #
+  # Returns a single field by name
+  #
+  def get_field( name )
+    self.fields.each { |f| return f if f.name == name }
+    nil
+  end
+  
+  #
+  # This method maps the field attributes for a table into known named
+  # keys, required mostly because sqlite doesn't match the others
+  #
+  def fields
+    fields = []
+    switch( self.database ) do
+      cid = 0
+      case self.driver.name
+      when 'sqlite3'
+        # map sqlite fields to match more common names
+        ActiveRecord::Base.connection.table_structure( self.name.to_sym ).each do |c|
+          attributes = {}
+          attributes[:cid]     = c['cid']
+          attributes[:name]    = c['name']
+          attributes[:type]    = c['type']
+          attributes[:primary] = c['pk']
+          attributes[:null]    = c['notnull']
+          attributes[:default] = c['dflt_value']
+          fields << Field.new( self, attributes )
+        end
+      else
+        # this same mapping currently works for both mysql and postgresql
+        ActiveRecord::Base.connection.columns( self.name.to_sym ).each do |c|
+          attributes = {}
+          attributes[:cid]       = cid
+          attributes[:name]      = c.name
+          attributes[:type]      = c.type
+          attributes[:sql_type]  = c.sql_type
+          attributes[:primary]   = c.primary
+          attributes[:null]      = c.null
+          attributes[:default]   = c.default
+          attributes[:scale]     = c.scale
+          attributes[:precision] = c.precision
+          attributes[:limit]     = c.limit
+          fields << Field.new( self, attributes )
+          cid += 1
+        end
+      end
+    end
+    fields.sort
+  end
+    
+end

data/app/models/user.rb

@@ -0,0 +1,98 @@
+require 'digest/sha1'
+
+class User < ActiveRecord::Base
+
+  has_many    :user_groups
+  has_many    :groups, :through => :user_groups
+
+  attr_accessor :password_confirmation
+
+  validates_presence_of     :fname,
+                            :message => 'first name required'
+
+  validates_presence_of     :lname,
+                            :message => 'last name required'
+
+  validates_presence_of     :username,
+                            :message => 'last name required'
+
+  validates_format_of       :email,
+                            :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i,
+                            :message => 'valid email required'
+
+  validates_uniqueness_of   :email,
+                            :message => 'unique email required'
+
+  validates_presence_of     :password,
+                            :message => 'password required'
+
+  validates_confirmation_of :password,
+                            :message => 'password confirmation required'
+
+  # Both of them, together
+  def fullname
+    "#{ self.fname } #{ self.lname }"
+  end
+
+  # Find permission by iterating over group permissions
+  def has_perm?( perm )
+    permission = Permission.find_by_name( perm )
+    raise "#{perm} not found" if permission.nil?
+    groups.each do |g|
+      g.permissions.each do |p|
+        return true if p.id == permission.id
+      end
+    end
+    return false
+  end
+
+  # Authenticate against the database
+  def self.authenticate( username, password )
+    @user = User.find( :first, :conditions => [ 'username = ?', username ] )
+    if @user.nil?
+      @user = User.find( :first, :conditions => [ 'email = ?', username ] )
+    end
+    return nil if @user.nil?
+    return @user if User.hash_password( password, @user.passwd_salt ) == @user.passwd_hash
+    nil
+  end
+
+  # Convenience method
+  def password
+    @password
+  end
+
+  # Setter method assigning a new password.  Re-salts automatically.
+  def password=( passwd )
+    @password = passwd
+    return if passwd.blank?
+    self.passwd_salt = User.salt
+    self.passwd_hash = User.hash_password( @password, self.passwd_salt )
+  end
+
+  private
+
+  def self.salt
+    Digest::SHA1.hexdigest( rand.to_s )
+  end
+
+  def self.hash_password( password, salt )
+    Digest::SHA1.hexdigest( password + salt )
+  end
+
+  def self.random_password
+    c = %w( b c d f g h j k l m n p qu r s t v w x z ) +
+        %w( ch cr fr nd ng nk nt ph pr rd sh sl sp st th tr )
+    v = %w( a e i o u y )
+    f, r = true, ''
+    6.times do
+      r << ( f ? c[ rand * c.size ] : v[ rand * v.size ] )
+      f = !f
+    end
+    2.times do
+      r << ( rand( 9 ) + 1 ).to_s
+    end
+    r
+  end
+
+end