waves-filebase 0.3.8

data/lib/filebase.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'filebase/drivers/mixin'
+require 'filebase/drivers/json'
+
+class Filebase
+  class << self ; attr_accessor :storage ; end
+  self.storage = Drivers::JSON
+end
+
+class String
+  unless method_defined?(:camel_case)
+    def camel_case
+      gsub(/(_)(\w)/) { $~[2].upcase }.gsub(/^([a-z])/) { $~[1].upcase }
+    end
+  end
+end

data/lib/filebase/attributes.rb

@@ -0,0 +1,44 @@
+module Attributes
+  
+	def initialize( assigns = {} ) ; self.attributes = assigns ; end
+	
+	def attributes=( hash )
+	  @attrs = {}; hash.each { |k,v| @attrs[k.to_s] = v }
+	end
+	
+	def attributes ; @attrs ||= {} ; end
+	
+	def has_key?( key ) ; @attrs.has_key?( key.to_s ) ; end
+	
+	def keys; @attrs.keys; end
+	
+	def delete( key ) ; @attrs.delete( key.to_s ) ; end
+	
+	def method_missing(name,*args)
+	  if args.empty?
+      get(name.to_s)
+    elsif (name = name.to_s) =~ /=$/
+      set(name.chop, args[0])
+    else
+      super
+    end
+	end
+	
+	def [](name)
+	  if ( rval = @attrs[name = name.to_s] ).is_a?( Hash )
+	    @attrs[name] = self.class.new( rval )
+    else
+      rval
+    end  
+	end
+	
+	def []=(name,val) ; @attrs[name.to_s] = val ; end
+	
+	def to_h ; @attrs ; end
+	
+	alias :set :[]=
+	alias :get :[]
+  alias :to_hash :to_h
+  
+	
+end

data/lib/filebase/drivers/json.rb

@@ -0,0 +1,50 @@
+require 'json'
+require 'fileutils'
+class Filebase
+  module Drivers
+    class JSON
+      include Mixin
+      
+      def initialize( root )
+        super
+        @extension = "json"
+      end
+
+    	def all
+        Dir["#{@root}/*.json"].map do |file|
+          obj = File.open(file) { |f| ::JSON.load(f) }
+          obj['key'] = File.basename(file, '.json') if obj.is_a? Hash
+          obj or nil
+        end
+    	end
+
+      def find( key )
+        obj = File.open( path(key) ) { |f| ::JSON.load(f) } rescue nil
+    		obj['key'] = key if obj.is_a? Hash
+    		obj or nil # convert false to nil
+    	end
+    	
+      def find_keys(keys)
+        keys.map do |key|
+          obj = File.open( path(key) ) { |f| ::JSON.load(f) } rescue nil
+      		obj['key'] = key if obj.is_a? Hash
+      		obj or nil # convert false to nil
+        end
+      end
+
+    	def write( key, hash )
+        File.open(path(key), "w") do |f|
+          begin
+            f.puts ::JSON.pretty_generate(hash)
+            true
+          rescue
+            nil
+          end
+        end
+    	end
+
+  	end
+  end
+
+
+end

data/lib/filebase/drivers/marshal.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+class Filebase
+  
+  module Drivers
+    class Marshal
+      include Mixin
+
+      def initialize( root )
+        super
+        @extension = "marshal"
+      end
+
+    	def all
+        Dir["#{@root}/*.marshal"].map do |file|
+          obj = File.open(file) { |f| ::Marshal.load(f) }
+          obj['key'] = File.basename(file, '.marshal') if obj.is_a? Hash
+          obj or nil
+        end
+    	end
+
+      def find( key )
+        obj = File.open( path(key) ) { |f| ::Marshal.load(f) } rescue nil
+    		obj['key'] = key if obj.is_a? Hash
+    		obj or nil # convert false to nil
+    	end
+    	
+    	def find_keys(keys)
+        keys.map do |key|
+          obj = File.open( path(key) ) { |f| ::Marshal.load(f) } rescue nil
+      		obj['key'] = key if obj.is_a? Hash
+      		obj or nil # convert false to nil
+        end
+      end
+
+    	def write( key, object )
+  		  File.open( path(key), "w" ) { |f| ::Marshal.dump(object, f); true }
+    	end
+
+  	end
+  end
+
+end

data/lib/filebase/drivers/mixin.rb

@@ -0,0 +1,38 @@
+require 'fileutils'
+class Filebase
+  module Drivers
+    module Mixin
+      
+      def initialize(root)
+        @root = root.to_s
+        FileUtils.mkdir_p(root) unless File.exist?(root)
+      end
+      
+      def root
+        @root
+      end
+      
+      def path( key )
+        raise Filebase::Error, "can't generate a path using a nil key" unless key
+        "#{@root}/#{key}.#{@extension}"
+      end
+
+      def has_key?( key )
+        File.exist?( path(key) )
+      end
+      
+      def keys
+        Dir["#{@root}/*.#{@extension}"].sort.map { |fname| File.basename(fname, ".#{@extension}") }
+      end
+      
+      def count
+        Dir["#{@root}/*.#{@extension}"].size
+      end
+      
+      def delete( key )
+    		::FileUtils.remove( path( key ) )
+  	  end
+      
+    end
+  end
+end

data/lib/filebase/drivers/yaml.rb

@@ -0,0 +1,43 @@
+require 'yaml'
+require 'fileutils'
+class Filebase
+  
+  module Drivers
+    class YAML
+      include Mixin
+
+      def initialize( root )
+        super
+        @extension = "yml"
+      end
+
+    	def all
+        Dir["#{@root}/*.yml"].map do |file|
+         obj = ::YAML.load_file(file) 
+         obj['key'] = File.basename(file, '.yml') if obj.is_a? Hash
+         obj or nil
+        end
+    	end
+
+      def find( key )
+    		obj = ::YAML.load_file( path( key ) ) rescue nil
+    		obj['key'] = key if obj.is_a? Hash
+    		obj or nil # convert false to nil
+    	end
+    	
+    	def find_keys(keys)
+        keys.map do |key|
+          obj = ::YAML.load_file( path( key ) ) rescue nil
+      		obj['key'] = key if obj.is_a? Hash
+      		obj or nil # convert false to nil
+        end
+      end
+
+    	def write( key, object )
+  		  object if File.open( path(key), "w" ) { |f| ::YAML.dump(object, f) }
+    	end
+
+  	end
+  end
+
+end

data/lib/filebase/model.rb

@@ -0,0 +1,203 @@
+require 'filebase/attributes'
+
+class Filebase
+  
+  Error = RuntimeError
+	
+	module Model
+	  
+		def self.[]( path, driver=nil )
+		  Module.new do |mixin|
+		    ( class << mixin ; self ; end ).module_eval do
+		      define_method( :included ) do | model |
+  		      model.module_eval do
+  		        storage = driver ? Filebase::Drivers.const_get(driver.to_s) : Filebase.storage
+  		        @db = storage.new(path)
+  		        extend Mixins::ClassMethods ; include Attributes ;  include Mixins::InstanceMethods
+  		      end
+  		    end
+		    end
+		  end
+		end
+		
+		module Mixins
+		  
+		  module ClassMethods
+		    attr_accessor :db
+		    def create( assigns )
+		      object = new( assigns )
+		      raise Filebase::Error, "record already exists" if @db.has_key?(object["key"])
+		      save( object )
+	      end
+		    def all ; @db.all.map { |attrs| new( attrs ) } ; end
+		    
+		    def find( key ) ; attrs = @db.find( key ); new( attrs ) if attrs ; end
+		    alias_method :[], :find
+		    
+		    def keys; @db.keys; end
+		    
+		    def find_keys(keys)
+		      @db.find_keys(keys).map { |h| new(h) if h }
+		    end
+		    
+		    def slice(start, length)
+		      k = self.keys.slice(start, length)
+		      k ? find_keys(k) : []
+		    end
+		    
+		    def reverse_slice(start, length)
+		      k = self.keys.reverse.slice(start, length)
+		      k ? find_keys(k) : []
+		    end
+		    
+		    def count
+		      @db.count
+		    end
+		    
+		    def save( object )
+		      key = object.key
+		      raise( Filebase::Error, 'attempted to save an object with nil key' ) unless key and !key.empty?
+          object if @db.write( key, object.to_h )
+		    end
+		    
+		    def delete( object )
+		      key = object.key
+		      raise( Filebase::Error, 'attempted to delete an object with nil key' ) unless key and !key.empty?
+		      @db.delete( object.key )
+		    end
+		    
+		    def index
+		      @index
+		    end
+		    
+		    def reindex # Yes, this would take a lot of time.
+		      @index.all { |field| field.delete }
+		      all.each { |record| record.save }
+		    end
+		    
+		    def has_one( assoc_key, options = {} )
+		      module_eval do
+		        define_method assoc_key do
+  	          foreign_class = options[:class] || Object.module_eval( assoc_key.to_s.camel_case )
+  		        @has_one ||= {}
+		          @has_one[assoc_key] ||= foreign_class.find( get( assoc_key ) ) 
+		        end
+		        define_method( assoc_key.to_s + '=' ) do | val |
+  		        @has_one ||= {}; @has_one[assoc_key] = nil
+		          set( assoc_key, String === val ? val : val.key )
+		        end
+		      end
+		    end
+		    
+		    def has_many( assoc_key, options = {} )
+		      module_eval do
+		        define_method( assoc_key ) do
+  	          foreign_class = options[:class] || Object.module_eval( assoc_key.to_s.camel_case )
+		          @has_many ||= {}
+		          @has_many[assoc_key] ||= ( get( assoc_key ) || [] ).uniq.map { |key| foreign_class.find( key ) } 
+		        end
+            # when we save, make sure to pick up any changes to the array
+            before_save do |object|
+              object.set( assoc_key, object.send( assoc_key ).map{ |x| x.key }.uniq )
+            end
+          end
+		    end
+		    
+		    def index_on( attribute, options={} )
+		      storage = options[:driver] ? Filebase::Drivers.const_get(options[:driver].to_s) : @db.class
+		      field_name = attribute.to_s
+		      @index = index ||= storage.new("#{@db.root}/indexes")
+		      klass = self
+		      
+		      (class<<self;self;end).module_eval do            
+            define_method "find_by_#{field_name}" do |val|
+              ids = index.find(field_name)[val]
+              ids ? ids.map { |id| klass.find(id)  } : []
+            end
+          end
+          
+		      after_save do |object|
+		        key = object.key
+            field = index.find(field_name) || {}
+            if val = object[field_name]
+              if val.is_a? Array
+                val.each do |v|
+                  list = (field[v.to_s] ||= [])
+                  list << key unless list.include? key
+                end
+              else
+                list = field[val.to_s] ||= []
+                list << key unless list.include? key
+              end
+            end
+            index.write(field_name, field)
+		      end
+          
+          before_delete do |object|
+		        (field = index.find(field_name)) || return
+            if val = object[field_name]
+              field[val.to_s].delete(object.key)
+            end
+            index.write(field_name, field)
+		      end
+		      
+		    end
+		    
+		    
+		    def before_save(&block)
+		      (class<<self;self;end).module_eval do
+            old_save = instance_method(:save)
+            define_method :save do |object|
+              yield object
+              old_save.bind(self).call(object)
+            end
+          end
+		    end
+		    
+		    def after_save(&block)
+		      (class<<self;self;end).module_eval do
+            old_save = instance_method(:save)
+            define_method :save do |object|
+              old_save.bind(self).call(object)
+              object if yield( object )
+            end
+          end
+		    end
+		    
+		    def before_delete(&block)
+		      (class<<self;self;end).module_eval do
+            old_delete = instance_method(:delete)
+            define_method :delete do |object|
+              yield object
+              old_delete.bind(self).call(object)
+            end
+          end
+		    end
+		    
+		    def after_delete(&block)
+		      (class<<self;self;end).module_eval do
+            old_delete = instance_method(:delete)
+            define_method :delete do |object|
+              old_delete.bind(self).call(object)
+              yield object
+            end
+          end
+		    end
+		    
+		  end
+		  
+      module InstanceMethods
+        def save ; self.class.save( self ) ; end
+        def delete ; self.class.delete( self ) ; self ; end
+        def ==(object)
+          key == object.key if object.is_a? Attributes
+        end
+        def eql?(object) ; key == object.key ; end # this seems iffy
+        def hash ; key.hash ; end
+      end
+
+		end
+	
+	end
+
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: waves-filebase
+version: !ruby/object:Gem::Version 
+  version: 0.3.8
+platform: ruby
+authors: 
+- Dan Yoder
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-30 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: extensions
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: dan@zeraweb.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/filebase/attributes.rb
+- lib/filebase/drivers/json.rb
+- lib/filebase/drivers/marshal.rb
+- lib/filebase/drivers/mixin.rb
+- lib/filebase/drivers/yaml.rb
+- lib/filebase/model.rb
+- lib/filebase.rb
+has_rdoc: true
+homepage: http://dev.zeraweb.com/waves
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: filebase
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Simple file-based database with model support.
+test_files: []
+