RubyGems - mack-active_record - Versions diffs - 0.8.2 → 0.8.3 - Mend

mack-active_record 0.8.2 → 0.8.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (318) hide show

data/lib/gems/activesupport-2.2.2/lib/active_support/vendor/builder-2.1.2/builder/xmlmarkup.rb DELETED Viewed

@@ -1,328 +0,0 @@
-#!/usr/bin/env ruby
-#--
-# Copyright 2004, 2005 by Jim Weirich (jim@weirichhouse.org).
-# All rights reserved.
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-# Provide a flexible and easy to use Builder for creating XML markup.
-# See XmlBuilder for usage details.
-require 'builder/xmlbase'
-module Builder
-  # Create XML markup easily.  All (well, almost all) methods sent to
-  # an XmlMarkup object will be translated to the equivalent XML
-  # markup.  Any method with a block will be treated as an XML markup
-  # tag with nested markup in the block.
-  #
-  # Examples will demonstrate this easier than words.  In the
-  # following, +xm+ is an +XmlMarkup+ object.
-  #
-  #   xm.em("emphasized")             # => <em>emphasized</em>
-  #   xm.em { xmm.b("emp & bold") }   # => <em><b>emph &amp; bold</b></em>
-  #   xm.a("A Link", "href"=>"http://onestepback.org")
-  #                                   # => <a href="http://onestepback.org">A Link</a>
-  #   xm.div { br }                    # => <div><br/></div>
-  #   xm.target("name"=>"compile", "option"=>"fast")
-  #                                   # => <target option="fast" name="compile"\>
-  #                                   # NOTE: order of attributes is not specified.
-  #
-  #   xm.instruct!                   # <?xml version="1.0" encoding="UTF-8"?>
-  #   xm.html {                      # <html>
-  #     xm.head {                    #   <head>
-  #       xm.title("History")        #     <title>History</title>
-  #     }                            #   </head>
-  #     xm.body {                    #   <body>
-  #       xm.comment! "HI"           #     <! -- HI -->
-  #       xm.h1("Header")            #     <h1>Header</h1>
-  #       xm.p("paragraph")          #     <p>paragraph</p>
-  #     }                            #   </body>
-  #   }                              # </html>
-  #
-  # == Notes:
-  #
-  # * The order that attributes are inserted in markup tags is
-  #   undefined.
-  #
-  # * Sometimes you wish to insert text without enclosing tags.  Use
-  #   the <tt>text!</tt> method to accomplish this.
-  #
-  #   Example:
-  #
-  #     xm.div {                          # <div>
-  #       xm.text! "line"; xm.br          #   line<br/>
-  #       xm.text! "another line"; xmbr   #    another line<br/>
-  #     }                                 # </div>
-  #
-  # * The special XML characters <, >, and & are converted to &lt;,
-  #   &gt; and &amp; automatically.  Use the <tt><<</tt> operation to
-  #   insert text without modification.
-  #
-  # * Sometimes tags use special characters not allowed in ruby
-  #   identifiers.  Use the <tt>tag!</tt> method to handle these
-  #   cases.
-  #
-  #   Example:
-  #
-  #     xml.tag!("SOAP:Envelope") { ... }
-  #
-  #   will produce ...
-  #
-  #     <SOAP:Envelope> ... </SOAP:Envelope>"
-  #
-  #   <tt>tag!</tt> will also take text and attribute arguments (after
-  #   the tag name) like normal markup methods.  (But see the next
-  #   bullet item for a better way to handle XML namespaces).
-  #
-  # * Direct support for XML namespaces is now available.  If the
-  #   first argument to a tag call is a symbol, it will be joined to
-  #   the tag to produce a namespace:tag combination.  It is easier to
-  #   show this than describe it.
-  #
-  #     xml.SOAP :Envelope do ... end
-  #
-  #   Just put a space before the colon in a namespace to produce the
-  #   right form for builder (e.g. "<tt>SOAP:Envelope</tt>" =>
-  #   "<tt>xml.SOAP :Envelope</tt>")
-  #
-  # * XmlMarkup builds the markup in any object (called a _target_)
-  #   that accepts the <tt><<</tt> method.  If no target is given,
-  #   then XmlMarkup defaults to a string target.
-  #
-  #   Examples:
-  #
-  #     xm = Builder::XmlMarkup.new
-  #     result = xm.title("yada")
-  #     # result is a string containing the markup.
-  #
-  #     buffer = ""
-  #     xm = Builder::XmlMarkup.new(buffer)
-  #     # The markup is appended to buffer (using <<)
-  #
-  #     xm = Builder::XmlMarkup.new(STDOUT)
-  #     # The markup is written to STDOUT (using <<)
-  #
-  #     xm = Builder::XmlMarkup.new
-  #     x2 = Builder::XmlMarkup.new(:target=>xm)
-  #     # Markup written to +x2+ will be send to +xm+.
-  #
-  # * Indentation is enabled by providing the number of spaces to
-  #   indent for each level as a second argument to XmlBuilder.new.
-  #   Initial indentation may be specified using a third parameter.
-  #
-  #   Example:
-  #
-  #     xm = Builder.new(:indent=>2)
-  #     # xm will produce nicely formatted and indented XML.
-  #
-  #     xm = Builder.new(:indent=>2, :margin=>4)
-  #     # xm will produce nicely formatted and indented XML with 2
-  #     # spaces per indent and an over all indentation level of 4.
-  #
-  #     builder = Builder::XmlMarkup.new(:target=>$stdout, :indent=>2)
-  #     builder.name { |b| b.first("Jim"); b.last("Weirich) }
-  #     # prints:
-  #     #     <name>
-  #     #       <first>Jim</first>
-  #     #       <last>Weirich</last>
-  #     #     </name>
-  #
-  # * The instance_eval implementation which forces self to refer to
-  #   the message receiver as self is now obsolete.  We now use normal
-  #   block calls to execute the markup block.  This means that all
-  #   markup methods must now be explicitly send to the xml builder.
-  #   For instance, instead of
-  #
-  #      xml.div { strong("text") }
-  #
-  #   you need to write:
-  #
-  #      xml.div { xml.strong("text") }
-  #
-  #   Although more verbose, the subtle change in semantics within the
-  #   block was found to be prone to error.  To make this change a
-  #   little less cumbersome, the markup block now gets the markup
-  #   object sent as an argument, allowing you to use a shorter alias
-  #   within the block.
-  #
-  #   For example:
-  #
-  #     xml_builder = Builder::XmlMarkup.new
-  #     xml_builder.div { |xml|
-  #       xml.stong("text")
-  #     }
-  #
-  class XmlMarkup < XmlBase
-    # Create an XML markup builder.  Parameters are specified by an
-    # option hash.
-    #
-    # :target=><em>target_object</em>::
-    #    Object receiving the markup.  +out+ must respond to the
-    #    <tt><<</tt> operator.  The default is a plain string target.
-    #
-    # :indent=><em>indentation</em>::
-    #    Number of spaces used for indentation.  The default is no
-    #    indentation and no line breaks.
-    #
-    # :margin=><em>initial_indentation_level</em>::
-    #    Amount of initial indentation (specified in levels, not
-    #    spaces).
-    #
-    # :escape_attrs=><b>OBSOLETE</em>::
-    #    The :escape_attrs option is no longer supported by builder
-    #    (and will be quietly ignored).  String attribute values are
-    #    now automatically escaped.  If you need unescaped attribute
-    #    values (perhaps you are using entities in the attribute
-    #    values), then give the value as a Symbol.  This allows much
-    #    finer control over escaping attribute values.
-    #
-    def initialize(options={})
-      indent = options[:indent] || 0
-      margin = options[:margin] || 0
-      super(indent, margin)
-      @target = options[:target] || ""
-    end
-    # Return the target of the builder.
-    def target!
-      @target
-    end
-    def comment!(comment_text)
-      _ensure_no_block block_given?
-      _special("<!-- ", " -->", comment_text, nil)
-    end
-    # Insert an XML declaration into the XML markup.
-    #
-    # For example:
-    #
-    #   xml.declare! :ELEMENT, :blah, "yada"
-    #       # => <!ELEMENT blah "yada">
-    def declare!(inst, *args, &block)
-      _indent
-      @target << "<!#{inst}"
-      args.each do |arg|
-        case arg
-        when String
-          @target << %{ "#{arg}"} # " WART
-        when Symbol
-          @target << " #{arg}"
-        end
-      end
-      if block_given?
-        @target << " ["
-        _newline
-        _nested_structures(block)
-        @target << "]"
-      end
-      @target << ">"
-      _newline
-    end
-    # Insert a processing instruction into the XML markup.  E.g.
-    #
-    # For example:
-    #
-    #    xml.instruct!
-    #        #=> <?xml version="1.0" encoding="UTF-8"?>
-    #    xml.instruct! :aaa, :bbb=>"ccc"
-    #        #=> <?aaa bbb="ccc"?>
-    #
-    def instruct!(directive_tag=:xml, attrs={})
-      _ensure_no_block block_given?
-      if directive_tag == :xml
-        a = { :version=>"1.0", :encoding=>"UTF-8" }
-        attrs = a.merge attrs
-      end
-      _special(
-      "<?#{directive_tag}",
-      "?>",
-      nil,
-      attrs,
-      [:version, :encoding, :standalone])
-    end
-    # Insert a CDATA section into the XML markup.
-    #
-    # For example:
-    #
-    #    xml.cdata!("text to be included in cdata")
-    #        #=> <![CDATA[text to be included in cdata]]>
-    #
-    def cdata!(text)
-      _ensure_no_block block_given?
-      _special("<![CDATA[", "]]>", text, nil)
-    end
-    private
-    # NOTE: All private methods of a builder object are prefixed when
-    # a "_" character to avoid possible conflict with XML tag names.
-    # Insert text directly in to the builder's target.
-    def _text(text)
-      @target << text
-    end
-    # Insert special instruction.
-    def _special(open, close, data=nil, attrs=nil, order=[])
-      _indent
-      @target << open
-      @target << data if data
-      _insert_attributes(attrs, order) if attrs
-      @target << close
-      _newline
-    end
-    # Start an XML tag.  If <tt>end_too</tt> is true, then the start
-    # tag is also the end tag (e.g.  <br/>
-    def _start_tag(sym, attrs, end_too=false)
-      @target << "<#{sym}"
-      _insert_attributes(attrs)
-      @target << "/" if end_too
-      @target << ">"
-    end
-    # Insert an ending tag.
-    def _end_tag(sym)
-      @target << "</#{sym}>"
-    end
-    # Insert the attributes (given in the hash).
-    def _insert_attributes(attrs, order=[])
-      return if attrs.nil?
-      order.each do |k|
-        v = attrs[k]
-        @target << %{ #{k}="#{_attr_value(v)}"} if v # " WART
-      end
-      attrs.each do |k, v|
-        @target << %{ #{k}="#{_attr_value(v)}"} unless order.member?(k) # " WART
-      end
-    end
-    def _attr_value(value)
-      case value
-      when Symbol
-        value.to_s
-      else
-        _escape_quote(value.to_s)
-      end
-    end
-    def _ensure_no_block(got_block)
-      if got_block
-        fail IllegalBlockError,
-        "Blocks are not allowed on XML instructions"
-      end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/vendor/builder-2.1.2/builder.rb DELETED Viewed

@@ -1,13 +0,0 @@
-#!/usr/bin/env ruby
-#--
-# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-# All rights reserved.
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-require 'builder/xmlmarkup'
-require 'builder/xmlevents'

data/lib/gems/activesupport-2.2.2/lib/active_support/vendor/i18n-0.0.1/i18n/backend/simple.rb DELETED Viewed

@@ -1,216 +0,0 @@
-require 'yaml'
-module I18n
-  module Backend
-    class Simple
-      INTERPOLATION_RESERVED_KEYS = %w(scope default)
-      MATCH = /(\\\\)?\{\{([^\}]+)\}\}/
-      # Accepts a list of paths to translation files. Loads translations from
-      # plain Ruby (*.rb) or YAML files (*.yml). See #load_rb and #load_yml
-      # for details.
-      def load_translations(*filenames)
-        filenames.each { |filename| load_file(filename) }
-      end
-      # Stores translations for the given locale in memory.
-      # This uses a deep merge for the translations hash, so existing
-      # translations will be overwritten by new ones only at the deepest
-      # level of the hash.
-      def store_translations(locale, data)
-        merge_translations(locale, data)
-      end
-      def translate(locale, key, options = {})
-        raise InvalidLocale.new(locale) if locale.nil?
-        return key.map { |k| translate(locale, k, options) } if key.is_a? Array
-        reserved = :scope, :default
-        count, scope, default = options.values_at(:count, *reserved)
-        options.delete(:default)
-        values = options.reject { |name, value| reserved.include?(name) }
-        entry = lookup(locale, key, scope)
-        if entry.nil?
-          entry = default(locale, default, options)
-          if entry.nil?
-            raise(I18n::MissingTranslationData.new(locale, key, options))
-          end
-        end
-        entry = pluralize(locale, entry, count)
-        entry = interpolate(locale, entry, values)
-        entry
-      end
-      # Acts the same as +strftime+, but returns a localized version of the
-      # formatted date string. Takes a key from the date/time formats
-      # translations as a format argument (<em>e.g.</em>, <tt>:short</tt> in <tt>:'date.formats'</tt>).
-      def localize(locale, object, format = :default)
-        raise ArgumentError, "Object must be a Date, DateTime or Time object. #{object.inspect} given." unless object.respond_to?(:strftime)
-        type = object.respond_to?(:sec) ? 'time' : 'date'
-        # TODO only translate these if format is a String?
-        formats = translate(locale, :"#{type}.formats")
-        format = formats[format.to_sym] if formats && formats[format.to_sym]
-        # TODO raise exception unless format found?
-        format = format.to_s.dup
-        # TODO only translate these if the format string is actually present
-        # TODO check which format strings are present, then bulk translate then, then replace them
-        format.gsub!(/%a/, translate(locale, :"date.abbr_day_names")[object.wday])
-        format.gsub!(/%A/, translate(locale, :"date.day_names")[object.wday])
-        format.gsub!(/%b/, translate(locale, :"date.abbr_month_names")[object.mon])
-        format.gsub!(/%B/, translate(locale, :"date.month_names")[object.mon])
-        format.gsub!(/%p/, translate(locale, :"time.#{object.hour < 12 ? :am : :pm}")) if object.respond_to? :hour
-        object.strftime(format)
-      end
-      def initialized?
-        @initialized ||= false
-      end
-      def reload!
-        @initialized = false
-        @translations = nil
-      end
-      protected
-        def init_translations
-          load_translations(*I18n.load_path)
-          @initialized = true
-        end
-        def translations
-          @translations ||= {}
-        end
-        # Looks up a translation from the translations hash. Returns nil if
-        # eiher key is nil, or locale, scope or key do not exist as a key in the
-        # nested translations hash. Splits keys or scopes containing dots
-        # into multiple keys, i.e. <tt>currency.format</tt> is regarded the same as
-        # <tt>%w(currency format)</tt>.
-        def lookup(locale, key, scope = [])
-          return unless key
-          init_translations unless initialized?
-          keys = I18n.send(:normalize_translation_keys, locale, key, scope)
-          keys.inject(translations) do |result, k|
-            if (x = result[k.to_sym]).nil?
-              return nil
-            else
-              x
-            end
-          end
-        end
-        # Evaluates a default translation.
-        # If the given default is a String it is used literally. If it is a Symbol
-        # it will be translated with the given options. If it is an Array the first
-        # translation yielded will be returned.
-        #
-        # <em>I.e.</em>, <tt>default(locale, [:foo, 'default'])</tt> will return +default+ if
-        # <tt>translate(locale, :foo)</tt> does not yield a result.
-        def default(locale, default, options = {})
-          case default
-            when String then default
-            when Symbol then translate locale, default, options
-            when Array  then default.each do |obj|
-              result = default(locale, obj, options.dup) and return result
-            end and nil
-          end
-        rescue MissingTranslationData
-          nil
-        end
-        # Picks a translation from an array according to English pluralization
-        # rules. It will pick the first translation if count is not equal to 1
-        # and the second translation if it is equal to 1. Other backends can
-        # implement more flexible or complex pluralization rules.
-        def pluralize(locale, entry, count)
-          return entry unless entry.is_a?(Hash) and count
-          # raise InvalidPluralizationData.new(entry, count) unless entry.is_a?(Hash)
-          key = :zero if count == 0 && entry.has_key?(:zero)
-          key ||= count == 1 ? :one : :other
-          raise InvalidPluralizationData.new(entry, count) unless entry.has_key?(key)
-          entry[key]
-        end
-        # Interpolates values into a given string.
-        #
-        #   interpolate "file {{file}} opened by \\{{user}}", :file => 'test.txt', :user => 'Mr. X'
-        #   # => "file test.txt opened by {{user}}"
-        #
-        # Note that you have to double escape the <tt>\\</tt> when you want to escape
-        # the <tt>{{...}}</tt> key in a string (once for the string and once for the
-        # interpolation).
-        def interpolate(locale, string, values = {})
-          return string unless string.is_a?(String)
-          if string.respond_to?(:force_encoding)
-            original_encoding = string.encoding
-            string.force_encoding(Encoding::BINARY)
-          end
-          result = string.gsub(MATCH) do
-            escaped, pattern, key = $1, $2, $2.to_sym
-            if escaped
-              pattern
-            elsif INTERPOLATION_RESERVED_KEYS.include?(pattern)
-              raise ReservedInterpolationKey.new(pattern, string)
-            elsif !values.include?(key)
-              raise MissingInterpolationArgument.new(pattern, string)
-            else
-              values[key].to_s
-            end
-          end
-          result.force_encoding(original_encoding) if original_encoding
-          result
-        end
-        # Loads a single translations file by delegating to #load_rb or
-        # #load_yml depending on the file extension and directly merges the
-        # data to the existing translations. Raises I18n::UnknownFileType
-        # for all other file extensions.
-        def load_file(filename)
-          type = File.extname(filename).tr('.', '').downcase
-          raise UnknownFileType.new(type, filename) unless respond_to?(:"load_#{type}")
-          data = send :"load_#{type}", filename # TODO raise a meaningful exception if this does not yield a Hash
-          data.each { |locale, d| merge_translations(locale, d) }
-        end
-        # Loads a plain Ruby translations file. eval'ing the file must yield
-        # a Hash containing translation data with locales as toplevel keys.
-        def load_rb(filename)
-          eval(IO.read(filename), binding, filename)
-        end
-        # Loads a YAML translations file. The data must have locales as
-        # toplevel keys.
-        def load_yml(filename)
-          YAML::load(IO.read(filename))
-        end
-        # Deep merges the given translations hash with the existing translations
-        # for the given locale
-        def merge_translations(locale, data)
-          locale = locale.to_sym
-          translations[locale] ||= {}
-          data = deep_symbolize_keys(data)
-          # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
-          merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-          translations[locale].merge!(data, &merger)
-        end
-        # Return a new hash with all keys and nested keys converted to symbols.
-        def deep_symbolize_keys(hash)
-          hash.inject({}) { |result, (key, value)|
-            value = deep_symbolize_keys(value) if value.is_a? Hash
-            result[(key.to_sym rescue key) || key] = value
-            result
-          }
-        end
-    end
-  end
-end

data/lib/gems/activesupport-2.2.2/lib/active_support/vendor/i18n-0.0.1/i18n/exceptions.rb DELETED Viewed

@@ -1,53 +0,0 @@
-module I18n
-  class ArgumentError < ::ArgumentError; end
-  class InvalidLocale < ArgumentError
-    attr_reader :locale
-    def initialize(locale)
-      @locale = locale
-      super "#{locale.inspect} is not a valid locale"
-    end
-  end
-  class MissingTranslationData < ArgumentError
-    attr_reader :locale, :key, :options
-    def initialize(locale, key, options)
-      @key, @locale, @options = key, locale, options
-      keys = I18n.send(:normalize_translation_keys, locale, key, options[:scope])
-      keys << 'no key' if keys.size < 2
-      super "translation missing: #{keys.join(', ')}"
-    end
-  end
-  class InvalidPluralizationData < ArgumentError
-    attr_reader :entry, :count
-    def initialize(entry, count)
-      @entry, @count = entry, count
-      super "translation data #{entry.inspect} can not be used with :count => #{count}"
-    end
-  end
-  class MissingInterpolationArgument < ArgumentError
-    attr_reader :key, :string
-    def initialize(key, string)
-      @key, @string = key, string
-      super "interpolation argument #{key} missing in #{string.inspect}"
-    end
-  end
-  class ReservedInterpolationKey < ArgumentError
-    attr_reader :key, :string
-    def initialize(key, string)
-      @key, @string = key, string
-      super "reserved key #{key.inspect} used in #{string.inspect}"
-    end
-  end
-  class UnknownFileType < ArgumentError
-    attr_reader :type, :filename
-    def initialize(type, filename)
-      @type, @filename = type, filename
-      super "can not load translations from #{filename}, the file type #{type} is not known"
-    end
-  end
-end