dm-xml-adapter 0.2

data/README

@@ -0,0 +1 @@
+This is an XML adapter.

data/lib/dm-xml-adapter.rb

@@ -0,0 +1,217 @@
+require 'rubygems'
+require 'dm-core'
+require 'builder'
+require 'dm-core/adapters/abstract_adapter'
+require 'pp'
+gem 'libxml-ruby', '>= 0.8.3'
+require 'xml'
+
+module DataMapper::Adapters
+
+  class XmlAdapter < AbstractAdapter      
+
+    def initialize(name, options)
+      super
+
+      @options = Hash.new
+      @options[:directory] = options[:directory]
+      @options[:directory] ||= './db'         
+   
+      @last_used_id = Hash.new
+
+    end
+    
+    def destroy_model_storage(repository, model)
+	    FileUtils.rm_rf(classname_to_dir(model.to_s))
+    end
+    
+    def create_model_storage(repository, model)
+	    FileUtils.mkdir_p(classname_to_dir(model.to_s))
+    end
+   
+    def create(resources) 
+       resources.each do |resource|
+	       model = resource.model
+	       id = find_free_id_for(resource.class.to_s)
+	       # find name of key attribute
+	       key = model.key.first.name
+	       resource.attributes[key] = id
+	       resource.instance_variable_set("@" + key.to_s, id)
+	       save(resource)
+       end
+       return resources.size
+    end
+    
+    def delete(collection)
+	    collection.each do |result|
+                    @last_used_id[result.class.to_s] = result.key.first
+		    xml_destroy(result)
+	    end
+	    return collection.size
+    end
+    
+    def update(attributes, collection)
+	    # ok, for each object found we have to update the attribs we found
+	    # first thing is figure out what class we are dealing with
+	    # iterate over every object in this set and set the given attributes
+	    collection.each do |obj|
+		    attributes.each do |attrib|
+			    # attrib is an array
+			    # first member is Property object
+			    # second member is the value
+			    obj.instance_variable_set("@" + attrib[0].name.to_s, attrib[1])
+		    end
+		    save(obj)
+	    end
+            return collection
+    end
+   
+    def read(query)
+            #puts "READING #{query.conditions}"
+            #puts query.conditions.operands.inspect
+	    return filter_result_set(get_all(query.model), query)
+    end
+  
+  private
+  
+  	def xml_destroy(resource)
+		# take an objects class and ID and figure
+		# out what file it's in
+		# and then remove that file
+		class_name = resource.class.to_s
+		id = resource.key.first
+		file = class_name_to_file(class_name, id)
+		File.unlink(file)
+	end
+	
+	def filter_result_set(objects, query)
+                #puts "before filter: #{objects.inspect}"
+		result_set = objects.clone
+                result_set = query.filter_records(result_set)
+                #puts "After filter: #{result_set.inspect}"
+		return query.filter_records(result_set)
+	end
+  	
+  	def get_all(model)
+		objects = Array.new
+		directory = classname_to_dir(model.to_s)
+		if ! File.exists?(directory)
+			return objects
+		end
+		Dir.glob(directory / "*.xml").each do |entry|
+			objects << file_to_object(entry, model)
+		end
+		return objects
+	end
+ 
+        def is_integer?(number)
+            if number.class == String and number.match(/^\-*[0-9]+$/) 
+                return true 
+            end
+            return false
+        end
+	
+	def file_to_object(file, model)
+		
+		# allocate new object to receive these fields
+                if (model.to_s.match(/\:\:/)) 
+                   modname, clazz = model.to_s.split("::")
+		   new_obj = Kernel.const_get(modname).const_get(clazz).new
+                else
+                   clazz = model.to_s
+                   new_obj = Kernel.const_get(clazz).new
+                end
+		
+		# file is our XML file
+		string = IO.read(file)
+		parser = XML::Parser.string(string)
+		doc = parser.parse
+		root_node = doc.root
+		# iterate over children
+		root_node.children.each do |child|
+			child_class = child.attributes["class"]
+			if child_class != nil
+				# this means we have an attribute
+				if (child_class == "Integer")
+					new_obj.instance_variable_set("@#{child.name}", child.content.to_i)
+				elsif (child_class == "String")
+					new_obj.instance_variable_set("@#{child.name}", child.content)
+				elsif (child_class == "TrueClass")
+					new_obj.instance_variable_set("@#{child.name}", true)
+				elsif (child_class == "FalseClass")
+					new_obj.instance_variable_set("@#{child.name}", false)
+				elsif (child_class == "DateTime")
+					new_obj.instance_variable_set("@#{child.name}", DateTime.parse(child.content))
+				end
+			end
+		end
+		
+		return new_obj
+	end
+  	
+   	def find_free_id_for(class_name)
+		# if there are no entries in the directory
+                # or the directory doesn't exist
+		# we need to create it...
+		if ! File.exists?(classname_to_dir(class_name))
+			# default ID
+			return 1
+		end
+		directory = Dir.new(classname_to_dir(class_name))
+		if directory.entries.size == 0
+			return 1
+		end
+		id = @last_used_id[class_name] || 0
+		while true do
+			if ! File.exists?(File.join(directory.path, id.to_s + ".xml"))
+                                @last_used_id[class_name] = id
+				return id
+			end
+                        id += 1
+		end
+	end
+  	
+        def save(resource)
+		file = File.join(class_name_to_file(resource.class.to_s, resource.key.first))
+		# see if the directory exists, if it doesn't, we need to create it
+		if ! File.exists?(classname_to_dir(resource.class.to_s))
+			FileUtils.mkdir_p(classname_to_dir(resource.class.to_s))
+		end
+		xmlfile = File.new(class_name_to_file(resource.class.to_s, resource.key.first), "w")
+		# puts resource.model.properties.inspect
+		
+		# set up builder
+		outString = ""
+		xml = Builder::XmlMarkup.new(:target => outString, :indent => 1)
+		
+                # iterate over the resource and figure out the fields
+                class_name = resource.model.to_s.gsub(/\:/, "_")
+		xml.tag!("RubyObject", :class => resource.model.to_s) do
+			resource.model.properties.each do |property|
+                                #puts "saving prop: #{property.name}"
+				#puts "primitive: #{property.primitive}"
+				value = resource.instance_variable_get("@" + property.name.to_s) 
+				# special case for false
+				if property.primitive == TrueClass and value == false
+				    xml.tag!(property.name.to_s, false, :class => FalseClass.to_s)
+				elsif (value != nil) 
+				    xml.tag!(property.name.to_s, value, :class => property.primitive) 
+                                end
+			end
+		end
+		xmlfile.puts outString
+		xmlfile.close
+	end
+
+	def classname_to_dir(class_name)
+		return File.join(@options[:directory], 
+                   class_name.gsub("/", "_").gsub(":", "_"))
+	end
+	
+	def class_name_to_file(class_name, id)
+		return File.join(classname_to_dir(class_name), id.to_s + ".xml")
+	end
+	
+    end
+end
+

data/lib/ratecounter.rb

@@ -0,0 +1,23 @@
+class RateCounter
+
+attr_accessor :samples, :sampledata
+
+def initialize(samples = 50)
+    self.samples = samples 
+    self.sampledata = Array.new 
+end
+
+def tick
+    self.sampledata << Time.now
+    while (self.sampledata.length > 50) do
+        self.sampledata.delete(self.sampledata.first)
+    end
+end
+
+def rate
+    numSeconds = self.sampledata.last - self.sampledata.first
+    return 0 if self.sampledata.length == 0 || numSeconds == 0 
+    return self.sampledata.length.to_f / numSeconds.to_f
+end
+
+end

data/spec/dm-xml-adapter_spec.rb

@@ -0,0 +1,129 @@
+require 'rubygems'
+require 'dm-core'
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path + 'spec_helper'
+
+describe DataMapper::Adapters::XmlAdapter do
+  before(:all) do
+     @adapter = DataMapper.setup(:default, {:adapter => 'xml', :directory => 'db'})
+  end
+  
+  after(:all) do
+          XMLTest::User.all.each {|u| u.destroy }
+          XMLTest::Post.all.each {|p| p.destroy }
+          AutoQuote.all.each {|aq| aq.destroy }
+  end
+  
+
+  describe "CRUD" do
+
+     describe "non-namedspaced class" do
+        it "should be able to persist" do
+            AutoQuote.create(:fullname => "Joshua Harding") 
+            AutoQuote.all.size.should == 1
+        end
+     end
+  
+     describe "content attribute" do
+        it "should be able to handle a content attribute" do
+           XMLTest::User.create(:name => "contentking", :content => "cool")
+           XMLTest::User.all.size.should == 1
+        end
+     end
+   
+     describe "datetime" do
+        it "should do datetime" do
+           u1 = XMLTest::User.new
+           u1.name = "cool!"
+           u1.created = DateTime.now
+           u1.save
+           u2 = XMLTest::User.first(:name => "cool!")           
+           u2.created.class.should == DateTime
+        end
+     end
+
+     describe "boolean" do
+         it "should be boolean" do 
+            u1 = XMLTest::User.new
+            u1.name = "yes"
+            u1.cool = true 
+            u1.save
+            u2 = XMLTest::User.first(:name => "yes")
+            u2.cool.class.should == TrueClass
+         end
+         it "falso thing" do
+            u1 = XMLTest::User.new
+            u1.name = "yes2"
+            u1.cool = false
+	    u1.save
+            u2 = XMLTest::User.first(:name => "yes2")
+            u2.cool.class.should == FalseClass 
+         end
+     end
+ 
+     describe "associations" do
+        it "should have associations" do
+           u1 = XMLTest::User.new
+ 	   u1.name = "bob"
+           u1.save 
+           p1 = XMLTest::Post.new
+           p1.title = "title o' post"
+           u1.posts << p1
+           p1.save
+           p2 = XMLTest::Post.new
+	   p2.title = "title of the second post"
+           u1.posts << p2
+           p2.save
+	   u1.posts.size.should == 2
+           u3 = XMLTest::User.first(:name => "bob")
+           u3.posts.size.should == 2
+        end
+     end
+  
+     describe "get all" do
+        it "should get all" do
+           XMLTest::User.create(:name => :yeah)
+           XMLTest::User.all.should_not == nil
+        end
+     end
+ 
+     describe "update" do
+        it "should update" do
+         u1 = XMLTest::User.new
+         u1.name = "bob"
+         u1.save 
+         u1.name = "steve"
+         u1.save
+         u1.name.should_not == "bob"
+        end
+     end
+
+     describe "create" do
+        it "should create" do
+           u = XMLTest::User.new
+           u.save
+           u.user_id.should_not == nil
+        end 
+     end
+     
+     describe "delete" do 
+	     it "should delete someone" do
+		     user = XMLTest::User.create
+		     user.destroy.should == true
+     	     end     
+     end
+ 
+     describe "find not" do
+             it "should find someone with a not clause" do
+                     user1 = XMLTest::User.create(:name => "joe")
+                     user2 = XMLTest::User.create(:name => "bob")
+                     users = XMLTest::User.all(:user_id.not => user1.user_id) 
+                     users.first.user_id.should_not == user1.user_id 
+             end
+     end
+ 
+  end
+  
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'dm-core'
+require 'pathname'
+require Pathname(__FILE__).dirname.parent.expand_path + 'lib/dm-xml-adapter'
+
+
+class AutoQuote
+    include DataMapper::Resource
+ 
+    property :quote_id, Serial
+    property :fullname, String
+end
+
+module XMLTest
+class Post
+  include DataMapper::Resource
+ 
+  property :post_id, Serial
+  property :title, String
+  property :created, DateTime
+  
+  belongs_to :user, :model => "User"
+end
+ 
+class User
+  include DataMapper::Resource
+  
+  property :user_id, Serial
+  property :name, String
+  property :age, Integer
+  property :created, DateTime
+  property :cool, Boolean
+  property :content, String
+  
+  has n, :posts, :model => "Post"
+end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: dm-xml-adapter
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+platform: ruby
+authors: 
+- Joshua Harding
+autorequire: dm-xml-adapter
+bindir: bin
+cert_chain: []
+
+date: 2009-10-23 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: libxml-ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: josh@statewidesoftware.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/dm-xml-adapter.rb
+- lib/ratecounter.rb
+- spec/dm-xml-adapter_spec.rb
+- spec/spec_helper.rb
+- README
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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 XML adapter for DataMapper. this adapter allows you to use DataMapper with XML files as a backing store.
+test_files: 
+- spec/dm-xml-adapter_spec.rb
+- spec/spec_helper.rb