webroar 0.2.2 → 0.2.3

data/src/admin_panel/vendor/rails/activesupport/lib/active_support/cache/synchronized_memory_store.rb

@@ -1,47 +0,0 @@
-module ActiveSupport
-  module Cache
-    # Like MemoryStore, but thread-safe.
-    class SynchronizedMemoryStore < MemoryStore
-      def initialize
-        super
-        @guard = Monitor.new
-      end
-
-      def fetch(key, options = {})
-        @guard.synchronize { super }
-      end
-
-      def read(name, options = nil)
-        @guard.synchronize { super }
-      end
-
-      def write(name, value, options = nil)
-        @guard.synchronize { super }
-      end
-
-      def delete(name, options = nil)
-        @guard.synchronize { super }
-      end
-
-      def delete_matched(matcher, options = nil)
-        @guard.synchronize { super }
-      end
-
-      def exist?(name,options = nil)
-        @guard.synchronize { super }
-      end
-
-      def increment(key, amount = 1)
-        @guard.synchronize { super }
-      end
-
-      def decrement(key, amount = 1)
-        @guard.synchronize { super }
-      end
-
-      def clear
-        @guard.synchronize { super }
-      end
-    end
-  end
-end

data/src/admin_panel/vendor/rails/activesupport/lib/active_support/cache.rb

@@ -1,228 +0,0 @@
-require 'benchmark'
-
-module ActiveSupport
-  # See ActiveSupport::Cache::Store for documentation.
-  module Cache
-    autoload :FileStore, 'active_support/cache/file_store'
-    autoload :MemoryStore, 'active_support/cache/memory_store'
-    autoload :SynchronizedMemoryStore, 'active_support/cache/synchronized_memory_store'
-    autoload :DRbStore, 'active_support/cache/drb_store'
-    autoload :MemCacheStore, 'active_support/cache/mem_cache_store'
-    autoload :CompressedMemCacheStore, 'active_support/cache/compressed_mem_cache_store'
-
-    module Strategy
-      autoload :LocalCache, 'active_support/cache/strategy/local_cache'
-    end
-
-    # Creates a new CacheStore object according to the given options.
-    #
-    # If no arguments are passed to this method, then a new
-    # ActiveSupport::Cache::MemoryStore object will be returned.
-    #
-    # If you pass a Symbol as the first argument, then a corresponding cache
-    # store class under the ActiveSupport::Cache namespace will be created.
-    # For example:
-    #
-    #   ActiveSupport::Cache.lookup_store(:memory_store)
-    #   # => returns a new ActiveSupport::Cache::MemoryStore object
-    #   
-    #   ActiveSupport::Cache.lookup_store(:drb_store)
-    #   # => returns a new ActiveSupport::Cache::DRbStore object
-    #
-    # Any additional arguments will be passed to the corresponding cache store
-    # class's constructor:
-    #
-    #   ActiveSupport::Cache.lookup_store(:file_store, "/tmp/cache")
-    #   # => same as: ActiveSupport::Cache::FileStore.new("/tmp/cache")
-    #
-    # If the first argument is not a Symbol, then it will simply be returned:
-    #
-    #   ActiveSupport::Cache.lookup_store(MyOwnCacheStore.new)
-    #   # => returns MyOwnCacheStore.new
-    def self.lookup_store(*store_option)
-      store, *parameters = *([ store_option ].flatten)
-
-      case store
-      when Symbol
-        store_class_name = (store == :drb_store ? "DRbStore" : store.to_s.camelize)
-        store_class = ActiveSupport::Cache.const_get(store_class_name)
-        store_class.new(*parameters)
-      when nil
-        ActiveSupport::Cache::MemoryStore.new
-      else
-        store
-      end
-    end
-
-    def self.expand_cache_key(key, namespace = nil)
-      expanded_cache_key = namespace ? "#{namespace}/" : ""
-
-      if ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]
-        expanded_cache_key << "#{ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]}/"
-      end
-
-      expanded_cache_key << case
-        when key.respond_to?(:cache_key)
-          key.cache_key
-        when key.is_a?(Array)
-          key.collect { |element| expand_cache_key(element) }.to_param
-        when key
-          key.to_param
-        end.to_s
-
-      expanded_cache_key
-    end
-
-    # An abstract cache store class. There are multiple cache store
-    # implementations, each having its own additional features. See the classes
-    # under the ActiveSupport::Cache module, e.g.
-    # ActiveSupport::Cache::MemCacheStore. MemCacheStore is currently the most
-    # popular cache store for large production websites.
-    #
-    # ActiveSupport::Cache::Store is meant for caching strings. Some cache
-    # store implementations, like MemoryStore, are able to cache arbitrary
-    # Ruby objects, but don't count on every cache store to be able to do that.
-    #
-    #   cache = ActiveSupport::Cache::MemoryStore.new
-    #   
-    #   cache.read("city")   # => nil
-    #   cache.write("city", "Duckburgh")
-    #   cache.read("city")   # => "Duckburgh"
-    class Store
-      cattr_accessor :logger
-
-      def silence!
-        @silence = true
-        self
-      end
-
-      # Fetches data from the cache, using the given key. If there is data in
-      # the cache with the given key, then that data is returned.
-      #
-      # If there is no such data in the cache (a cache miss occurred), then
-      # then nil will be returned. However, if a block has been passed, then
-      # that block will be run in the event of a cache miss. The return value
-      # of the block will be written to the cache under the given cache key,
-      # and that return value will be returned.
-      #
-      #   cache.write("today", "Monday")
-      #   cache.fetch("today")  # => "Monday"
-      #   
-      #   cache.fetch("city")   # => nil
-      #   cache.fetch("city") do
-      #     "Duckburgh"
-      #   end
-      #   cache.fetch("city")   # => "Duckburgh"
-      #
-      # You may also specify additional options via the +options+ argument.
-      # Setting <tt>:force => true</tt> will force a cache miss:
-      #
-      #   cache.write("today", "Monday")
-      #   cache.fetch("today", :force => true)  # => nil
-      #
-      # Other options will be handled by the specific cache store implementation.
-      # Internally, #fetch calls #read, and calls #write on a cache miss.
-      # +options+ will be passed to the #read and #write calls.
-      #
-      # For example, MemCacheStore's #write method supports the +:expires_in+
-      # option, which tells the memcached server to automatically expire the
-      # cache item after a certain period. We can use this option with #fetch
-      # too:
-      #
-      #   cache = ActiveSupport::Cache::MemCacheStore.new
-      #   cache.fetch("foo", :force => true, :expires_in => 5.seconds) do
-      #     "bar"
-      #   end
-      #   cache.fetch("foo")  # => "bar"
-      #   sleep(6)
-      #   cache.fetch("foo")  # => nil
-      def fetch(key, options = {})
-        @logger_off = true
-        if !options[:force] && value = read(key, options)
-          @logger_off = false
-          log("hit", key, options)
-          value
-        elsif block_given?
-          @logger_off = false
-          log("miss", key, options)
-
-          value = nil
-          ms = Benchmark.ms { value = yield }
-
-          @logger_off = true
-          write(key, value, options)
-          @logger_off = false
-
-          log('write (will save %.2fms)' % ms, key, nil)
-
-          value
-        end
-      end
-
-      # Fetches data from the cache, using the given key. If there is data in
-      # the cache with the given key, then that data is returned. Otherwise,
-      # nil is returned.
-      #
-      # You may also specify additional options via the +options+ argument.
-      # The specific cache store implementation will decide what to do with
-      # +options+.
-      def read(key, options = nil)
-        log("read", key, options)
-      end
-
-      # Writes the given value to the cache, with the given key.
-      #
-      # You may also specify additional options via the +options+ argument.
-      # The specific cache store implementation will decide what to do with
-      # +options+.
-      # 
-      # For example, MemCacheStore supports the +:expires_in+ option, which
-      # tells the memcached server to automatically expire the cache item after
-      # a certain period:
-      #
-      #   cache = ActiveSupport::Cache::MemCacheStore.new
-      #   cache.write("foo", "bar", :expires_in => 5.seconds)
-      #   cache.read("foo")  # => "bar"
-      #   sleep(6)
-      #   cache.read("foo")  # => nil
-      def write(key, value, options = nil)
-        log("write", key, options)
-      end
-
-      def delete(key, options = nil)
-        log("delete", key, options)
-      end
-
-      def delete_matched(matcher, options = nil)
-        log("delete matched", matcher.inspect, options)
-      end
-
-      def exist?(key, options = nil)
-        log("exist?", key, options)
-      end
-
-      def increment(key, amount = 1)
-        log("incrementing", key, amount)
-        if num = read(key)
-          write(key, num + amount)
-        else
-          nil
-        end
-      end
-
-      def decrement(key, amount = 1)
-        log("decrementing", key, amount)
-        if num = read(key)
-          write(key, num - amount)
-        else
-          nil
-        end
-      end
-
-      private
-        def log(operation, key, options)
-          logger.debug("Cache #{operation}: #{key}#{options ? " (#{options.inspect})" : ""}") if logger && !@silence && !@logger_off
-        end
-    end
-  end
-end

data/src/admin_panel/vendor/rails/activesupport/lib/active_support/callbacks.rb

@@ -1,279 +0,0 @@
-module ActiveSupport
-  # Callbacks are hooks into the lifecycle of an object that allow you to trigger logic
-  # before or after an alteration of the object state.
-  #
-  # Mixing in this module allows you to define callbacks in your class.
-  #
-  # Example:
-  #   class Storage
-  #     include ActiveSupport::Callbacks
-  #
-  #     define_callbacks :before_save, :after_save
-  #   end
-  #
-  #   class ConfigStorage < Storage
-  #     before_save :saving_message
-  #     def saving_message
-  #       puts "saving..."
-  #     end
-  #
-  #     after_save do |object|
-  #       puts "saved"
-  #     end
-  #
-  #     def save
-  #       run_callbacks(:before_save)
-  #       puts "- save"
-  #       run_callbacks(:after_save)
-  #     end
-  #   end
-  #
-  #   config = ConfigStorage.new
-  #   config.save
-  #
-  # Output:
-  #   saving...
-  #   - save
-  #   saved
-  #
-  # Callbacks from parent classes are inherited.
-  #
-  # Example:
-  #   class Storage
-  #     include ActiveSupport::Callbacks
-  #
-  #     define_callbacks :before_save, :after_save
-  #
-  #     before_save :prepare
-  #     def prepare
-  #       puts "preparing save"
-  #     end
-  #   end
-  #
-  #   class ConfigStorage < Storage
-  #     before_save :saving_message
-  #     def saving_message
-  #       puts "saving..."
-  #     end
-  #
-  #     after_save do |object|
-  #       puts "saved"
-  #     end
-  #
-  #     def save
-  #       run_callbacks(:before_save)
-  #       puts "- save"
-  #       run_callbacks(:after_save)
-  #     end
-  #   end
-  #
-  #   config = ConfigStorage.new
-  #   config.save
-  #
-  # Output:
-  #   preparing save
-  #   saving...
-  #   - save
-  #   saved
-  module Callbacks
-    class CallbackChain < Array
-      def self.build(kind, *methods, &block)
-        methods, options = extract_options(*methods, &block)
-        methods.map! { |method| Callback.new(kind, method, options) }
-        new(methods)
-      end
-
-      def run(object, options = {}, &terminator)
-        enumerator = options[:enumerator] || :each
-
-        unless block_given?
-          send(enumerator) { |callback| callback.call(object) }
-        else
-          send(enumerator) do |callback|
-            result = callback.call(object)
-            break result if terminator.call(result, object)
-          end
-        end
-      end
-
-      # TODO: Decompose into more Array like behavior
-      def replace_or_append!(chain)
-        if index = index(chain)
-          self[index] = chain
-        else
-          self << chain
-        end
-        self
-      end
-
-      def find(callback, &block)
-        select { |c| c == callback && (!block_given? || yield(c)) }.first
-      end
-
-      def delete(callback)
-        super(callback.is_a?(Callback) ? callback : find(callback))
-      end
-
-      private
-        def self.extract_options(*methods, &block)
-          methods.flatten!
-          options = methods.extract_options!
-          methods << block if block_given?
-          return methods, options
-        end
-
-        def extract_options(*methods, &block)
-          self.class.extract_options(*methods, &block)
-        end
-    end
-
-    class Callback
-      attr_reader :kind, :method, :identifier, :options
-
-      def initialize(kind, method, options = {})
-        @kind       = kind
-        @method     = method
-        @identifier = options[:identifier]
-        @options    = options
-      end
-
-      def ==(other)
-        case other
-        when Callback
-          (self.identifier && self.identifier == other.identifier) || self.method == other.method
-        else
-          (self.identifier && self.identifier == other) || self.method == other
-        end
-      end
-
-      def eql?(other)
-        self == other
-      end
-
-      def dup
-        self.class.new(@kind, @method, @options.dup)
-      end
-
-      def hash
-        if @identifier
-          @identifier.hash
-        else
-          @method.hash
-        end
-      end
-
-      def call(*args, &block)
-        evaluate_method(method, *args, &block) if should_run_callback?(*args)
-      rescue LocalJumpError
-        raise ArgumentError,
-          "Cannot yield from a Proc type filter. The Proc must take two " +
-          "arguments and execute #call on the second argument."
-      end
-
-      private
-        def evaluate_method(method, *args, &block)
-          case method
-            when Symbol
-              object = args.shift
-              object.send(method, *args, &block)
-            when String
-              eval(method, args.first.instance_eval { binding })
-            when Proc, Method
-              method.call(*args, &block)
-            else
-              if method.respond_to?(kind)
-                method.send(kind, *args, &block)
-              else
-                raise ArgumentError,
-                  "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
-                  "a block to be invoked, or an object responding to the callback method."
-              end
-          end
-        end
-
-        def should_run_callback?(*args)
-          [options[:if]].flatten.compact.all? { |a| evaluate_method(a, *args) } &&
-          ![options[:unless]].flatten.compact.any? { |a| evaluate_method(a, *args) }
-        end
-    end
-
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def define_callbacks(*callbacks)
-        callbacks.each do |callback|
-          class_eval <<-"end_eval"
-            def self.#{callback}(*methods, &block)                             # def self.before_save(*methods, &block)
-              callbacks = CallbackChain.build(:#{callback}, *methods, &block)  #   callbacks = CallbackChain.build(:before_save, *methods, &block)
-              @#{callback}_callbacks ||= CallbackChain.new                     #   @before_save_callbacks ||= CallbackChain.new
-              @#{callback}_callbacks.concat callbacks                          #   @before_save_callbacks.concat callbacks
-            end                                                                # end
-                                                                               #
-            def self.#{callback}_callback_chain                                # def self.before_save_callback_chain
-              @#{callback}_callbacks ||= CallbackChain.new                     #   @before_save_callbacks ||= CallbackChain.new
-                                                                               #
-              if superclass.respond_to?(:#{callback}_callback_chain)           #   if superclass.respond_to?(:before_save_callback_chain)
-                CallbackChain.new(                                             #     CallbackChain.new(
-                  superclass.#{callback}_callback_chain +                      #       superclass.before_save_callback_chain +
-                  @#{callback}_callbacks                                       #       @before_save_callbacks
-                )                                                              #     )
-              else                                                             #   else
-                @#{callback}_callbacks                                         #     @before_save_callbacks
-              end                                                              #   end
-            end                                                                # end
-          end_eval
-        end
-      end
-    end
-
-    # Runs all the callbacks defined for the given options.
-    #
-    # If a block is given it will be called after each callback receiving as arguments:
-    #
-    #  * the result from the callback
-    #  * the object which has the callback
-    #
-    # If the result from the block evaluates to false, the callback chain is stopped.
-    #
-    # Example:
-    #   class Storage
-    #     include ActiveSupport::Callbacks
-    #
-    #     define_callbacks :before_save, :after_save
-    #   end
-    #
-    #   class ConfigStorage < Storage
-    #     before_save :pass
-    #     before_save :pass
-    #     before_save :stop
-    #     before_save :pass
-    #
-    #     def pass
-    #       puts "pass"
-    #     end
-    #
-    #     def stop
-    #       puts "stop"
-    #       return false
-    #     end
-    #
-    #     def save
-    #       result = run_callbacks(:before_save) { |result, object| result == false }
-    #       puts "- save" if result
-    #     end
-    #   end
-    #
-    #   config = ConfigStorage.new
-    #   config.save
-    #
-    # Output:
-    #   pass
-    #   pass
-    #   stop
-    def run_callbacks(kind, options = {}, &block)
-      self.class.send("#{kind}_callback_chain").run(self, options, &block)
-    end
-  end
-end

data/src/admin_panel/vendor/rails/activesupport/lib/active_support/core_ext/array/access.rb

@@ -1,53 +0,0 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Array #:nodoc:
-      # Makes it easier to access parts of an array.
-      module Access
-        # Returns the tail of the array from +position+.
-        #
-        #   %w( a b c d ).from(0)  # => %w( a b c d )
-        #   %w( a b c d ).from(2)  # => %w( c d )
-        #   %w( a b c d ).from(10) # => nil
-        #   %w().from(0)           # => nil
-        def from(position)
-          self[position..-1]
-        end
-        
-        # Returns the beginning of the array up to +position+.
-        #
-        #   %w( a b c d ).to(0)  # => %w( a )
-        #   %w( a b c d ).to(2)  # => %w( a b c )
-        #   %w( a b c d ).to(10) # => %w( a b c d )
-        #   %w().to(0)           # => %w()
-        def to(position)
-          self[0..position]
-        end
-
-        # Equal to <tt>self[1]</tt>.
-        def second
-          self[1]
-        end
-
-        # Equal to <tt>self[2]</tt>.
-        def third
-          self[2]
-        end
-
-        # Equal to <tt>self[3]</tt>.
-        def fourth
-          self[3]
-        end
-
-        # Equal to <tt>self[4]</tt>.
-        def fifth
-          self[4]
-        end
-
-        # Equal to <tt>self[41]</tt>. Also known as accessing "the reddit".
-        def forty_two
-          self[41]
-        end
-      end
-    end
-  end
-end