filebase 0.3.6 → 0.3.10

data/lib/filebase.rb

@@ -1,11 +1,15 @@
 require 'rubygems'
-require 'drivers/yaml'
+require 'filebase/drivers/json'
+
 class Filebase
   class << self ; attr_accessor :storage ; end
-  self.storage = YAML
-	def initialize( root = '.', storage = nil )
-		@storage = ( storage || Filebase.storage ).new( root )
-	end
-	# delegate everything to the storage object ...
-	def method_missing( name,*args ) ; @storage.send( name, *args ) ; 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

@@ -1,44 +1,44 @@
 module Attributes
   
-	def initialize( hash = {} ) ; self.attributes = hash ; end
+	def initialize( assigns = {} ) ; self.attributes = assigns ; end
 	
 	def attributes=( hash )
-	  # copy the hash, converting all keys to strings
-		@attrs = hash.inject({}) { |h,p| k,v = p; h[k.to_s] = v; h  }
+	  @attrs = {}; hash.each { |k,v| @attrs[k.to_s] = v }
 	end
 	
 	def attributes ; @attrs ||= {} ; end
 	
-	def has_key?( key ) ; attributes.has_key?( key.to_s ) ; end
+	def has_key?( key ) ; @attrs.has_key?( key.to_s ) ; end
 	
-	def delete( key ) ; attributes.delete( key.to_s ) ; end
+	def keys; @attrs.keys; end
+	
+	def delete( key ) ; @attrs.delete( key.to_s ) ; end
 	
 	def method_missing(name,*args)
-	  name = name.to_s
-	  case args.length
-    when 0 then get( name )
-    when 1
-      if name[-1,1] == '=' 
-        set( name[0..-2], args[0] )
-      else
-        super
-      end
-    else super
-		end
+	  if args.empty?
+      get(name.to_s)
+    elsif (name = name.to_s) =~ /=$/
+      set(name.chop, args[0])
+    else
+      super
+    end
 	end
 	
-	def [](name) ; get(name) ; end
-	
-	def []=(name,val) ; set(name,val) ; end
-	
-	def set(name, val) ; attributes[name.to_s] = val ; end
-	
-	def get(name)
-		( ( rval = attributes[name.to_s] ).is_a?( Hash ) and attributes[name.to_s] = self.class.new( rval ) ) or rval
+	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_method :to_hash, :to_h
+	alias :set :[]=
+	alias :get :[]
+  alias :to_hash :to_h
   
+	
 end

data/lib/filebase/drivers/json.rb

@@ -0,0 +1,52 @@
+require 'json'
+require 'fileutils'
+require 'filebase/drivers/mixin'
+
+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,44 @@
+require 'fileutils'
+require 'filebase/drivers/mixin'
+
+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,45 @@
+require 'yaml'
+require 'fileutils'
+require 'filebase/drivers/mixin'
+
+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

@@ -5,13 +5,14 @@ class Filebase
   Error = RuntimeError
 	
 	module Model
-		
-		def self.[]( path )
+	  
+		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
-              @db = Filebase.new( path )
+  		        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
@@ -23,57 +24,175 @@ class Filebase
 		  
 		  module ClassMethods
 		    attr_accessor :db
-		    def create( assigns ) ; save( new( assigns ) ) ; end
-		    def all ; db.all.map { |attrs| new( attrs ) } ; end
-		    def find( key ) ; attrs = db.find( key ); new( attrs ) if attrs ; end
-		    def []( key ) ; find( key ) ; end
+		    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 )
-		      raise( Filebase::Error.new, 'attempted to save an object with nil key' ) if object.key.nil? or object.key.empty?
-          db.save( object.key, object.to_h ) and 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 )
-		      raise( Filebase::Error.new, 'attempted to delete an object with nil key' ) if object.key.nil? or object.key.empty?
-		      db.delete( object.key )
+		      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( name, options = {} )
+		    
+		    def has_one( assoc_key, options = {} )
 		      module_eval do
-		        define_method name do
+		        define_method assoc_key do
+  	          foreign_class = options[:class] || Object.module_eval( assoc_key.to_s.camel_case )
   		        @has_one ||= {}
-    		      options[:class] ||= Object.module_eval( name.to_s.gsub(/(_)(\w)/) { $2.upcase }.gsub(/^([a-z])/) { $1.upcase } )
-		          @has_one[name] ||= options[:class].find( get( name ) ) 
+		          @has_one[assoc_key] ||= foreign_class.find( get( assoc_key ) ) 
 		        end
-		        define_method( name.to_s + '=' ) do | val |
-  		        @has_one ||= {}; @has_one[name] = nil
-		          set( name, String === val ? val : val.key )
+		        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( name, options = {} )
+		    
+		    def has_many( assoc_key, options = {} )
 		      module_eval do
-		        define_method( name ) do
+		        define_method( assoc_key ) do
+  	          foreign_class = options[:class] || Object.module_eval( assoc_key.to_s.camel_case )
 		          @has_many ||= {}
-    		      options[:class] ||= Object.module_eval( name.to_s.camel_case )
-		          @has_many[name] ||= ( get( name ) || [] ).uniq.map { |key| options[:class].find( key ) } 
+		          @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
-            (class<<self;self;end).module_eval do
-              old_save = instance_method(:save)
-              define_method :save do |object|
-  		          object.set( name, object.send( name ).map{ |x| x.key }.uniq )
-                old_save.bind(self).call(object)
+            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 initialize( assigns ) ; super ; assign( assigns ) ; end
-        def assign( assigns ) ; assigns.each { |k,v| self.send( "#{k}=", v ) }; self ; end
-        def save ; self.class.save( self ) ; self; end
+        def save ; self.class.save( self ) ; end
         def delete ; self.class.delete( self ) ; self ; end
-        def ==(object) ; key == object.key ; end
-        def eql?(object) ; key == object.key ; 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
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: filebase
 version: !ruby/object:Gem::Version 
-  version: 0.3.6
+  version: 0.3.10
 platform: ruby
 authors: 
 - Dan Yoder
@@ -18,9 +18,19 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - "="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 0.6.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.1.7
     version: 
 description: 
 email: dan@zeraweb.com
@@ -31,8 +41,11 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/drivers/yaml.rb
 - 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
@@ -57,7 +70,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: filebase
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Simple file-based database with model support.

data/lib/drivers/yaml.rb

@@ -1,35 +0,0 @@
-require 'yaml'
-require 'extensions/io'
-class Filebase
-  
-  class YAML
-    
-    def initialize( root )
-      @root = root.to_s
-    end
-    
-  	def path( key )
-  	  File.join( @root, key.to_s ) + '.yml'
-  	end
-  	
-  	def all
-  	  Dir[ path('*') ].map { |file| find( File.basename(file,'.yml' ) ) }.compact
-  	end
-    
-    def find( key )
-  		obj = ::YAML.load( File.read( path( key ) ) ) rescue nil
-  		obj['key'] = key if Hash === obj
-  		obj or nil # convert false to nil
-  	end
-  	
-  	def save( key, object )
-  		File.write( path( key ), object.to_yaml ) and object
-  	end
-  	
-  	def delete( key )
-  		FileUtils.remove( path( key ) )
-	  end
-	  
-	end
-
-end