yuki 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+pkg
+yuki.gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Doug Tangren
+ 
+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,122 @@
+# Yuki
+
+a model wrapper for key-value objects around tokyo products (cabinet/tyrant) 
+    
+# Play with Ninjas
+
+    class Ninja
+      include Yuki
+      store :cabinet, :path => "path/to/ninja.tct"
+      has :color,     :string, :default => "black"
+      has :name,      :string
+      has :mp,        :numeric
+      has :last_kill, :timestamp
+    end
+    
+    # Tyrant requires tokyo tyrant to be started
+    #   ttserver -port 45002 data.tct
+    class Ninja
+      include Yuki
+      store :tyrant, :host => "localhost", :port => 45002
+      # ...
+    end
+    
+    class Ninja
+      include Yuki
+      store :cabinet, :path => "/path/to/ninja.tct"
+      has :color, :default => "black"
+      has :name, :string, :default => "unknown"
+      has :mp, :numeric
+      has :last_kill, :timestamp
+      
+      # object will remain in the store after deletion
+      # with 'deleted' # => Time of deletion
+      soft_delete!
+
+      def before_save
+        puts "kick"
+      end
+
+      def after_save
+        puts "young blood..."
+      end
+
+      def before_delete
+        puts "stabs murderer"
+      end
+
+      def after_delete
+        puts "fights as ghost"
+      end
+
+      def validate!
+        puts "ensure ninjatude"
+      end
+
+      # hook for serialization
+      # (green ninjas get more mp with serialized)
+      def to_h
+        if color == "green"
+          super.to_h.merge({
+            "mp" => (mp + 1000).to_s
+          })
+        else
+          super
+        end
+      end
+    end
+
+    # queryable attributes
+    Ninja.new.mp? # false
+
+    ninja = Ninja.new(:mp => 700, :last_kill => Time.now)
+
+    ninja.mp? # true
+    
+    # crud
+    ninja.save!
+    ninja.update!
+    ninja.delete!
+    
+    Ninja.filter({
+      :color => [:eq, 'red'],
+      :mp => [:gt, 40],
+      :order => :last_kill
+    }) # => all red ninjas with mp > 40
+    
+    Ninja.union([{
+      :color => [:eq, 'red'],
+      :mp => [:gt, 40],
+    }, {
+        :color => [:eq, 'black']
+    }]) # => all black ninjas mixed with red ninjas with mp > 20
+    
+    Ninja.first
+    
+    Ninja.last
+    
+    Ninja.keys
+    
+    Ninja.any?
+    
+    Ninja.empty?
+    
+    Ninja.build([
+      { ... },
+      { ... },
+      { ... }
+    ]) # 3 ninjas built from 3 hashes
+    
+## Install
+    > make sure to have the following tokyo products installed
+      - tokyocabinet-1.4.36 or greater
+      - tokyotyrant-1.1.37 or greater
+      - [install tokyo products]:(@ http://openwferu.rubyforge.org/tokyo.html)
+
+    > rip install git://github.com/softprops/yuki      
+    
+    > include Yuki in your model
+    
+    > run with it
+
+2009 Doug Tangren (softprops)

data/Rakefile

@@ -0,0 +1,20 @@
+task :default => :test
+
+task :test do
+  sh "ruby test/yuki_test.rb"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "yuki"
+    gemspec.summary = "A Toyko model"
+    gemspec.description = "A Toyko model"
+    gemspec.email = "d.tangren@gmail.com"
+    gemspec.homepage = "http://github.com/softprops/yuki"
+    gemspec.authors = ["softprops"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/cast_system.rb

@@ -0,0 +1,38 @@
+module CastSystem
+  TO = {
+    :numeric    => lambda { |v| v.to_i },
+    :float      => lambda { |v| v.to_f },
+    :timestamp  => lambda { |v|
+      unless v.kind_of? Time
+        Time.at(v.to_i)
+      else
+        v
+      end
+    },
+    :boolean    => lambda { |v| 
+      case v
+      when "false" then false
+      when "true" then true
+      end
+    }, 
+    :regex      => lambda { |v| Regexp.new(v) },
+    :string     => lambda { |v| v.to_s }
+  }
+
+  FROM = {
+    :numeric    => lambda { |v| FROM[:string].call v },
+    :float      => lambda { |v| FROM[:string].call v },
+    :timestamp  => lambda { |v| FROM[:string].call v.to_i },
+    :boolean    => lambda { |v| FROM[:string].call v }, 
+    :regex      => lambda { |v| FROM[:string].call v },
+    :string     => lambda { |v| v.to_s }
+  }
+  
+  def cast(val, type)
+    CastSystem::TO[type].call(val)
+  end
+
+  def uncast(val, type)
+    CastSystem::FROM[type].call(val)
+  end     
+end

data/lib/store/abstract.rb

@@ -0,0 +1,199 @@
+module HashExtentions
+  def without(*args)
+    return if Hash.respond_to? :without
+    self.inject({}) { |wo, (k,v)| 
+      wo[k] = v unless args.include? k
+      wo
+    }
+  end
+end
+Hash.send :include, HashExtentions
+module Yuki
+  module Store
+    class AbstractStore
+      class InvalidStore < Exception; end
+     
+      # Determines if the current state of the store is valid
+      def valid?; false; end
+      
+      # @see http://github.com/jmettraux/rufus-tokyo/blob/master/lib/rufus/tokyo/query.rb
+      # expects
+      # conditions = {
+      #   :attr => [:operation, :value],
+      #   :limit => [:offset, :max]
+      #   :order => [:attr, :direction]
+      # }
+      # todo
+      # db.union( db.prepare_query{|q| q.add(att, op, val)})
+      #
+      def filter(conditions = {}, &blk)
+        ordering = extract_ordering!(conditions)
+        max, offset = *extract_limit!(conditions)
+        open { |db|
+          db.query { |q|
+            prepare_conditions(conditions) { |attr, op, val|
+              q.add_condition(attr, op, val)
+            }
+            q.order_by(ordering[0])
+            q.limit(max, offset) if max && offset
+          }
+        }
+      end
+      
+      # unioned_conditions = db.union([
+      #   { :attr => [:op, :val] }
+      #   { :attr => [:op, :val2] }
+      # ])
+      def union(conditions)
+        ordering = extract_ordering!(conditions)
+        max, offset = *extract_limit!(conditions)
+        open { |db|
+          queries = conditions.inject([]) { |arr, cond|
+            prepare_conditions(cond) { |attr, op, val|
+              db.prepare_query { |q|
+                q.add(attr, op, val)
+                arr << q
+              }
+            }
+            arr
+          }
+          db.union(*queries).map { |k, v| v.merge!(:pk => k) }
+        }
+      end
+      
+      def delete!(key)
+       open { |db| db.delete(key) }
+      end
+      
+      def keys
+        open { |db| db.keys }
+      end
+    
+      def any?
+        open { |db| db.any? }
+      end
+      
+      def empty?
+        !any?
+      end
+      
+      # Creates a new value. 
+      # store << { 'foo' => 'bar' } => { 'foo' => 'bar', :pk => '1' }
+      def <<(val)
+        open { |db|
+          key = key!(db, val)
+          (db[key] = stringify_keys(val).without('pk')).merge(:pk => key)
+        }
+      end
+    
+      # Gets an value by key. 
+      # store['1'] => { 'foo' => 'bar', :pk => '1' }
+      def [](key)
+        open { |db| db[key] }
+      end
+    
+      # Merges changes into an value by key. 
+      # store['1'] = { 'foo' => 'bar', 'baz' => 'boo' } => ...
+      def []=(key, val)
+        open { |db| 
+          db[key] = (db[key] || {}).merge(val) 
+        }.merge({
+          'pk' => key
+        })
+      end
+      
+      protected
+      
+      # each store should override this with key-value
+      # pairs representing the name and explaination of 
+      # the error
+      def errors
+        {}
+      end
+      
+      # Override this and return a db connection
+      def aquire; end
+      
+      ## helpers
+
+      def stringified_hash(h)
+        h.inject({}) { |a, (k, v)| a[k.to_s] = v.to_s; a }
+      end
+      
+      def stringify_keys(hash)
+        hash.inject({}) { |stringified, (k,v)| stringified.merge({k.to_s => v}) }
+      end
+      
+      private 
+    
+      def formatted_errors
+        errors.inject([]) { |errs, (k,v)|
+          errs << v
+        }.join(', or ')
+      end
+      
+      def extract_ordering!(hash)
+        ordering = hash.delete(:order) || [:pk, :asc]
+        ordering = [ordering] if(!ordering.kind_of?(Array))
+        ordering[1] = :desc if ordering.size == 1
+        ordering
+      end
+      
+      def extract_limit!(hash)
+        hash.delete(:limit)
+      end
+      
+      def prepare_conditions(conditions, &blk)
+        conditions.each { |attr, cond|
+            validate_condition(cond)
+            attr = '' if attr.to_s == 'pk'
+            yield attr.to_s, cond[0], cond[1]
+        }
+      end
+      
+      def validate_condition(v)
+        raise (
+          ArgumentError.new("#{v.inspect} is not a valid condition") 
+        ) if invalid_condition?(v)
+        
+        raise (
+          ArgumentError.new("#{v[0]} is not a valid operator") 
+        ) if invalid_op?(v[0])
+      end
+
+      def invalid_condition?(v)
+        !(v && v.size == 2)
+      end
+
+      def invalid_op?(op)
+        !Rufus::Tokyo::QueryConstants::OPERATORS.include?(op)
+      end
+
+      def key!(db, *args)
+        db.genuid.to_s
+      end
+      
+      def open(&blk)
+        raise( 
+          InvalidStore.new(formatted_errors)
+        ) if !valid?
+        Thread.current[:db] = begin
+          db = aquire
+          yield db
+        ensure
+          db.close if db
+        end
+      end   
+    end
+  end
+end
+
+# adapters
+
+Yuki::Store.autoload :TokyoCabinet, File.join(
+  File.dirname(__FILE__), 'cabinet'
+)
+
+Yuki::Store.autoload :TokyoTyrant, File.join(
+  File.dirname(__FILE__), 'tyrant'
+)

data/lib/store/cabinet.rb

@@ -0,0 +1,28 @@
+module Yuki
+  module Store
+    class TokyoCabinet < Yuki::Store::AbstractStore
+      require 'rufus/tokyo'
+      
+      def initialize(config = {})
+        @file = config[:file]
+      end
+      
+      def valid?
+        errors.empty?
+      end
+    
+      protected
+      
+      def errors
+        unless @file =~ /[.]tct$/
+          { "invalid file" => "Please provide a file in the format '{name}.tct'" }
+        else {}
+        end
+      end
+      
+      def aquire
+        Rufus::Tokyo::Table.new(@file)
+      end
+    end
+  end
+end

data/lib/store/tyrant.rb

@@ -0,0 +1,58 @@
+module Yuki
+  module Store
+    class TokyoTyrant < Yuki::Store::AbstractStore
+      require 'rufus/tokyo/tyrant'
+      
+      def initialize(config = {})
+        @socket = config[:socket] if config.include? :socket
+        @host, @port = config[:host], config[:port]
+      end
+    
+      def valid?
+        unless(socket_valid? || host_and_port_valid?)
+          errors.size < 2
+        else {}
+        end
+      end
+        
+      def stat
+        open { |db| db.stat.inject('') { |s, (k, v)| s << "#{k} => #{v}\n" } }
+      end
+    
+      protected
+      
+      def errors
+        unless(socket_valid? || host_and_port_valid?)
+          errs = {}
+          unless(socket_valid?)
+            errs.merge!({
+              "invalid socket" => "Please provide a valid socket"
+            })
+          end  
+          unless(host_and_port_valid?)
+            errs.merge!({
+              "invalid host and port" => "Please provde a valid host and port"
+            })
+          end
+          errs
+        else {}
+        end
+      end
+      
+      def aquire
+        Rufus::Tokyo::TyrantTable.new(@socket? @socket : @host, @port)
+      end
+      
+      private
+      
+      def socket_valid?
+        @socket
+      end
+      
+      def host_and_port_valid?
+        @host && @port
+      end
+      
+    end
+  end
+end

data/lib/yuki.rb

@@ -0,0 +1,323 @@
+require File.join(File.dirname(__FILE__), *%w(store abstract))
+require File.join(File.dirname(__FILE__),'cast_system')
+
+# A wrapper for tokyo-x products for persistence of ruby objects
+module Yuki 
+  class InvalidAdapter < Exception; end
+  
+  def self.included(base)
+    base.send :include, Yuki::Resource
+  end
+  
+  module Resource
+    
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.class_eval { @store = nil }
+      base.instance_eval { alias __new__ new }
+      base.extend ClassMethods
+      base.extend Validations
+      base.instance_eval { 
+        has :type 
+        has :pk
+      }
+    end
+   
+    module Callbacks
+      def before_save(); end
+      def after_save(); end
+      def before_delete(); end
+      def after_delete(); end
+    end
+   
+    module ClassMethods
+      attr_reader :db
+      
+      # assign the current storage adapter and config
+      def store(adapter, opts = {})
+        @db = (case adapter
+        when :cabinet then use_cabinet
+        when :tyrant then use_tyrant
+        else raise(
+          InvalidAdapter.new(
+            'Invalid Adapter. Try :cabinet or :tyrant.'
+          )
+        )
+        end).new(opts)
+      end
+      
+      def inherited(c)
+        c.instance_variable_set(:@db, @db.dup || nil)
+      end
+      
+      # Redefines #new method in order to build the object
+      # from a hash. Assumes a constructor that takes a hash or a
+      # no-args constructor
+      def new(attrs = {})
+        begin
+          __new__(attrs).from_hash(attrs)
+        rescue
+          __new__.from_hash(attrs)
+        end
+      end
+      
+      # Returns all of the keys for the class's store
+      def keys
+        db.keys
+      end
+       
+      # Gets all instances matching query criteria
+      # :limit 
+      # :conditions => [[:attr, :cond, :expected]]
+      def filter(opts = {})
+        build(db.filter(opts))
+      end
+      alias_method :all, :filter
+      
+      def union(opts = {})
+        build(db.union(opts))
+      end
+      
+      def soft_delete!
+        has :deleted, :timestamp
+        define_method(:delete!) { 
+          self['deleted'] = Time.now 
+          self.save!
+        }
+      end
+      
+      # Gets an instance by key
+      def get(key)
+        val = db[key]
+        build(val)[0] if val && val[type_desc]
+      end
+      
+      # Updates an instance by key the the given attrs hash
+      def put(key, attrs)
+        db[key] = attrs
+        val = db[key]
+        build(val)[0] if val && val[type_desc]
+      end
+      
+      # An object Type descriminator
+      # This is implicitly differentiates 
+      # what a class a hash is associated with
+      def type_desc
+        'type'
+      end
+      
+      # Attribute definition api.
+      # At a minimum this method expects the name 
+      # of the attribute. 
+      #
+      # This method also specifies type information 
+      # about attributes. The default type is :default
+      # which is a String. Other valid options for type
+      # are.
+      # :numeric
+      # :timestamp
+      # :float
+      # :regex
+      # 
+      # opts can be
+      #   :default - defines a default value to return if a value
+      #              is not supplied
+      #   :mutable - determines if the attr should be mutable. 
+      #              true or false. (false is default)
+      # 
+      # TODO
+      # opts planened to be supported in the future are
+      # :alias      - altername name 
+      # :collection - true or false
+      #
+      def has(attr, type = :string, opts = {})
+        if type.is_a?(Hash)
+          opts.merge!(type)
+          type = :string
+        end
+        define_methods(attr, type, opts)
+      end
+      
+      # Builds one or more instance's of the class from
+      # a hash or array of hashes
+      def build(hashes)
+        [hashes].flatten.inject([]) do |list, hash|
+          type = hash[type_desc] || self.to_s.split('::').last
+          cls = resolve(type)
+          list << cls.new(hash) if cls
+          list
+        end if hashes
+      end
+      
+      # Resolves a class given a string or hash
+      # If given a hash, the expected format is
+      # { :foo => { :type => :Bar, ... } }
+      # or
+      # "Bar"
+      def resolve(cls_def)
+        if cls_def.kind_of? Hash
+          class_key = cls_def.keys.first
+          clazz = resolve(cls_def[class_key][:type])
+          resource = clazz.new(info[class_key]) if clazz 
+        else
+          clazz = begin
+            cls_def.split("::").inject(Object) { |obj, const| 
+              obj.const_get(const) 
+            } unless cls_def.strip.empty?
+          rescue NameError => e
+            puts "given #{cls_def} got #{e.inspect}"
+            raise e
+          end
+        end
+      end
+      
+      def define_methods(attr, type, opts = {})
+        default_val = opts.delete(:default)
+        mutable = opts.delete(:mutable) || false
+        casted, uncasted = :"cast_#{attr}", :"uncast_#{attr}"
+        define_method(casted) { |val| cast(val, type) }
+        define_method(uncasted) { uncast(self[attr], type) }
+        define_method(attr) { self[attr] || default_val }
+        define_method(:"#{attr}=") { |v| self[attr] = v } if mutable 
+        define_method(:"#{attr}?") { self[attr] }
+      end
+      
+      private 
+      
+      def use_cabinet
+        Yuki::Store::TokyoCabinet
+      end
+      
+      def use_tyrant
+        Yuki::Store::TokyoTyrant
+      end
+    end
+    
+    
+    module Validations
+      # config opts
+      #   :msg => the display message
+      def validates_presence_of(attr, config={})
+        unless(send(attr.to_sym))
+          add_error(
+            "invalid #{attr}", 
+            (config[:msg] || "#{attr} is required")
+          )
+        end
+      end
+    end
+    
+    module InstanceMethods
+      include CastSystem
+      include Callbacks
+      
+      def save!
+        before_save
+        validate!
+        
+        raise(
+          Exception.new("Object not valid. #{formatted_errors}")
+        ) unless valid?
+        
+        val = if(key) 
+          db[key] = self.to_h
+        else 
+          db << self.to_h
+        end
+        
+        data.merge!('pk' => (val[:pk] || val['pk']))
+        after_save
+        self
+      end
+      
+      def delete!
+        before_delete
+        db.delete!(key)
+        after_delete
+        self
+      end
+      
+      def errors
+        @errors ||= {}
+      end
+      
+      def add_error(k,v)
+        errors.merge!({k,v})
+      end
+      
+      def formatted_errors
+        errors.inject([]) { |errs, (k,v)|
+          errs << v
+        }.join(', ')
+      end
+      
+      def valid?
+        errors.empty?
+      end
+      
+      def validate!; end
+      
+      def key
+        data['pk']
+      end
+      
+      def to_h
+        data.inject({}) do |h, (k, v)|
+          typed_val  = method("uncast_#{k}").call
+          h[k.to_s] = typed_val
+          h
+        end if data
+      end
+      
+      def from_hash(h)
+        type = { self.class.type_desc => self.class.to_s }
+        h.merge!(type) unless h.include? self.class.type_desc
+        
+        h.each { |k, v|
+          if attr_defined?(k)
+            self[k.to_s] = v
+          else
+            p "#{k} is undef! for #{self.inspect}"
+          end
+        } if h
+        
+        self
+      end
+      
+      # access attr as if model was hash
+      def [](attr)
+        data[attr.to_s]
+      end
+      
+      # specifies the object 'type' to serialize
+      def type
+        self['type'] || self.class
+      end
+      
+      protected
+      
+      def db
+        self.class.db
+      end
+      
+      def attrs
+        data.dup
+      end
+      
+      private
+      
+      def []=(attr, val) 
+        val = method("cast_#{attr}").call(val)
+        data[attr.to_s] = val
+      end
+    
+      def attr_defined?(attr)
+        respond_to?(:"cast_#{attr}")
+      end
+    
+      def data
+        @data ||= {}
+      end  
+    end  
+  end
+end

data/test/cast_system_test.rb

@@ -0,0 +1,63 @@
+require File.join(File.dirname(__FILE__), *%w(helper))
+#require File.join(File.dirname(__FILE__), *%w(.. lib cast_system))
+
+class Casting
+  extend CastSystem
+end
+class CastSystemTest < Test::Unit::TestCase
+  context "a cast system" do
+    should "cast numeric values" do
+      assert_equal 123, Casting.cast("123", :numeric)
+    end
+    
+    should "uncast numeric values" do
+      assert_equal "123", Casting.uncast(123, :numeric)
+    end
+    
+    should "cast float values" do
+      assert_equal 123.09, Casting.cast("123.09", :float)
+    end
+    
+    should "uncast float values" do
+      assert_equal "123.09", Casting.uncast(123.09, :float)
+    end
+    
+    should "cast timestamp values" do
+      now = Time.now
+      assert_equal now.to_s, Casting.cast(now.to_i.to_s, :timestamp).to_s
+    end
+    
+    should "uncast timestamp values" do
+       now = Time.now
+      assert_equal now.to_i.to_s, Casting.uncast(now, :timestamp)
+    end
+    
+    should "cast boolean values" do
+      assert_equal true, Casting.cast("true", :boolean)
+      assert_equal false, Casting.cast("false", :boolean)
+    end
+    
+    should "uncast boolean values" do
+      assert_equal "true", Casting.uncast(true, :boolean)
+      assert_equal "false", Casting.uncast(false, :boolean)
+    end
+    
+    should "cast regex values" do
+      assert_equal /[\@]+/, Casting.cast(/[\@]+/.to_s, :regex)
+    end
+    
+    should "uncast regex values" do
+      assert_equal /[\@]+/.to_s, Casting.uncast(/[\@]+/, :regex)
+    end
+    
+    should "cast string values" do
+      assert_equal "foo", Casting.cast("foo", :string)
+    end
+    
+    should "uncast string values" do
+      assert_equal "foo", Casting.uncast("foo", :string)
+    end
+    
+    
+  end
+end

data/test/helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require File.join(File.dirname(__FILE__), *%w(.. lib yuki))

data/test/store_test.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), *%w(helper))
+
+class StoreTest < Test::Unit::TestCase
+  TC = Yuki::Store::TokyoCabinet
+  TY = Yuki::Store::TokyoTyrant
+  
+  context "a tokyo cabinet store" do
+    context "with a valid config" do
+      setup do
+        @store = TC.new :file => "test.tct"
+      end
+    
+      should "be valid" do
+        assert @store.valid?
+      end
+    end
+    
+    context "without a valid config" do
+      setup do
+        @store = TC.new
+      end
+      
+      should "not be valid" do
+        assert !@store.valid?
+      end
+    end
+  end
+  
+  context "a tokyo tyrant store" do
+    context "with a valid config" do
+      setup do
+        @store = TY.new({
+          :host => "localhost",
+          :port => 45002
+        })
+      end
+
+      should "be valid" do
+        assert @store.valid?
+      end
+     end
+     
+     context "without a valid config" do
+       setup do
+         @store = TY.new
+       end
+
+       should "not be valid" do
+         assert !@store.valid?
+       end
+     end
+  end 
+end

data/test/yuki_test.rb

@@ -0,0 +1,160 @@
+require File.join(File.dirname(__FILE__), *%w(helper))
+
+class Ninja
+  include Yuki
+  store :cabinet, :file => File.join(
+    File.dirname(__FILE__), *%w(data test.tct)
+  )
+  has :weapon
+  has :mp, :numeric
+  has :last_kill, :timestamp
+end
+
+class YukiTest < Test::Unit::TestCase
+  context "a model's attributes" do   
+    
+    should "have a default object type of string" do
+      assert_equal '3', Ninja.new(:weapon => 3).weapon
+    end
+     
+    should "provide a option for defaulting values" do
+      class Paint 
+        include Yuki
+        has :color, :default => "red"
+      end
+      
+      assert_equal "red", Paint.new.color     
+    end
+    
+    should "be typed" do
+      kill_time = Time.now
+      
+      object = Ninja.new({
+        :weapon => "sword",               # string
+        :mp => "45",                      # numeric
+        :last_kill => kill_time.to_i.to_s # timestamp
+      })
+      
+      assert_equal "sword", object.weapon
+      assert_equal 45, object.mp
+      assert_equal kill_time.to_s, object.last_kill.to_s
+    end
+    
+    should "serialize and deserialize with type" do 
+      kill_time = Time.now.freeze
+      
+      ninja = Ninja.new({
+        :weapon => 'sword',         #string
+        :mp => 45,                  # numeric
+        :last_kill => kill_time     # timestamp
+      }).save!   
+        
+      object = Ninja.get(ninja.key)
+      assert_equal "sword", object.weapon
+      assert_equal 45, object.mp
+      assert_equal kill_time.to_s, object.last_kill.to_s
+    end      
+  
+    should "be queryable" do
+      ninja = Ninja.new(:weapon => 'knife')
+      assert ninja.weapon?
+      assert !ninja.mp?
+      assert !ninja.last_kill?
+    end
+  
+    should "should be immutable by default" do
+      class ImmutableNinja 
+        include Yuki
+        has :weapon
+      end
+      
+      assert !ImmutableNinja.new.respond_to?(:weapon=)
+    end  
+    
+    should "provide an option for mutablility" do
+      class MutableNinja 
+        include Yuki
+        has :weapon, :mutable => true
+      end
+      
+      assert MutableNinja.new.respond_to?(:weapon=)
+    end
+  end
+  
+  context "a model's lifecyle operations" do
+    should "provide callbacks" do
+      
+      class Sensei < Ninja
+        attr_accessor :bs, :as, :bd, :ad
+        def initialize
+          @bs, @as, @bd, @ad = false, false, false, false
+        end
+        def before_save;    @bs = true; end
+        def after_save;     @as = true; end
+        def before_delete;  @bd = true; end
+        def after_delete;   @ad = true; end
+      end
+      
+      object = Sensei.new(:weapon => 'test')
+      object.save!
+      object.delete!  
+      
+      [:bs, :as, :bd, :ad].each { |cb| assert object.send(cb) }
+    end
+  end
+  
+  context "a model's serialized type" do
+    should "default to the model's class name" do
+      module Foo
+        class Bar
+          include Yuki
+        end
+      end
+      
+      assert "YukiTest::Foo::Bar", Foo::Bar.new.to_h['type']  
+    end
+  end
+
+  context "a model's api methods" do
+    should "provide a creation method" do
+      assert Ninja.new.respond_to?(:save!)
+    end
+    
+    should "provide an update method" do
+      assert Ninja.respond_to?(:put)
+      ninja  = Ninja.new.save!
+      ninja = Ninja.put(ninja.key, { 'mp' => 6 })
+      assert_equal(6, ninja.mp)
+    end
+    
+    should "provide a deletion method" do
+      ninja = Ninja.new.save!
+      assert ninja.respond_to?(:delete!)
+      ninja.delete!
+      assert !Ninja.get(ninja.key)
+    end
+    
+    should "provide query method(s)" do
+      # write me
+    end
+    
+  end
+
+  context "an auditable model" do
+    should "be soft deleted" do
+      class ImmortalNinja
+        include Yuki
+        store :cabinet, :file => File.join(
+          File.dirname(__FILE__), *%w(data test.tct)
+        )
+        has :mp, :numeric
+        soft_delete!
+      end
+    
+      ninja = ImmortalNinja.new(:mp => 6).save!
+      ninja.delete!
+      ninja = Ninja.get(ninja.key)
+      assert ninja.deleted?
+    end
+  end
+end

data/yuki.rb

@@ -0,0 +1,2 @@
+$: < File.join(File.dirname(__FILE__), 'lib')
+require 'yuki'

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: yuki
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- softprops
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-18 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: A Toyko model
+email: d.tangren@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/cast_system.rb
+- lib/store/abstract.rb
+- lib/store/cabinet.rb
+- lib/store/tyrant.rb
+- lib/yuki.rb
+- test/cast_system_test.rb
+- test/helper.rb
+- test/store_test.rb
+- test/yuki_test.rb
+- yuki.rb
+has_rdoc: true
+homepage: http://github.com/softprops/yuki
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Toyko model
+test_files: 
+- test/cast_system_test.rb
+- test/helper.rb
+- test/store_test.rb
+- test/yuki_test.rb