motr 0.0.5 → 0.0.6

data/README.rdoc

@@ -2,11 +2,10 @@
 
 {Official Documentation}[http://rubydoc.info/github/kurbmedia/motr/master/frames]
 
-Motr is a basic Rails engine which adds additional functionality to your applications, and creates the ability to "extend" models 
+Motr is a basic Rails engine which adds additional functionality to your applications, and creates the ability to "mod" models and classes
 easily to support routine functionality. The {core Motr}[http://github.com/kurbmedia/motr] engine 
 provides a number of helpers and functionality geared towards bringing the ease of Rails back-end development, to the front-end. It
-also implements a {Devise}[https://github.com/plataformatec/devise] inspired "hook" system to support easily adding data functionality to 
-models in a similar manner to how Devise adds session management functionality.
+also implements a "modding" system to support easily adding data functionality to classes/models.
 
 Rails view helpers and form builders are convenient an easy to use, however some aren't very design/html friendly (whose idea was it to 
 wrap fields with errors in a div?). The goal is to keep html valid and sensible where possible, and make things like javascript integration 
@@ -23,7 +22,7 @@ feature requests, especially from designers/front-end developers who spend a lot
 
 == Credits
 
-Thanks to José Valim and {Devise}[https://github.com/plataformatec/devise] which inspired the model hook functionality.
+Thanks to José Valim and {Devise}[https://github.com/plataformatec/devise] which inspired the "modding" concept.
 
 == License
 

data/lib/motr.rb

@@ -3,15 +3,12 @@ require 'active_support/dependencies'
 require 'set'
 
 require 'motr/forms'
-require 'motr/model'
+require 'motr/modding'
+require 'motr/mods'
+require 'motr/dash'
 
 module Motr
 
-  module Schema
-    autoload :Base,      'motr/schema/base'
-    autoload :Generator, 'motr/schema/generator'
-  end
-
   module Controller #:nodoc:
     autoload :Helpers,    'motr/controller/helpers'
     autoload :Responder,  'motr/controller/responder'
@@ -29,52 +26,26 @@ module Motr
     autoload :ModuleMissing,  'motr/errors/module_missing'
   end
   
-  # Store configurations for included models
-  ALL         = []
-  CONFIGS     = {}
   
   ##
   # 
-  # Enable adding models to the core Motr library. These modules
-  # can then be included/initialized using the +motr+ method.
+  # Enable autoloading of mods
   # 
   # @param [Symbol] module_name The name of the module to be added (underscored)
-  # @param [Hash] config Default configuration options for the module
-  # 
-  # @option config [String, Boolean] :autoload The path to autoload the module from (optional)
+  # @param [Hash] options Hash including options for the mod
   # 
-  # All other configuration options are considered default options for that particular module.
+  # @option options [String, Boolean] :autoload The path to autoload the module from (optional)
   # 
   # 
-  def self.add_module(module_name, config = {})
+  def self.add_mod(module_name, options = {})
     
-    # Store a reference to any module loaded
-    ALL << module_name
-    config.assert_valid_keys(:autoload)
-     
     const_name = ActiveSupport::Inflector.camelize(module_name.to_s)
 
-    # Setup autoloading for this module if necessary
-    if autoload_path = config.delete(:autoload)
-      path = (autoload_path == true ? "motr/model/#{module_name.to_s}" : autoload_path)
-      Motr::Model.send(:autoload, const_name, path)
+    if autoload_path = options.delete(:autoload)
+      path = (autoload_path == true ? "motr/mods/#{module_name.to_s}" : autoload_path)
+      Motr::Mods.send(:autoload, const_name, path)
     end
     
-    # Setup placeholder for configuration
-    Motr::CONFIGS[module_name] ||= {}
-        
-    # Setup configuration method for module.
-    # 
-    self.class_eval <<-METHOD, __FILE__, __LINE__ + 1      
-      def self.#{module_name.to_s}(options = {})
-        raise Motr::Errors::InvalidOptions.new('Configuration for #{module_name} must be a hash.') unless options.is_a?(Hash)
-        Motr::CONFIGS[:#{module_name.to_s}].merge!(options)
-      end      
-    METHOD
-    
-    # Apply any defaults
-    Motr.send(:"#{module_name}", config)
-    
   end
   
   # Support initializer configuration

data/lib/motr/controller/helpers.rb

@@ -71,7 +71,7 @@ module Motr
         # @deprecated Use add_response_meta
         # 
         def enable_script_events(opts = {})
-          ActiveSupport::Deprecation.issue_warning("enable_script_events is deprecated. Please use the 'add_response_meta helper'")
+          ActiveSupport::Deprecation.warn("enable_script_events is deprecated. Please use the 'add_response_meta helper'")
           response_metadata = opts
         end
         

data/lib/motr/dash.rb

@@ -0,0 +1,33 @@
+require 'active_support'
+
+module Motr
+  ##
+  # Motr::Dash is basically a dashboard for an entire rails app. 
+  # It does things like setting up app-wide configurations etc.
+  # 
+  module Dash
+    
+    ##
+    # Defines an application-wide configuration hash created from config/config.yml
+    # 
+    def config
+      return @motr_application_config unless @motr_application_config.nil?
+      begin
+        config_data = YAML::load(File.open("#{Rails.root}/config/config.yml")) 
+      rescue
+        warn("Motr::Dash: Application configuration not found, please create a config.yml at #{Rails.root}/config/config.yml")
+        config_data = {}
+      end
+      @motr_application_config = ActiveSupport::HashWithIndifferentAccess::new(config_data[Rails.env] ||= {})
+    end
+    
+    ##
+    # Force reload of application configuration (without server restart)
+    # 
+    def reconfigure!
+      @motr_application_config = nil
+    end
+    
+  end
+  
+end

data/lib/motr/defaults.rb

@@ -1 +1 @@
-Motr.add_module(:sluggable, :autoload => true)
+Motr.add_mod(:sluggable, :autoload => true)

data/lib/motr/helpers/elements.rb

@@ -51,6 +51,8 @@ module Motr
       #
       def flash_messages(attrs = {})
         
+        return if flash.nil? or flash.empty?
+        
         wrapper = attrs.delete(:wrapper) || :div
         closer  = attrs.delete(:closer)
         unless closer === false
@@ -60,10 +62,10 @@ module Motr
         klasses << "flash_message"  
         content = ""    
         
-        flash.each_key do |k|
-          klasses << "flash_message_#{k.to_s.underscore}"
-          msg_attrs = attrs.merge(:class => [k.to_s, klasses].flatten.join(' '))
-          content.concat content_tag(wrapper, "#{flash[k]} #{closer}".html_safe, msg_attrs).html_safe
+        flash.each do |key, value|
+          klasses << "flash_message_#{key.to_s.underscore}"
+          msg_attrs = attrs.merge(:class => [key.to_s, klasses].flatten.join(' '))
+          content.concat content_tag(wrapper, "#{value} #{closer}".html_safe, msg_attrs).html_safe
         end    
         
         content.html_safe    

data/lib/motr/helpers/navigation.rb

@@ -75,8 +75,8 @@ module Motr
       # @private
       def update_link_attrs(path, attrs)
         
-        proc          = attrs.delete(:proc)
-        regex         = attrs.delete(:matcher)
+        proc          = attrs.delete(:proc) || false
+        regex         = attrs.delete(:matcher) || false
         klasses       = attrs.delete(:class).try(:split, ' ')
         on_class      = attrs.delete(:active_class) || "on"
         wrapper_attrs = attrs.delete(:wrapper) || {}
@@ -85,11 +85,20 @@ module Motr
         klasses  ||= []
         wklasses ||= []
         
-        if ((proc && proc.call(path)) || (regex && request.path =~ regex) || (request.path == path || request.path.match(/#{path}\/.*/i)))
+        matcher = (proc || regex || request.path)
+        
+        active = case matcher
+          when Proc then proc.call(path)
+          when Regexp then request.path.match(regex)
+          when String then (request.path == path || request.path.match(/#{path}\/\w/im))
+          else raise Motr::Errors::InvalidOptions.new('Proc, Regexp or String required... passed #{matcher.class}.')
+        end
+        
+        if active
           klasses  << on_class
           wklasses << on_class
         end
-        
+
         attrs.merge!(:class => klasses.join(" ")) unless klasses.compact.empty?
         wrapper_attrs.merge!(:class => wklasses.join(" ")) unless wklasses.compact.empty?
         

data/lib/motr/mapper.rb

@@ -0,0 +1,7 @@
+module Motr
+  ##
+  # Mapper handles configuring mod based routes within an application
+  # 
+  module Mapper
+  end
+end

data/lib/motr/modding.rb

@@ -0,0 +1,98 @@
+##
+#
+# Each mod extends Motr::Mod which provides necessary functionality to
+# perform setup and configuration.
+# 
+module Motr
+  module Modding
+    
+    def append_features(base)
+      return false if base < self
+      super
+      # Apply any orm specific configurations
+      #
+      if instance_variable_defined?("@_mod_config_for_orm")
+        @_mod_config_for_orm.each do |orm, configs|            
+          # Each orm should implement a motr_orm_type value which identifies
+          # itself to mods (ie :active_record, :mongoid)
+          next unless base.respond_to?(:motr_orm_type) && base.__send__(:motr_orm_type).to_s === orm.to_s
+          [configs].flatten.each{ |conf| base.class_eval(&conf) }
+        end          
+      end
+      
+      base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
+      base.send :include, const_get("InstanceMethods") if const_defined?("InstanceMethods")
+      base.class_eval(&@_mod_config_callback) if instance_variable_defined?("@_mod_config_callback")
+      
+    end
+    
+    ##
+    # Apply is run each time a mod is applied to a model. As opposed to the configure method,
+    # apply blocks are run each time modded_with :your_mod is called.
+    # 
+    # @param [Block] &block The callback to be run when the mod is applied
+    # 
+    # @example Configure a before_save callback to be applied to each instance
+    # 
+    #   module MyMod
+    #     apply do
+    #       before_save :something_each_time
+    #     end
+    #   end
+    # 
+    def apply(&block)
+      @_mod_apply_callback = block
+    end
+    
+    
+    ##
+    # Each mod can pass an optional configuration block (or one global config and one per orm) which 
+    # is run when a particular class or model implements that mod. Configure methods are only run on first inclusion.
+    # To run functionality each time the mod is applied, see Motr::Mod.apply
+    # 
+    # Orm specific functionality can be configured by passing an :orm as the first option
+    # 
+    # @param [Symbol] orm The name of the orm in which this configuration applies
+    # 
+    # @example Configure a before_filter callback when a model implements your mod
+    #   
+    #   module MyMod
+    #     configure do
+    #       before_filter :something_awesome
+    #     end
+    #   end
+    # 
+    # @example Configure mongoid only functionality
+    # 
+    #   module MyMod
+    #     configure(:mongoid) do
+    #       embeds_many :somethings
+    #     end
+    #   end
+    # 
+    def configure(orm = nil, &block)
+      if orm.nil?
+        @_mod_config_callback = block
+      else
+        (@_mod_config_for_orm ||= {})[orm] = block        
+      end
+    end
+    
+    ##
+    # Each mod can specify any number of options that may be passed to it
+    # when applied to a class/model.
+    # 
+    # @param [Array] *options Argument list of options to create.
+    # 
+    # @example Create configuration options on a module
+    #   module Motr::Mods::Sample
+    #     options(:sample, :option1, :option2)
+    #   end
+    # 
+    # 
+    def options(*options)
+      @_mod_options = options
+    end
+    
+  end
+end

data/lib/motr/mods.rb

@@ -0,0 +1,67 @@
+module Motr
+  module Mods
+    
+    ##
+    # modded_with provides the "hook" functionality to mod a model/class with a particular mod.
+    # Multiple mods can be applied at once, with options.
+    # 
+    # @param [Array] *mods Argument list of mods, and/or options
+    # @option *mods [Hash] options Options to be applied to each included mod
+    # 
+    # @example Mod a model with the sluggable mod
+    # 
+    #   class Awesome < ActiveRecord::Base
+    #     modded_with :sluggable, :fields => :title, :as => :slug
+    #   end
+    # 
+    # 
+    def modded_with(*mods)
+      
+      options  = mods.extract_options!
+      modules  = mods.map(&:to_sym).uniq
+      
+      modules.each do |mod|          
+        const_name = mod.to_s.classify
+        next unless Motr::Mods.const_defined?(:"#{const_name}")
+        
+        const_incl = Motr::Mods.const_get(:"#{const_name}")        
+        
+        # Apply passed options to modules where applicable.
+        # 
+        if const_incl.instance_variable_defined?("@_mod_options")        
+          mod_opts = const_incl.instance_variable_get("@_mod_options")
+
+          new_opts = mod_opts.inject({}) do |hsh, option|
+            next hsh unless options.key?(option)
+            hsh.merge!(option => options.delete(option))
+          end
+          
+          (class << self; self; end).class_eval do            
+            define_method("#{mod}_mod_options"){ motr_mod_options[mod.to_s] }
+            define_method("#{mod}_mod_options="){ |opts| motr_mod_options[mod.to_s] = opts }                       
+          end
+          
+          write_inheritable_attribute(:motr_mod_options, {}) if motr_mod_options.nil?
+          motr_mod_options[mod.to_s] = new_opts
+          
+        end
+
+        if const_incl.instance_variable_defined?("@_mod_apply_callback")
+          self.class_eval(&const_incl.instance_variable_get("@_mod_apply_callback"))
+        end
+        
+        include const_incl
+        
+      end
+      
+    end
+    
+    def motr_mod_options
+      read_inheritable_attribute(:motr_mod_options)
+    end
+    
+    alias :motr :modded_with
+    alias :mod_with :modded_with
+    
+  end
+end

data/lib/motr/mods/sluggable.rb

@@ -0,0 +1,65 @@
+module Motr
+  module Mods
+    ##
+    # Sluggable generates a url-friendly "slug" from a particular attribute.
+    # @param [Hash] options Options for generating a slug or slugs
+    # @option options [Hash,Symbol,String] :fields The fields that will be slugged
+    # @option options [Array, Symbol] :on The callback(s) in which slugs will be created (:create, :save, etc)
+    # @option options [Symbol, String] :as The attribute that receives the slugged value
+    #   If an array is passed to both :fields and :as, :as will be used in order of the arrays.
+    # 
+    # @example Slugify a "title" attribute into the "slug" attribute when new instances are saved
+    #   modded_with :sluggable, :fields => :title, :on => :create, :as => :slug
+    # 
+    # @example Slugify a "title" as a "slug" and a "subtitle" into itself
+    #   modded_with :sluggable, :fields => [:title, :subtitle], :as => [:slug]
+    #
+    module Sluggable
+      extend Motr::Modding
+      
+      options(:fields, :on, :as)
+      
+      configure do
+        pos = sluggable_mod_options[:on] || "create"
+        send(:"before_#{pos.to_s}", :_create_slugged_fields)
+      end
+      
+      def _create_slugged_fields
+
+        slug_opts   = self.class.sluggable_mod_options
+        slug_fields = slug_opts[:fields]
+        slug_as     = [slug_opts[:as]].flatten
+        
+        [slug_fields].flatten.map(&:to_sym).each_with_index do |atr, i|
+
+          next if self.send(atr).nil?          
+          unless slug_as.empty? || slug_as[i].nil?
+            self.send(:"#{slug_as[i]}=", self.send(atr).to_slug)
+          else
+            self.send(:"#{atr.to_s}=", self.send(atr).to_slug)
+          end          
+        end
+        
+      end
+      
+    end
+    
+  end
+end
+
+##
+# Original implementation by Ludo van den Boom's to_slug plugin 
+# @see to_slug (https://github.com/ludo/to_slug)
+#
+module ToSlug #:nodoc:
+  def to_slug
+    value = self.mb_chars.normalize(:kd).gsub(/[^\x00-\x7F]/n, '').to_s
+    value.gsub!(/[']+/, '')
+    value.gsub!(/\W+/, ' ')
+    value.strip!
+    value.downcase!
+    value.gsub!(' ', '-')
+    value
+  end
+end
+String.send(:include, ToSlug)

data/lib/motr/orm/active_record.rb

@@ -5,11 +5,11 @@ module Motr
       extend ActiveSupport::Concern
       
       included do        
-        extend Motr::Model
+        extend Motr::Mods
       end
       
-      module Schema
-        include Motr::Schema::Base
+      module ClassMethods
+        def motr_orm_type; :active_record; end
       end
       
     end

data/lib/motr/orm/mongoid.rb

@@ -2,28 +2,13 @@ module Motr
   module Orm
     
     module Mongoid #:nodoc:
-      def motrize_model!
-        extend Schema
-        yield
-        motrize_schema!
-      end
-      
-      module Schema
-        include Motr::Schema::Base
-        
-        def apply_motr_schema(field_name, field_type, options = {})
-          field_type = Time if field_type == DateTime
-          field field_name, { :type => field_type }.merge!(options)
-        end
-        
-      end
-      
+      def motr_orm_type; :mongoid; end
     end
     
   end
 end
 
 Mongoid::Document::ClassMethods.class_eval do
-  include Motr::Model
+  include Motr::Mods
   include Motr::Orm::Mongoid
 end

data/lib/motr/rails.rb

@@ -1,12 +1,14 @@
 module Motr
   class Engine < ::Rails::Engine #:nodoc:
-    config.motr = Motr    
+    config.motr = Motr
     
     # Add load paths straight to I18n, so engines and application can overwrite it.
     require 'active_support/i18n'
     I18n.load_path << File.expand_path('../../config/locales/en.yml', __FILE__)
     
     initializer 'motr.initializer' do
+      require 'motr/orm/mongoid' if defined?(Mongoid)
+            
       ActiveSupport.on_load(:action_view) do
         include Motr::Helpers::LayoutHelpers
         include Motr::Helpers::Navigation
@@ -18,9 +20,8 @@ module Motr
         include Motr::Controller::Helpers
         self.responder = Motr::Controller::Responder
       end
-      ActiveSupport.on_load(:after_initialize) do
-        require 'motr/orm/mongoid' if defined?(Mongoid)          
-        require 'motr/orm/active_record' if defined?(ActiveRecord)  
+      ActiveSupport.on_load(:active_record) do        
+        require 'motr/orm/active_record'
       end
       
     end

data/lib/motr/version.rb

@@ -1,3 +1,3 @@
 module Motr #:nodoc:
-  VERSION = "0.0.5".freeze
+  VERSION = "0.0.6".freeze
 end

metadata

@@ -2,7 +2,7 @@
 name: motr
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Brent Kirby
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-11 00:00:00 -04:00
+date: 2011-05-18 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -125,6 +125,7 @@ files:
 - lib/generators/templates/post_install
 - lib/motr/controller/helpers.rb
 - lib/motr/controller/responder.rb
+- lib/motr/dash.rb
 - lib/motr/defaults.rb
 - lib/motr/errors/invalid_options.rb
 - lib/motr/errors/module_missing.rb
@@ -136,13 +137,13 @@ files:
 - lib/motr/helpers/elements.rb
 - lib/motr/helpers/layout_helpers.rb
 - lib/motr/helpers/navigation.rb
-- lib/motr/model/sluggable.rb
-- lib/motr/model.rb
+- lib/motr/mapper.rb
+- lib/motr/modding.rb
+- lib/motr/mods/sluggable.rb
+- lib/motr/mods.rb
 - lib/motr/orm/active_record.rb
 - lib/motr/orm/mongoid.rb
 - lib/motr/rails.rb
-- lib/motr/schema/base.rb
-- lib/motr/schema/generator.rb
 - lib/motr/version.rb
 - lib/motr.rb
 - config/en.yml
@@ -164,7 +165,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3118347757184532695
+      hash: -2994942846918813196
       segments: 
       - 0
       version: "0"

data/lib/motr/model.rb

@@ -1,134 +0,0 @@
-module Motr
-
-  ##
-  # Provides a interface for extending models and controllers with additional Motr libraries.
-  # To create a new library, sub-class/module Motr::Model or Motr::Controller depending on the 
-  # functionality to include. To 'attach' functionality call motr :module_name 
-  # 
-  # @example Create a "postable" model using Motr::Model::Postable (see the motr-content gem)
-  #   class MyPost
-  #     motr :postable
-  #   end
-  #
-  module Model
-    ##
-    # Stores a list of available options for a model. This way when 
-    # options are passed at load-time, they can be applied to the proper modules.
-    # 
-    # @param [Class, Module] mod The module to configure
-    # @param [Symbol] cfg_name The name of the configuration to modify
-    # @param [Array] *options Argument list of options to create.
-    # 
-    # @example Create configuration options on a module
-    #   module Motr::Model::Sample
-    #     module ClassMethods
-    #       Motr::Model.config(self, :sample, :option1, :option2)
-    #     end
-    #   end
-    #
-    #
-    def self.config(mod, cfg_name, *options)
-      (class << mod; self; end).send(:attr_accessor_with_default, :motr_options, {})
-      mod.motr_options[cfg_name] ||= []
-      
-      options.each do |option|
-        mod.motr_options[cfg_name] << option
-        fullname = [cfg_name, option].map(&:to_s).join("_")
-                
-        mod.class_eval <<-METHOD, __FILE__, __LINE__ + 1
-          def #{fullname}
-            if defined?(@#{fullname})
-              @#{fullname}
-            elsif superclass.respond_to?(:#{fullname})
-              superclass.#{fullname}
-            else
-              Motr::CONFIGS[:#{cfg_name}][:#{option}]
-            end
-          end
-          def #{fullname}=(value)
-            @#{fullname} = value
-          end
-        METHOD
-      end
-    end
-    
-    ##
-    # The motr method enables loading other motr libraries into application modules/classes.
-    # 
-    # @example Create a model include to hook into any model class
-    #   module Motr::Model::Sample
-    #     def instance_method
-    #     end
-    # 
-    #     module ClassMethods
-    #       def class_method
-    #       end
-    #     end
-    #   end
-    # 
-    #   class SomeModel < ActiveRecord::Base
-    #     motr :sample
-    #   end
-    # 
-    # 
-    def motr(*mods)
-      
-      options  = mods.extract_options!
-      modules  = mods.map(&:to_sym).uniq
-
-      # Track what modules have been added to each class.
-      self.class_eval do
-        class_attribute :motr_modules, :instance_writer => false unless defined?(self.motr_modules)
-        self.motr_modules ||= []
-      end
-      
-      motrize_model! do
-        
-        modules.each do |mod|          
-          const_name = mod.to_s.classify
-          raise Motr::Model.load_failure("Motr::Model::#{const_name}") unless Motr::ALL.include?(mod)
-          
-          begin
-            const_incl = Motr::Model.const_get(:"#{const_name}")
-          rescue NameError
-            raise Motr::Errors.ModuleMissing.new("Motr::Model::#{const_name} could not be found. Perhaps try adding the module with the :autoload option.")
-          end
-          
-          if const_incl.const_defined?('ClassMethods')
-            class_incl = const_incl.const_get("ClassMethods")
-            extend class_incl
-          end
-          # # Apply passed options to modules where applicable.
-          # 
-          if class_incl.respond_to?(:motr_options)
-            class_incl.motr_options[mod].each do |option|
-              next unless options.key?(option)
-              send(:"#{mod}_#{option}=", options.delete(option))
-            end
-          end
-          
-          include const_incl
-          
-        end
-        
-        self.motr_modules |= modules
-        
-      end
-      
-    end
-    
-    # Raise a ModuleMissing error if a module cannot be loaded.
-    # @private
-    # 
-    def self.load_failure(mod) #:nodoc:
-      Motr::Errors::ModuleMissing.new("The module #{mod} wasn't found. Add it with Motr.add_module(#{mod})") and return
-    end
-    
-    # Override motrize_model! to create specific functionality on a model
-    # @private
-    def motrize_model! #:nodoc:
-      yield
-    end
-    
-  end
-end

data/lib/motr/model/sluggable.rb

@@ -1,45 +0,0 @@
-module Motr
-  module Model
-    
-    module Sluggable #:nodoc:
-      extend ActiveSupport::Concern
-      
-      included do
-        callback_opt = (self.sluggable_on || "save")
-        send(:"before_#{callback_opt.to_s}", :make_sluggable_fields)
-      end
-      
-      # @private
-      def make_sluggable_fields #:nodoc:
-        [self.class.sluggable_fields].flatten.each do |atr|
-          orig = self.send(:"#{atr}")
-          self.send(:"#{atr}=", orig.to_slug)
-        end
-      end
-      
-      # @private
-      module ClassMethods #:nodoc:
-        Motr::Model.config(self, :sluggable, :fields, :on)
-      end
-      
-    end
-    
-  end
-end
-
-##
-# Original implementation by Ludo van den Boom's to_slug plugin 
-# @see to_slug (https://github.com/ludo/to_slug)
-#
-module ToSlug #:nodoc:
-  def to_slug
-    value = self.mb_chars.normalize(:kd).gsub(/[^\x00-\x7F]/n, '').to_s
-    value.gsub!(/[']+/, '')
-    value.gsub!(/\W+/, ' ')
-    value.strip!
-    value.downcase!
-    value.gsub!(' ', '-')
-    value
-  end
-end
-String.send(:include, ToSlug)

data/lib/motr/schema/base.rb

@@ -1,20 +0,0 @@
-module Motr
-  module Schema
-    
-    ##
-    # Stubs schema methods to ensure ORM's implement them
-    # @private
-    # 
-    module Base #:nodoc:
-      
-      def motrize_schema!
-        Motr::Schema::Generator.set_target(self)        
-      end
-            
-      def apply_motr_schema(name, type, options={})
-        raise NotImplementedError
-      end
-    end
-    
-  end
-end

data/lib/motr/schema/generator.rb

@@ -1,79 +0,0 @@
-module Motr
-  module Schema
-    ##
-    # Generates a schema for a Motr module. To define a module schema, create a 
-    # subclass that implements a "generate" class method. Generator classes
-    # should follow the convention Motr::Schema::ModuleGenerator where "Module" is the module the 
-    # schema applies to. For instance if you have a module: Motr::Model::Sample, your generator class 
-    # would be called Motr::Schema::SampleGenerator
-    # 
-    # @example A generator for the module "sample"
-    # 
-    #   class Motr::Schema::SampleGenerator < Motr::Schema::Generator
-    #     def self.generate
-    #       apply(:field_name, String, {})  # => creates the field "field_name" with the type of String
-    # 
-    #       # only run for mongoid models
-    #       apply_for(:mongoid) do
-    #           embeds_many :children
-    #       end
-    #     end
-    #   end
-    # 
-    #
-    class Generator
-      
-      # Make er clean
-      instance_methods.each { |m| undef_method m unless m =~ /^(__.*__|object_id)$/ }
-      
-      class_attribute :schema_runner, :instance_writer => false
-      
-      # @private
-      # Delegates callbacks to a particular class/module. This allows generators to be flexible and 
-      # somewhat similar to migrations.
-      # 
-      def self.set_target(target) #:nodoc:
-        self.schema_runner = target
-      end
-     
-      # Override in subclasses to run.
-      # 
-      def self.generate
-        raise NotImplementedError
-      end
-      
-      protected
-      
-      ##
-      # Apply a callback only if the including module implements the specified ORM
-      # 
-      # @param [Symbol] orm The ORM which handles the block (ie: :mongoid or :active_record)
-      # @param [Block] &block The block to be run.
-      # 
-      # @example Apply an option only to mongoid based models
-      #   apply_for(:mongoid) do |model|
-      #     model.embeds_many :children
-      #   end
-      # 
-      def self.apply_for(orm, &block)
-        # TODO: This should maybe be more efficient?
-        puts self.schema_runner.inspect
-        return unless self.schema_runner.ancestors.map(&:to_s).detect{ |a| a.to_s.match(/#{orm.to_s.classify}/) }
-        yield self.schema_runner
-      end
-      
-      ##
-      # Creates a field on the model (or migration method in ActiveRecord)
-      # 
-      # @param [Symbol] name The name of the field to create
-      # @param [Class] type The class type to create (ie: String, DateTime...)
-      # @param [Hash] options Specific options for the class type (ie: :default => nil)
-      # 
-      def self.apply(name, type, options = {})
-        self.schema_runner.__send__(:apply_motr_schema, name, type, options)
-      end
-      
-    end
-    
-  end
-end