redisabel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3c8c70acdee7a5f3241bcdea83c38da43ed4360
+  data.tar.gz: e8db271bab1fbab6bd989d9711557d1c122afee2
+SHA512:
+  metadata.gz: e59e627086b94b466f55da6aa0123bf29b0f76a1616c6a2d7a8ed9979877afc491ef67d5746717c0012deda2928ac5d5c0e65d00c894dc2d8d1ca970a2e1d145
+  data.tar.gz: 0aee823341f55bba873ce6c6db3e64393ad99ce56341cffb93bef999bd4cef84cba31cfba313ebcdf0ed68bc156e975ce9d2089a61d10d02f5a98061428b716c

data/LICENSE.md

@@ -0,0 +1,23 @@
+Copyright (c) 2014, Matthias Geier
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/redisabel/database.rb

@@ -0,0 +1,31 @@
+
+module Redisabel
+  class Database
+
+    attr_reader :db
+    @@db = nil
+
+    private_class_method :new
+    def initialize(db=0)
+      @db = Redis.new(:db => db)
+    end
+
+    def self.create(db=0)
+      return if @@db
+      @@db = new(db)
+    end
+
+    def self.close
+      return unless @@db
+      @@db.disconnect
+    end
+
+    def self.db
+      return @@db.db if @@db
+    end
+
+    def self.ok
+      return "OK"
+    end
+  end
+end

data/lib/redisabel/extensions/string.rb

@@ -0,0 +1,55 @@
+# = String class extension
+#
+# A string that is supposed to becode a Module, Class or similar can be
+# transformed by using #constantize
+#
+#   "Array".constantize
+#   => Array
+#
+# When writing file names in ruby, they are usually an underscore (snakecase)
+# representation of the class name. It can be transformed with #camelize and
+# in place with #camelize!
+#
+#   "file_reader".camelize
+#   => "FileReader"
+#
+#   s = "file_reader"
+#   s.camelize!
+#   s
+#   => "FileReader"
+#
+# The backwards transformation from a class name to snakecase is done with
+# #underscore and in place with #underscore!
+#
+#   "FileReader".underscore
+#   => "file_reader"
+#
+#   s = "FileReader".underscore
+#   s.underscore!
+#   s
+#   => "file_reader"
+#
+#
+#
+class String
+  def constantize
+    return self.to_s.split('::').reduce(Module){ |m, c| m.const_get(c) }
+  end
+
+  def camelize
+    return self.to_s.split(/_/).map(&:capitalize).join
+  end
+
+  def camelize!
+    self.replace(self.to_s.camelize)
+  end
+
+  def underscore
+    return self.to_s.split(/([A-Z]?[^A-Z]*)/).reject(&:empty?).
+      map(&:downcase).join('_')
+  end
+
+  def underscore!
+    self.replace(self.to_s.underscore)
+  end
+end

data/lib/redisabel/finders.rb

@@ -0,0 +1,19 @@
+
+module Redisabel
+  module Finders
+    def find(id, asave=false)
+      key = "#{self.database_key_name}:#{id}"
+      return unless Database.db.exists(key)
+      return self.new(asave, id, transform(key))
+    end
+
+    def filter(pattern, asave=false)
+      filter_term = "#{self.database_key_name}:#{pattern}"
+      keys = Database.db.keys(filter_term)
+      return keys.map do |key|
+        id = key.gsub("#{self.database_key_name}:", '')
+        self.new(asave, id, transform(key))
+      end
+    end
+  end
+end

data/lib/redisabel/hash_functions.rb

@@ -0,0 +1,53 @@
+
+module Redisabel
+  module HashFunctions
+
+    def key_valid?(key)
+      return key.is_a?(Numeric)
+    end
+    protected :key_valid?
+
+    def [](key)
+      return @data[key]
+    end
+
+    def update_data(*data)
+      data = data.first.is_a?(Hash) ? data.first : {}
+      unless data.is_a?(self.class.data_type)
+        raise ArgumentError.new("update_data expects a #{self.class.data_type}")
+      end
+
+      data.each{ |k, v| self.store(k, v) }
+    end
+
+    def delete(key)
+      if (value = @data.delete(key)) && self.autosave? && !self.id.to_s.empty?
+        Database.db.send(self.class.redis_delete_method, self.database_key,
+          value)
+      end
+    end
+
+    def store(key, value)
+      @data.delete(key)
+      @data.store(key, value.to_s)
+      if self.autosave? && !self.id.to_s.empty?
+        Database.db.send(self.class.redis_store_method, self.database_key, key,
+          value.to_s)
+      end
+    end
+    alias_method :[]=, :store
+
+    def to_hash
+      return @data
+    end
+
+    def to_h
+      return @data.dup
+    end
+
+    def to_ary
+      return @data.values.flatten
+    end
+    alias_method :to_a, :to_ary
+  end
+end

data/lib/redisabel/key_array.rb

@@ -0,0 +1,58 @@
+
+module Redisabel
+  class KeyArray < KeyValue
+
+    def self.data_type
+      return Array
+    end
+
+    def [](i)
+      return @data[i]
+    end
+
+    def delete(value)
+      if @data.delete(value) && self.autosave? && !self.id.to_s.empty?
+        Database.db.lrem(self.database_key, 0, value)
+      end
+    end
+
+    def delete_at(i)
+      if @data.delete_at(i) && self.autosave? && !self.id.to_s.empty?
+        tmp_value = Time.now.to_s
+        self.insert(i, tmp_value)
+        Database.db.lrem(self.database_key, 0, tmp_value)
+      end
+    end
+
+    def insert(i, value)
+      params = i.nil? ? [value] : [i, value]
+      amethod, lmethod = i.nil? ? [:push, :rpush] : [:insert, :lset]
+      @data.send(amethod, *params)
+      if self.autosave? && !self.id.to_s.empty?
+        Database.db.send(lmethod, self.database_key, *params)
+      end
+    end
+    alias_method :[]=, :insert
+
+    def push(*values)
+      values = values.shift if values.first.is_a?(Array)
+      values.each{ |v| self.insert(nil, v) }
+    end
+
+    def save
+      return super do |key|
+        Database.db.del(key)
+        results = @data.map{ |v| Database.db.rpush(key, v.to_s) }
+        next results.all?
+      end
+    end
+
+    def to_ary
+      return @data
+    end
+
+    def to_a
+      return @data.dup
+    end
+  end
+end

data/lib/redisabel/key_hash.rb

@@ -0,0 +1,25 @@
+
+module Redisabel
+  class KeyHash < KeyValue
+    include HashFunctions
+
+    def self.data_type
+      return Hash
+    end
+
+    def self.redis_store_method
+      return :hset
+    end
+
+    def self.redis_delete_method
+      return :hdel
+    end
+
+    def save
+      return super do |key|
+        key_values = @data.to_a.flatten
+        next Database.db.hmset(key, *key_values) == Database::ok
+      end
+    end
+  end
+end

data/lib/redisabel/key_ordered_set.rb

@@ -0,0 +1,42 @@
+
+module Redisabel
+  class KeyOrderedSet < KeyValue
+    include HashFunctions
+
+    def self.data_type
+      return Hash
+    end
+
+    def self.redis_store_method
+      return :zadd
+    end
+
+    def self.redis_delete_method
+      return :zrem
+    end
+
+    def self.range(id, first, last)
+      key = "#{self.database_key_name}:#{id}"
+      return unless Database.db.exists(key)
+      data = transform_zset(key, :zrangebyscore, first, last)
+      return self.new(false, id, data).freeze
+    end
+
+    def value=(val)
+      if !val.respond_to?(:keys) || val.keys.any?{ |k| !self.key_valid?(k) }
+        raise ArgumentError.new('ordered sets only accept numbers as Hash keys')
+      end
+      super
+    end
+
+    def save
+      return super do |key|
+        Database.db.del(key)
+        results = @data.map do |k, v|
+          Database.db.zadd(key, k, v)
+        end
+        next results.all?
+      end
+    end
+  end
+end

data/lib/redisabel/key_set.rb

@@ -0,0 +1,51 @@
+
+module Redisabel
+  class KeySet < KeyValue
+    def self.data_type
+      return Array
+    end
+
+    def update_data(*data)
+      return super(data.flatten.uniq)
+    end
+    protected :update_data
+
+    def save
+      return super do |key|
+        Database.db.del(key)
+        results = @data.map{ |v| Database.db.sadd(key, v) }
+        next results.all?
+      end
+    end
+
+    def delete(value)
+      if @data.delete(value) && self.autosave? && !self.id.to_s.empty?
+        Database.db.srem(self.database_key, value)
+      end
+    end
+
+    def push(*values)
+      values = values.shift if values.first.is_a?(Array)
+      values.uniq!
+      @data += values - @data
+      if self.autosave? && !self.id.to_s.empty?
+        values.each{ |v| Database.db.sadd(self.database_key, v) }
+      end
+    end
+
+    def to_ary
+      return @data.dup
+    end
+    alias_method :to_a, :to_ary
+
+    def ==(other)
+      return (other.is_a?(KeyValue) && self.id == other.id &&
+        @data.sort == other.value.sort)
+    end
+
+    def value=(val)
+      super
+      @data.uniq!
+    end
+  end
+end

data/lib/redisabel/key_value.rb

@@ -0,0 +1,112 @@
+
+module Redisabel
+  class KeyValue
+    extend Transformations
+    extend Finders
+
+    class << self; public :transform end
+    attr_accessor :id
+
+    def self.data_type
+      return String
+    end
+
+    def self.database_key_name
+      return self.name.underscore
+    end
+
+    def initialize(asave=false, id='', *data)
+      @autosave = asave
+      @data = self.class.data_type.new
+      self.id = id || ''
+      self.update_data(*data)
+    end
+
+    def update_data(*data)
+      if data.first.is_a?(self.class.data_type)
+        data = data.shift
+      elsif !data.is_a?(self.class.data_type)
+        data = self.class.data_type.new
+      end
+      unless data.is_a?(self.class.data_type)
+        raise ArgumentError.new("update_data expects a #{self.class.data_type}")
+      end
+      @data = data
+      self.autosave
+    end
+    protected :update_data
+
+    def empty?
+      return @data.empty?
+    end
+
+    def inspect
+      return "#{self.class.name}:#{self.id} #{@data.inspect}"
+    end
+
+    def to_s
+      return "#{self.class.name}:#{self.id}"
+    end
+    alias_method :to_str, :to_s
+
+    def eql?(other)
+      return self == other
+    end
+
+    def ==(other)
+      return (other.is_a?(KeyValue) && self.id == other.id &&
+        @data == other.value)
+    end
+
+    def save
+      return false if self.id.to_s.empty? || self.frozen?
+      key = self.database_key
+      if block_given?
+        return yield(key)
+      else
+        return Database.db.set(key, @data) == Database::ok
+      end
+    end
+
+    def destroy
+      key = self.database_key
+      return Database.db.del(key) > 0
+    end
+
+    def load
+      key = self.database_key
+      data = self.class.transform(key)
+      @data = data
+    end
+
+    def database_key
+      return "#{self.class.database_key_name}:#{self.id}"
+    end
+    protected :database_key
+
+    def autosave
+      self.save if @autosave
+    end
+    protected :autosave
+
+    def autosave?
+      return (!self.frozen? && @autosave)
+    end
+
+    def autosave=(bool)
+      @autosave = bool
+      self.save if self.autosave?
+    end
+
+    def value
+      return @data.dup
+    end
+
+    def value=(val)
+      unless val.is_a?(self.class.data_type)
+        val = self.class.data_type.new
+      end
+      @data = val
+    end
+  end
+end

data/lib/redisabel/search.rb

@@ -0,0 +1,31 @@
+
+module Redisabel
+  class Search
+    def initialize(pattern='*', asave=false)
+      @pattern = pattern
+      @autosave = asave
+    end
+
+    def keys
+      @keys ||= Database.db.keys(@pattern)
+    end
+
+    def objects
+      self.keys
+      @objects ||= @keys.map do |key|
+        object_name, id = key.split(':')
+        next object_name.camelize.constantize.new(@autosave, id,
+          Transformations.transform(key))
+      end
+    end
+
+    def objects_by_type
+      self.objects
+      @objects_by_type ||= @objects.reduce({}) do |acc, obj|
+        acc[obj.class] ||= []
+        acc[obj.class] << obj
+        next acc
+      end
+    end
+  end
+end

data/lib/redisabel/transformations.rb

@@ -0,0 +1,48 @@
+
+module Redisabel
+  module Transformations
+    def detect_type(key)
+      return Database.db.type(key)
+    end
+    module_function :detect_type
+
+    def transform(key)
+      type = detect_type(key)
+      return self.send("transform_#{type}", key)
+    end
+    module_function :transform
+
+    def transform_hash(key)
+      db = Database.db
+      keys = db.hkeys(key)
+      values = db.hvals(key)
+      return keys.zip(values).to_h
+    end
+    module_function :transform_hash
+
+    def transform_list(key)
+      return Database.db.lrange(key, 0, -1)
+    end
+    module_function :transform_list
+
+    def transform_string(key)
+      return Database.db.get(key)
+    end
+    module_function :transform_string
+
+    def transform_set(key)
+      return Database.db.smembers(key)
+    end
+    module_function :transform_set
+
+    def transform_zset(key, method=:zrange, first=0, last=-1)
+      return Database.db.send(method, key, first, last, :withscores => true).
+        reduce({}) do |acc, (v, k)|
+
+        acc[k.to_i] = v
+        acc
+      end
+    end
+    module_function :transform_zset
+  end
+end

data/lib/redisabel.rb

@@ -0,0 +1,11 @@
+require 'redisabel/extensions/string'
+require 'redisabel/database'
+require 'redisabel/transformations'
+require 'redisabel/finders'
+require 'redisabel/hash_functions'
+require 'redisabel/search'
+require 'redisabel/key_value'
+require 'redisabel/key_hash'
+require 'redisabel/key_set'
+require 'redisabel/key_ordered_set'
+require 'redisabel/key_array'

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: redisabel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matthias Geier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- lib/redisabel.rb
+- lib/redisabel/database.rb
+- lib/redisabel/extensions/string.rb
+- lib/redisabel/finders.rb
+- lib/redisabel/hash_functions.rb
+- lib/redisabel/key_array.rb
+- lib/redisabel/key_hash.rb
+- lib/redisabel/key_ordered_set.rb
+- lib/redisabel/key_set.rb
+- lib/redisabel/key_value.rb
+- lib/redisabel/search.rb
+- lib/redisabel/transformations.rb
+homepage: https://github.com/matthias-geier/redisabel
+licenses:
+- BSD-2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A minimal object mapper for Redis
+test_files: []