kvbean 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Sen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+Kvbean
+======
+
+Make redis on rails easier
+
+Install
+-------
+
+put this code in Gemfile
+
+```ruby
+  gem 'kvbean'
+```
+
+
+Usage
+-----
+
+```ruby
+class Message
+  include Kvbean::Base
+
+  kv_field :content, :title
+end
+
+Message.create(title: 'i am title', content: 'i am content')
+
+message = Message.new(title: 'i am title', content: 'i am content')
+message.save
+```
+
+Callbacks
+---------
+
+```ruby
+class Message
+  include Kvbean::Base
+
+  kv_field :content, :title
+
+  before_create :set_content
+
+  private
+
+  def set_content
+    self.content = 'some text'
+  end
+end
+```
+
+Validations
+-----------
+
+```ruby
+class Message
+  include Kvbean::Base
+
+  kv_field :content, :title
+
+  validates_presence_of :title
+end
+```

data/Rakefile

@@ -0,0 +1,45 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Kvbean'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:benchmark) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'perf/*_test.rb'
+  t.verbose = false
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/kvbean.rb

@@ -0,0 +1,15 @@
+$:.unshift(File.dirname(__FILE__))
+require "kvbean/ext/array"
+
+module Kvbean
+  class InvalidRecord < StandardError; end
+end
+
+module Kvbean
+  autoload :Redis,       'kvbean/redis'
+  autoload :Base,        'kvbean/base'
+  autoload :Validations, 'kvbean/validations'
+  autoload :Callbacks,   'kvbean/callbacks'
+  autoload :Observing,   'kvbean/observing'
+  autoload :Timestamp,   'kvbean/timestamp'
+end

data/lib/kvbean/base.rb

@@ -0,0 +1,233 @@
+require 'SecureRandom'
+
+module Kvbean
+  module Base
+    module ClassMethods
+      attr_accessor :primary_key, :kv_fields
+
+      def kv_field(*attributes)
+        define_attribute_methods attributes
+        @kv_fields ||= []
+        attributes.each do |attribute|
+          @kv_fields << attribute
+          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def #{attribute}
+              @#{attribute}
+            end
+
+            def #{attribute}=(val)
+              #{attribute}_will_change! unless val == @#{attribute}
+              @#{attribute} = val
+            end
+          EOS
+        end
+      end
+
+      def collection(&block)
+        @collection ||= Class.new(Array)
+        @collection.class_eval(&block) if block_given?
+        @collection
+      end
+
+      def primary_key
+        @primary_key ||= 'id'
+      end
+
+      def records
+        @records ||= {}
+      end
+
+      def raw_find(id)
+        records[id] || raise(UnknownRecord, "Couldn't find #{self.name} with ID=#{id}")
+      end
+
+      def find(id)
+        item = raw_find(id)
+        item && item.dup
+      end
+
+      def first
+        item = records.values[0]
+        item && item.dup
+      end
+
+      def last
+        item = records.values[-1]
+        item && item.dup
+      end
+
+      def all
+        clear_all
+        super.each { |item| records[item.id] = item.dup }
+        collection.new(records.values.deep_dup)
+      end
+
+      def count
+        all.size
+      end
+
+      def update(id, attrs)
+        find(id).update_attributes(attrs)
+      end
+
+      def destroy_all
+        all.each { |item| item.destroy }
+        clear_all
+      end
+
+      def clear_all
+        records.clear
+      end
+
+      def create(attrs = {})
+        record = self.new(attrs)
+        record.save && record
+      end
+
+      def create!(attrs = {})
+        create(*attrs) || raise(Kvbean::InvalidRecord)
+      end
+
+      def find_by_attribute(name, value)
+        item = records.values.find {|r| r.send(name) == value }
+        item && item.dup
+      end
+
+      def find_all_by_attribute(name, value)
+        items = records.values.select {|r| r.send(name) == value }
+        collection.new(items.deep_dup)
+      end
+
+      def method_missing(method_symbol, *args)
+        method_name = method_symbol.to_s
+
+        if method_name =~ /^find_by_(\w+)!/
+          send("find_by_#{$1}", *args) || raise(UnknownRecord)
+        elsif method_name =~ /^find_by_(\w+)/
+          find_by_attribute($1, args.first)
+        elsif method_name =~ /^find_or_create_by_(\w+)/
+          send("find_by_#{$1}", *args) || create($1 => args.first)
+        elsif method_name =~ /^find_all_by_(\w+)/
+          find_all_by_attribute($1, args.first)
+        else
+          super
+        end
+      end
+    end
+
+    module InstanceMethods
+      attr_accessor :attributes, :new_record
+
+      def initialize(attributes = {})
+        @new_record = true
+        @attributes = {}.with_indifferent_access
+        @attributes.merge!(self.class.kv_fields.inject({}) {|h, n| h[n] = nil; h })
+        @changed_attributes = {}
+        load_to_instance(attributes)
+      end
+
+      def saved
+        @previously_changed = changes
+        @changed_attributes.clear
+        @new_record = false
+      end
+
+      def new_record?
+        @new_record
+      end
+
+      def load_to_instance(attributes)
+        return unless attributes
+        attributes.each do |key, value|
+          self.send "#{key}=".to_sym, value
+        end
+      end
+
+      def reload_to_instance(attributes)
+        return unless attributes
+        attributes.each do |key, value|
+          self.send "#{key}=".to_sym, value
+        end
+      end
+
+      def update_attributes(attributes)
+        load_to_instance(attributes) && save
+      end
+
+      def id
+        attributes[self.class.primary_key]
+      end
+
+      def id=(value)
+        attributes[self.class.primary_key] = value
+      end
+
+      def save
+        new_record? ? create : update
+      end
+
+      def raw_create
+        super
+        self.class.records[self.id] = self.dup
+      end
+
+      def raw_update
+        super
+        item = self.class.raw_find(id)
+        item.load_to_instance(attributes)
+      end
+
+      def raw_delete
+        super
+        self.class.records.delete(self.id)
+      end
+
+      def create
+        self.id ||= generate_id
+        @new_record = false
+        raw_create
+        self.id
+      end
+
+      def update
+        raw_update
+        true
+      end
+
+      def destroy
+        raw_destroy
+        true
+      end
+
+      def exists?
+        !new_record?
+      end
+      alias_method :persisted?, :exists?
+
+      def generate_id
+        SecureRandom.hex(13)
+      end
+
+      def ==(other)
+        other.equal?(self) || (other.instance_of?(self.class) && other.id == id)
+      end
+
+      def eql?(other)
+        self == other
+      end
+    end
+
+    def self.included(base)
+      base.send :include, ActiveModel::Serialization
+      base.send :include, ActiveModel::Dirty
+      base.send :include, Kvbean::Redis
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+      base.send :include, Kvbean::Validations
+      base.send :include, Kvbean::Callbacks
+      base.send :include, Kvbean::Observing
+      base.send :include, Kvbean::Timestamp
+    end
+
+  end
+end

data/lib/kvbean/callbacks.rb

@@ -0,0 +1,23 @@
+module Kvbean
+  module Callbacks
+    module InstanceMethods
+      %w( create save update destroy ).each do |method|
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{method}
+            run_callbacks :#{method} do
+              super
+            end
+          end
+        EOS
+      end
+    end
+
+    def self.included(base)
+      base.send :extend,  ActiveModel::Callbacks
+      base.instance_eval do
+        define_model_callbacks :create, :save, :update, :destroy
+      end
+      base.send :include, InstanceMethods
+    end
+  end
+end

data/lib/kvbean/ext/array.rb

@@ -0,0 +1,7 @@
+class Array
+  unless defined?(deep_dup)
+    def deep_dup
+      Marshal.load(Marshal.dump(self))
+    end
+  end
+end

data/lib/kvbean/observing.rb

@@ -0,0 +1,29 @@
+module Kvbean
+  module Observing
+    #CALLBACKS = [
+      #:before_create, :before_destroy, :before_save, :before_update,
+      #:before_validation, :after_create, :after_destroy, :after_save,
+      #:after_update, :after_validation
+    #]
+    CALLBACKS = [
+      :before_create, :before_destroy, :before_save, :before_update,
+      :after_create, :after_destroy, :after_save,
+      :after_update
+    ]
+    def self.included(base)
+      base.send :include, ActiveModel::Observing
+      CALLBACKS.each do |callback|
+        callback_method = :"notify_observers_#{callback}"
+
+        base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          #{callback}(#{callback_method.inspect})
+
+          def #{callback_method}(&block)
+            notify_observers(#{callback.inspect}, &block)
+          end
+          private #{callback_method.inspect}
+        RUBY
+      end
+    end
+  end
+end

data/lib/kvbean/redis.rb

@@ -0,0 +1,109 @@
+module Kvbean
+  module Redis
+    module ClassMethods
+      def redis
+        @redis ||= ::Redis.new
+      end
+
+      def namespace
+        @namespace ||= self.name.downcase
+      end
+
+      def namespace=(namespace)
+        @namespace = namespace
+      end
+
+      def redis_key(*args)
+        args.unshift(self.namespace)
+        args.join(':')
+      end
+
+      def all
+        from_ids(redis.sort(redis_key))
+      end
+
+      protected
+
+      def from_ids(ids)
+        ids.map { |id| existing('id' => id) }
+      end
+
+      def existing(attrs = {})
+        item = self.new(attrs)
+        item.new_record = false
+        item.redis_get
+        item
+      end
+    end
+
+    module InstanceMethods
+      protected
+
+        def redis
+          self.class.redis
+        end
+
+        def redis_key(*args)
+          self.class.redis_key(id, *args)
+        end
+
+        def redis_set
+          redis.set(redis_key, serializable_hash.to_json)
+        end
+
+        def redis_get
+          data = redis.get(redis_key)
+          if data
+            load_to_instance(ActiveSupport::JSON.decode(data))
+          else
+            nil
+          end
+        end
+        public :redis_get
+
+        def destroy_indexes
+          self.class.kv_fields.each do |field|
+            old_value = changes[field].try(:first) || send(field)
+            redis.srem(self.class.redis_key(field, old_value), id)
+            if redis.smembers(self.class.redis_key(field, old_value)).blank?
+              redis.del(self.class.redis_key(field, old_value))
+            end
+          end
+        end
+
+        def create_indexes
+          self.class.kv_fields.each do |field|
+            new_value = send(field)
+            redis.sadd(self.class.redis_key(field, new_value), id)
+          end
+        end
+
+        def raw_create
+          redis_set
+          create_indexes
+          redis.sadd(self.class.redis_key, self.id)
+          saved
+        end
+
+        def raw_update
+          destroy_indexes
+          redis_set
+          create_indexes
+          saved
+        end
+
+        def raw_destroy
+          return if new_record?
+
+          destroy_indexes
+          redis.srem(self.class.redis_key, self.id)
+          redis.del(redis_key)
+        end
+    end
+
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+    end
+  end
+end