tiny-safe-mod 0.0.1

data/stringex-2.8.6/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/stringex-2.8.6/lib/stringex/acts_as_url.rb

@@ -0,0 +1,107 @@
+# encoding: UTF-8
+require "stringex/acts_as_url/adapter"
+
+module Stringex
+  module ActsAsUrl # :nodoc:
+    def self.configure(&block)
+      Stringex::Configuration::ActsAsUrl.configure(&block)
+    end
+
+    def self.unconfigure!
+      Stringex::Configuration::ActsAsUrl.unconfigure!
+    end
+
+    module ActsAsUrlClassMethods # :doc:
+      # Creates a callback to automatically create an url-friendly representation
+      # of the <tt>attribute</tt> argument. Example:
+      #
+      #   acts_as_url :title
+      #
+      # will use the string contents of the <tt>title</tt> attribute
+      # to create the permalink. <strong>Note:</strong> you can also use a non-database-backed
+      # method to supply the string contents for the permalink. Just use that method's name
+      # as the argument as you would an attribute.
+      #
+      # 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>: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>:duplicate_sequence</tt>:: Supply an enumerator to generate the values used to generate
+      #                                unique urls (when <tt>:allow_duplicates</tt> is false).
+      #                                By default, generates positive integers in sequence from 1.
+      #                                <strong>Note:</strong> The sequence is restarted for each record
+      #                                (by calling <tt>#rewind</tt>).
+      # <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.
+      # <tt>:url_attribute</tt>:: The name of the attribute to use for storing the generated url string.
+      #                           Default is <tt>:url</tt>.
+      # <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 = {})
+        class_eval do
+          class << self
+            attr_accessor :acts_as_url_configuration
+          end
+
+          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
+
+        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 = nil, &block)
+        super
+
+        if base
+          base.send :include, Stringex::ActsAsUrl::ActsAsUrlInstanceMethods
+          base.send :extend, Stringex::ActsAsUrl::ActsAsUrlClassMethods
+        end
+      end
+
+      # Initialize the url fields for the records that need it. Designed for people who add
+      # <tt>acts_as_url</tt> support once there's already development/production data they'd
+      # like to keep around.
+      #
+      # Note: This method can get very expensive, very fast. If you're planning on using this
+      # on a large selection, you will get much better results writing your own version with
+      # using pagination.
+      def initialize_urls
+        acts_as_url_configuration.adapter.initialize_urls! self
+      end
+    end
+
+    module ActsAsUrlInstanceMethods
+      def ensure_unique_url
+        acts_as_url_configuration.adapter.ensure_unique_url! self
+      end
+    end
+  end
+end

data/stringex-2.8.6/lib/stringex/configuration/acts_as_url.rb

@@ -0,0 +1,50 @@
+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,
+          :truncate_words
+        ].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,
+          callback_method: :before_validation,
+          duplicate_count_separator: "-",
+          enforce_uniqueness_on_sti_base_class: false,
+          only_when_blank: false,
+          scope_for_url: nil,
+          sync_url: false,
+          url_attribute: "url",
+          blacklist: %w[new],
+          blacklist_policy: lambda { |instance, url|
+            "#{url}-#{instance.class.to_s.downcase}"
+          }
+        }.merge(Stringex::Configuration::StringExtensions.new.default_settings)
+      end
+    end
+  end
+end

data/stringex-2.8.6/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/stringex-2.8.6/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/stringex-2.8.6/lib/stringex/configuration/string_extensions.rb

@@ -0,0 +1,20 @@
+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: "-",
+          truncate_words: true
+        }
+      end
+    end
+  end
+end

data/stringex-2.8.6/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/stringex-2.8.6/lib/stringex/configuration_lite.rb

@@ -0,0 +1,3 @@
+require 'stringex/configuration/base'
+require 'stringex/configuration/configurator'
+require 'stringex/configuration/string_extensions'

data/stringex-2.8.6/lib/stringex/core_ext.rb

@@ -0,0 +1,10 @@
+Stringex = Module.new unless defined?(Stringex)
+ensure_module_defined = ->(base, module_name){
+  base.const_set(module_name, Module.new) unless base.const_defined?(module_name)
+}
+ensure_module_defined[Stringex, :StringExtensions]
+ensure_module_defined[Stringex::StringExtensions, :PublicInstanceMethods]
+ensure_module_defined[Stringex::StringExtensions, :PublicClassMethods]
+
+String.send :include, Stringex::StringExtensions::PublicInstanceMethods
+String.send :extend, Stringex::StringExtensions::PublicClassMethods

data/stringex-2.8.6/lib/stringex/localization/backend/base.rb

@@ -0,0 +1,13 @@
+module Stringex
+  module Localization
+    module Backend
+      class Base
+        class << self
+          def reset!
+            instance_variables.each { |var| remove_instance_variable var }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Stringex
+  module Localization
+    module Backend
+      class I18n < Base
+        LOAD_PATH_BASE = File.join(File.expand_path(File.dirname(__FILE__)), '..', '..', '..', '..', 'locales')
+
+        class << self
+          def reset!
+            super
+            @locale = nil
+            ::I18n.reload! if defined?(::I18n) && ::I18n.respond_to?(:reload!)
+          end
+
+          def locale
+            @locale || ::I18n.locale
+          end
+
+          def locale=(new_locale)
+            @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}})
+            reset_translations_cache
+          end
+
+          def translations
+            # Set up hash like translations[:en][:transliterations]["é"]
+            @translations ||= Hash.new { |hsh, locale| hsh[locale] = Hash.new({}).merge(i18n_translations_for(locale)) }
+          end
+
+          def initial_translation(scope, key, locale)
+            translations[locale][scope][key.to_sym]
+          end
+
+          def load_translations(locale = nil)
+            locale ||= self.locale
+            ::I18n.load_path |= Dir[File.join(LOAD_PATH_BASE, "#{locale}.yml")]
+            ::I18n.backend.load_translations
+            reset_translations_cache
+          end
+
+          def i18n_translations_for(locale)
+            ensure_locales_enforced_or_not
+            ::I18n.translate("stringex", locale: locale, default: {})
+          end
+
+          def reset_translations_cache
+            @translations = nil
+          end
+
+          def ensure_locales_enforced_or_not
+            return unless ::I18n.respond_to?(:enforce_available_locales)
+            # Allow users to have set this to false manually but default to true
+            return unless ::I18n.enforce_available_locales == nil
+            ::I18n.enforce_available_locales = ::I18n.available_locales != []
+          end
+        end
+      end
+
+      class I18nNotDefined < RuntimeError
+        def initialize
+          super 'Stringex cannot use I18n backend: I18n is not defined'
+        end
+      end
+
+      class I18nMissingTranslate < RuntimeError
+        def initialize
+          super 'Stringex cannot use I18n backend: I18n is defined but missing a translate method'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Stringex
+  module Localization
+    module Backend
+      class Internal < Base
+        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
+        end
+      end
+    end
+  end
+end

data/stringex-2.8.6/lib/stringex/localization/conversion_expressions.rb

@@ -0,0 +1,154 @@
+# encoding: UTF-8
+
+module Stringex
+  module Localization
+    module ConversionExpressions
+      ABBREVIATION = /(\s|\(|^)([[:alpha:]](\.[[:alpha:]])+(\.?)[[:alpha:]]*(\s|\)|$))/
+
+      ACCENTED_HTML_ENTITY = /&([A-Za-z])(grave|acute|circ|tilde|uml|ring|cedil|slash);/
+
+      APOSTROPHE = /(^|[[:alpha:]])'|`([[:alpha:]]|$)/
+
+      CHARACTERS =  {
+        and:      /\s*&\s*/,
+        at:       /\s*@\s*/,
+        degrees:  /\s*°\s*/,
+        divide:   /\s*÷\s*/,
+        dot:      /(\S|^)\.(\S)/,
+        ellipsis: /\s*\.{3,}\s*/,
+        equals:   /\s*=\s*/,
+        number:   /\s*#/,
+        percent:  /\s*%\s*/,
+        plus:     /\s*\+\s*/,
+        slash:    /\s*(\\|\/|／)\s*/,
+        star:     /\s*\*\s*/,
+      }
+
+      # Things that just get converted to spaces
+      CLEANUP_CHARACTERS = /[\.,:;(){}\[\]\?!\^'ʼ"`~_\|<>]/
+      CLEANUP_HTML_ENTITIES = /&[^;]+;/
+
+      CURRENCIES_SUPPORTED_SIMPLE = {
+        generic: /¤/,
+        dollars: /\$/,
+        euros:   /€/,
+        pounds:  /£/,
+        yen:     /¥/,
+        reais:   /R\$/
+      }
+      CURRENCIES_SUPPORTED_COMPLEX = {
+        dollars: :dollars_cents,
+        euros:   :euros_cents,
+        pounds:  :pounds_pence,
+        reais:   :reais_cents
+      }
+      CURRENCIES_SUPPORTED = Regexp.new(CURRENCIES_SUPPORTED_SIMPLE.values.join('|'))
+      CURRENCIES_SIMPLE = CURRENCIES_SUPPORTED_SIMPLE.inject({}) do |hash, content|
+        key, expression = content
+        hash[key] = /(?:\s|^)#{expression}(\d*)(?:\s|$)/
+        hash
+      end
+      CURRENCIES_COMPLEX = CURRENCIES_SUPPORTED_SIMPLE.inject({}) do |hash, content|
+        key, expression = content
+        # Do we really need to not worry about complex currencies if there are none for the currency?
+        complex_key = CURRENCIES_SUPPORTED_COMPLEX[key]
+        if complex_key
+          hash[complex_key] = /(?:\s|^)#{expression}(\d+)\.(\d+)(?:\s|$)/
+        end
+        hash
+      end
+      CURRENCIES = CURRENCIES_SIMPLE.merge(CURRENCIES_COMPLEX)
+
+      HTML_ENTITIES = Proc.new(){
+        base = {
+          amp:          %w{#38 amp},
+          cent:         %w{#162 cent},
+          copy:         %w{#169 copy},
+          deg:          %w{#176 deg},
+          divide:       %w{#247 divide},
+          double_quote: %w{#34 #822[012] quot ldquo rdquo dbquo},
+          ellipsis:     %w{#8230 hellip},
+          en_dash:      %w{#8211 ndash},
+          em_dash:      %w{#8212 mdash},
+          frac14:       %w{#188 frac14},
+          frac12:       %w{#189 frac12},
+          frac34:       %w{#190 frac34},
+          gt:           %w{#62 gt},
+          lt:           %w{#60 lt},
+          nbsp:         %w{#160 nbsp},
+          pound:        %w{#163 pound},
+          reg:          %w{#174 reg},
+          single_quote: %w{#39 #821[678] apos lsquo rsquo sbquo},
+          times:        %w{#215 times},
+          trade:        %w{#8482 trade},
+          yen:          %w{#165 yen},
+        }
+        base.inject({}) do |hash, content|
+          key, expression = content
+          hash[key] = /&(#{expression.join('|')});/
+          hash
+        end
+      }.call
+
+      HTML_TAG = Proc.new(){
+        name = /[\w:-]+/
+        value = /([A-Za-z0-9]+|('[^']*?'|"[^"]*?"))/
+        attr = /(#{name}(\s*=\s*#{value})?)/
+        /<[!\/?\[]?(#{name}|--)(\s+(#{attr}(\s+#{attr})*))?\s*([!\/?\]]+|--)?>/
+      }.call
+
+      SMART_PUNCTUATION = {
+        /(“|”|\302\223|\302\224|\303\222|\303\223)/ => '"',
+        /(‘|’|\302\221|\302\222|\303\225)/ => "'",
+        /…/ => "...",
+      }
+
+      UNREADABLE_CONTROL_CHARACTERS = /[[:cntrl:]]/
+
+      # Ordered by denominator then numerator of the value
+      VULGAR_FRACTIONS = {
+        half:          /(&#189;|&frac12;|½)/,
+        one_third:     /(&#8531;|⅓)/,
+        two_thirds:    /(&#8532;|⅔)/,
+        one_fourth:    /(&#188;|&frac14;|¼)/,
+        three_fourths: /(&#190;|&frac34;|¾)/,
+        one_fifth:     /(&#8533;|⅕)/,
+        two_fifths:    /(&#8534;|⅖)/,
+        three_fifths:  /(&#8535;|⅗)/,
+        four_fifths:   /(&#8536;|⅘)/,
+        one_sixth:     /(&#8537;|⅙)/,
+        five_sixths:   /(&#8538;|⅚)/,
+        one_eighth:    /(&#8539;|⅛)/,
+        three_eighths: /(&#8540;|⅜)/,
+        five_eighths:  /(&#8541;|⅝)/,
+        seven_eighths: /(&#8542;|⅞)/,
+      }
+
+      WHITESPACE = /\s+/
+
+      class << self
+        %w{
+          abbreviation
+          accented_html_entity
+          apostrophe
+          characters
+          cleanup_characters
+          cleanup_html_entities
+          currencies
+          currencies_simple
+          currencies_complex
+          html_entities
+          html_tag
+          smart_punctuation
+          unreadable_control_characters
+          vulgar_fractions
+          whitespace
+        }.each do |conversion_type|
+          define_method conversion_type do
+            const_get conversion_type.upcase
+          end
+        end
+      end
+    end
+  end
+end