DimaD-daylite-models 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.1.0 / 11.02.2009
+
+* Release
+

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2009 Dmitriy Dzema, Infonium Inc 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,25 @@
+History.txt
+LICENSE
+Manifest.txt
+README.markdown
+Rakefile
+app/models/daylite.rb
+app/models/daylite/contact.rb
+app/models/daylite/organization.rb
+app/models/daylite/organization_task_join.rb
+app/models/daylite/project.rb
+app/models/daylite/project_task_join.rb
+app/models/daylite/role.rb
+app/models/daylite/role_type.rb
+app/models/daylite/task.rb
+app/models/daylite/user.rb
+config/database.yml.exmp
+daylite_models.gemspec
+daylite_models.rb
+init.rb
+install.rb
+lib/active_record/connection_adapters/openbase_adapter.rb
+tasks/users_plugin_tasks.rake
+test/daylite_models_plugin_test.rb
+test/test_helper.rb
+uninstall.rb

data/README.markdown

@@ -0,0 +1,47 @@
+DayliteModels
+===========
+
+This is a set of ActiveRecord classes, designed to work with Daylite 3 by [Marketcircle](www.marketcircle.com).
+
+All the classes are in namespace Daylite. For example Daylite projects live in the class Daylite::Project.
+
+Models attributes are mapped to usual ruby underscore_notation from Daylite cameCase notation.
+
+Usage
+=======
+
+You can use this module as rails plugin and as a standalone library.
+
+Usage as Rails plugin
+---------------------
+
+Install the plugin
+
+    ./script/plugin install <path_to_repo>
+
+
+Add _daylite_ section to you database.yml
+
+    daylite:
+        adapter: openbase
+        database: MyOrganization
+        host: localhost
+        username: my_username
+        password: my_password
+
+
+Add the following line to you environment.rb
+
+Daylite::Base.establish_connection(:daylite)
+
+You are ready to rock! Now you can use Daylite classes in you application as usual Rails models.
+
+Usage as a standalone library
+-----------------------------
+The easiest way is to create file config/database.yml relative to you running script and place _daylite_ config in it (see Usage as Rails plugin for example). After this you need to place
+
+    require 'daylite_models'
+
+somewhere in you initialization code and you are done.
+
+Another way is to provide connection info directly through Daylite::Base.establish_connection call. You will need to provide adapter, database, host, username and password params. See ActiveRecord::Base.establish_connection and Openbase documentation for more info.

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Generate documentation for the daylite_models plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DayliteModels'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.markdown')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'daylite_models'
+  require 'hoe'
+
+  #oh, shit
+  class Hoe
+    def extra_deps
+      @extra_deps.reject do |x|
+        Array(x).first == 'hoe'
+      end
+    end
+  end
+
+  Hoe.new('daylite-models', DayliteModels::VERSION) do |s|
+    s.name = "daylite-models"
+    s.version = "0.1.0"
+    s.author = "Dmitriy Dzema"
+    s.email = "dimad.ag@gmail.com"
+    s.summary = "Set of ActiveRecord classes to work with the Daylite 3 database"
+
+    s.rubyforge_name = 'daylite-models'
+    s.remote_rdoc_dir = '' # Release to root
+    s.need_zip = true
+    s.extra_deps = [ ["activesupport", ">= 2.0.0"], ["activerecord", ">= 2.0.0"], ["activerecord", ">= 0.8.3"]]
+  end
+rescue LoadError => e
+  
+end

data/app/models/daylite.rb

@@ -0,0 +1,31 @@
+module Daylite
+end
+
+class Daylite::Base < ActiveRecord::Base
+  self.abstract_class = true
+  self.pluralize_table_names = false
+
+  set_primary_key "_rowid"
+  set_table_name do
+    self.name.sub("Daylite::", "")
+  end
+
+  # don't allow to save Daylite::Base objects to DB
+  def readonly?
+    true
+  end
+
+  def method_missing(symbol, *args)
+    guess_attribute = symbol.to_s.camelize(:lower).sub("Id", "ID")
+    if result = attributes[guess_attribute]
+      self.class.class_eval do
+        define_method symbol do
+          return attributes[guess_attribute]
+        end
+      end
+      result
+    else
+      super
+    end
+  end
+end

data/app/models/daylite/contact.rb

@@ -0,0 +1,3 @@
+class Daylite::Contact < Daylite::Base
+  has_one :user, :foreign_key => "contactID"
+end

data/app/models/daylite/organization.rb

@@ -0,0 +1,17 @@
+class Daylite::Organization < Daylite::Base
+  belongs_to :owner, :class_name => "User", :foreign_key => "assignedToID"
+
+  has_many :organization_task_joins, :foreign_key => "organizationID"
+  has_many :tasks, :through => :organization_task_joins
+
+  has_many :roles, :foreign_key => "organizationID"
+  has_many :projects, :through => :roles
+
+  def projects_tasks
+    projects.collect { |p| p.tasks }.flatten
+  end
+
+  def all_tasks
+    projects_tasks + tasks
+  end
+end

data/app/models/daylite/organization_task_join.rb

@@ -0,0 +1,4 @@
+class Daylite::OrganizationTaskJoin < Daylite::Base
+  belongs_to :organization, :class_name => "Organization", :foreign_key => "organizationID"
+  belongs_to :task, :class_name => "Task", :foreign_key => "taskID"
+end

data/app/models/daylite/project.rb

@@ -0,0 +1,24 @@
+class Daylite::Project < Daylite::Base
+  belongs_to :owner, :class_name => "User", :foreign_key => "assignedToID"
+
+  has_many :roles, :foreign_key => "projectID"
+  has_many :projects, :through => :roles
+
+  has_many :project_task_joins, :foreign_key => "projectID"
+  has_many :tasks, :through => :project_task_joins
+
+  def status_codes
+    @@status_codes ||= {
+      0 => "In Progress",
+      1 => "Deffered",
+      2 => "Canceled",
+      3 => "Abandoned",
+      4 => "New",
+      7 => "Done",
+    }
+  end
+
+  def status_string
+    status_codes[attributes["statusCode"]] || "Unknown status"
+  end
+end

data/app/models/daylite/project_task_join.rb

@@ -0,0 +1,4 @@
+class Daylite::ProjectTaskJoin < Daylite::Base
+  belongs_to :project, :foreign_key => "projectID"
+  belongs_to :task, :foreign_key => "taskID"
+end

data/app/models/daylite/role.rb

@@ -0,0 +1,10 @@
+class Daylite::Role < Daylite::Base
+  belongs_to :organization, :foreign_key => "organizationID"
+  belongs_to :project, :foreign_key => "projectID"
+
+  belongs_to :role_type, :foreign_key => "roleTypeID"
+
+  def type
+    role_type.name
+  end
+end

data/app/models/daylite/role_type.rb

@@ -0,0 +1,2 @@
+class Daylite::RoleType < Daylite::Base
+end

data/app/models/daylite/task.rb

@@ -0,0 +1,17 @@
+class Daylite::Task < Daylite::Base
+  belongs_to :owner, :class_name => "User", :foreign_key => "assignedToID"
+
+  has_many :organization_task_joins, :foreign_key => "taskID"
+  has_many :organizations, :through => :organization_task_joins
+
+  has_many :project_task_joins, :foreign_key => "taskID"
+  has_many :projects, :through => :project_task_joins
+
+  def organization
+    organizations[0]
+  end
+
+  def to_s
+    "#<Daylite::Task:#{title}>"
+  end
+end

data/app/models/daylite/user.rb

@@ -0,0 +1,10 @@
+class Daylite::User < Daylite::Base
+  belongs_to :contact, :foreign_key => "contactID"
+
+  has_many :organizations, :foreign_key => "assignedToID"
+  has_many :tasks, :class_name => "Task", :foreign_key => "assignedToID"
+
+  def name
+    contact.cachedName
+  end
+end

data/config/database.yml.exmp

@@ -0,0 +1,9 @@
+#database connection info.
+#Don't touch this file if you use it as rails plugin
+#Specify daylite: settings in you rails database.yml instead
+daylite:
+    adapter: openbase
+    database: MyOrganization
+    host: localhost
+    username: user
+    password: password

data/daylite_models.gemspec

@@ -0,0 +1,38 @@
+Gem::Specification.new do |s|
+  s.name = %q{daylite-models}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Dmitriy Dzema"]
+  s.date = %q{2009-02-11}
+  s.email = %q{dimad.ag@gmail.com}
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt"]
+  s.files = ["History.txt", "LICENSE", "Manifest.txt", "README.markdown", "Rakefile", "app/models/daylite.rb", "app/models/daylite/contact.rb", "app/models/daylite/organization.rb", "app/models/daylite/organization_task_join.rb", "app/models/daylite/project.rb", "app/models/daylite/project_task_join.rb", "app/models/daylite/role.rb", "app/models/daylite/role_type.rb", "app/models/daylite/task.rb", "app/models/daylite/user.rb", "config/database.yml.exmp", "daylite_models.gemspec", "daylite_models.rb", "init.rb", "install.rb", "lib/active_record/connection_adapters/openbase_adapter.rb", "tasks/users_plugin_tasks.rake", "test/daylite_models_plugin_test.rb", "test/test_helper.rb", "uninstall.rb"]
+  s.has_rdoc = true
+  s.rdoc_options = ["--main", "README.markdown"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{daylite-models}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Set of ActiveRecord classes to work with the Daylite 3 database}
+  s.test_files = ["test/test_helper.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.0.0"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 2.0.0"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 0.8.3"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.3"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 2.0.0"])
+      s.add_dependency(%q<activerecord>, [">= 2.0.0"])
+      s.add_dependency(%q<activerecord>, [">= 0.8.3"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 2.0.0"])
+    s.add_dependency(%q<activerecord>, [">= 2.0.0"])
+    s.add_dependency(%q<activerecord>, [">= 0.8.3"])
+  end
+end

data/daylite_models.rb

@@ -0,0 +1,17 @@
+$: << File.join(File.dirname(__FILE__), 'lib')
+require 'init'
+
+module DayliteModels
+  VERSION = '0.1.1'
+end
+
+DAYLITE_DATABASE_CONFIG = 'config/database.yml'
+DAYLITE_CONFIG_SECTION = 'daylite'
+
+if File.exist?(DAYLITE_DATABASE_CONFIG)
+  yaml = YAML::load(File.read(DAYLITE_DATABASE_CONFIG))
+
+  if yaml[DAYLITE_CONFIG_SECTION]
+    Daylite::Base.establish_connection( yaml[DAYLITE_CONFIG_SECTION] )
+  end
+end

data/init.rb

@@ -0,0 +1,8 @@
+require 'active_record'
+require 'active_support'
+
+models_path = File.join(File.dirname(__FILE__), 'app', 'models')
+daylite_path = File.join(models_path, 'daylite')
+
+$LOAD_PATH << models_path << daylite_path << './lib'
+ActiveSupport::Dependencies.load_paths << models_path << daylite_path << './lib'

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/active_record/connection_adapters/openbase_adapter.rb

@@ -0,0 +1,515 @@
+require 'active_record/connection_adapters/abstract_adapter'
+
+module ActiveRecord
+  class Base
+    # Establishes a connection to the database that's used by all Active Record objects
+    def self.openbase_connection(config) # :nodoc:
+      require_library_or_gem 'openbase' unless self.class.const_defined?(:OpenBase)
+
+      config = config.symbolize_keys
+      host     = config[:host]
+      username = config[:username].to_s
+      password = config[:password].to_s
+      
+
+      if config.has_key?(:database)
+        database = config[:database]
+      else
+        raise ArgumentError, "No database specified. Missing argument: database."
+      end
+
+      oba = ConnectionAdapters::OpenBaseAdapter.new(
+        OpenBase.new(database, host, username, password), logger
+      )
+      
+      if oba.raw_connection.connected?
+        unless oba.tables.include?(ConnectionAdapters::OpenBaseAdapter::COLUMN_SUPPORT_TABLE)
+          oba.execute(<<-SQL,"Creating OpenBase Column Support Table")
+          CREATE TABLE #{ConnectionAdapters::OpenBaseAdapter::COLUMN_SUPPORT_TABLE} (name char, type char, precision int, scale int)
+          SQL
+        end
+        oba.select_all("SELECT * FROM #{ConnectionAdapters::OpenBaseAdapter::COLUMN_SUPPORT_TABLE}").each do |col|
+          ConnectionAdapters::OpenBaseAdapter::DECIMAL_COLUMNS.store(col["name"],[col["precision"],col["scale"]])
+        end
+      end
+      
+      oba
+    end
+    
+  end
+
+  module ConnectionAdapters
+    class OpenBaseColumn < Column #:nodoc:
+      private
+        def simplified_type(field_type)
+          return :integer if field_type.downcase =~ /long/
+          return :decimal if field_type.downcase == "money"
+          return :binary  if field_type.downcase == "object"
+          super
+        end
+    end
+    # The OpenBase adapter works with the Ruby/Openbase driver by Tetsuya Suzuki.
+    # http://www.spice-of-life.net/ruby-openbase/ (needs version 0.7.3+)
+    #
+    # Options:
+    #
+    # * <tt>:host</tt> -- Defaults to localhost
+    # * <tt>:username</tt> -- Defaults to nothing
+    # * <tt>:password</tt> -- Defaults to nothing
+    # * <tt>:database</tt> -- The name of the database. No default, must be provided.
+    #
+    # The OpenBase adapter will make use of OpenBase's ability to generate unique ids
+    # for any column with an unique index applied.  Thus, if the value of a primary
+    # key is not specified at the time an INSERT is performed, the adapter will prefetch
+    # a unique id for the primary key.  This prefetching is also necessary in order 
+    # to return the id after an insert.
+    #
+    # Caveat: Operations involving LIMIT and OFFSET do not yet work!
+    #
+    # Maintainer: derrick.spell@gmail.com
+    class OpenBaseAdapter < AbstractAdapter
+      DECIMAL_COLUMNS = {}
+      COLUMN_SUPPORT_TABLE = "rails_openbase_column_support"
+      def adapter_name
+        'OpenBase'
+      end
+      
+      def native_database_types
+        {
+          :primary_key => "integer NOT NULL UNIQUE INDEX DEFAULT _rowid",
+          :string      => { :name => "char", :limit => 4096 },
+          :text        => { :name => "text" },
+          :integer     => { :name => "integer" },
+          :float       => { :name => "float" },
+          :decimal     => { :name => "decimal" },
+          :datetime    => { :name => "datetime" },
+          :timestamp   => { :name => "timestamp" },
+          :time        => { :name => "time" },
+          :date        => { :name => "date" },
+          :binary      => { :name => "object" },
+          :boolean     => { :name => "boolean" }
+        }
+      end
+      
+      def supports_migrations?
+        true
+      end      
+      
+      def prefetch_primary_key?(table_name = nil)
+        true
+      end
+      
+      def default_sequence_name(table_name, primary_key) # :nodoc:
+        "#{table_name} #{primary_key}"
+      end
+      
+      def next_sequence_value(sequence_name)
+        ary = sequence_name.split(' ')
+        if (!ary[1]) then
+          ary[0] =~ /(\w+)_nonstd_seq/
+          ary[0] = $1
+        end
+        @connection.unique_row_id(ary[0], ary[1])
+      end
+
+      
+      # QUOTING ==================================================
+      
+      def quote(value, column = nil)
+        if value.kind_of?(String) && column && column.type == :binary
+          "'#{@connection.insert_binary(value)}'"
+        elsif value.kind_of?(BigDecimal)
+          return "'#{value.to_s}'"
+        elsif column && column.type == :integer && column.sql_type =~ /decimal/
+          return "'#{value.to_s}'"
+        elsif [Float,Fixnum,Bignum].include?(value.class) && column && column.type == :string
+          return "'#{value.to_s}'"
+        else
+          super
+        end
+      end
+      
+      def quoted_true
+        "1"
+      end
+      
+      def quoted_false
+        "0"
+      end
+      
+
+
+      # DATABASE STATEMENTS ======================================
+
+      def add_limit_offset!(sql, options) #:nodoc:
+        return if options[:limit].nil?
+        limit = options[:limit]
+        offset = options[:offset]
+        if limit == 0
+          # Mess with the where clause to ensure we get no results
+          if sql =~ /WHERE/i
+            sql.sub!(/WHERE/i, 'WHERE 1 = 2 AND ')
+          elsif sql =~ /ORDER\s+BY/i
+            sql.sub!(/ORDER\s+BY/i, 'WHERE 1 = 2 ORDER BY')
+          else
+            sql << 'WHERE 1 = 2'
+          end
+        elsif offset.nil?
+          sql << " RETURN RESULTS #{limit}"
+        else
+          sql << " RETURN RESULTS #{offset} TO #{limit + offset}"
+        end
+      end
+
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+        execute(sql, name)
+        update_nulls_after_insert(sql, name, pk, id_value, sequence_name)
+        id_value
+      end
+      
+      def execute(sql, name = nil) #:nodoc:
+        log(sql, name) { @connection.execute(sql) }
+      end
+      
+      def direct_execute(sql, name = nil) #:nodoc:
+        log(sql, name) { @connection.execute(sql) }
+      end
+
+      def update(sql, name = nil) #:nodoc:
+        execute(sql, name).rows_affected
+      end
+
+      alias_method :delete, :update #:nodoc:
+
+      def begin_db_transaction #:nodoc:
+        execute "START TRANSACTION"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def commit_db_transaction #:nodoc:
+        execute "COMMIT"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+      def rollback_db_transaction #:nodoc:
+        execute "ROLLBACK"
+      rescue Exception
+        # Transactions aren't supported
+      end
+
+
+      # SCHEMA STATEMENTS ========================================
+      # Return the list of all tables in the schema search path.
+      def tables(name = nil) #:nodoc:
+        tables = @connection.tables
+        tables.reject! { |t| /\A_SYS_/ === t }
+      end
+
+      def columns(table_name, name = nil) #:nodoc:
+        sql = "SELECT * FROM _sys_tables "
+        sql << "WHERE tablename='#{table_name}' AND INDEXOF(fieldname,'_')<>0 "
+        sql << "ORDER BY columnNumber"
+        columns = []
+        direct_execute(sql, name).each_hash do |row|
+          columns << OpenBaseColumn.new(row["fieldname"],
+                                default_value(row["defaultvalue"],row["typename"]),
+                                sql_type_name(table_name,row["fieldname"],row["typename"],row["length"]),
+                                (row["notnull"] == 1 ? false : true)
+                                )
+        end
+        columns
+      end
+      
+      def column_names(table_name) #:nodoc:
+        sql = "SELECT fieldname FROM _sys_tables "
+        sql << "WHERE tablename='#{table_name}' AND INDEXOF(fieldname,'_')<>0 "
+        sql << "ORDER BY columnNumber"
+        names = direct_execute(sql).fetch_all
+        names.flatten! || names
+      end
+
+      def indexes(table_name, name = nil)#:nodoc:
+        sql = "SELECT fieldname, notnull, searchindex, uniqueindex, clusteredindex FROM _sys_tables "
+        sql << "WHERE tablename='#{table_name}' AND INDEXOF(fieldname,'_')<>0 "
+        sql << "AND primarykey=0 "
+        sql << "AND (searchindex=1 OR uniqueindex=1 OR clusteredindex=1) "
+        sql << "ORDER BY columnNumber"
+        indexes = []
+        execute(sql, name).each do |row|
+          indexes << IndexDefinition.new(table_name,ob_index_name(row),row[3]==1,[row[0]])
+        end
+        indexes
+      end
+      
+      def create_table(name, options = {}) #:nodoc:
+        return_value = super
+        
+        # Get my own copy of TableDefinition so that i can detect decimal columns
+        table_definition = TableDefinition.new(self)
+        yield table_definition
+        
+        table_definition.columns.each do |col|
+          if col.type == :decimal
+            record_decimal(name, col.name, col.precision, col.scale)
+          end
+        end
+        
+        unless options[:id] == false
+          primary_key = (options[:primary_key] || "id") 
+          direct_execute("CREATE PRIMARY KEY #{name} (#{primary_key})")
+        end
+        return_value
+      end
+      
+      def rename_table(name, new_name)
+        execute "RENAME #{name} #{new_name}"
+      end  
+
+      def add_column(table_name, column_name, type, options = {})
+        return_value = super(table_name, "COLUMN " + column_name.to_s, type, options)
+        if type == :decimal
+          record_decimal(table_name, column_name, options[:precision], options[:scale])
+        end
+      end
+      
+      def remove_column(table_name, column_name)
+        execute "ALTER TABLE #{table_name} REMOVE COLUMN #{quote_column_name(column_name)}"
+      end
+      
+      def rename_column(table_name, column_name, new_column_name)
+        execute "ALTER TABLE #{table_name} RENAME #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
+      end
+      
+      def add_column_options!(sql, options) #:nodoc:
+        sql << " NOT NULL" if options[:null] == false
+        sql << " DEFAULT #{quote(options[:default], options[:column])}" if options_include_default?(options)
+      end
+      
+      def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        unless options_include_default?(options)
+          options[:default] = select_one("SELECT * FROM _sys_tables WHERE tablename='#{table_name}' AND fieldname='#{column_name}'")["defaultvalue"]
+        end
+        
+        change_column_sql = "ALTER TABLE #{table_name} ADD COLUMN #{column_name} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(change_column_sql, options)
+        execute(change_column_sql)
+      end
+      
+      def change_column_default(table_name, column_name, default)
+        execute "ALTER TABLE #{table_name} COLUMN #{column_name} SET DEFAULT #{quote(default)}"
+      end
+      
+      def add_index(table_name, column_name, options = {})
+        if Hash === options # legacy support, since this param was a string
+          index_type = options[:unique] ? "UNIQUE" : ""
+        else
+          index_type = options
+        end
+        execute "CREATE #{index_type} INDEX #{table_name} #{column_name}"
+      end
+      
+      def remove_index(table_name, options = {})
+        execute "DROP INDEX #{table_name} #{options === Hash ? options[:column] : options}"
+      end
+      
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+        return super unless type.to_s == 'decimal'
+        
+        if (scale.to_i == 2)
+          return 'money'
+        elsif (scale.to_i == 0)
+          return 'longlong'
+        else
+          return "char(#{precision.to_i + 1})"
+        end
+      end
+      
+
+
+      private
+        def select(sql, name = nil)
+          decimals = detect_decimals(sql) || []
+          sql = add_order_by_rowid(sql)
+          
+          # OpenBase ignores the return results when there is a group by
+          # so limit the result set that we return to rails if need be
+          if (sql =~ /GROUP BY/i)
+            sql.sub!(/RETURN RESULTS (\d+)( TO (\d+))?/i,"")
+          
+            results = execute(sql, name)
+            if ($2)
+              results.fetch_offset = $1.to_i
+              results.fetch_limit = $3.to_i - $1.to_i
+            elsif ($1)
+              results.fetch_limit = $1.to_i
+            end
+          else
+            results = execute(sql, name)
+          end
+
+          rows = []
+          if ( results.rows_affected )
+            results.each_hash do |row|  # loop through result rows
+              # row.delete("_rowid") if row.key?("_rowid")
+              decimals.each do |name, precision, scale|
+                row[name] = BigDecimal.new(row[name]) if row[name] === String
+              end
+              rows << row
+            end
+          end
+          rows
+        end
+        
+        def default_value(value,type=nil)
+          return value if value.nil?
+          
+          # Boolean type values
+          return true if value =~ /true/
+          return false if value =~ /false/
+          # Alternative boolean default declarations
+          return true if (value == 1 && type == "boolean")
+          return false if (value == 0 && type == "boolean")
+ 
+          # Date / Time magic values
+          return Time.now.to_s if value =~ /^now\(\)/i
+ 
+          # Empty strings should be set to nil
+          return nil if value.empty?
+          
+          # Otherwise return what we got from OpenBase
+          # and hope for the best...
+          # Take off the leading space and unquote
+          value.lstrip!
+          value = value[1,value.length-2] if value.first.eql?("'") && value.last.eql?("'")
+          return nil if value.eql?("NULL")
+          return value
+        end 
+        
+        def sql_type_name(table_name, col_name, type, length)
+          full_name = table_name.to_s + "." + col_name.to_s
+          if DECIMAL_COLUMNS.include?(full_name) && type != "longlong"
+            return "decimal(#{DECIMAL_COLUMNS[full_name][0]},#{DECIMAL_COLUMNS[full_name][1]})"
+          end
+          return "#{type}(#{length})" if ( type =~ /char/ )
+          type
+        end
+                
+        def ob_index_name(row = [])
+          name = ""
+          name << "UNIQUE " if row[3]
+          name << "CLUSTERED " if row[4]
+          name << "INDEX"
+          name
+        end
+        
+        def detect_decimals(sql)
+#=begin
+          # Detect any decimal columns that will need to be cast when fetched
+          decimals = []
+          sql =~ /SELECT\s+(.*)\s+FROM\s+(\w+)/i
+          select_clause = $1
+          main_table = $2
+          if select_clause == "*"
+            column_names(main_table).each do |col|
+              full_name = main_table + "." + col
+              if DECIMAL_COLUMNS.include?(full_name)
+                decimals << [col,DECIMAL_COLUMNS[full_name][0].to_i,DECIMAL_COLUMNS[full_name][1].to_i]
+              end
+            end
+          end
+          return decimals
+=begin  {        
+          # Change table.* to list of columns in table
+          while (sql =~ /SELECT.*\s(\w+)\.\*/)
+            table = $1
+            cols = columns(table)
+            if ( cols.size == 0 ) then
+              # Maybe this is a table alias
+              sql =~ /FROM(.+?)(?:LEFT|OUTER|JOIN|WHERE|GROUP|HAVING|ORDER|RETURN|$)/  
+              $1 =~ /[\s|,](\w+)\s+#{table}[\s|,]/ # get the tablename for this alias
+              cols = columns($1)
+            end
+            select_columns = []
+            cols.each do |col|
+              select_columns << table + '.' + col.name
+            end
+            sql.gsub!(table + '.*',select_columns.join(", ")) if select_columns
+          end
+   
+          # Change JOIN clause to table list and WHERE condition
+}
+=begin {
+          while (sql =~ /JOIN/)
+            sql =~ /((LEFT )?(OUTER )?JOIN (\w+) ON )(.+?)(?:LEFT|OUTER|JOIN|WHERE|GROUP|HAVING|ORDER|RETURN|$)/
+            join_clause = $1 + $5
+            is_outer_join = $3
+            join_table = $4
+            join_condition = $5
+            join_condition.gsub!(/=/,"*") if is_outer_join
+            if (sql =~ /WHERE/)
+              sql.gsub!(/WHERE/,"WHERE (#{join_condition}) AND")
+            else
+              sql.gsub!(join_clause,"#{join_clause} WHERE #{join_condition}")
+            end
+            sql =~ /(FROM .+?)(?:LEFT|OUTER|JOIN|WHERE|$)/
+            from_clause = $1
+            sql.gsub!(from_clause,"#{from_clause}, #{join_table} ")
+            sql.gsub!(join_clause,"")
+          end
+
+   
+          # ORDER BY _rowid if no explicit ORDER BY
+          # This will ensure that find(:first) returns the first inserted row
+          if (sql !~ /(ORDER BY)|(GROUP BY)/)
+            if (sql =~ /RETURN RESULTS/)
+              sql.sub!(/RETURN RESULTS/,"ORDER BY _rowid RETURN RESULTS")
+            else
+              sql << " ORDER BY _rowid"
+            end
+          end
+}
+=end    
+        end
+        
+        def add_order_by_rowid(sql)
+          # ORDER BY _rowid if no explicit ORDER BY
+          # This will ensure that find(:first) returns the first inserted row
+          if (sql !~ /(ORDER BY)|(GROUP BY)/)
+            if (sql =~ /RETURN RESULTS/)
+              sql.sub!(/RETURN RESULTS/,"ORDER BY _rowid RETURN RESULTS")
+            else
+              sql << " ORDER BY _rowid"
+            end
+          end
+          sql
+        end
+        
+        def record_decimal(table_name, column_name, precision, scale)
+          full_name = table_name.to_s + "." + column_name.to_s
+          DECIMAL_COLUMNS.store(full_name, [precision.to_i,scale.to_i])
+          direct_execute("INSERT INTO #{COLUMN_SUPPORT_TABLE} (name,type,precision,scale) VALUES ('#{full_name}','decimal',#{precision.to_i},#{scale.to_i})")
+        end
+        
+        def update_nulls_after_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+          sql =~ /INSERT INTO (\w+) \((.*)\) VALUES\s*\((.*)\)/m
+          table = $1
+          cols = $2
+          values = $3
+          cols = cols.split(',')
+          values.gsub!(/'[^']*'/,"''")
+          values.gsub!(/"[^"]*"/,"\"\"")
+          values = values.split(',')
+          update_cols = []
+          values.each_index { |index| update_cols << cols[index] if values[index] =~ /\s*NULL\s*/ }
+          update_sql = "UPDATE #{table} SET"
+          update_cols.each { |col| update_sql << " #{col}=NULL," unless col.empty? }
+          update_sql.chop!()
+          update_sql << " WHERE #{pk}=#{quote(id_value)}"
+          direct_execute(update_sql,"Null Correction") if update_cols.size > 0
+        end
+        
+      end
+  end
+end

data/tasks/users_plugin_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :users_plugin do
+#   # Task goes here
+# end

data/test/daylite_models_plugin_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class DayliteModelsPluginTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'active_support'
+require 'active_support/test_case'

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: DimaD-daylite-models
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Dmitriy Dzema
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-11 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.3
+    version: 
+description: 
+email: dimad.ag@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- LICENSE
+- Manifest.txt
+- README.markdown
+- Rakefile
+- app/models/daylite.rb
+- app/models/daylite/contact.rb
+- app/models/daylite/organization.rb
+- app/models/daylite/organization_task_join.rb
+- app/models/daylite/project.rb
+- app/models/daylite/project_task_join.rb
+- app/models/daylite/role.rb
+- app/models/daylite/role_type.rb
+- app/models/daylite/task.rb
+- app/models/daylite/user.rb
+- config/database.yml.exmp
+- daylite_models.gemspec
+- daylite_models.rb
+- init.rb
+- install.rb
+- lib/active_record/connection_adapters/openbase_adapter.rb
+- tasks/users_plugin_tasks.rake
+- test/daylite_models_plugin_test.rb
+- test/test_helper.rb
+- uninstall.rb
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: daylite-models
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Set of ActiveRecord classes to work with the Daylite 3 database
+test_files: 
+- test/test_helper.rb