stringex 1.5.1 → 2.0.0

data/lib/stringex.rb

@@ -1,9 +1,17 @@
 # encoding: UTF-8
+
+require 'ostruct'
+require 'stringex/configuration'
+require 'stringex/localization'
 require 'stringex/string_extensions'
 require 'stringex/unidecoder'
+require 'stringex/acts_as_url'
 
-String.send :include, Stringex::StringExtensions
+String.send :include, Stringex::StringExtensions::PublicInstanceMethods
+String.send :extend, Stringex::StringExtensions::PublicClassMethods
 
-require 'stringex/acts_as_url' if defined?(ActiveRecord) || defined?(Mongoid::Document)
+Stringex::ActsAsUrl::Adapter.load_available
 
-ActiveRecord::Base.send :include, Stringex::ActsAsUrl if defined?(ActiveRecord)
+if defined?(Rails::Railtie)
+  require 'stringex/rails/railtie'
+end

data/lib/stringex/acts_as_url.rb

@@ -1,66 +1,17 @@
 # encoding: UTF-8
+require "stringex/acts_as_url/adapter"
+
 module Stringex
   module ActsAsUrl # :nodoc:
-    def self.included(base)
-      base.extend ClassMethods
+    def self.configure(&block)
+      Stringex::Configuration::ActsAsUrl.configure &block
     end
 
-    class Configuration
-      attr_accessor :allow_slash, :allow_duplicates, :attribute_to_urlify, :duplicate_count_separator,
-        :exclude, :only_when_blank, :scope_for_url, :sync_url, :url_attribute, :url_limit
-
-      def initialize(klass, options = {})
-        self.allow_slash = options[:allow_slash]
-        self.allow_duplicates = options[:allow_duplicates]
-        self.attribute_to_urlify = options[:attribute]
-        self.duplicate_count_separator = options[:duplicate_count_separator] || "-"
-        self.exclude = options[:exclude] || []
-        self.only_when_blank = options[:only_when_blank]
-        self.scope_for_url = options[:scope]
-        self.sync_url = options[:sync_url]
-        self.url_attribute = options[:url_attribute] || "url"
-        self.url_limit = options[:limit]
-      end
-
-      def get_base_url!(instance)
-        base_url = instance.send(url_attribute)
-        if base_url.blank? || !only_when_blank
-          root = instance.send(attribute_to_urlify).to_s
-          base_url = root.to_url(:allow_slash => allow_slash, :limit => url_limit, :exclude => exclude)
-        end
-        instance.instance_variable_set "@acts_as_url_base_url", base_url
-      end
-
-      def get_conditions!(instance)
-        conditions = ["#{url_attribute} LIKE ?", instance.instance_variable_get("@acts_as_url_base_url") + '%']
-        unless instance.new_record?
-          conditions.first << " and id != ?"
-          conditions << instance.id
-        end
-        if scope_for_url
-          conditions.first << " and #{scope_for_url} = ?"
-          conditions << instance.send(scope_for_url)
-        end
-        conditions
-      end
-
-      def handle_duplicate_urls!(instance)
-        return if allow_duplicates
-
-        base_url = instance.instance_variable_get("@acts_as_url_base_url")
-        url_owners = instance.class.unscoped.find(:all, :conditions => get_conditions!(instance))
-        if url_owners.any?{|owner| owner.send(url_attribute) == base_url}
-          separator = duplicate_count_separator
-          n = 1
-          while url_owners.any?{|owner| owner.send(url_attribute) == "#{base_url}#{separator}#{n}"}
-            n = n.succ
-          end
-          instance.send :write_attribute, url_attribute, "#{base_url}#{separator}#{n}"
-        end
-      end
+    def self.unconfigure!
+      Stringex::Configuration::ActsAsUrl.unconfigure!
     end
 
-    module ClassMethods # :doc:
+    module ActsAsUrlClassMethods # :doc:
       # Creates a callback to automatically create an url-friendly representation
       # of the <tt>attribute</tt> argument. Example:
       #
@@ -74,48 +25,58 @@ module Stringex
       # The default attribute <tt>acts_as_url</tt> uses to save the permalink is <tt>url</tt>
       # but this can be changed in the options hash. Available options are:
       #
-      # <tt>:allow_slash</tt>:: If true, allow the generated url to contain slashes. Default is false[y].
-      # <tt>:allow_duplicates</tt>:: If true, allow duplicate urls instead of appending numbers to
-      #                              differentiate between urls. Default is false[y].
+      # <tt>:adapter</tt>:: If specified, will indicate what ORM adapter to use. Default functionality
+      #                     is to use the first available adapter. This should work for most cases
+      #                     unless you are using multiple ORMs in a single project.
+      # <tt>:allow_slash</tt>:: If true, allows the generated url to contain slashes. Default is false[y].
+      # <tt>:allow_duplicates</tt>:: If true, allows duplicate urls instead of appending numbers to
+      #                              differentiate between urls. Default is false[y]. See note on <tt>:scope</tt>.
       # <tt>:duplicate_count_separator</tt>:: String to use when forcing unique urls from non-unique strings.
       #                                       Default is "-".
+      # <tt>:force_downcase</tt>:: If false, allows generated url to contain uppercased letters. Default is false.
       # <tt>:exclude_list</tt>:: List of complete strings that should not be transformed by <tt>acts_as_url</tt>.
       #                          Default is empty.
       # <tt>:only_when_blank</tt>:: If true, the url generation will only happen when <tt>:url_attribute</tt> is
       #                             blank. Default is false[y] (meaning url generation will happen always).
       # <tt>:scope</tt>:: The name of model attribute to scope unique urls to. There is no default here.
+      #                   <strong>Note:</strong> this will automatically act as if <tt>:allow_duplicates</tt>
+      #                   is set to true.
       # <tt>:sync_url</tt>:: If set to true, the url field will be updated when changes are made to the
-      #                      attribute it is based on. Default is false[y].
+      #                      attribute it is based on. Default is false.
       # <tt>:url_attribute</tt>:: The name of the attribute to use for storing the generated url string.
       #                           Default is <tt>:url</tt>.
-      # <tt>:url_limit</tt>:: The maximum size a generated url should be. <strong>Note:</strong> this does not
-      #                       include the characters needed to enforce uniqueness on duplicate urls.
-      #                       Default is nil.
+      # <tt>:limit</tt>:: The maximum size a generated url should be. <strong>Note:</strong> this does not
+      #                   include the characters needed to enforce uniqueness on duplicate urls.
+      #                   Default is nil.
       def acts_as_url(attribute, options = {})
-        cattr_accessor :acts_as_url_configuration
-
-        options[:attribute] = attribute
-        self.acts_as_url_configuration = ActsAsUrl::Configuration.new(self, options)
-
-        if acts_as_url_configuration.sync_url
-          before_validation(:ensure_unique_url)
-        else
-          if defined?(ActiveModel::Callbacks)
-            before_validation(:ensure_unique_url, :on => :create)
-          else
-            before_validation_on_create(:ensure_unique_url)
+        class_eval do
+          class << self
+            attr_accessor :acts_as_url_configuration
           end
-        end
 
-        class_eval <<-"END"
-          def #{acts_as_url_configuration.url_attribute}
-            if !new_record? && errors[acts_as_url_configuration.attribute_to_urlify].present?
-              self.class.find(id).send(acts_as_url_configuration.url_attribute)
-            else
-              read_attribute(acts_as_url_configuration.url_attribute)
+          define_method :acts_as_url_configuration do
+            klass = self.class
+            while klass.acts_as_url_configuration.nil?
+              klass = klass.superclass
             end
+            klass.acts_as_url_configuration
           end
-        END
+        end
+
+        options[:attribute_to_urlify] = attribute
+        self.acts_as_url_configuration = Stringex::Configuration::ActsAsUrl.new(options)
+
+        acts_as_url_configuration.adapter.create_callbacks! self
+      end
+
+
+      # Some ORMs function as mixins not base classes and need to have a hook to reinclude
+      # and re-extend ActsAsUrl methods
+      def included(base)
+        super
+
+        base.send :include, Stringex::ActsAsUrl::ActsAsUrlInstanceMethods
+        base.send :extend, Stringex::ActsAsUrl::ActsAsUrlClassMethods
       end
 
       # Initialize the url fields for the records that need it. Designed for people who add
@@ -126,23 +87,14 @@ module Stringex
       # on a large selection, you will get much better results writing your own version with
       # using pagination.
       def initialize_urls
-        find_each(:conditions => {acts_as_url_configuration.url_attribute => nil}) do |instance|
-          instance.send :ensure_unique_url
-          instance.save
-        end
+        acts_as_url_configuration.adapter.initialize_urls! self
       end
     end
 
-  private
-
-    def ensure_unique_url
-      # Just to save some typing
-      config = acts_as_url_configuration
-      url_attribute = config.url_attribute
-
-      config.get_base_url! self
-      write_attribute url_attribute, @acts_as_url_base_url
-      config.handle_duplicate_urls!(self) unless config.allow_duplicates
+    module ActsAsUrlInstanceMethods
+      def ensure_unique_url
+        acts_as_url_configuration.adapter.ensure_unique_url! self
+      end
     end
   end
 end

data/lib/stringex/acts_as_url/adapter.rb

@@ -0,0 +1,26 @@
+require "stringex/acts_as_url/adapter/base"
+require "stringex/acts_as_url/adapter/active_record"
+require "stringex/acts_as_url/adapter/data_mapper"
+require "stringex/acts_as_url/adapter/mongoid"
+
+module Stringex
+  module ActsAsUrl
+    module Adapter
+      def self.add_loaded_adapter(adapter)
+        @loaded_adapters << adapter
+      end
+
+      def self.load_available
+        @loaded_adapters = []
+        constants.each do |name|
+          adapter = const_get(name)
+          adapter.load if adapter.loadable?
+        end
+      end
+
+      def self.first_available
+        @loaded_adapters[0]
+      end
+    end
+  end
+end

data/lib/stringex/acts_as_url/adapter/active_record.rb

@@ -0,0 +1,23 @@
+module Stringex
+  module ActsAsUrl
+    module Adapter
+      class ActiveRecord < Base
+        def self.load
+          ensure_loadable
+          orm_class.send :include, ActsAsUrlInstanceMethods
+          orm_class.send :extend, ActsAsUrlClassMethods
+        end
+
+      private
+
+        def klass_previous_instances(&block)
+          klass.find_each(:conditions => {settings.url_attribute => nil}, &block)
+        end
+
+        def self.orm_class
+          ::ActiveRecord::Base
+        end
+      end
+    end
+  end
+end

data/lib/stringex/acts_as_url/adapter/base.rb

@@ -0,0 +1,188 @@
+module Stringex
+  module ActsAsUrl
+    module Adapter
+      class Base
+        attr_accessor :base_url, :configuration, :instance, :klass, :settings
+
+        def initialize(configuration)
+          ensure_loadable
+          self.configuration = configuration
+          self.settings = configuration.settings
+        end
+
+        def create_callbacks!(klass)
+          self.klass = klass
+          create_method_to_callback
+          create_callback
+        end
+
+        def ensure_unique_url!(instance)
+          @url_owners = nil
+          self.instance = instance
+
+          handle_url!
+          handle_duplicate_url! unless settings.allow_duplicates
+        end
+
+        def initialize_urls!(klass)
+          self.klass = klass
+          klass_previous_instances do |instance|
+            ensure_unique_url_for! instance
+          end
+        end
+
+        def url_attribute(instance)
+          # Retrieve from database record if there are errors on attribute_to_urlify
+          if !is_new?(instance) && is_present?(instance.errors[settings.attribute_to_urlify])
+            self.instance = instance
+            read_attribute instance_from_db, settings.url_attribute
+          else
+            read_attribute instance, settings.url_attribute
+          end
+        end
+
+        def self.ensure_loadable
+          raise "The #{self} adapter cannot be loaded" unless loadable?
+          Stringex::ActsAsUrl::Adapter.add_loaded_adapter self
+        end
+
+        def self.loadable?
+          orm_class
+        rescue NameError
+          false
+        end
+
+      private
+
+        def add_new_record_url_owner_conditions
+          return if is_new?(instance)
+          @url_owner_conditions.first << " and #{instance.class.primary_key} != ?"
+          @url_owner_conditions << instance.id
+        end
+
+        def add_scoped_url_owner_conditions
+          return unless settings.scope_for_url
+          @url_owner_conditions.first << " and #{settings.scope_for_url} = ?"
+          @url_owner_conditions << instance.send(settings.scope_for_url)
+        end
+
+        def create_callback
+          if settings.sync_url
+            klass.before_validation :ensure_unique_url
+          else
+            klass.before_validation :ensure_unique_url, :on => :create
+          end
+        end
+
+        def create_method_to_callback
+          klass.class_eval <<-"END"
+            def #{settings.url_attribute}
+              acts_as_url_configuration.adapter.url_attribute self
+            end
+          END
+        end
+
+        def duplicate_for_base_url(n)
+          "#{base_url}#{settings.duplicate_count_separator}#{n}"
+        end
+
+        def ensure_loadable
+          self.class.ensure_loadable
+        end
+
+        # NOTE: The <tt>instance</tt> here is not the cached instance but a block variable
+        # passed from <tt>klass_previous_instances</tt>, just to be clear
+        def ensure_unique_url_for!(instance)
+          instance.send :ensure_unique_url
+          instance.save
+        end
+
+        def get_base_url_owner_conditions
+          @url_owner_conditions = ["#{settings.url_attribute} LIKE ?", base_url + '%']
+        end
+
+        def handle_duplicate_url!
+          return if url_owners.none?{|owner| url_attribute_for(owner) == base_url}
+          n = 1
+          while url_owners.any?{|owner| url_attribute_for(owner) == duplicate_for_base_url(n)}
+            n = n.succ
+          end
+          write_url_attribute duplicate_for_base_url(n)
+        end
+
+        def handle_url!
+          self.base_url = instance.send(settings.url_attribute)
+          modify_base_url if is_blank?(base_url) || !settings.only_when_blank
+          write_url_attribute base_url
+        end
+
+        def instance_from_db
+          instance.class.find(instance.id)
+        end
+
+        def is_blank?(object)
+          object.blank?
+        end
+
+        def is_new?(object)
+          object.new_record?
+        end
+
+        def is_present?(object)
+          object.present?
+        end
+
+        def loadable?
+          self.class.loadable?
+        end
+
+        def modify_base_url
+          root = instance.send(settings.attribute_to_urlify).to_s
+          self.base_url = root.to_url(configuration.string_extensions_settings)
+        end
+
+        def orm_class
+          self.class.orm_class
+        end
+
+        def read_attribute(instance, attribute)
+          instance.read_attribute attribute
+        end
+
+        def url_attribute_for(object)
+          object.send settings.url_attribute
+        end
+
+        def url_owner_conditions
+          get_base_url_owner_conditions
+          add_new_record_url_owner_conditions
+          add_scoped_url_owner_conditions
+
+          @url_owner_conditions
+        end
+
+        def url_owners
+          @url_owners ||= url_owners_class.unscoped.where(url_owner_conditions).to_a
+        end
+
+        def url_owners_class
+          return instance.class unless settings.enforce_uniqueness_on_sti_base_class
+
+          klass = instance.class
+          while klass.superclass < orm_class
+            klass = klass.superclass
+          end
+          klass
+        end
+
+        def write_attribute(instance, attribute, value)
+          instance.send :write_attribute, attribute, value
+        end
+
+        def write_url_attribute(value)
+          write_attribute instance, settings.url_attribute, value
+        end
+      end
+    end
+  end
+end