social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/cache/compressed_mem_cache_store.rb

@@ -1,13 +0,0 @@
-module ActiveSupport
-  module Cache
-    class CompressedMemCacheStore < MemCacheStore
-      def initialize(*args)
-        ActiveSupport::Deprecation.warn('ActiveSupport::Cache::CompressedMemCacheStore has been deprecated in favor of ActiveSupport::Cache::MemCacheStore(:compress => true).', caller)
-        addresses = args.dup
-        options = addresses.extract_options!
-        args = addresses + [options.merge(:compress => true)]
-        super(*args)
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/cache/file_store.rb

@@ -1,189 +0,0 @@
-require 'active_support/core_ext/file/atomic'
-require 'active_support/core_ext/string/conversions'
-
-module ActiveSupport
-  module Cache
-    # A cache store implementation which stores everything on the filesystem.
-    #
-    # FileStore implements the Strategy::LocalCache strategy which implements
-    # an in memory cache inside of a block.
-    class FileStore < Store
-      attr_reader :cache_path
-
-      DIR_FORMATTER = "%03X"
-      ESCAPE_FILENAME_CHARS = /[^a-z0-9_.-]/i
-      UNESCAPE_FILENAME_CHARS = /%[0-9A-F]{2}/
-
-      def initialize(cache_path, options = nil)
-        super(options)
-        @cache_path = cache_path
-        extend Strategy::LocalCache
-      end
-
-      def clear(options = nil)
-        root_dirs = Dir.entries(cache_path).reject{|f| ['.', '..'].include?(f)}
-        FileUtils.rm_r(root_dirs.collect{|f| File.join(cache_path, f)})
-      end
-
-      def cleanup(options = nil)
-        options = merged_options(options)
-        each_key(options) do |key|
-          entry = read_entry(key, options)
-          delete_entry(key, options) if entry && entry.expired?
-        end
-      end
-
-      def increment(name, amount = 1, options = nil)
-        file_name = key_file_path(namespaced_key(name, options))
-        lock_file(file_name) do
-          options = merged_options(options)
-          if num = read(name, options)
-            num = num.to_i + amount
-            write(name, num, options)
-            num
-          else
-            nil
-          end
-        end
-      end
-
-      def decrement(name, amount = 1, options = nil)
-        file_name = key_file_path(namespaced_key(name, options))
-        lock_file(file_name) do
-          options = merged_options(options)
-          if num = read(name, options)
-            num = num.to_i - amount
-            write(name, num, options)
-            num
-          else
-            nil
-          end
-        end
-      end
-
-      def delete_matched(matcher, options = nil)
-        options = merged_options(options)
-        instrument(:delete_matched, matcher.inspect) do
-          matcher = key_matcher(matcher, options)
-          search_dir(cache_path) do |path|
-            key = file_path_key(path)
-            delete_entry(key, options) if key.match(matcher)
-          end
-        end
-      end
-
-      protected
-
-        def read_entry(key, options)
-          file_name = key_file_path(key)
-          if File.exist?(file_name)
-            entry = File.open(file_name) { |f| Marshal.load(f) }
-            if entry && !entry.expired? && !entry.expires_in && !self.options[:expires_in]
-              # Check for deprecated use of +:expires_in+ option from versions < 3.0
-              deprecated_expires_in = options[:expires_in]
-              if deprecated_expires_in
-                ActiveSupport::Deprecation.warn('Setting :expires_in on read has been deprecated in favor of setting it on write.', caller)
-                if entry.created_at + deprecated_expires_in.to_f <= Time.now.to_f
-                  delete_entry(key, options)
-                  entry = nil
-                end
-              end
-            end
-            entry
-          end
-        rescue
-          nil
-        end
-
-        def write_entry(key, entry, options)
-          file_name = key_file_path(key)
-          ensure_cache_path(File.dirname(file_name))
-          File.atomic_write(file_name, cache_path) {|f| Marshal.dump(entry, f)}
-          true
-        end
-
-        def delete_entry(key, options)
-          file_name = key_file_path(key)
-          if File.exist?(file_name)
-            begin
-              File.delete(file_name)
-              delete_empty_directories(File.dirname(file_name))
-              true
-            rescue => e
-              # Just in case the error was caused by another process deleting the file first.
-              raise e if File.exist?(file_name)
-              false
-            end
-          end
-        end
-
-      private
-        # Lock a file for a block so only one process can modify it at a time.
-        def lock_file(file_name, &block) # :nodoc:
-          if File.exist?(file_name)
-            File.open(file_name, 'r') do |f|
-              begin
-                f.flock File::LOCK_EX
-                yield
-              ensure
-                f.flock File::LOCK_UN
-              end
-            end
-          else
-            yield
-          end
-        end
-
-        # Translate a key into a file path.
-        def key_file_path(key)
-          fname = key.to_s.gsub(ESCAPE_FILENAME_CHARS){|match| "%#{match.ord.to_s(16).upcase}"}
-          hash = Zlib.adler32(fname)
-          hash, dir_1 = hash.divmod(0x1000)
-          dir_2 = hash.modulo(0x1000)
-          fname_paths = []
-          # Make sure file name is < 255 characters so it doesn't exceed file system limits.
-          if fname.size <= 255
-            fname_paths << fname
-          else
-            while fname.size <= 255
-              fname_path << fname[0, 255]
-              fname = fname[255, -1]
-            end
-          end
-          File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, *fname_paths)
-        end
-
-        # Translate a file path into a key.
-        def file_path_key(path)
-          fname = path[cache_path.size, path.size].split(File::SEPARATOR, 4).last
-          fname.gsub(UNESCAPE_FILENAME_CHARS){|match| $1.ord.to_s(16)}
-        end
-
-        # Delete empty directories in the cache.
-        def delete_empty_directories(dir)
-          return if dir == cache_path
-          if Dir.entries(dir).reject{|f| ['.', '..'].include?(f)}.empty?
-            File.delete(dir) rescue nil
-            delete_empty_directories(File.dirname(dir))
-          end
-        end
-
-        # Make sure a file path's directories exist.
-        def ensure_cache_path(path)
-          FileUtils.makedirs(path) unless File.exist?(path)
-        end
-
-        def search_dir(dir, &callback)
-          Dir.foreach(dir) do |d|
-            next if d == "." || d == ".."
-            name = File.join(dir, d)
-            if File.directory?(name)
-              search_dir(name, &callback)
-            else
-              callback.call name
-            end
-          end
-        end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/cache/mem_cache_store.rb

@@ -1,190 +0,0 @@
-begin
-  require 'memcache'
-rescue LoadError => e
-  $stderr.puts "You don't have memcache installed in your application. Please add it to your Gemfile and run bundle install"
-  raise e
-end
-require 'digest/md5'
-
-module ActiveSupport
-  module Cache
-    # A cache store implementation which stores data in Memcached:
-    # http://www.danga.com/memcached/
-    #
-    # This is currently the most popular cache store for production websites.
-    #
-    # Special features:
-    # - Clustering and load balancing. One can specify multiple memcached servers,
-    #   and MemCacheStore will load balance between all available servers. If a
-    #   server goes down, then MemCacheStore will ignore it until it comes back up.
-    #
-    # MemCacheStore implements the Strategy::LocalCache strategy which implements
-    # an in memory cache inside of a block.
-    class MemCacheStore < Store
-      module Response # :nodoc:
-        STORED      = "STORED\r\n"
-        NOT_STORED  = "NOT_STORED\r\n"
-        EXISTS      = "EXISTS\r\n"
-        NOT_FOUND   = "NOT_FOUND\r\n"
-        DELETED     = "DELETED\r\n"
-      end
-
-      ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/
-
-      def self.build_mem_cache(*addresses)
-        addresses = addresses.flatten
-        options = addresses.extract_options!
-        addresses = ["localhost:11211"] if addresses.empty?
-        MemCache.new(addresses, options)
-      end
-
-      # Creates a new MemCacheStore object, with the given memcached server
-      # addresses. Each address is either a host name, or a host-with-port string
-      # in the form of "host_name:port". For example:
-      #
-      #   ActiveSupport::Cache::MemCacheStore.new("localhost", "server-downstairs.localnetwork:8229")
-      #
-      # If no addresses are specified, then MemCacheStore will connect to
-      # localhost port 11211 (the default memcached port).
-      #
-      # Instead of addresses one can pass in a MemCache-like object. For example:
-      #
-      #   require 'memcached' # gem install memcached; uses C bindings to libmemcached
-      #   ActiveSupport::Cache::MemCacheStore.new(Memcached::Rails.new("localhost:11211"))
-      def initialize(*addresses)
-        addresses = addresses.flatten
-        options = addresses.extract_options!
-        super(options)
-
-        if addresses.first.respond_to?(:get)
-          @data = addresses.first
-        else
-          mem_cache_options = options.dup
-          UNIVERSAL_OPTIONS.each{|name| mem_cache_options.delete(name)}
-          @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
-        end
-
-        extend Strategy::LocalCache
-        extend LocalCacheWithRaw
-      end
-
-      # Reads multiple values from the cache using a single call to the
-      # servers for all keys. Options can be passed in the last argument.
-      def read_multi(*names)
-        options = names.extract_options!
-        options = merged_options(options)
-        keys_to_names = names.inject({}){|map, name| map[escape_key(namespaced_key(name, options))] = name; map}
-        raw_values = @data.get_multi(keys_to_names.keys, :raw => true)
-        values = {}
-        raw_values.each do |key, value|
-          entry = deserialize_entry(value)
-          values[keys_to_names[key]] = entry.value unless entry.expired?
-        end
-        values
-      end
-
-      # Increment a cached value. This method uses the memcached incr atomic
-      # operator and can only be used on values written with the :raw option.
-      # Calling it on a value not stored with :raw will initialize that value
-      # to zero.
-      def increment(name, amount = 1, options = nil) # :nodoc:
-        options = merged_options(options)
-        response = instrument(:increment, name, :amount => amount) do
-          @data.incr(escape_key(namespaced_key(name, options)), amount)
-        end
-        response == Response::NOT_FOUND ? nil : response.to_i
-      rescue MemCache::MemCacheError
-        nil
-      end
-
-      # Decrement a cached value. This method uses the memcached decr atomic
-      # operator and can only be used on values written with the :raw option.
-      # Calling it on a value not stored with :raw will initialize that value
-      # to zero.
-      def decrement(name, amount = 1, options = nil) # :nodoc:
-        options = merged_options(options)
-        response = instrument(:decrement, name, :amount => amount) do
-          @data.decr(escape_key(namespaced_key(name, options)), amount)
-        end
-        response == Response::NOT_FOUND ? nil : response.to_i
-      rescue MemCache::MemCacheError
-        nil
-      end
-
-      # Clear the entire cache on all memcached servers. This method should
-      # be used with care when shared cache is being used.
-      def clear(options = nil)
-        @data.flush_all
-      end
-
-      # Get the statistics from the memcached servers.
-      def stats
-        @data.stats
-      end
-
-      protected
-        # Read an entry from the cache.
-        def read_entry(key, options) # :nodoc:
-          deserialize_entry(@data.get(escape_key(key), true))
-        rescue MemCache::MemCacheError => e
-          logger.error("MemCacheError (#{e}): #{e.message}") if logger
-          nil
-        end
-
-        # Write an entry to the cache.
-        def write_entry(key, entry, options) # :nodoc:
-          method = options && options[:unless_exist] ? :add : :set
-          value = options[:raw] ? entry.value.to_s : entry
-          expires_in = options[:expires_in].to_i
-          if expires_in > 0 && !options[:raw]
-            # Set the memcache expire a few minutes in the future to support race condition ttls on read
-            expires_in += 5.minutes
-          end
-          response = @data.send(method, escape_key(key), value, expires_in, options[:raw])
-          response == Response::STORED
-        rescue MemCache::MemCacheError => e
-          logger.error("MemCacheError (#{e}): #{e.message}") if logger
-          false
-        end
-
-        # Delete an entry from the cache.
-        def delete_entry(key, options) # :nodoc:
-          response = @data.delete(escape_key(key))
-          response == Response::DELETED
-        rescue MemCache::MemCacheError => e
-          logger.error("MemCacheError (#{e}): #{e.message}") if logger
-          false
-        end
-
-      private
-        def escape_key(key)
-          key = key.to_s.gsub(ESCAPE_KEY_CHARS){|match| "%#{match.getbyte(0).to_s(16).upcase}"}
-          key = "#{key[0, 213]}:md5:#{Digest::MD5.hexdigest(key)}" if key.size > 250
-          key
-        end
-
-        def deserialize_entry(raw_value)
-          if raw_value
-            entry = Marshal.load(raw_value) rescue raw_value
-            entry.is_a?(Entry) ? entry : Entry.new(entry)
-          else
-            nil
-          end
-        end
-
-      # Provide support for raw values in the local cache strategy.
-      module LocalCacheWithRaw # :nodoc:
-        protected
-          def write_entry(key, entry, options) # :nodoc:
-            retval = super
-            if options[:raw] && local_cache && retval
-              raw_entry = Entry.new(entry.value.to_s)
-              raw_entry.expires_at = entry.expires_at
-              local_cache.write_entry(key, raw_entry, options)
-            end
-            retval
-          end
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/cache/memory_store.rb

@@ -1,159 +0,0 @@
-require 'monitor'
-
-module ActiveSupport
-  module Cache
-    # A cache store implementation which stores everything into memory in the
-    # same process. If you're running multiple Ruby on Rails server processes
-    # (which is the case if you're using mongrel_cluster or Phusion Passenger),
-    # then this means that Rails server process instances won't be able
-    # to share cache data with each other and this may not be the most
-    # appropriate cache in that scenario.
-    #
-    # This cache has a bounded size specified by the :size options to the
-    # initializer (default is 32Mb). When the cache exceeds the allotted size,
-    # a cleanup will occur which tries to prune the cache down to three quarters
-    # of the maximum size by removing the least recently used entries.
-    #
-    # MemoryStore is thread-safe.
-    class MemoryStore < Store
-      def initialize(options = nil)
-        options ||= {}
-        super(options)
-        @data = {}
-        @key_access = {}
-        @max_size = options[:size] || 32.megabytes
-        @max_prune_time = options[:max_prune_time] || 2
-        @cache_size = 0
-        @monitor = Monitor.new
-        @pruning = false
-      end
-
-      def clear(options = nil)
-        synchronize do
-          @data.clear
-          @key_access.clear
-          @cache_size = 0
-        end
-      end
-
-      def cleanup(options = nil)
-        options = merged_options(options)
-        instrument(:cleanup, :size => @data.size) do
-          keys = synchronize{ @data.keys }
-          keys.each do |key|
-            entry = @data[key]
-            delete_entry(key, options) if entry && entry.expired?
-          end
-        end
-      end
-
-      # To ensure entries fit within the specified memory prune the cache by removing the least
-      # recently accessed entries.
-      def prune(target_size, max_time = nil)
-        return if pruning?
-        @pruning = true
-        begin
-          start_time = Time.now
-          cleanup
-          instrument(:prune, target_size, :from => @cache_size) do
-            keys = synchronize{ @key_access.keys.sort{|a,b| @key_access[a].to_f <=> @key_access[b].to_f} }
-            keys.each do |key|
-              delete_entry(key, options)
-              return if @cache_size <= target_size || (max_time && Time.now - start_time > max_time)
-            end
-          end
-        ensure
-          @pruning = false
-        end
-      end
-
-      # Returns true if the cache is currently being pruned.
-      def pruning?
-        @pruning
-      end
-
-      # Increment an integer value in the cache.
-      def increment(name, amount = 1, options = nil)
-        synchronize do
-          options = merged_options(options)
-          if num = read(name, options)
-            num = num.to_i + amount
-            write(name, num, options)
-            num
-          else
-            nil
-          end
-        end
-      end
-
-      # Decrement an integer value in the cache.
-      def decrement(name, amount = 1, options = nil)
-        synchronize do
-          options = merged_options(options)
-          if num = read(name, options)
-            num = num.to_i - amount
-            write(name, num, options)
-            num
-          else
-            nil
-          end
-        end
-      end
-
-      def delete_matched(matcher, options = nil)
-        options = merged_options(options)
-        instrument(:delete_matched, matcher.inspect) do
-          matcher = key_matcher(matcher, options)
-          keys = synchronize { @data.keys }
-          keys.each do |key|
-            delete_entry(key, options) if key.match(matcher)
-          end
-        end
-      end
-
-      def inspect # :nodoc:
-        "<##{self.class.name} entries=#{@data.size}, size=#{@cache_size}, options=#{@options.inspect}>"
-      end
-
-      # Synchronize calls to the cache. This should be called wherever the underlying cache implementation
-      # is not thread safe.
-      def synchronize(&block) # :nodoc:
-        @monitor.synchronize(&block)
-      end
-
-      protected
-        def read_entry(key, options) # :nodoc:
-          entry = @data[key]
-          synchronize do
-            if entry
-              @key_access[key] = Time.now.to_f
-            else
-              @key_access.delete(key)
-            end
-          end
-          entry
-        end
-
-        def write_entry(key, entry, options) # :nodoc:
-          synchronize do
-            old_entry = @data[key]
-            @cache_size -= old_entry.size if old_entry
-            @cache_size += entry.size
-            @key_access[key] = Time.now.to_f
-            @data[key] = entry
-            prune(@max_size * 0.75, @max_prune_time) if @cache_size > @max_size
-            true
-          end
-        end
-
-        def delete_entry(key, options) # :nodoc:
-          synchronize do
-            @key_access.delete(key)
-            entry = @data.delete(key)
-            @cache_size -= entry.size if entry
-            !!entry
-          end
-        end
-    end
-  end
-end