backbone-deep-rails 0.0.2 → 0.0.3

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/json/variable.rb

@@ -1,9 +0,0 @@
-module ActiveSupport
-  module JSON
-    # A string that returns itself as its JSON-encoded form.
-    class Variable < String
-      def as_json(options = nil) self end #:nodoc:
-      def encode_json(encoder) self end #:nodoc:
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/lazy_load_hooks.rb

@@ -1,46 +0,0 @@
-# lazy_load_hooks allows rails to lazily load a lot of components and thus making the app boot faster. Because of
-# this feature now there is no need to require <tt>ActiveRecord::Base</tt> at boot time purely to apply configuration. Instead
-# a hook is registered that applies configuration once <tt>ActiveRecord::Base</tt> is loaded. Here <tt>ActiveRecord::Base</tt> is used
-# as example but this feature can be applied elsewhere too.
-#
-# Here is an example where +on_load+ method is called to register a hook.
-#
-#   initializer "active_record.initialize_timezone" do
-#     ActiveSupport.on_load(:active_record) do
-#       self.time_zone_aware_attributes = true
-#       self.default_timezone = :utc
-#     end
-#   end
-#
-# When the entirety of +activerecord/lib/active_record/base.rb+ has been evaluated then +run_load_hooks+ is invoked.
-# The very last line of +activerecord/lib/active_record/base.rb+ is:
-#
-#   ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
-#
-module ActiveSupport
-  @load_hooks = Hash.new { |h,k| h[k] = [] }
-  @loaded = Hash.new { |h,k| h[k] = [] }
-
-  def self.on_load(name, options = {}, &block)
-    @loaded[name].each do |base|
-      execute_hook(base, options, block)
-    end
-
-    @load_hooks[name] << [block, options]
-  end
-
-  def self.execute_hook(base, options, block)
-    if options[:yield]
-      block.call(base)
-    else
-      base.instance_eval(&block)
-    end
-  end
-
-  def self.run_load_hooks(name, base = Object)
-    @loaded[name] << base
-    @load_hooks[name].each do |hook, options|
-      execute_hook(base, options, hook)
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/locale/en.yml

@@ -1,36 +0,0 @@
-en:
-  date:
-    formats:
-      # Use the strftime parameters for formats.
-      # When no format has been given, it uses default.
-      # You can provide other formats here if you like!
-      default: "%Y-%m-%d"
-      short: "%b %d"
-      long: "%B %d, %Y"
-
-    day_names: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
-    abbr_day_names: [Sun, Mon, Tue, Wed, Thu, Fri, Sat]
-
-    # Don't forget the nil at the beginning; there's no such thing as a 0th month
-    month_names: [~, January, February, March, April, May, June, July, August, September, October, November, December]
-    abbr_month_names: [~, Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec]
-    # Used in date_select and datetime_select.
-    order:
-      - :year
-      - :month
-      - :day
-
-  time:
-    formats:
-      default: "%a, %d %b %Y %H:%M:%S %z"
-      short: "%d %b %H:%M"
-      long: "%B %d, %Y %H:%M"
-    am: "am"
-    pm: "pm"
-
-# Used in array.to_sentence.
-  support:
-    array:
-      words_connector: ", "
-      two_words_connector: " and "
-      last_word_connector: ", and "

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/log_subscriber.rb

@@ -1,122 +0,0 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/class/attribute'
-
-module ActiveSupport
-  # ActiveSupport::LogSubscriber is an object set to consume ActiveSupport::Notifications
-  # with the sole purpose of logging them. The log subscriber dispatches notifications to 
-  # a registered object based on its given namespace.
-  #
-  # An example would be Active Record log subscriber responsible for logging queries:
-  #
-  #   module ActiveRecord
-  #     class LogSubscriber < ActiveSupport::LogSubscriber
-  #       def sql(event)
-  #         "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
-  #       end
-  #     end
-  #   end
-  #
-  # And it's finally registered as:
-  #
-  #   ActiveRecord::LogSubscriber.attach_to :active_record
-  #
-  # Since we need to know all instance methods before attaching the log subscriber,
-  # the line above should be called after your <tt>ActiveRecord::LogSubscriber</tt> definition.
-  #
-  # After configured, whenever a "sql.active_record" notification is published,
-  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
-  # the sql method.
-  #
-  # Log subscriber also has some helpers to deal with logging and automatically flushes
-  # all logs when the request finishes (via action_dispatch.callback notification) in
-  # a Rails environment.
-  class LogSubscriber
-    # Embed in a String to clear all previous ANSI sequences.
-    CLEAR   = "\e[0m"
-    BOLD    = "\e[1m"
-
-    # Colors
-    BLACK   = "\e[30m"
-    RED     = "\e[31m"
-    GREEN   = "\e[32m"
-    YELLOW  = "\e[33m"
-    BLUE    = "\e[34m"
-    MAGENTA = "\e[35m"
-    CYAN    = "\e[36m"
-    WHITE   = "\e[37m"
-
-    mattr_accessor :colorize_logging
-    self.colorize_logging = true
-
-    class_attribute :logger
-
-    class << self
-      remove_method :logger
-      def logger
-        @logger ||= Rails.logger if defined?(Rails)
-      end
-
-      def attach_to(namespace, log_subscriber=new, notifier=ActiveSupport::Notifications)
-        log_subscribers << log_subscriber
-        @@flushable_loggers = nil
-
-        log_subscriber.public_methods(false).each do |event|
-          next if 'call' == event.to_s
-
-          notifier.subscribe("#{event}.#{namespace}", log_subscriber)
-        end
-      end
-
-      def log_subscribers
-        @@log_subscribers ||= []
-      end
-
-      def flushable_loggers
-        @@flushable_loggers ||= begin
-          loggers = log_subscribers.map(&:logger)
-          loggers.uniq!
-          loggers.select { |l| l.respond_to?(:flush) }
-        end
-      end
-
-      # Flush all log_subscribers' logger.
-      def flush_all!
-        flushable_loggers.each { |log| log.flush }
-      end
-    end
-
-    def call(message, *args)
-      return unless logger
-
-      method = message.split('.').first
-      begin
-        send(method, ActiveSupport::Notifications::Event.new(message, *args))
-      rescue Exception => e
-        logger.error "Could not log #{message.inspect} event. #{e.class}: #{e.message}"
-      end
-    end
-
-  protected
-
-    %w(info debug warn error fatal unknown).each do |level|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{level}(*args, &block)
-          return unless logger
-          logger.#{level}(*args, &block)
-        end
-      METHOD
-    end
-
-    # Set color by using a string or one of the defined constants. If a third
-    # option is set to true, it also adds bold to the string. This is based
-    # on the Highline implementation and will automatically append CLEAR to the
-    # end of the returned String.
-    #
-    def color(text, color, bold=false)
-      return text unless colorize_logging
-      color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
-      bold  = bold ? BOLD : ""
-      "#{bold}#{color}#{text}#{CLEAR}"
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/log_subscriber/test_helper.rb

@@ -1,101 +0,0 @@
-require 'active_support/log_subscriber'
-require 'active_support/buffered_logger'
-require 'active_support/notifications'
-
-module ActiveSupport
-  class LogSubscriber
-    # Provides some helpers to deal with testing log subscribers by setting up
-    # notifications. Take for instance Active Record subscriber tests:
-    #
-    #   class SyncLogSubscriberTest < ActiveSupport::TestCase
-    #     include ActiveSupport::LogSubscriber::TestHelper
-    #
-    #     def setup
-    #       ActiveRecord::LogSubscriber.attach_to(:active_record)
-    #     end
-    #
-    #     def test_basic_query_logging
-    #       Developer.all
-    #       wait
-    #       assert_equal 1, @logger.logged(:debug).size
-    #       assert_match(/Developer Load/, @logger.logged(:debug).last)
-    #       assert_match(/SELECT \* FROM "developers"/, @logger.logged(:debug).last)
-    #     end
-    #   end
-    #
-    # All you need to do is to ensure that your log subscriber is added to Rails::Subscriber,
-    # as in the second line of the code above. The test helpers are responsible for setting
-    # up the queue, subscriptions and turning colors in logs off.
-    #
-    # The messages are available in the @logger instance, which is a logger with limited
-    # powers (it actually does not send anything to your output), and you can collect them
-    # doing @logger.logged(level), where level is the level used in logging, like info,
-    # debug, warn and so on.
-    #
-    module TestHelper
-      def setup
-        @logger   = MockLogger.new
-        @notifier = ActiveSupport::Notifications::Fanout.new
-
-        ActiveSupport::LogSubscriber.colorize_logging = false
-
-        @old_notifier = ActiveSupport::Notifications.notifier
-        set_logger(@logger)
-        ActiveSupport::Notifications.notifier = @notifier
-      end
-
-      def teardown
-        set_logger(nil)
-        ActiveSupport::Notifications.notifier = @old_notifier
-      end
-
-      class MockLogger
-        include ActiveSupport::BufferedLogger::Severity
-
-        attr_reader :flush_count
-        attr_accessor :level
-
-        def initialize(level = DEBUG)
-          @flush_count = 0
-          @level = level
-          @logged = Hash.new { |h,k| h[k] = [] }
-        end
-
-        def method_missing(level, message)
-          @logged[level] << message
-        end
-
-        def logged(level)
-          @logged[level].compact.map { |l| l.to_s.strip }
-        end
-
-        def flush
-          @flush_count += 1
-        end
-
-        ActiveSupport::BufferedLogger::Severity.constants.each do |severity|
-          class_eval <<-EOT, __FILE__, __LINE__ + 1
-            def #{severity.downcase}?
-              #{severity} >= @level
-            end
-          EOT
-        end
-      end
-
-      # Wait notifications to be published.
-      def wait
-        @notifier.wait
-      end
-
-      # Overwrite if you use another logger in your log subscriber:
-      #
-      #   def logger
-      #     ActiveRecord::Base.logger = @logger
-      #   end
-      #
-      def set_logger(logger)
-        ActiveSupport::LogSubscriber.logger = logger
-      end
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/memoizable.rb

@@ -1,116 +0,0 @@
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/deprecation'
-
-module ActiveSupport
-  module Memoizable
-    def self.extended(base)
-      ActiveSupport::Deprecation.warn "ActiveSupport::Memoizable is deprecated and will be removed in future releases," \
-        "simply use Ruby memoization pattern instead.", caller
-      super
-    end
-
-    def self.memoized_ivar_for(symbol)
-      "@_memoized_#{symbol.to_s.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')}".to_sym
-    end
-
-    module InstanceMethods
-      def self.included(base)
-        base.class_eval do
-          unless base.method_defined?(:freeze_without_memoizable)
-            alias_method_chain :freeze, :memoizable
-          end
-        end
-      end
-
-      def freeze_with_memoizable
-        memoize_all unless frozen?
-        freeze_without_memoizable
-      end
-
-      def memoize_all
-        prime_cache ".*"
-      end
-
-      def unmemoize_all
-        flush_cache ".*"
-      end
-
-      def prime_cache(*syms)
-        syms.each do |sym|
-          methods.each do |m|
-            if m.to_s =~ /^_unmemoized_(#{sym})/
-              if method(m).arity == 0
-                __send__($1)
-              else
-                ivar = ActiveSupport::Memoizable.memoized_ivar_for($1)
-                instance_variable_set(ivar, {})
-              end
-            end
-          end
-        end
-      end
-
-      def flush_cache(*syms)
-        syms.each do |sym|
-          (methods + private_methods + protected_methods).each do |m|
-            if m.to_s =~ /^_unmemoized_(#{sym.to_s.gsub(/\?\Z/, '\?')})/
-              ivar = ActiveSupport::Memoizable.memoized_ivar_for($1)
-              instance_variable_get(ivar).clear if instance_variable_defined?(ivar)
-            end
-          end
-        end
-      end
-    end
-
-    def memoize(*symbols)
-      symbols.each do |symbol|
-        original_method = :"_unmemoized_#{symbol}"
-        memoized_ivar = ActiveSupport::Memoizable.memoized_ivar_for(symbol)
-
-        class_eval <<-EOS, __FILE__, __LINE__ + 1
-          include InstanceMethods                                                  # include InstanceMethods
-                                                                                   #
-          if method_defined?(:#{original_method})                                  # if method_defined?(:_unmemoized_mime_type)
-            raise "Already memoized #{symbol}"                                     #   raise "Already memoized mime_type"
-          end                                                                      # end
-          alias #{original_method} #{symbol}                                       # alias _unmemoized_mime_type mime_type
-                                                                                   #
-          if instance_method(:#{symbol}).arity == 0                                # if instance_method(:mime_type).arity == 0
-            def #{symbol}(reload = false)                                          #   def mime_type(reload = false)
-              if reload || !defined?(#{memoized_ivar}) || #{memoized_ivar}.empty?  #     if reload || !defined?(@_memoized_mime_type) || @_memoized_mime_type.empty?
-                #{memoized_ivar} = [#{original_method}]                            #       @_memoized_mime_type = [_unmemoized_mime_type]
-              end                                                                  #     end
-              #{memoized_ivar}[0]                                                  #     @_memoized_mime_type[0]
-            end                                                                    #   end
-          else                                                                     # else
-            def #{symbol}(*args)                                                   #   def mime_type(*args)
-              #{memoized_ivar} ||= {} unless frozen?                               #     @_memoized_mime_type ||= {} unless frozen?
-              args_length = method(:#{original_method}).arity                      #     args_length = method(:_unmemoized_mime_type).arity
-              if args.length == args_length + 1 &&                                 #     if args.length == args_length + 1 &&
-                (args.last == true || args.last == :reload)                        #       (args.last == true || args.last == :reload)
-                reload = args.pop                                                  #       reload = args.pop
-              end                                                                  #     end
-                                                                                   #
-              if defined?(#{memoized_ivar}) && #{memoized_ivar}                    #     if defined?(@_memoized_mime_type) && @_memoized_mime_type
-                if !reload && #{memoized_ivar}.has_key?(args)                      #       if !reload && @_memoized_mime_type.has_key?(args)
-                  #{memoized_ivar}[args]                                           #         @_memoized_mime_type[args]
-                elsif #{memoized_ivar}                                             #       elsif @_memoized_mime_type
-                  #{memoized_ivar}[args] = #{original_method}(*args)               #         @_memoized_mime_type[args] = _unmemoized_mime_type(*args)
-                end                                                                #       end
-              else                                                                 #     else
-                #{original_method}(*args)                                          #       _unmemoized_mime_type(*args)
-              end                                                                  #     end
-            end                                                                    #   end
-          end                                                                      # end
-                                                                                   #
-          if private_method_defined?(#{original_method.inspect})                   # if private_method_defined?(:_unmemoized_mime_type)
-            private #{symbol.inspect}                                              #   private :mime_type
-          elsif protected_method_defined?(#{original_method.inspect})              # elsif protected_method_defined?(:_unmemoized_mime_type)
-            protected #{symbol.inspect}                                            #   protected :mime_type
-          end                                                                      # end
-        EOS
-      end
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/message_encryptor.rb

@@ -1,103 +0,0 @@
-require 'openssl'
-require 'active_support/base64'
-
-module ActiveSupport
-  # MessageEncryptor is a simple way to encrypt values which get stored somewhere
-  # you don't trust.
-  #
-  # The cipher text and initialization vector are base64 encoded and returned to you.
-  #
-  # This can be used in situations similar to the <tt>MessageVerifier</tt>, but where you don't
-  # want users to be able to determine the value of the payload.
-  class MessageEncryptor
-    module NullSerializer #:nodoc:
-      def self.load(value)
-        value
-      end
-
-      def self.dump(value)
-        value
-      end
-    end
-
-    class InvalidMessage < StandardError; end
-    OpenSSLCipherError = OpenSSL::Cipher.const_defined?(:CipherError) ? OpenSSL::Cipher::CipherError : OpenSSL::CipherError
-
-    def initialize(secret, options = {})
-      unless options.is_a?(Hash)
-        ActiveSupport::Deprecation.warn "The second parameter should be an options hash. Use :cipher => 'algorithm' to specify the cipher algorithm."
-        options = { :cipher => options }
-      end
-
-      @secret = secret
-      @cipher = options[:cipher] || 'aes-256-cbc'
-      @verifier = MessageVerifier.new(@secret, :serializer => NullSerializer)
-      @serializer = options[:serializer] || Marshal
-    end
-
-    def encrypt(value)
-      ActiveSupport::Deprecation.warn "MessageEncryptor#encrypt is deprecated as it is not safe without a signature. " \
-        "Please use MessageEncryptor#encrypt_and_sign instead."
-      _encrypt(value)
-    end
-
-    def decrypt(value)
-      ActiveSupport::Deprecation.warn "MessageEncryptor#decrypt is deprecated as it is not safe without a signature. " \
-        "Please use MessageEncryptor#decrypt_and_verify instead."
-      _decrypt(value)
-    end
-
-    # Encrypt and sign a message. We need to sign the message in order to avoid padding attacks.
-    # Reference: http://www.limited-entropy.com/padding-oracle-attacks
-    def encrypt_and_sign(value)
-      verifier.generate(_encrypt(value))
-    end
-
-    # Decrypt and verify a message. We need to verify the message in order to avoid padding attacks.
-    # Reference: http://www.limited-entropy.com/padding-oracle-attacks
-    def decrypt_and_verify(value)
-      _decrypt(verifier.verify(value))
-    end
-
-    private
-
-    def _encrypt(value)
-      cipher = new_cipher
-      # Rely on OpenSSL for the initialization vector
-      iv = cipher.random_iv
-
-      cipher.encrypt
-      cipher.key = @secret
-      cipher.iv  = iv
-
-      encrypted_data = cipher.update(@serializer.dump(value))
-      encrypted_data << cipher.final
-
-      [encrypted_data, iv].map {|v| ::Base64.strict_encode64(v)}.join("--")
-    end
-
-    def _decrypt(encrypted_message)
-      cipher = new_cipher
-      encrypted_data, iv = encrypted_message.split("--").map {|v| ::Base64.decode64(v)}
-
-      cipher.decrypt
-      cipher.key = @secret
-      cipher.iv  = iv
-
-      decrypted_data = cipher.update(encrypted_data)
-      decrypted_data << cipher.final
-
-      @serializer.load(decrypted_data)
-    rescue OpenSSLCipherError, TypeError
-      raise InvalidMessage
-    end
-
-    def new_cipher
-      OpenSSL::Cipher::Cipher.new(@cipher)
-    end
-
-    def verifier
-      @verifier
-    end
-  end
-end