redis-roc 0.5.0

data/lib/roc/store.rb

@@ -0,0 +1,2 @@
+require 'roc/store/redis_store'
+require 'roc/store/transient_store'

data/lib/roc/types/all_types.rb

@@ -0,0 +1,41 @@
+require 'roc/types/method_generators'
+
+module ROC
+  module Types
+    module AllTypes
+      extend(ROC::Types::MethodGenerators)
+
+      zero_arg_method :exists
+     
+      alias exists? exists
+      
+      zero_arg_method :del
+      
+      alias forget del
+
+      nonserializing_method :expire
+
+      nonserializing_method :expireat
+
+      zero_arg_method :ttl
+
+      zero_arg_method :persist
+      
+      def eval(script, *args)
+        keys = [self.key]
+        argv = []
+        args.each do |a|
+          if a.is_a?(ROC::Base)
+            keys << a.key
+          else
+            argv << a
+          end
+        end
+        self.storage.call :eval, script, keys.size, *keys, *argv
+      end
+
+    end
+  end
+end
+
+

data/lib/roc/types/array_type.rb

@@ -0,0 +1,106 @@
+require 'roc/types/method_generators'
+
+module ROC
+  module Types
+    module ArrayType
+
+      def self.included(base)
+        base.send :delegate_methods, :on => [], :to => :values
+      end
+
+      ## methods that must be implemented
+
+      def size
+        raise NotImplementedError, 'size must be overriden in any class including ArrayType'
+      end
+
+      def clobber(data)
+        raise NotImplementedError, 'clobber must be overriden in any class including ArrayType'
+      end
+      
+      # note - overriden methods should always return an array, never nil
+      def values
+        raise NotImplementedError, 'values must be overriden in any class including ArrayType'
+      end
+
+      ## common stuff
+
+      # can't alias - it will to find the method in subclass
+      def to_array 
+        self.values
+      end
+      def to_ary
+        self.values
+      end
+      def to_a
+        self.values
+      end
+
+      def values=(data)
+        self.clobber(data)
+      end
+
+      def inspect
+        "<#{self.class} @storage=#{self.storage.inspect} @key=#{self.key.inspect} @size=#{self.size}>"
+      end      
+
+      ## destructive methods that we can implement here
+
+      def replace(val)
+        self.clobber(val)
+        self
+      end
+
+      def clear
+        self.replace([])
+      end     
+
+      ## destructive methods that would otherwise be delegated -- override if possible (these are in addition to a ny methods ending in ! or =, which are caught by method_missing)
+
+      def delete(val)
+        raise NotImplementedError
+      end
+
+      def delete_at(ind)
+        raise NotImplementedError
+      end
+      
+      def delete_if
+        raise NotImplementedError
+      end
+
+      def <<(val)
+        raise NotImplementedError
+      end
+      
+      def fill(*args)
+        raise NotImplementedError
+      end
+
+      def insert(*args)
+        raise NotImplementedError
+      end
+
+      def keep_if
+        raise NotImplementedError
+      end
+
+      def push(*args)
+        raise NotImplementedError
+      end
+
+      def pop(*args)
+        raise NotImplementedError
+      end
+
+      def shift(*args)
+        raise NotImplementedError
+      end
+
+      def unshift(*args)
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/roc/types/method_generators.rb

@@ -0,0 +1,38 @@
+module ROC
+  module Types
+    module MethodGenerators
+
+      def serializing_method(method_name)
+        self.send :define_method, method_name do |val|
+          self.call method_name, self.serialize(val)        
+        end
+      end
+
+      def deserializing_method(method_name)
+        self.send :define_method, method_name do
+          self.deserialize(self.call method_name)
+        end
+      end
+
+      def serializing_and_deserializing_method(method_name)
+        self.send :define_method, method_name do |val|
+          self.deserialize(self.call method_name, self.serialize(val))
+        end
+      end
+
+      def zero_arg_method(method_name)
+        self.send :define_method, method_name do
+          self.call method_name
+        end
+      end
+
+      def nonserializing_method(method_name)
+        self.send :define_method, method_name do |val|
+          self.call method_name, val
+        end
+      end
+
+    end
+  end
+end
+

data/lib/roc/types/scalar_type.rb

@@ -0,0 +1,58 @@
+require 'roc/types/method_generators'
+
+module ROC
+  module Types
+    module ScalarType
+      extend ROC::Types::MethodGenerators
+      
+      deserializing_method :get
+        
+      alias value get
+
+      serializing_method :set
+
+      alias value= set
+
+      serializing_method :setnx
+
+      serializing_and_deserializing_method :getset
+
+      def setex(secs, val)
+        self.set(val)
+        self.expire(secs)
+      end
+
+      def clobber(data)
+        self.set(data)
+      end
+
+      def inspect
+        "<#{self.class} @storage=#{self.storage.inspect} @key=#{self.key.inspect} @value=#{self.value.inspect}>"
+      end      
+
+      def serialize(val)
+        raise "serialize must be overriden in any class including ScalarType"
+      end
+      
+      def deserialize(val)
+        raise "deserialize must be overriden in any class including ScalarType"
+      end
+
+#       def respond_to?(method_name)
+#         ## todo - what about :value, deserialize, etc!!
+#         self.value.respond_to?(method_name)
+#       end
+      
+#       def method_missing(method_name, *args, &block)
+#         v = self.value
+#         if v.respond_to?(method_name)
+#           v.send(method_name, *args, &block)
+#         else
+#           super(method_name, *args, &block)        
+#         end
+#       end
+
+
+    end
+  end
+end

data/lib/roc/types/sortable_type.rb

@@ -0,0 +1,32 @@
+module ROC
+  module Types
+    module SortableType
+
+#      c.value :by
+#      c.splat :limit
+#      c.multi :get
+#      c.words :order
+#      c.value :store
+
+      def sort(opts={})
+        raise ":by not yet supported" if opts.has_key?(:by)
+        raise ":get not yet supported" if opts.has_key?(:by)
+
+        store = opts[:store]
+        if store.is_a?(ROC::List)
+          store = store.key
+        elsif !store.nil? && !store.is_a?(::String)
+          raise "unsupported :store value"
+        end
+
+        self.call :sort, {:store => store, :limit => opts[:limit], :order => opts[:order]}
+      end
+
+      def sort!(opts={})
+        raise ":store is self in sort!" if opts.has_key?(:store)
+        self.sort({:store => self.key}.merge(opts.dup))
+      end
+
+    end
+  end
+end

data/lib/roc/version.rb

@@ -0,0 +1,3 @@
+module ROC
+  VERSION = '0.5.0'
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: redis-roc
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Ben Lund
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-08 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cim_attributes
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Collection of Ruby classes wrapping the Redis data structures
+email: ben@benlund.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/redis-roc.rb
+- lib/roc/objects.rb
+- lib/roc/store.rb
+- lib/roc/version.rb
+- lib/roc/ext/redis_ext.rb
+- lib/roc/objects/base.rb
+- lib/roc/objects/float.rb
+- lib/roc/objects/hash.rb
+- lib/roc/objects/integer.rb
+- lib/roc/objects/list.rb
+- lib/roc/objects/lock.rb
+- lib/roc/objects/set.rb
+- lib/roc/objects/sorted_set.rb
+- lib/roc/objects/string.rb
+- lib/roc/objects/time.rb
+- lib/roc/store/object_initializers.rb
+- lib/roc/store/redis_eval.rb
+- lib/roc/store/redis_store.rb
+- lib/roc/store/roc_store.rb
+- lib/roc/store/transient_eval.rb
+- lib/roc/store/transient_store.rb
+- lib/roc/types/all_types.rb
+- lib/roc/types/array_type.rb
+- lib/roc/types/method_generators.rb
+- lib/roc/types/scalar_type.rb
+- lib/roc/types/sortable_type.rb
+has_rdoc: true
+homepage: http://github.com/benlund/roc
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: ROC::String, ROC::Integer, ROC::List, ROC::SortedSet, etc. Also a Ruby in-memory implementation of the Redis commmands to allow you to use the ROC classes without a connection to Redis.
+test_files: []
+