vibes-bj 1.2.1

data/spec/rails_root/vendor/rails/activesupport/lib/active_support/cache/file_store.rb

@@ -0,0 +1,70 @@
+module ActiveSupport
+  module Cache
+    class FileStore < Store
+      attr_reader :cache_path
+
+      def initialize(cache_path)
+        @cache_path = cache_path
+      end
+
+      def read(name, options = nil)
+        super
+        File.open(real_file_path(name), 'rb') { |f| f.read } rescue nil
+      end
+
+      def write(name, value, options = nil)
+        super
+        ensure_cache_path(File.dirname(real_file_path(name)))
+        File.open(real_file_path(name), "wb+") { |f| f.write(value) }
+      rescue => e
+        RAILS_DEFAULT_LOGGER.error "Couldn't create cache directory: #{name} (#{e.message})" if RAILS_DEFAULT_LOGGER
+      end
+
+      def delete(name, options = nil)
+        super
+        File.delete(real_file_path(name))
+      rescue SystemCallError => e
+        # If there's no cache, then there's nothing to complain about
+      end
+
+      def delete_matched(matcher, options = nil)
+        super
+        search_dir(@cache_path) do |f|
+          if f =~ matcher
+            begin
+              File.delete(f)
+            rescue SystemCallError => e
+              # If there's no cache, then there's nothing to complain about
+            end
+          end
+        end
+      end
+
+      def exist?(name, options = nil)
+        super
+        File.exist?(real_file_path(name))
+      end
+
+      private
+        def real_file_path(name)
+          '%s/%s.cache' % [@cache_path, name.gsub('?', '.').gsub(':', '.')]
+        end
+
+        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/spec/rails_root/vendor/rails/activesupport/lib/active_support/cache/mem_cache_store.rb

@@ -0,0 +1,100 @@
+require 'memcache'
+
+module ActiveSupport
+  module Cache
+    class MemCacheStore < Store
+      module Response
+        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
+
+      attr_reader :addresses
+
+      def initialize(*addresses)
+        addresses = addresses.flatten
+        options = addresses.extract_options!
+        addresses = ["localhost"] if addresses.empty?
+        @addresses = addresses
+        @data = MemCache.new(addresses, options)
+      end
+
+      def read(key, options = nil)
+        super
+        @data.get(key, raw?(options))
+      rescue MemCache::MemCacheError => e
+        logger.error("MemCacheError (#{e}): #{e.message}")
+        nil
+      end
+
+      # Set key = value. Pass :unless_exist => true if you don't 
+      # want to update the cache if the key is already set. 
+      def write(key, value, options = nil)
+        super
+        method = options && options[:unless_exist] ? :add : :set
+        response = @data.send(method, key, value, expires_in(options), raw?(options))
+        response == Response::STORED
+      rescue MemCache::MemCacheError => e
+        logger.error("MemCacheError (#{e}): #{e.message}")
+        false
+      end
+
+      def delete(key, options = nil)
+        super
+        response = @data.delete(key, expires_in(options))
+        response == Response::DELETED
+      rescue MemCache::MemCacheError => e
+        logger.error("MemCacheError (#{e}): #{e.message}")
+        false
+      end
+
+      def exist?(key, options = nil)
+        # Doesn't call super, cause exist? in memcache is in fact a read
+        # But who cares? Reading is very fast anyway
+        !read(key, options).nil?
+      end
+
+      def increment(key, amount = 1)       
+        log("incrementing", key, amount)
+        
+        response = @data.incr(key, amount)  
+        response == Response::NOT_FOUND ? nil : response
+      rescue MemCache::MemCacheError 
+        nil
+      end
+
+      def decrement(key, amount = 1)
+        log("decrement", key, amount)
+        
+        response = data.decr(key, amount) 
+        response == Response::NOT_FOUND ? nil : response
+      rescue MemCache::MemCacheError 
+        nil
+      end        
+      
+      def delete_matched(matcher, options = nil)
+        super
+        raise "Not supported by Memcache"
+      end        
+      
+      def clear
+        @data.flush_all
+      end        
+      
+      def stats
+        @data.stats
+      end
+
+      private
+        def expires_in(options)
+          (options && options[:expires_in]) || 0
+        end
+
+        def raw?(options)
+          options && options[:raw]
+        end
+    end
+  end
+end

data/spec/rails_root/vendor/rails/activesupport/lib/active_support/cache/memory_store.rb

@@ -0,0 +1,38 @@
+module ActiveSupport
+  module Cache
+    class MemoryStore < Store
+      def initialize
+        @data = {}
+      end
+
+      def read(name, options = nil)
+        super
+        @data[name]
+      end
+
+      def write(name, value, options = nil)
+        super
+        @data[name] = value
+      end
+
+      def delete(name, options = nil)
+        super
+        @data.delete(name)
+      end
+
+      def delete_matched(matcher, options = nil)
+        super
+        @data.delete_if { |k,v| k =~ matcher }
+      end
+
+      def exist?(name,options = nil)
+        super
+        @data.has_key?(name)
+      end
+
+      def clear
+        @data.clear
+      end
+    end
+  end
+end

data/spec/rails_root/vendor/rails/activesupport/lib/active_support/callbacks.rb

@@ -0,0 +1,275 @@
+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
+
+      def |(chain)
+        if chain.is_a?(CallbackChain)
+          chain.each { |callback| self | callback }
+        else
+          if (found_callback = find(chain)) && (index = index(chain))
+            self[index] = chain
+          else
+            self << chain
+          end
+        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 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)
+          if options[:if]
+            evaluate_method(options[:if], *args)
+          elsif options[:unless]
+            !evaluate_method(options[:unless], *args)
+          else
+            true
+          end
+        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)
+              callbacks = CallbackChain.build(:#{callback}, *methods, &block)
+              (@#{callback}_callbacks ||= CallbackChain.new).concat callbacks
+            end
+
+            def self.#{callback}_callback_chain
+              @#{callback}_callbacks ||= CallbackChain.new
+
+              if superclass.respond_to?(:#{callback}_callback_chain)
+                CallbackChain.new(superclass.#{callback}_callback_chain + @#{callback}_callbacks)
+              else
+                @#{callback}_callbacks
+              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