acts_as_hashish 0.1.0

data/lib/acts_as_hashish/configuration.rb

@@ -0,0 +1,25 @@
+module Hashish
+  # Configuration
+  module Configuration
+    # Redis connection instance
+    attr_accessor :redis_connection
+    
+    # Redis namespace for keys
+    attr_writer :redis_namespace
+
+    # Redis namespace for keys
+    attr_writer :redis_search_keys_ttl
+
+    def redis_namespace
+      @redis_namespace ||= 'hashish'
+    end
+
+    def redis_search_keys_ttl
+      @redis_search_keys_ttl ||= 5 # minutes
+    end
+
+    def configure
+      yield self
+    end
+  end
+end

data/lib/acts_as_hashish/hashish.rb

@@ -0,0 +1,169 @@
+module Hashish
+
+  def acts_as_hashish(options = {})
+    raise "Cannot act as hashish without a redis connection!" unless Hashish.redis_connection
+    options[:key_prefix] ||= Hashish.redis_namespace + ':' + self.to_s
+    raise "Please specify a primary index via the :key option!" unless options[:key]
+    options[:indexes] ||= {}
+    options[:sorters] ||= {}
+    
+    @options = options
+    extend ClassMethods
+  end
+
+  module ClassMethods
+    
+    private
+    def get_hashish_key(item)
+      key = @options[:key]
+      key_value = key.is_a?(Proc) ? key.call(item) : item[key]
+    end
+
+    public
+    # this needs some improvisation
+    def rebuild_indexes
+      get_list(:page_size => 0).each do |item|
+        hashish_insert(item)
+      end
+    end
+    
+    def flush!
+      Hashish.redis_connection.keys("#{@options[:key_prefix]}*").each{|x| Hashish.redis_connection.del(x)}
+    end
+
+    def size(category = '')
+      Hashish.redis_connection.zcard("#{@options[:key_prefix]}:#{category}")
+    end
+    
+    def hashish_delete(key = nil)
+      key ||= get_hashish_key(get_hashish_list.first)
+      prefix = @options[:key_prefix]
+      Hashish.redis_connection.smembers("#{prefix}:status:*").each do |v|
+        Hashish.redis_connection.zrem(v, "#{prefix}:#{key}")
+      end
+      Hashish.redis_connection.del("#{prefix}:#{key}")
+    end
+    
+    def hashish_insert(o, category = '', t = Time.now.to_i)
+      data = o.to_json
+      prefix = @options[:key_prefix]
+      category += ':' unless category.empty?
+      key = get_hashish_key(o)
+      
+      Hashish.redis_connection.zadd("#{prefix}:#{category}", t , "#{prefix}:#{key}")
+      Hashish.redis_connection.zremrangebyrank("#{prefix}:#{category}", 0, -(@options[:max_size] + 1)) if @options[:max_size]
+      Hashish.redis_connection.sadd("#{prefix}:status:*", "#{prefix}:#{category}")
+      @options[:indexes].each do |index_field, index|
+        index_value = index.is_a?(Proc) ? index.call(o) : o[index]
+        if index_value.is_a?(Array)
+          index_value.each do |i|
+            Hashish.redis_connection.zadd("#{prefix}:#{index_field}:#{i}", t, "#{prefix}:#{key}") if i.is_a?(String)
+          end
+        else
+          Hashish.redis_connection.zadd("#{prefix}:#{index_field}:#{index_value}", t, "#{prefix}:#{key}")
+        end
+      end
+      @options[:sorters].each do |sort_field, sort|
+        sort_value = sort.is_a?(Proc) ? sort.call(o) : o[sort]
+        Hashish.redis_connection.set("#{prefix}:#{key}:#{sort}", sort_value)
+      end
+      Hashish.redis_connection.set("#{prefix}:#{key}", data)
+      true
+    end
+    
+    def hashish_list(*args)
+      category = nil
+      
+      options = {}
+      
+      # handle all kinds of argument structures that make sense
+      if args.length == 1
+        if args[0].is_a?(Hash)
+          options = args[0]
+        elsif args[0].is_a?(String)
+          category = args[0]
+        else
+          raise
+        end
+      elsif args.length > 1
+        category = args[0]
+        options = args[1]
+      end
+      
+      category += ':' if category          
+      page_no = options[:page_no] || 1
+      page_size = options[:page_size] || 10
+      
+      max_time = options[:to] || '+inf'
+      min_time = options[:from] || '-inf'
+      
+      filters = options[:filters] || {}
+      sort_by = options[:sort_by] || nil
+      sort_order = options[:sort_order] || nil
+      
+      offset = (page_no - 1) * page_size
+      limit = offset + page_size
+      
+      # get the next seq no for search operations for this search instance (perhaps this entire section shld be oops based stuff but what the heck :E mayb later)
+      seq = Hashish.redis_connection.incr("#{@options[:key_prefix]}:result:seq")
+      
+      # search
+      inter = []
+      unless filters.empty?
+        # inter = filters.map{|k,v| "#{@options[:key_prefix]}:#{k}:#{v}"}
+        
+        filters.each do |key, value|
+          if value.is_a?(Array)
+            union = []
+            union_key = "#{@options[:key_prefix]}:union:#{key}:#{seq}"
+            value.each do |v|
+              union << "#{@options[:key_prefix]}:#{key}:#{v}"
+            end
+            Hashish.redis_connection.zunionstore(union_key, union.uniq)
+            Hashish.redis_connection.expire(union_key, Hashish.redis_search_keys_ttl)
+            inter << union_key
+          else
+            inter << "#{@options[:key_prefix]}:#{key}:#{value}"
+          end
+        end
+        
+      end
+      
+      full_list = "#{@options[:key_prefix]}:#{category}"
+      
+      # is the user askin for a cropped set of data (min/max date/time of nQ)
+      if min_time == '-inf' and max_time == '+inf'
+        inter << full_list
+      else
+        # copy the full list to different temp set
+        all_items_key = "#{@options[:key_prefix]}:all_items:#{seq}"
+        Hashish.redis_connection.zunionstore(all_items_key, [full_list])
+        Hashish.redis_connection.expire(all_items_key, Hashish.redis_search_keys_ttl * 60)
+        # crop the set based on min/max (wish we had a 1 step zcroprangebyscore)
+        Hashish.redis_connection.zremrangebyscore(all_items_key, "-inf", "(#{min_time}") if min_time != '-inf'
+        Hashish.redis_connection.zremrangebyscore(all_items_key, "(#{max_time}", "+inf") if max_time != '+inf'
+        inter << all_items_key
+      end
+      
+      result_key = "#{@options[:key_prefix]}:result:#{seq}"
+      Hashish.redis_connection.zinterstore(result_key, inter, :aggregate => 'max')
+      Hashish.redis_connection.expire(result_key, Hashish.redis_search_keys_ttl * 60)
+      result = nil
+      if sort_by
+        custom_sort = "#{@options[:key_prefix]}:custom_sort:#{seq}"
+        Hashish.redis_connection.sort(result_key, :by => "*:#{sort_by}",:get => '*', :store => custom_sort, :order => sort_order)
+        Hashish.redis_connection.expire(custom_sort, Hashish.redis_search_keys_ttl * 60)
+        result = Hashish.redis_connection.lrange(custom_sort, offset, limit -1)
+      else
+        res_keys = Hashish.redis_connection.zrevrange(result_key, offset, limit - 1)
+        if res_keys.empty?
+          result = []
+        else
+          result = Hashish.redis_connection.mget(*res_keys)
+        end
+      end
+      result.compact.map{|x| JSON.parse(x) rescue x}
+    end
+    
+  end
+end

data/lib/acts_as_hashish/version.rb

@@ -0,0 +1,3 @@
+module Hashish
+  VERSION = '0.1.0'
+end

data/lib/acts_as_hashish.rb

@@ -0,0 +1,13 @@
+require 'redis'
+require 'json'
+require 'acts_as_hashish'
+require 'acts_as_hashish/version'
+require 'acts_as_hashish/configuration'
+require 'acts_as_hashish/hashish'
+
+module Hashish
+  extend Configuration
+end
+
+Object.extend Hashish
+

data/spec/hashish_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Hashish do
+  
+  describe ".acts_as_hashish" do
+    it "should hashify the class" do
+      SampleClass.expects(:hashify)
+      SampleClass.acts_as_hashish(:key => 'id')
+      SampleClass.instance_variable_get(:@options)[:key_prefix].should eq(Hashish.redis_namespace + ":" + SampleClass.to_s)
+      puts SampleClass.methods.sort
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'acts_as_hashish'
+
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+require 'rspec/autorun'
+require 'test/unit'
+require 'mocha'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+  config.color_enabled = true
+
+  config.before(:all) do
+    Hashish.configure do |configuration|
+      configuration.redis_connection = Redis.new(:db => 15, :host => '172.16.54.24')
+      configuration.redis_namespace = 'hashish_test_namspace'
+    end
+  end
+
+  config.before(:each) do
+    Hashish.redis_connection.flushdb
+    class SampleClass
+    end
+  end
+
+  config.after(:each) do
+    Object.send(:remove_const, :SampleClass)
+  end
+
+  config.after(:all) do
+    Hashish.redis_connection.flushdb
+    Hashish.redis_connection.quit
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+  
+  # treats :focus to be true by default
+  # config.treat_symbols_as_metadata_keys_with_true_values = true
+  
+  # runs only the specs who have focus tag
+  # config.filter_run_including :focus => true
+  
+  # runs specs excluding specs with broken tag
+  # config.filter_run_excluding :broken => true
+  
+  # runs all specs if filters are matched
+  # config.run_all_when_everything_filtered = true
+  
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_hashish
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Schubert Cardozo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-01-25 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: A sortable and searchable list backed by Redis
+email: 
+- cardozoschubert@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/acts_as_hashish/configuration.rb
+- lib/acts_as_hashish/hashish.rb
+- lib/acts_as_hashish/version.rb
+- lib/acts_as_hashish.rb
+- spec/hashish_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/saturnine/acts_as_hashish
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: acts_as_hashish
+rubygems_version: 1.8.19
+signing_key: 
+specification_version: 3
+summary: A sortable and searchable list backed by Redis
+test_files: []
+