stringex 1.5.1 → 2.0.0

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

@@ -0,0 +1,67 @@
+module Stringex
+  module ActsAsUrl
+    module Adapter
+      class DataMapper < Base
+        def self.load
+          ensure_loadable
+          orm_class.send :include, Stringex::ActsAsUrl::ActsAsUrlInstanceMethods
+          ::DataMapper::Model.send :include, Stringex::ActsAsUrl::ActsAsUrlClassMethods
+        end
+
+      private
+
+        def create_callback
+          if settings.sync_url
+            klass.class_eval do
+              before :save, :ensure_unique_url
+            end
+          else
+            klass.class_eval do
+              before :create, :ensure_unique_url
+            end
+          end
+        end
+
+        def instance_from_db
+          instance.class.get(instance.id)
+        end
+
+        def is_blank?(object)
+          object.nil? || object == '' || object == []
+        end
+
+        def is_new?(object)
+          object.new?
+        end
+
+        def is_present?(object)
+          !is_blank? object
+        end
+
+        def klass_previous_instances(&block)
+          klass.all(:conditions => {settings.url_attribute => nil}).each(&block)
+        end
+
+        def read_attribute(instance, attribute)
+          instance.attributes[attribute]
+        end
+
+        def url_owners
+          @url_owners ||= url_owners_class.all(:conditions => url_owner_conditions)
+        end
+
+        def read_attribute(instance, name)
+          instance.attribute_get name
+        end
+
+        def write_attribute(instance, name, value)
+          instance.attribute_set name, value
+        end
+
+        def self.orm_class
+          ::DataMapper::Resource
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Stringex
+  module ActsAsUrl
+    module Adapter
+      class Mongoid < Base
+        def self.load
+          ensure_loadable
+          orm_class.send :extend, Stringex::ActsAsUrl::ActsAsUrlClassMethods
+        end
+
+      private
+
+        def add_new_record_url_owner_conditions
+          return if instance.new_record?
+          @url_owner_conditions.merge! :id => {'$ne' => instance.id}
+        end
+
+        def add_scoped_url_owner_conditions
+          return unless settings.scope_for_url
+          @url_owner_conditions.merge! settings.scope_for_url => instance.send(settings.scope_for_url)
+        end
+
+        def get_base_url_owner_conditions
+          @url_owner_conditions = {settings.url_attribute => /^#{Regexp.escape(base_url)}/}
+        end
+
+        def klass_previous_instances(&block)
+          klass.where(settings.url_attribute => nil).to_a.each(&block)
+        end
+
+        def self.orm_class
+          ::Mongoid::Document
+        end
+      end
+    end
+  end
+end

data/lib/stringex/configuration.rb

@@ -0,0 +1,4 @@
+require "stringex/configuration/base"
+require "stringex/configuration/configurator"
+require "stringex/configuration/acts_as_url"
+require "stringex/configuration/string_extensions"

data/lib/stringex/configuration/acts_as_url.rb

@@ -0,0 +1,44 @@
+module Stringex
+  module Configuration
+    class ActsAsUrl < Base
+      def initialize(options = {})
+        if options[:scope]
+          options[:scope_for_url] = options.delete(:scope)
+        end
+        super
+      end
+
+      def string_extensions_settings
+        [
+          :allow_slash,
+          :exclude,
+          :force_downcase,
+          :limit,
+          :replace_whitespace_with
+        ].inject(Hash.new){|m, x| m[x] = settings.send(x); m}
+      end
+
+      def self.settings
+        @settings
+      end
+
+    private
+
+      def default_settings
+        self.class.default_settings
+      end
+
+      def self.default_settings
+        @default_settings ||= {
+          :allow_duplicates => false,
+          :duplicate_count_separator => "-",
+          :enforce_uniqueness_on_sti_class => false,
+          :only_when_blank => false,
+          :scope_for_url => nil,
+          :sync_url => false,
+          :url_attribute => "url",
+        }.merge(Stringex::Configuration::StringExtensions.new.default_settings)
+      end
+    end
+  end
+end

data/lib/stringex/configuration/base.rb

@@ -0,0 +1,58 @@
+module Stringex
+  module Configuration
+    class Base
+      attr_accessor :settings
+
+      def initialize(local_options = {})
+        current_settings = default_settings.merge(system_wide_customizations)
+        current_settings.merge! local_options
+
+        @settings = OpenStruct.new(current_settings)
+      end
+
+      # NOTE: This does not cache itself so that instance and class can be cached on the adapter
+      # without worrying about thread safety or race conditions
+      def adapter
+        adapter_name = settings.adapter || Stringex::ActsAsUrl::Adapter.first_available
+        case adapter_name
+        when Class
+          adapter_name.send :new, self
+        when :active_record
+          Stringex::ActsAsUrl::Adapter::ActiveRecord.new self
+        when :mongoid
+          Stringex::ActsAsUrl::Adapter::Mongoid.new self
+        else
+          raise ArgumentError, "#{adapter_name} is not a defined ActsAsUrl adapter. Please feel free to implement your own and submit it back upstream."
+        end
+      end
+
+      def self.configure(&block)
+        configurator = Stringex::Configuration::Configurator.new(self)
+        yield configurator
+      end
+
+      def self.system_wide_customizations
+        @system_wide_customizations ||= {}
+      end
+
+      def self.unconfigure!
+        @system_wide_customizations = {}
+      end
+
+    private
+
+      def default_settings
+        raise ArgumentError, "You shouldn't have hit default_settings on Stringex::Configuration::Base. Check your code."
+      end
+
+      def system_wide_customizations
+        self.class.system_wide_customizations
+      end
+
+      def self.valid_configuration_details
+        default_settings.keys
+      end
+    end
+  end
+end
+

data/lib/stringex/configuration/configurator.rb

@@ -0,0 +1,25 @@
+module Stringex
+  module Configuration
+    class Configurator
+      attr_accessor :klass
+
+      def initialize(klass)
+        @klass = klass
+
+        self.klass.valid_configuration_details.each do |name|
+          define_instance_method_for_configuration_wrapper name
+        end
+      end
+
+      def define_instance_method_for_configuration_wrapper(name)
+        name = name.respond_to?(:intern) ? name.intern : name
+        (class << self; self; end).instance_eval do
+          define_method("#{name}=") do |value|
+            customizations = klass.send(:system_wide_customizations)
+            customizations[name] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stringex/configuration/string_extensions.rb

@@ -0,0 +1,19 @@
+module Stringex
+  module Configuration
+    class StringExtensions < Base
+      def default_settings
+        self.class.default_settings
+      end
+
+      def self.default_settings
+        @default_settings ||= {
+          :allow_slash => false,
+          :exclude => [],
+          :force_downcase => true,
+          :limit => nil,
+          :replace_whitespace_with => "-"
+        }
+      end
+    end
+  end
+end

data/lib/stringex/localization.rb

@@ -0,0 +1,98 @@
+# encoding: UTF-8
+
+require 'stringex/localization/converter'
+require 'stringex/localization/default_conversions'
+require 'stringex/localization/backend/internal'
+require 'stringex/localization/backend/i18n'
+
+module Stringex
+  module Localization
+    include DefaultConversions
+
+    class << self
+      def backend
+        @backend ||= defined?(I18n) ? Backend::I18n : Backend::Internal
+      end
+
+      def backend=(sym_or_class)
+        if sym_or_class.is_a?(Symbol)
+          @backend = case sym_or_class
+            when :internal then Backend::Internal
+            when :i18n then Backend::I18n
+            else raise "Invalid backend :#{sym_or_class}"
+          end
+        else
+          @backend = sym_or_class
+        end
+      end
+
+      def store_translations(locale, scope, data)
+        backend.store_translations(locale, scope, data)
+      end
+
+      def translate(scope, key, options = {})
+        return if key == "." # I18n doesn't support dots as translation keys so we don't either
+
+        locale = options[:locale] || self.locale
+
+        translation = initial_translation(scope, key, locale)
+
+        return translation unless translation.nil?
+
+        if locale != default_locale
+          translate scope, key, options.merge(:locale => default_locale)
+        else
+          default_conversion(scope, key) || options[:default]
+        end
+      end
+
+      def locale
+        backend.locale
+      end
+
+      def locale=(new_locale)
+        backend.locale = new_locale
+      end
+
+      def default_locale
+        backend.default_locale
+      end
+
+      def default_locale=(new_locale)
+        backend.default_locale = new_locale
+      end
+
+      def with_locale(new_locale, &block)
+        new_locale = default_locale if new_locale == :default
+        backend.with_locale new_locale, &block
+      end
+
+      def with_default_locale(&block)
+        with_locale default_locale, &block
+      end
+
+      def reset!
+        backend.reset!
+        @backend = nil
+      end
+
+      def convert(string, options = {}, &block)
+        converter = Converter.new(string)
+        converter.instance_exec &block
+        converter.smart_strip!
+        converter.string
+      end
+
+    private
+
+      def initial_translation(scope, key, locale)
+        backend.initial_translation(scope, key, locale)
+      end
+
+      def default_conversion(scope, key)
+        return unless DefaultConversions.respond_to?(scope)
+        DefaultConversions.send(scope)[key]
+      end
+    end
+  end
+end

data/lib/stringex/localization/backend/i18n.rb

@@ -0,0 +1,53 @@
+module Stringex
+  module Localization
+    module Backend
+      module I18n
+        LOAD_PATH_BASE = File.join(File.expand_path(File.dirname(__FILE__)), '..', '..', '..', '..', 'locales')
+
+        class << self
+          def locale
+            ::I18n.locale
+          end
+
+          def locale=(new_locale)
+            ::I18n.locale = new_locale
+          end
+
+          def default_locale
+            ::I18n.default_locale
+          end
+
+          def default_locale=(new_locale)
+            ::I18n.default_locale = new_locale
+          end
+
+          def with_locale(new_locale, &block)
+            ::I18n.with_locale new_locale, &block
+          end
+
+          def store_translations(locale, scope, data)
+            ::I18n.backend.store_translations(locale, { :stringex => { scope => data } })
+          end
+
+          def initial_translation(scope, key, locale)
+            # I18n can't return a nil as default as this gets interpreted as if no default
+            # is specified, so we use a string instead.
+            translated = ::I18n.translate(key, :scope => [:stringex, scope], :locale => locale, :default => "__default__")
+            translated == "__default__" ? nil : translated
+          end
+
+          def load_translations(locale = nil)
+            locale ||= ::I18n.locale
+            path = Dir[File.join(LOAD_PATH_BASE, "#{locale}.yml")]
+            ::I18n.load_path |= Dir[File.join(LOAD_PATH_BASE, "#{locale}.yml")]
+            ::I18n.backend.load_translations
+          end
+
+          def reset!
+            # Can't reset I18n. Needed?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stringex/localization/backend/internal.rb

@@ -0,0 +1,51 @@
+module Stringex
+  module Localization
+    module Backend
+      module Internal
+        DEFAULT_LOCALE = :en
+
+        class << self
+          def locale
+            @locale || default_locale
+          end
+
+          def locale=(new_locale)
+            @locale = new_locale.to_sym
+          end
+
+          def default_locale
+            @default_locale || DEFAULT_LOCALE
+          end
+
+          def default_locale=(new_locale)
+            @default_locale = @locale = new_locale.to_sym
+          end
+
+          def with_locale(new_locale, &block)
+            original_locale = locale
+            self.locale = new_locale
+            yield
+            self.locale = original_locale
+          end
+
+          def translations
+            # Set up hash like translations[:en][:transliterations]["é"]
+            @translations ||= Hash.new { |k, v| k[v] = Hash.new({}) }
+          end
+
+          def store_translations(locale, scope, data)
+            self.translations[locale.to_sym][scope.to_sym] = Hash[data.map { |k, v| [k.to_sym, v] }] # Symbolize keys
+          end
+
+          def initial_translation(scope, key, locale)
+            translations[locale][scope][key.to_sym]
+          end
+
+          def reset!
+            @translations = @locale = @default_locale = nil
+          end
+        end
+      end
+    end
+  end
+end