remodel-h-r19 0.2.4

data/example/book.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/../lib/remodel-h"
+
+class Book < Remodel::Entity
+  has_many :chapters, :class => 'Chapter', :reverse => :book
+  property :title, :class => 'String'
+  property :year, :class => 'Integer'
+end
+
+class Chapter < Remodel::Entity
+  has_one :book, :class => Book, :reverse => :chapters
+  property :title, :class => String
+end
+

data/lib/remodel-h.rb

@@ -0,0 +1,69 @@
+require 'rubygems'
+require 'redis'
+require 'date'
+
+# If available, use the superfast YAJL lib to parse JSON.
+begin
+  require 'yajl/json_gem'
+rescue LoadError
+  require 'json'
+end
+
+# Define `Boolean` -- the missing superclass of `true` and `false`.
+module Boolean; end
+true.extend(Boolean)
+false.extend(Boolean)
+
+# Find the `Class` object for a given class name, which can be
+# a `String` or a `Symbol` (or a `Class`).
+def Class.[](clazz)
+  return clazz if clazz.nil? or clazz.is_a?(Class)
+  clazz.to_s.split('::').inject(Kernel) { |mod, name| mod.const_get(name) }
+end
+
+require File.join(File.dirname(__FILE__), 'remodel', 'mapper')
+require File.join(File.dirname(__FILE__), 'remodel', 'has_many')
+require File.join(File.dirname(__FILE__), 'remodel', 'entity')
+
+
+module Remodel
+
+  # Custom errors
+  class Error < ::StandardError; end
+  class EntityNotFound < Error; end
+  class EntityNotSaved < Error; end
+  class InvalidKeyPrefix < Error; end
+  class InvalidType < Error; end
+  class MissingContext < Error; end
+
+  # By default, the redis server is expected to listen at `localhost:6379`.
+  # Otherwise you will have to set `Remodel.redis` to a suitably initialized
+  # redis client.
+  def self.redis
+    @redis ||= Redis.new
+  end
+
+  def self.redis=(redis)
+    @redis = redis
+  end
+  
+  # Returns the mapper defined for a given class, or the identity mapper.
+  def self.mapper_for(clazz)
+    mapper_by_class[Class[clazz]]
+  end
+
+  # Define some mappers for common types.
+  def self.mapper_by_class
+    @mapper_by_class ||= Hash.new(Mapper.new).merge(
+      Boolean => Mapper.new(Boolean),
+      String => Mapper.new(String),
+      Integer => Mapper.new(Integer),
+      Float => Mapper.new(Float),
+      Array => Mapper.new(Array),
+      Hash => Mapper.new(Hash),
+      Date => Mapper.new(Date, :to_s, :parse),
+      Time => Mapper.new(Time, :to_i, :at)
+    )
+  end
+
+end

data/lib/remodel/entity.rb

@@ -0,0 +1,202 @@
+module Remodel
+
+  # The superclass of all persistent remodel entities.
+  class Entity
+    attr_accessor :context, :key
+
+    def initialize(context, attributes = {}, key = nil)
+      @context = context
+      @attributes = {}
+      @key = key
+      attributes = self.class.default_values.merge(attributes) if key.nil?
+      attributes.each do |name, value|
+        send("#{name}=", value) if respond_to? "#{name}="
+      end
+    end
+
+    def id
+      key && key.match(/\d+/)[0].to_i
+    end
+
+    def save
+      @key = next_key unless @key
+      Remodel.redis.hset(@context, @key, to_json)
+      self
+    end
+
+    def update(properties)
+      properties.each { |name, value| send("#{name}=", value) }
+      save
+    end
+
+    def reload
+      raise EntityNotSaved unless @key
+      initialize(@context, self.class.parse(self.class.fetch(@context, @key)), @key)
+      instance_variables.each do |var|
+        remove_instance_variable(var) if var =~ /^@association_/
+      end
+      self
+    end
+
+    def delete
+      raise EntityNotSaved unless @key
+      Remodel.redis.hdel(@context, @key)
+      instance_variables.each do |var|
+        Remodel.redis.hdel(@context, var.to_s.sub('@association', @key)) if var =~ /^@association_/
+      end
+    end
+
+    def as_json
+      { :id => id }.merge(@attributes)
+    end
+
+    def to_json
+      JSON.generate(self.class.pack(@attributes))
+    end
+
+    def inspect
+      properties = @attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(', ')
+      "\#<#{self.class.name}(#{context}, #{id}) #{properties}>"
+    end
+
+    def self.create(context, attributes = {})
+      new(context, attributes).save
+    end
+
+    def self.find(context, key)
+      key = "#{key_prefix}#{key}" if key.kind_of? Integer
+      restore(context, key, fetch(context, key))
+    end
+
+    def self.restore(context, key, json)
+      new(context, parse(json), key)
+    end
+
+  protected # --- DSL for subclasses ---
+
+    def self.set_key_prefix(prefix)
+      raise(InvalidKeyPrefix, prefix) unless prefix =~ /^[a-z]+$/
+      @key_prefix = prefix
+    end
+
+    def self.property(name, options = {})
+      name = name.to_sym
+      mapper[name] = Remodel.mapper_for(options[:class])
+      default_values[name] = options[:default] if options.has_key?(:default)
+      define_method(name) { @attributes[name] }
+      define_method("#{name}=") { |value| @attributes[name] = value }
+    end
+
+    def self.has_many(name, options)
+      var = "@association_#{name}".to_sym
+
+      define_method(name) do
+        if instance_variable_defined? var
+          instance_variable_get(var)
+        else
+          clazz = Class[options[:class]]
+          instance_variable_set(var, HasMany.new(self, clazz, "#{key}_#{name}", options[:reverse]))
+        end
+      end
+    end
+
+    def self.has_one(name, options)
+      var = "@association_#{name}".to_sym
+
+      define_method(name) do
+        if instance_variable_defined? var
+          instance_variable_get(var)
+        else
+          clazz = Class[options[:class]]
+          value_key = Remodel.redis.hget(self.context, "#{key}_#{name}")
+          instance_variable_set(var, clazz.find(self.context, value_key)) if value_key
+        end
+      end
+
+      define_method("#{name}=") do |value|
+        send("_reverse_association_of_#{name}=", value) if options[:reverse]
+        send("_#{name}=", value)
+      end
+
+      define_method("_#{name}=") do |value|
+        if value
+          instance_variable_set(var, value)
+          Remodel.redis.hset(self.context, "#{key}_#{name}", value.key)
+        else
+          remove_instance_variable(var) if instance_variable_defined? var
+          Remodel.redis.hdel(self.context, "#{key}_#{name}")
+        end
+      end; private "_#{name}="
+
+      if options[:reverse]
+        define_method("_reverse_association_of_#{name}=") do |value|
+          if old_value = send(name)
+            association = old_value.send("#{options[:reverse]}")
+            if association.is_a? HasMany
+              association.send("_remove", self)
+            else
+              old_value.send("_#{options[:reverse]}=", nil)
+            end
+          end
+          if value
+            association = value.send("#{options[:reverse]}")
+            if association.is_a? HasMany
+              association.send("_add", self)
+            else
+              value.send("_#{options[:reverse]}=", self)
+            end
+          end
+        end; private "_reverse_association_of_#{name}="
+      end
+    end
+
+  private # --- Helper methods ---
+
+    def self.fetch(context, key)
+      Remodel.redis.hget(context, key) || raise(EntityNotFound, "no #{name} with key #{key} in context #{context}")
+    end
+
+    # Each entity has its own sequence to generate unique ids.
+    def next_key
+      id = Remodel.redis.hincrby(@context, "#{self.class.key_prefix}", 1)
+      "#{self.class.key_prefix}#{id}"
+    end
+
+    # Default key prefix is the first letter of the class name, in lowercase.
+    def self.key_prefix
+      @key_prefix ||= name.split('::').last[0,1].downcase
+    end
+
+    def self.parse(json)
+      unpack(JSON.parse(json))
+    end
+
+    def self.pack(attributes)
+      result = {}
+      attributes.each do |name, value|
+        result[name] = mapper[name].pack(value)
+      end
+      result
+    end
+
+    def self.unpack(attributes)
+      result = {}
+      attributes.each do |name, value|
+        name = name.to_sym
+        result[name] = mapper[name].unpack(value) if mapper[name]
+      end
+      result
+    end
+
+    # Lazy init
+    def self.mapper
+      @mapper ||= {}
+    end
+
+    def self.default_values
+      @default_values ||= {}
+    end
+
+  end
+
+end

data/lib/remodel/has_many.rb

@@ -0,0 +1,71 @@
+module Remodel
+
+  # Represents the many-end of a many-to-one or many-to-many association.
+  class HasMany < Array
+    def initialize(this, clazz, key, reverse = nil)
+      super _fetch(clazz, this.context, key)
+      @this, @clazz, @key, @reverse = this, clazz, key, reverse
+    end
+
+    def create(attributes = {})
+      add(@clazz.create(@this.context, attributes))
+    end
+
+    def find(id)
+      detect { |x| x.id == id } || raise(EntityNotFound, "no element with id #{id}")
+    end
+
+    def add(entity)
+      _add_to_reverse_association_of(entity) if @reverse
+      _add(entity)
+    end
+
+    def remove(entity)
+      _remove_from_reverse_association_of(entity) if @reverse
+      _remove(entity)
+    end
+
+  private
+
+    def _add(entity)
+      self << entity
+      _store
+      entity
+    end
+
+    def _remove(entity)
+      delete_if { |x| x.key == entity.key }
+      _store
+      entity
+    end
+
+    def _add_to_reverse_association_of(entity)
+      if entity.send(@reverse).is_a? HasMany
+        entity.send(@reverse).send(:_add, @this)
+      else
+        entity.send("_#{@reverse}=", @this)
+      end
+    end
+
+    def _remove_from_reverse_association_of(entity)
+      if entity.send(@reverse).is_a? HasMany
+        entity.send(@reverse).send(:_remove, @this)
+      else
+        entity.send("_#{@reverse}=", nil)
+      end
+    end
+
+    def _store
+      Remodel.redis.hset(@this.context, @key, JSON.generate(self.map(&:key)))
+    end
+
+    def _fetch(clazz, context, key)
+      keys = JSON.parse(Remodel.redis.hget(context, key) || '[]')
+      values = keys.empty? ? [] : Remodel.redis.hmget(context, *keys)
+      keys.zip(values).map do |key, json|
+        clazz.restore(context, key, json) if json
+      end.compact
+    end
+  end
+
+end

data/lib/remodel/mapper.rb

@@ -0,0 +1,29 @@
+module Remodel
+
+  # A mapper converts a given value into a native JSON value —
+  # *nil*, *true*, *false*, *Number*, *String*, *Hash*, *Array* —
+  # via `pack`, and back again via `unpack`.
+  #
+  # Without any arguments, `Mapper.new` returns the identity mapper, which
+  # maps every value to itself. If `clazz` is set, the mapper rejects any
+  # value which is not of the given type.
+  class Mapper
+    def initialize(clazz = nil, pack_method = nil, unpack_method = nil)
+      @clazz = clazz
+      @pack_method = pack_method
+      @unpack_method = unpack_method
+    end
+
+    def pack(value)
+      return nil if value.nil?
+      raise(InvalidType, "#{value.inspect} is not a #{@clazz}") if @clazz && !value.is_a?(@clazz)
+      @pack_method ? value.send(@pack_method) : value
+    end
+
+    def unpack(value)
+      return nil if value.nil?
+      @unpack_method ? @clazz.send(@unpack_method, value) : value
+    end
+  end
+
+end

data/remodel-h.gemspec

@@ -0,0 +1,73 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{remodel-h}
+  s.version = "0.2.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tim Lossen"]
+  s.date = %q{2010-09-24}
+  s.default_executable = %q{redis-monitor.rb}
+  s.description = %q{persist your objects to redis hashes.}
+  s.email = %q{tim@lossen.de}
+  s.executables = ["redis-monitor.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "bin/redis-monitor.rb",
+     "docs/docco.css",
+     "docs/remodel.html",
+     "example/book.rb",
+     "lib/remodel-h.rb",
+     "lib/remodel/entity.rb",
+     "lib/remodel/has_many.rb",
+     "lib/remodel/mapper.rb",
+     "remodel-h.gemspec",
+     "test/helper.rb",
+     "test/test_entity.rb",
+     "test/test_entity_delete.rb",
+     "test/test_many_to_many.rb",
+     "test/test_many_to_one.rb",
+     "test/test_mappers.rb",
+     "test/test_monkeypatches.rb",
+     "test/test_one_to_many.rb",
+     "test/test_one_to_one.rb"
+  ]
+  s.homepage = %q{http://github.com/tlossen/remodel}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{remodel variant which uses hashes}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_entity.rb",
+     "test/test_entity_delete.rb",
+     "test/test_many_to_many.rb",
+     "test/test_many_to_one.rb",
+     "test/test_mappers.rb",
+     "test/test_monkeypatches.rb",
+     "test/test_one_to_many.rb",
+     "test/test_one_to_one.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+