benschwarz-smoke 0.5.7 → 0.5.8

data/vendor/gems/gems/simple-rss-1.2/test/test_helper.rb

@@ -1,4 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-
-require 'test/unit'
-require 'simple-rss'

data/vendor/gems/gems/wycats-moneta-0.6.0/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2009 Yehuda Katz
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/gems/gems/wycats-moneta-0.6.0/README

@@ -1,50 +0,0 @@
-Moneta: A unified interface for key/value stores
-================================================
-
-Moneta provides a standard interface for interacting with various kinds of key/value stores.
-
-Out of the box, it supports:
-
-* File store
-* Memcache store
-* In-memory store
-* The xattrs in a file system
-* DataMapper
-* S3
-* Berkeley DB
-* Redis
-* SDBM
-* Tokyo
-* CouchDB
-
-All stores support key expiration, but only memcache supports it natively. All other stores
-emulate expiration.
-
-The Moneta API is purposely extremely similar to the Hash API. In order so support an
-identical API across stores, it does not support iteration or partial matches, but that
-might come in a future release.
-
-The API:
-
-#initialize(options)::          options differs per-store, and is used to set up the store
-
-#[](key)::                      retrieve a key. if the key is not available, return nil
-
-#[]=(key, value)::              set a value for a key. if the key is already used, clobber it.
-                                keys set using []= will never expire
-
-#delete(key)::                  delete the key from the store and return the current value
-
-#key?(key)::                    true if the key exists, false if it does not
-
-#has_key?(key)::                alias for key?
-
-#store(key, value, options)::   same as []=, but you can supply an :expires_in option, 
-                                which will specify a number of seconds before the key
-                                should expire. In order to support the same features
-                                across all stores, only full seconds are supported
-
-#update_key(key, options)::     updates an existing key with a new :expires_in option.
-                                if the key has already expired, it will not be updated.
-
-#clear::                        clear all keys in this store

data/vendor/gems/gems/wycats-moneta-0.6.0/Rakefile

@@ -1,60 +0,0 @@
-require 'rubygems'
-require 'rake/gempackagetask'
-require 'rubygems/specification'
-require 'spec/rake/spectask'
-require 'date'
-
-GEM = "moneta"
-GEM_VERSION = "0.5.0"
-AUTHOR = "Yehuda Katz"
-EMAIL = "wycats@gmail.com"
-HOMEPAGE = "http://www.yehudakatz.com"
-SUMMARY = "A unified interface to key/value stores"
-
-spec = Gem::Specification.new do |s|
-  s.name = GEM
-  s.version = GEM_VERSION
-  s.platform = Gem::Platform::RUBY
-  s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
-  s.summary = SUMMARY
-  s.description = s.summary
-  s.author = AUTHOR
-  s.email = EMAIL
-  s.homepage = HOMEPAGE
-  
-  # Uncomment this to add a dependency
-  # s.add_dependency "foo"
-  
-  s.require_path = 'lib'
-  s.autorequire = GEM
-  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.gem_spec = spec
-end
-
-desc "install the gem locally"
-task :install => [:package] do
-  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
-end
-
-desc "create a gemspec file"
-task :make_spec do
-  File.open("#{GEM}.gemspec", "w") do |file|
-    file.puts spec.to_ruby
-  end
-end
-
-desc "Run all examples (or a specific spec with TASK=xxxx)"
-Spec::Rake::SpecTask.new('spec') do |t|
-  t.spec_opts  = ["-cfs"]
-  t.spec_files = begin
-    if ENV["TASK"] 
-      ENV["TASK"].split(',').map { |task| "spec/**/#{task}_spec.rb" }
-    else
-      FileList['spec/**/*_spec.rb']
-    end
-  end
-end

data/vendor/gems/gems/wycats-moneta-0.6.0/TODO

@@ -1,4 +0,0 @@
-TODO:
-Fix LICENSE with your name
-Fix Rakefile with your name and contact info
-Add your code to lib/<%= name %>.rb

data/vendor/gems/gems/wycats-moneta-0.6.0/lib/moneta.rb

@@ -1,76 +0,0 @@
-module Moneta
-  module Expires
-    def check_expired(key)
-      if @expiration[key] && Time.now > @expiration[key]
-        @expiration.delete(key)
-        self.delete(key)
-      end
-    end
-
-    def key?(key)
-      check_expired(key)
-      super
-    end
-
-    def [](key)
-      check_expired(key)
-      super
-    end
-
-    def fetch(key, default = nil, &blk)
-      check_expired(key)
-      super
-    end
-
-    def delete(key)
-      check_expired(key)
-      super
-    end
-
-    def update_key(key, options)
-      update_options(key, options)
-    end
-
-    def store(key, value, options = {})
-      ret = super(key, value)
-      update_options(key, options)
-      ret
-    end
-
-    private
-    def update_options(key, options)
-      if options[:expires_in]
-        @expiration[key] = (Time.now + options[:expires_in])
-      end
-    end
-  end
-
-  module StringExpires
-    include Expires
-
-    def check_expired(key)
-      if @expiration[key] && Time.now > Time.at(@expiration[key].to_i)
-        @expiration.delete(key)
-        delete(key)
-      end
-    end
-
-    private
-    def update_options(key, options)
-      if options[:expires_in]
-        @expiration[key] = (Time.now + options[:expires_in]).to_i.to_s
-      end
-    end
-  end
-  
-  module Defaults
-    def fetch(key, value = nil)
-      value ||= block_given? ? yield(key) : default
-      self[key] || value
-    end
-    
-    def store(key, value, options = {})
-      self[key] = value
-    end        
-  end
-end

data/vendor/gems/gems/wycats-moneta-0.6.0/lib/moneta/datamapper.rb

@@ -1,117 +0,0 @@
-begin
-  gem "dm-core", "0.9.10"
-  require "dm-core"
-rescue LoadError
-  puts "You need the dm-core gem in order to use the DataMapper moneta store"
-  exit
-end
-
-class MonetaHash
-  include DataMapper::Resource
-
-  property :the_key, String, :key => true
-  property :value, Object, :lazy => false
-  property :expires, Time
-
-  def self.value(key)
-    obj = self.get(key)
-    obj && obj.value
-  end
-end
-
-module Moneta
-  class DataMapper
-    class Expiration
-      def initialize(klass, repository)
-        @klass = klass
-        @repository = repository
-      end
-
-      def [](key)
-        if obj = get(key)
-          obj.expires
-        end
-      end
-
-      def []=(key, value)
-        obj = get(key)
-        obj.expires = value
-        obj.save(@repository)
-      end
-
-      def delete(key)
-        obj = get(key)
-        obj.expires = nil
-        obj.save(@repository)
-      end
-
-      private
-      def get(key)
-        repository(@repository) { @klass.get(key) }
-      end
-    end
-
-    def initialize(options = {})
-      @repository = options.delete(:repository) || :moneta
-      ::DataMapper.setup(@repository, options[:setup])
-      repository_context { MonetaHash.auto_upgrade! }
-      @hash = MonetaHash
-      @expiration = Expiration.new(MonetaHash, @repository)
-    end
-
-    module Implementation
-      def key?(key)
-        repository_context { !!@hash.get(key) }
-      end
-
-      def has_key?(key)
-        repository_context { !!@hash.get(key) }
-      end
-
-      def [](key)
-        repository_context { @hash.value(key) }
-      end
-
-      def []=(key, value)
-        repository_context {
-          obj = @hash.get(key)
-          if obj
-            obj.update(key, value)
-          else
-            @hash.create(:the_key => key, :value => value)
-          end
-        }
-      end
-
-      def fetch(key, value = nil)
-        repository_context {
-          value ||= block_given? ? yield(key) : default
-          self[key] || value
-        }
-      end
-
-      def delete(key)
-        repository_context {
-          value = self[key]
-          @hash.all(:the_key => key).destroy!
-          value
-        }
-      end
-
-      def store(key, value, options = {})
-        repository_context { self[key] = value }
-      end
-
-      def clear
-        repository_context { @hash.all.destroy! }
-      end
-
-      private
-      def repository_context
-        repository(@repository) { yield }
-      end
-    end
-    include Implementation
-    include Expires
-  end
-end

data/vendor/gems/gems/wycats-moneta-0.6.0/lib/moneta/file.rb

@@ -1,91 +0,0 @@
-begin
-  require "xattr"
-rescue LoadError
-  puts "You need the xattr gem to use the File moneta store"
-  exit
-end
-require "fileutils"
-
-module Moneta
-  class File
-    class Expiration
-      def initialize(directory)
-        @directory = directory
-      end
-      
-      def [](key)
-        attrs = xattr(key)
-        ret = Marshal.load(attrs.get("moneta_expires"))
-      rescue Errno::ENOENT, SystemCallError
-      end
-      
-      def []=(key, value)
-        attrs = xattr(key)
-        attrs.set("moneta_expires", Marshal.dump(value))
-      end
-      
-      def delete(key)
-        attrs = xattr(key)
-        attrs.remove("moneta_expires")
-      end
-
-      private
-      def xattr(key)
-        ::Xattr.new(::File.join(@directory, key))
-      end
-    end
-    
-    def initialize(options = {})
-      @directory = options[:path]
-      if ::File.file?(@directory)
-        raise StandardError, "The path you supplied #{@directory} is a file"
-      elsif !::File.exists?(@directory)
-        FileUtils.mkdir_p(@directory)
-      end
-      
-      @expiration = Expiration.new(@directory)
-    end
-    
-    module Implementation
-      def key?(key)
-        ::File.exist?(path(key))
-      end
-      
-      alias has_key? key?
-      
-      def [](key)
-        if ::File.exist?(path(key))
-          Marshal.load(::File.read(path(key)))
-        end
-      end
-      
-      def []=(key, value)
-        ::File.open(path(key), "w") do |file|
-          contents = Marshal.dump(value)
-          file.puts(contents)
-        end
-      end
-            
-      def delete(key)
-        value = self[key]
-        FileUtils.rm(path(key))
-        value
-      rescue Errno::ENOENT
-      end
-            
-      def clear
-        FileUtils.rm_rf(@directory)
-        FileUtils.mkdir(@directory)
-      end
-      
-      private
-      def path(key)
-        ::File.join(@directory, key)
-      end
-    end
-    include Implementation
-    include Defaults
-    include Expires
-    
-  end
-end

data/vendor/gems/gems/wycats-moneta-0.6.0/lib/moneta/memcache.rb

@@ -1,52 +0,0 @@
-begin
-  require "memcached"
-rescue LoadError
-  require "memcache"
-rescue LoadError
-  puts "You need the memcache gem to use the Memcache moneta store"
-  exit
-end
-
-module Moneta
-  class Memcache
-    include Defaults
-    
-    def initialize(options = {})
-      @cache = MemCache.new(options.delete(:server), options)
-    end
-
-    def key?(key)
-      !self[key].nil?
-    end
-
-    alias has_key? key?
-
-    def [](key)
-      @cache.get(key)
-    end
-
-    def []=(key, value)
-      store(key, value)
-    end
-
-    def delete(key)
-      value = self[key]
-      @cache.delete(key) if value
-      value
-    end
-
-    def store(key, value, options = {})
-      args = [key, value, options[:expires_in]].compact
-      @cache.set(*args)
-    end
-
-    def update_key(key, options = {})
-      val = self[key]
-      self.store(key, val, options)
-    end
-
-    def clear
-      @cache.flush_all
-    end
-  end
-end