mack-data_mapper 0.5.5 → 0.6.0

data/README

@@ -1,3 +1,9 @@
 README
 ========================================================================
 mack-data_mapper was developed by: markbates
+
+This gem provides Mack integration with the ORM Framework, DataMapper.
+
+For more information on DataMapper please visit:
+
+http://www.datamapper.org

data/lib/database.rb

@@ -0,0 +1,94 @@
+module Mack
+  module Database
+    
+    # Sets up and establishes connections to the database based on the specified environment
+    # and the settings in the database.yml file.
+    def self.establish_connection(env = Mack.env)
+      dbs = YAML::load(ERB.new(IO.read(File.join(Mack.root, "config", "database.yml"))).result)
+      settings = dbs[env]
+      settings.symbolize_keys!
+      if settings[:default]
+        settings.each do |k,v|
+          DataMapper.setup(k, v.symbolize_keys)
+        end
+      else
+        DataMapper.setup(:default, settings)
+      end
+    end # establish_connection
+    
+    # Creates a database, if it doesn't already exist for the specified environment
+    def self.create(env = Mack.env, repis = :default)
+      Mack::Database.establish_connection(env)
+      create_database(repis)
+    end
+    
+    # Drops a database, if it exists for the specified environment
+    def self.drop(env = Mack.env, repis = :default)
+      Mack::Database.establish_connection(env)
+      drop_database(repis)
+    end
+    
+    private
+    def self.setup_temp(uri, adapter)
+      DataMapper.setup(:tmp, {
+        :adapter => adapter,
+        :host => "localhost",
+        :database => adapter,
+        :username => ENV["DB_USERNAME"] || uri.user,
+        :password => ENV["DB_PASSWORD"] || uri.password
+      })
+    end
+    
+    def self.create_database(repis = :default)
+      uri = repository(repis).adapter.uri
+      case repository(repis).adapter.class.name
+        when /Mysql/
+          setup_temp(uri, "mysql")
+          repository(:tmp) do |repo|
+            puts "Creating (MySQL): #{uri.basename}"
+            repo.adapter.execute "CREATE DATABASE `#{uri.basename}` DEFAULT CHARACTER SET `utf8`"
+          end
+        when /Postgres/
+          setup_temp(uri, "postgres")
+          repository(:tmp) do |repo|
+            puts "Creating (PostgreSQL): #{uri.basename}"
+            repo.adapter.execute "CREATE DATABASE #{uri.basename} ENCODING = 'utf8'"
+          end
+        when /Sqlite3/
+          db_dir = File.join(Mack.root, "db")
+          puts "Creating (SQLite3): #{uri.basename}"
+          FileUtils.mkdir_p(db_dir)
+          FileUtils.touch(File.join(db_dir, uri.basename))
+        else
+          raise "Task not supported for '#{repository(repis).adapter.class.name}'"
+      end
+    end
+    
+    
+    def self.drop_database(repis = :default)
+      uri = repository(repis).adapter.uri
+      case repository(repis).adapter.class.name
+        when /Mysql/
+          setup_temp(uri, "mysql")
+          repository(:tmp) do |repo|
+            puts "Dropping (MySQL): #{uri.basename}"
+            repo.adapter.execute "DROP DATABASE IF EXISTS `#{uri.basename}`"
+          end
+        when /Postgres/
+          setup_temp(uri, "postgres")
+          repository(:tmp) do |repo|
+            puts "Dropping (PostgreSQL): #{uri.basename}"
+            repo.adapter.execute "DROP DATABASE IF EXISTS #{uri.basename}"
+          end
+        when /Sqlite3/
+          puts "Dropping (SQLite3): #{uri.basename}"
+          db_dir = File.join(Mack.root, "db")
+          FileUtils.rm_rf(File.join(db_dir.to_s, uri.basename))
+        else
+          raise "Task not supported for '#{repository(repis).adapter.class.name}'"
+      end
+    end
+    
+  end # Database
+  
+end # Mack

data/lib/dm_patches/confirmation_validation.rb

@@ -0,0 +1,19 @@
+module DataMapper # :nodoc:
+  module Validate # :nodoc:
+
+    class ConfirmationValidator < GenericValidator # :nodoc:
+
+      def valid?(target)
+        field_value = target.instance_variable_get("@#{@field_name}")
+        return true if @options[:allow_nil] && field_value.nil?
+        return false if !@options[:allow_nil] && field_value.nil?
+        return true unless target.attribute_dirty?(@field_name)
+
+        confirm_value = target.instance_variable_get("@#{@confirm_field_name}")
+        field_value == confirm_value
+      end
+
+    end # class ConfirmationValidator
+
+  end # module Validate
+end # module DataMapper

data/lib/dm_patches/dm-cli.rb

@@ -0,0 +1 @@
+require 'data_mapper/cli'

data/lib/dm_patches/migrations.rb

@@ -0,0 +1,23 @@
+module DataMapper # :nodoc:
+  module MigrationRunner # :nodoc:
+    
+    def reset!
+      @@migrations = []
+    end
+    
+  end
+end
+
+module SQL # :nodoc:
+  class TableCreator # :nodoc:
+    class Column # :nodoc:
+
+      def build_type(type_class)
+        schema = {:name => @name, :quote_column_name => quoted_name}.merge(@opts)
+        schema = @adapter.class.type_map[type_class].merge(schema)
+        @adapter.property_schema_statement(schema)
+      end
+
+    end
+  end
+end

data/lib/dm_patches/pooling.rb

@@ -0,0 +1,229 @@
+require 'set'
+require 'thread'
+
+module Extlib # :nodoc:
+  # ==== Notes
+  # Provides pooling support to class it got included in.
+  #
+  # Pooling of objects is a faster way of aquiring instances
+  # of objects compared to regular allocation and initialization
+  # because instances are keeped in memory reused.
+  #
+  # Classes that include Pooling module have re-defined new
+  # method that returns instances acquired from pool.
+  #
+  # Term resource is used for any type of poolable objects
+  # and should NOT be thought as DataMapper Resource or
+  # ActiveResource resource and such.
+  #
+  # In Data Objects connections are pooled so that it is
+  # unnecessary to allocate and initialize connection object
+  # each time connection is needed, like per request in a
+  # web application.
+  #
+  # Pool obviously has to be thread safe because state of
+  # object is reset when it is released.
+  module Pooling # :nodoc:
+
+    def self.scavenger
+      @scavenger || begin
+        @scavenger = Thread.new do
+          loop do
+            lock.synchronize do
+              pools.each do |pool|
+                # This is a useful check, but non-essential, and right now it breaks lots of stuff.
+                # if pool.expired?
+                pool.lock.synchronize do
+                  if pool.reserved_count == 0
+                    pool.dispose
+                  end
+                end
+                # end
+              end
+            end
+            sleep(scavenger_interval)
+          end # loop
+        end
+
+        @scavenger.priority = -10
+        @scavenger
+      end
+    end
+
+    def self.pools
+      @pools ||= Set.new
+    end
+
+    def self.append_pool(pool)
+      lock.synchronize do
+        pools << pool
+      end
+      Extlib::Pooling::scavenger
+    end
+
+    def self.lock
+      @lock ||= Mutex.new
+    end
+
+    class CrossPoolError < StandardError # :nodoc:
+    end
+
+    class OrphanedObjectError < StandardError # :nodoc:
+    end
+
+    class ThreadStopError < StandardError # :nodoc:
+    end
+
+    def self.included(target)
+      target.class_eval do
+        class << self
+          alias __new new
+        end
+
+        @__pools = Hash.new { |h,k| __pool_lock.synchronize { h[k] = Pool.new(target.pool_size, target, k) } }
+        @__pool_lock = Mutex.new
+
+        def self.__pool_lock
+          @__pool_lock
+        end
+
+        def self.new(*args)
+          @__pools[args].new
+        end
+
+        def self.__pools
+          @__pools
+        end
+
+        def self.pool_size
+          8
+        end
+      end
+    end
+
+    def release
+      @__pool.release(self)
+    end
+
+    class Pool # :nodoc:
+      def initialize(max_size, resource, args)
+        raise ArgumentError.new("+max_size+ should be a Fixnum but was #{max_size.inspect}") unless Fixnum === max_size
+        raise ArgumentError.new("+resource+ should be a Class but was #{resource.inspect}") unless Class === resource
+
+        @max_size = max_size
+        @resource = resource
+        @args = args
+
+        @available = []
+        @reserved_count = 0
+      end
+
+      def lock
+        @resource.__pool_lock
+      end
+
+      def scavenge_interval
+        @resource.scavenge_interval
+      end
+
+      def new
+        instance = nil
+
+        lock.synchronize do
+          instance = acquire
+        end
+
+        Extlib::Pooling::append_pool(self)
+
+        if instance.nil?
+          # Account for the current thread, and the pool scavenger.
+          if ThreadGroup::Default.list.size == 2 && @reserved_count >= @max_size
+            raise ThreadStopError.new(size)
+          else
+            sleep(0.05)
+            new
+          end
+        else
+          instance
+        end
+      end
+
+      def release(instance)
+        lock.synchronize do
+          instance.instance_variable_set(:@__pool, nil)
+          @reserved_count -= 1
+          @available.push(instance)
+        end
+        nil
+      end
+
+      def size
+        @available.size + @reserved_count
+      end
+      alias length size
+
+      def inspect
+        "#<Extlib::Pooling::Pool<#{@resource.name}> available=#{@available.size} reserved_count=#{@reserved_count}>"
+      end
+
+      def flush!
+        until @available.empty?
+          instance = @available.pop
+          instance.dispose
+        end
+        @available.clear
+      end
+
+      def dispose
+        flush!
+        @resource.__pools.delete(@args)
+        !Extlib::Pooling::pools.delete?(self).nil?
+      end
+
+      # Disabled temporarily.
+      #
+      # def expired?
+      #   lock.synchronize do
+      #     @available.each do |instance|
+      #       if instance.instance_variable_get(:@__allocated_in_pool) + scavenge_interval < Time.now
+      #         instance.dispose
+      #         @available.delete(instance)
+      #       end
+      #     end
+      #
+      #     size == 0
+      #   end
+      # end
+
+      def reserved_count
+        @reserved_count
+      end
+
+      private
+
+      def acquire
+        instance = if !@available.empty?
+          @available.pop
+        elsif size < @max_size
+          @resource.__new(*@args)
+        else
+          nil
+        end
+
+        if instance.nil?
+          instance
+        else
+          raise CrossPoolError.new(instance) if instance.instance_variable_get(:@__pool)
+          @reserved_count += 1
+          instance.instance_variable_set(:@__pool, self)
+          instance.instance_variable_set(:@__allocated_in_pool, Time.now)
+          instance
+        end
+      end
+    end
+
+    def self.scavenger_interval
+      60
+    end
+  end # module Pooling
+end # module Extlib

data/lib/genosaurus_helpers.rb

@@ -0,0 +1,40 @@
+module Mack
+  module Genosaurus # :nodoc:
+    module DataMapper # :nodoc:
+      module Helpers
+      
+        def columns(name = param(:name))
+          ivar_cache("form_columns") do
+            cs = []
+            cols = (param(:cols) || param(:columns))
+            if cols
+              cols.split(",").each do |x|
+                cs << Mack::Genosaurus::DataMapper::ModelColumn.new(name, x)
+              end
+            end
+            cs
+          end
+        end
+
+        def db_directory
+          File.join(Mack.root, "db")
+        end
+      
+        def migrations_directory
+          File.join(db_directory, "migrations")
+        end
+      
+        def next_migration_number
+          last = Dir.glob(File.join(migrations_directory, "*.rb")).last
+          if last
+            return File.basename(last).match(/^\d+/).to_s.succ
+          end
+          return "001"
+        end
+      
+        ::Genosaurus.send(:include, self)
+      
+      end # Helpers
+    end # DataMapper
+  end # Genosaurus
+end # Mack

data/lib/helpers/orm_helpers.rb

@@ -1,47 +1,76 @@
 module Mack
-  module ViewHelpers
-    module OrmHelpers
+  module ViewHelpers # :nodoc:
+    module DataMapperHelpers
+
       DEFAULT_PARTIAL = %{
-        <div>
-          <div class="errorExplanation" id="errorExplanation">
-            <h2><%= pluralize_word(errors.size, "error") %> occured.</h2>
-            <ul>
-              <% for error in errors %>
-                <li><%= error %></li>
-              <% end %>  
-            </ul>
-          </div>
-        </div>
-      }
-  
+<div>
+  <div class="errorExplanation" id="errorExplanation">
+    <h2><%= pluralize_word(errors.size, "error") %> occured.</h2>
+    <ul>
+      <% for error in errors %>
+        <li><%= error %></li>
+      <% end %>  
+    </ul>
+  </div>
+</div>
+      } unless Mack::ViewHelpers::DataMapperHelpers.const_defined?("DEFAULT_PARTIAL")
+      
+      # Provides view level support for printing out all the errors associated with the
+      # models you tell it. 
+      # The DEFAULT_PARTIAL constant provides a simple, default, set of HTML for displaying
+      # the errors. If you wish to change this HTML there are two simple ways of doing it.
+      # First if you have a partial named: app/views/application/_error_messages.html.erb,
+      # then it will use that default, and not DEFAULT_PARTIAL. The other option is to pass
+      # in a path to partial as the second argument and that partial will be rendered.
       def error_messages_for(object_names = [], view_partial = nil)
         object_names = [object_names].flatten
         app_errors = []
         object_names.each do |name|
           object = instance_variable_get("@#{name}")
           if object
-            if object.is_a?(DataMapper::Persistence)
-              app_errors << object.errors.full_messages
+            if object.is_a?(DataMapper::Resource)
+              app_errors << object.errors.full_messages.uniq
             end
           end
         end
         app_errors.flatten!
-        File.join(Mack::Configuration.views_directory, "application", "_error_messages.html.erb")
         unless app_errors.empty?
           if view_partial.nil?
-            if File.exist?(File.join(Mack::Configuration.views_directory, "application", "_error_messages.html.erb"))
+            if File.exist?(File.join(Mack.root, "app", "views", "application", "_error_messages.html.erb"))
               render(:partial, "application/error_messages", :locals => {:errors => app_errors})
             else
-              render(:text, DEFAULT_PARTIAL, :locals => {:errors => app_errors})
+              render(:inline, DEFAULT_PARTIAL, :locals => {:errors => app_errors})
             end
-          else        
+          else
             render(:partial, view_partial, :locals => {:errors => app_errors})
           end
         else
           ""
         end
       end
-      # self.include_safely_into(Mack::ViewBinder)
+      
+      # Generates a text input tag for a given model and field
+      # 
+      # Example:
+      # model_text_field(@user, :username) # => <input id="user_username" name="user[username]" type="text" value="<@user.username's value>" />
+      def model_text_field(model, property, options = {})
+        m_name = model.class.to_s.underscore
+        non_content_tag(:input, {:type => :text, :name => "#{m_name}[#{property}]", :id => "#{m_name}_#{property}", :value => model.send(property)}.merge(options))
+      end
+      
+      # Generates a password input tag for a given model and field
+      # 
+      # Example:
+      # model_password_field(@user, :password) # => <input id="user_username" name="user[username]" type="password" value="<@user.username's value>" />
+      def model_password_field(model, property, options = {})
+        model_text_field(model, property, {:type => :password}.merge(options))
+      end
+      
+      def model_textarea(model, property, options = {})
+        m_name = model.class.to_s.underscore
+        content_tag(:textarea, {:name => "#{m_name}[#{property}]", :id => "#{m_name}_#{property}", :cols => 60, :rows => 20}.merge(options), model.send(property))
+      end
+
     end # OrmHelpers
   end # ViewHelpers
 end # Mack