swagger 1.4.0 → 1.4.1

data/.gitignore

@@ -17,6 +17,7 @@ tmtags
 coverage
 rdoc
 pkg
+.rvmrc
 
 ## PROJECT::SPECIFIC
 test.db

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    swagger (1.4.1)
+      activerecord
+      resque (>= 1.10.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activerecord (3.0.3)
+      activemodel (= 3.0.3)
+      activesupport (= 3.0.3)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.3)
+    arel (2.0.7)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    i18n (0.5.0)
+    json (1.4.6)
+    rack (1.2.1)
+    rake (0.8.7)
+    redis (2.1.1)
+    redis-namespace (0.8.0)
+      redis (< 3.0.0)
+    resque (1.10.0)
+      json (~> 1.4.6)
+      redis-namespace (~> 0.8.0)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    rspec (2.4.0)
+      rspec-core (~> 2.4.0)
+      rspec-expectations (~> 2.4.0)
+      rspec-mocks (~> 2.4.0)
+    rspec-core (2.4.0)
+    rspec-expectations (2.4.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.4.0)
+    sinatra (1.1.2)
+      rack (~> 1.1)
+      tilt (~> 1.2)
+    sqlite3 (1.3.3)
+    tilt (1.2.2)
+    tzinfo (0.3.24)
+    vegas (0.1.8)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  rake (~> 0.8.7)
+  resque (>= 1.10.0)
+  rspec (>= 2.4.0)
+  sqlite3 (>= 1.3.3)
+  swagger!

data/README.rdoc

@@ -1,7 +1,7 @@
 = Swagger = Resque + ActiveRecord - Redis
- 
+
 Swagger marries the power and robustness of Resque with the trivial setup of delayed_job. Swagger allows you to use all the features of Resque (http://github.com/defunkt/resque) without any of the "Redis" by adding one table to your existing database.
- 
+
 == Getting Started
 
 === 1. Add resque and swagger to your gem dependencies (order is important)
@@ -19,20 +19,22 @@ Swagger marries the power and robustness of Resque with the trivial setup of del
    Resque.connect_to_database(database)
 
 ==== NOTE: This allows rails and the resque admin app to use the same initializer by executing at the console: resque-web config/initializers/resque.rb
-    
+
 === 3. Create an active record migration
-    
+
    create_table :resque_values do |table|
      table.column :key,      :string
      table.column :key_type, :string
-     table.column :value, :text
+     table.column :score,    :integer
+     table.column :value,    :text
+     table.timestamps
    end
-  
+
    add_index :resque_values, :key
    add_index :resque_values, [:key, :key_type]
 
 == Note on Patches/Pull Requests
- 
+
 * Fork the project.
 * Make your feature addition or bug fix.
 * Add tests for it. This is important so I don't break it in a

data/Rakefile

@@ -1,46 +1,10 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "swagger"
-    gem.summary = %Q{Everything Resque provides minus Redis}
-    gem.description = %Q{Duck punch Resque to use active record for backround jobs instead of redis}
-    gem.email = "mdeiters@gmail.com"
-    gem.homepage = "http://github.com/mdeiters/swagger"
-    gem.authors = ["mdeiters"]
-    gem.add_development_dependency "rspec", ">= 1.2.9"
-    gem.add_dependency "activerecord" #, "2.3.8"
-    gem.add_dependency "resque", ">= 1.10.0"
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
+require 'bundler'
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :spec => :check_dependencies
-
-task :default => :spec
+require 'rake'
+require 'rspec/core/rake_task'
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+RSpec::Core::RakeTask.new
 
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "swagger #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+task :default => :spec

data/lib/resque_extension.rb

@@ -1,11 +1,11 @@
 Resque.module_eval do
   def swagger!
     define_method(:redis=) do |*args|
-      @redis = RedisImpersonator.new
+      @redis = Swagger::Redis.new
     end
-    
+
     define_method(:connect_to_database) do |database|
       ResqueValue.establish_connection database
     end
-  end  
+  end
 end

data/lib/resque_value.rb

@@ -1,3 +1,2 @@
 class ResqueValue < ActiveRecord::Base
-  
 end

data/lib/swagger.rb

@@ -1,4 +1,7 @@
 require 'active_record'
 require 'resque_value'
-require 'redis_impersonator'
-require 'resque_extension'
+require 'swagger/redis'
+require 'resque_extension'
+
+module Swagger
+end

data/lib/swagger/commands/helpers.rb

@@ -0,0 +1,16 @@
+module Swagger
+  module Commands
+    module Helpers
+      module_function
+
+      def select_values(sql)
+        ResqueValue.connection.select_values(sanitize(sql))
+      end
+
+      def sanitize(sql)
+        ResqueValue.send(:sanitize_sql, sql)
+      end
+
+    end
+  end
+end

data/lib/swagger/commands/keys.rb

@@ -0,0 +1,21 @@
+module Swagger
+  module Commands
+    module Keys
+
+      def del(key)
+        ResqueValue.delete_all(:key => key.to_s)
+        nil
+      end
+
+      def exists(key)
+        ResqueValue.exists?(:key => key.to_s)
+      end
+
+      def keys(pattern = '*')
+        raise "Pattern '#{pattern}' not supported" if pattern != '*'
+        ResqueValue.all(:select => 'DISTINCT resque_values.key').map(&:key)
+      end
+
+    end
+  end
+end

data/lib/swagger/commands/lists.rb

@@ -0,0 +1,53 @@
+module Swagger
+  module Commands
+    module Lists
+      KEY_TYPE = 'list'
+
+      def llen(list_name)
+        ResqueValue.all(:conditions => {:key => list_name.to_s, :key_type=> KEY_TYPE }).size
+      end
+
+      def lset(list_name, index, value)
+        rpush(list_name, value)
+      end
+
+      def lrange(list_name, start_range, end_range)
+        options = { :conditions => {
+                      :key => list_name.to_s,
+                      :key_type=> KEY_TYPE}}
+        unless end_range < 0
+          limit = end_range - start_range + 1
+          options.merge!(:limit => limit, :offset => start_range)
+        end
+        values = ResqueValue.all(options)
+        values.map(&:value)
+      end
+
+      def lrem(list_name, count, value)
+        raise "Only supports count of 0 which means to remove all elements in list" if count != 0
+        ResqueValue.delete_all(:key => list_name.to_s, :key_type=> KEY_TYPE, :value => value )
+      end
+
+      def lpop(list_name)
+        ResqueValue.transaction do
+          last = ResqueValue.last(:conditions => {:key => list_name.to_s, :key_type => KEY_TYPE}, :lock => true)
+          if last
+            last.destroy
+            return last.value
+          end
+        end
+      end
+
+      def rpush(list_name, value)
+        ResqueValue.create!(:key => list_name.to_s, :key_type => KEY_TYPE, :value => value.to_s)
+      end
+
+      def ltrim(list_name, start_range, end_range)
+        limit = end_range - start_range + 1
+        ids = ResqueValue.all(:select => "id", :conditions => {:key => list_name}, :offset => start_range, :limit => limit)
+        ResqueValue.delete_all(["`key` = ? AND id NOT IN (?)", list_name, ids.collect{|i| i.id}])
+      end
+
+    end
+  end
+end

data/lib/swagger/commands/sets.rb

@@ -0,0 +1,25 @@
+module Swagger
+  module Commands
+    module Sets
+      KEY_TYPE = 'set'
+
+      def sadd(set_name, value)
+        sismember(set_name, value) || ResqueValue.create!(:key => set_name.to_s, :key_type => KEY_TYPE, :value => value.to_s)
+      end
+
+      def srem(set_name, value)
+        ResqueValue.delete_all(:key => set_name.to_s, :key_type => KEY_TYPE, :value => value.to_s)
+        nil
+      end
+
+      def smembers(set_name)
+        ResqueValue.all(:conditions => {:key => set_name.to_s, :key_type => KEY_TYPE}).map(&:value)
+      end
+
+      def sismember(set_name, value)
+        ResqueValue.exists?(:key => set_name.to_s, :key_type => KEY_TYPE, :value => value.to_s)
+      end
+
+    end
+  end
+end

data/lib/swagger/commands/sorted_sets.rb

@@ -0,0 +1,56 @@
+module Swagger
+  module Commands
+    module SortedSets
+
+      KEY_TYPE = 'sorted_set'
+
+      def zadd(key, score, value)
+        record = ResqueValue.find_or_initialize_by_key_and_key_type_and_value(
+          key.to_s, KEY_TYPE, value)
+        record.score = score
+        record.save!
+        record
+      end
+
+      def zrem(key, value)
+        ResqueValue.delete_all conditions(key).merge(:value => value)
+      end
+
+      def zcard(key)
+        ResqueValue.count :conditions => conditions(key)
+      end
+
+      def zrange(key, start, stop)
+        Helpers.select_values(
+          'SELECT value FROM resque_values ' \
+          "WHERE key = #{key} " \
+          'ORDER BY score'
+        )[start..stop]
+      end
+
+      def zrangebyscore(key, min, max, options = {})
+        min = ResqueValue.minimum(:score, :conditions => conditions(key)) || 0 if min == '-inf'
+        max = ResqueValue.maximum(:score, :conditions => conditions(key)) || 0 if max == '+inf'
+
+        Helpers.select_values(
+          [].tap do |sql|
+            sql << 'SELECT value FROM resque_values'
+            sql << "WHERE `key` = '#{key}'"
+            sql << "AND score BETWEEN #{min} AND #{max}"
+            sql << 'ORDER BY score'
+            if limit = options[:limit]
+              sql << "LIMIT #{limit.join(', ')}"
+            end
+          end.join(' ')
+        )
+      end
+
+    private
+
+      def conditions(key)
+        { :key => key.to_s, :key_type => KEY_TYPE }
+      end
+
+    end
+  end
+end

data/lib/swagger/commands/strings.rb

@@ -0,0 +1,60 @@
+module Swagger
+  module Commands
+    module Strings
+
+      def get(key)
+        resque_value = ResqueValue.first(:conditions => {:key => key})
+        resque_value.value if resque_value
+      end
+
+      def set(key, value)
+        resque_value = ResqueValue.find_or_initialize_by_key(key.to_s)
+        resque_value.value = value
+        resque_value.save!
+        value
+      end
+
+      def setnx(key, value)
+        resque_value = ResqueValue.find_or_initialize_by_key(key.to_s)
+        if resque_value.new_record?
+          resque_value.value = value
+          resque_value.save!
+        end
+        resque_value.value
+      end
+
+      def incr(key)
+        incrby(key, '1')
+      end
+
+      def decr(key)
+        decrby(key, '1')
+      end
+
+      def incrby(key, value)
+        object = ResqueValue.find_or_initialize_by_key(key.to_s)
+        object.value = (object.value.to_i + value.to_i).to_s
+        object.save!
+        object.value
+      end
+
+      def decrby(key, value)
+        object = ResqueValue.find_or_initialize_by_key(key.to_s)
+        object.value = (object.value.to_i - value.to_i).to_s
+        object.save!
+        object.value
+      end
+
+      def mapped_mget(*keys)
+        Hash[*keys.zip(mget(*keys)).flatten]
+      end
+
+      def mget(*keys)
+        keys.collect!{|key| key.to_s }
+        resque_values = ResqueValue.all(:conditions => {:key => keys})
+        resque_values.map(&:value)
+      end
+
+    end
+  end
+end

data/lib/swagger/redis.rb

@@ -0,0 +1,26 @@
+require 'swagger/swallow'
+require 'swagger/commands/helpers'
+require 'swagger/commands/keys'
+require 'swagger/commands/lists'
+require 'swagger/commands/sets'
+require 'swagger/commands/sorted_sets'
+require 'swagger/commands/strings'
+
+module Swagger
+  class Redis
+
+    extend Swallow
+
+    swallow :namespace=
+    swallow :namespace, 'not applicable'
+    swallow :server, 'ActiveRecord'
+    swallow :info, self.inspect
+
+    include Commands::Keys
+    include Commands::Lists
+    include Commands::Sets
+    include Commands::SortedSets
+    include Commands::Strings
+
+  end
+end