keepyourhead 0.2.0

data/lib/Keepyourhead/database/FileRoot.rb

@@ -0,0 +1,44 @@
+#	Copyright 2008 Burghard Oliver
+#
+#	This file is part of KeepYourHead.
+#
+#	KeepYourHead is free software: you can redistribute it and/or modify
+#	it under the terms of the GNU General Public License as published by
+#	the Free Software Foundation, either version 3 of the License, or
+#	(at your option) any later version.
+#
+#	KeepYourHead is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#	GNU General Public License for more details.
+#
+#	You should have received a copy of the GNU General Public License
+#	along with KeepYourHead.  If not, see <http://www.gnu.org/licenses/>.
+
+
+module KeepYourHead
+module Database
+	class FileRoot < BaseItemWithXml
+		def initialize( file, node )
+			super file, node
+			
+			assert self.version == Project::FILE_VERSION
+
+		end
+		
+		XmlAccessor.addAttribute self, :version, "version", :onItemChange, proc {  |item,v| v }
+		
+		xml = XmlAccessorElementList.new self, :collection, /^collection$/,
+			proc { |item,node|
+				item.objectFromNode(node) { 
+					Collection.new item.file, node  
+				} 
+			}
+
+		xml.addRead
+		xml.addInsert :onItemInsert
+		xml.addRemove :onItemRemove
+	end
+end 
+
+end

data/lib/Keepyourhead/database/Flashcard.rb

@@ -0,0 +1,116 @@
+#	Copyright 2008 Burghard Oliver
+#
+#	This file is part of KeepYourHead.
+#
+#	KeepYourHead is free software: you can redistribute it and/or modify
+#	it under the terms of the GNU General Public License as published by
+#	the Free Software Foundation, either version 3 of the License, or
+#	(at your option) any later version.
+#
+#	KeepYourHead is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#	GNU General Public License for more details.
+#
+#	You should have received a copy of the GNU General Public License
+#	along with KeepYourHead.  If not, see <http://www.gnu.org/licenses/>.
+
+
+module KeepYourHead
+module Database
+	class Flashcard < BaseItemWithXml
+		XmlAccessor::addElementCData self, :front, "front", :onItemChange, proc { |item,v| v || "" }
+		XmlAccessor::addElementCData self, :back, "back", :onItemChange, proc {  |item,v| v || "" }
+		
+		XmlAccessor::addAttribute self, :name, "name", :onItemChange, proc {  |item,v| v || "" }
+		XmlAccessor::addAttribute self, :type, "type", :onItemChange, proc {  |item,v| v || "" }
+		XmlAccessor::addAttribute self, :style, "style", :onItemChange, proc {  |item,v| v || "" }
+
+		XmlAccessor::addElementText self, :nextCheck, "nextCheck", :onItemChange, proc { |item, v| (v && Time.parse(v)) || (Time.now - 60) }
+		XmlAccessor::addElementText self, :level, "level", :onItemChange, proc { |item, v| (v && v.to_i) || 0 }
+
+#		XmlAccessor::addElementText self, :cacheFilename, "cacheFilename", nil 
+#		XmlAccessor::addElementText self, :cacheFrontContentHash, "cacheFrontContentHash",  nil
+#		XmlAccessor::addElementText self, :cacheFrontFileHash, "cacheFrontFileHash", nil
+#		XmlAccessor::addElementText self, :cacheBackContentHash, "cacheBackContentHash", nil
+
+
+# some functions defined on all database entities for iteration
+		def collectFlashcards
+			[self]
+		end
+		
+		def count
+			1
+		end
+		def countActive
+			active? ? 1 : 0
+		end
+		def countPassive
+			active? ? 0 : 1
+		end
+
+		def distribution
+			distribution = []
+		
+			distribution[self.level] = 1
+
+			distribution
+		end
+
+		def removeStatistics
+			self.level = 0
+			self.nextCheck = Time.new - 60
+		end
+
+
+
+
+		def active?
+			nextCheck <= Time.now
+		end
+		
+		def content(type, options = {})
+			styleInstance = file.style(self.style)
+			styleInstance.content(type, self, options)
+		end
+		def compileImage(type, options = {})
+			styleInstance = file.style(self.style)
+			compilation = styleInstance.createImage(type, self, options )
+		end
+
+		def collection
+			ret = self
+			while ret and not ret.kind_of? Collection
+				ret = ret.parent
+			end
+			ret
+		end
+
+		def topic
+			parent && parent.class == Topic && parent
+		end
+		def topicNames
+			topics = []
+
+			n = topic
+			while n do
+				topics << n.name
+				n = n.topic
+			end
+
+			topics = topics.reverse
+			topics
+		end
+
+
+		def self.createNode( file )
+			obj = Flashcard.new file, ::REXML::Element.new("flashcard")
+			obj.name = "neue Flashcard" 
+			obj.style = "latex"
+			obj.node
+		end
+	end
+end 
+
+end

data/lib/Keepyourhead/database/Topic.rb

@@ -0,0 +1,40 @@
+#	Copyright 2008 Burghard Oliver
+#
+#	This file is part of KeepYourHead.
+#
+#	KeepYourHead is free software: you can redistribute it and/or modify
+#	it under the terms of the GNU General Public License as published by
+#	the Free Software Foundation, either version 3 of the License, or
+#	(at your option) any later version.
+#
+#	KeepYourHead is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#	GNU General Public License for more details.
+#
+#	You should have received a copy of the GNU General Public License
+#	along with KeepYourHead.  If not, see <http://www.gnu.org/licenses/>.
+
+
+module KeepYourHead
+module Database
+	class Topic < BaseTopicFlashcardContainer
+		def initialize( file, node )
+			super file, node
+		end
+
+		XmlAccessor::addAttribute self, :name, "name", :onItemChange
+		
+		def topic
+			parent && parent.class == Topic && parent
+		end
+
+		def self.createNode(file)
+				obj = Topic.new file, ::REXML::Element.new("topic") 
+				obj.name = "neues Topic" 
+				obj.node
+		end
+	end
+end 
+end
+

data/lib/Keepyourhead/database/Visitor.rb

@@ -0,0 +1,33 @@
+#	Copyright 2008 Burghard Oliver
+#
+#	This file is part of KeepYourHead.
+#
+#	KeepYourHead is free software: you can redistribute it and/or modify
+#	it under the terms of the GNU General Public License as published by
+#	the Free Software Foundation, either version 3 of the License, or
+#	(at your option) any later version.
+#
+#	KeepYourHead is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#	GNU General Public License for more details.
+#
+#	You should have received a copy of the GNU General Public License
+#	along with KeepYourHead.  If not, see <http://www.gnu.org/licenses/>.
+
+
+module KeepYourHead
+module Database
+	class Visitor
+		def onItemChange(item)
+		end
+		def onItemRemove(item)
+		end
+		def onItemInsert(item)
+		end
+		def onReload()
+		end
+	end
+end 
+
+end

data/lib/Keepyourhead/database/XmlAccessor.rb

@@ -0,0 +1,315 @@
+#	Copyright 2008 Burghard Oliver
+#
+#	This file is part of KeepYourHead.
+#
+#	KeepYourHead is free software: you can redistribute it and/or modify
+#	it under the terms of the GNU General Public License as published by
+#	the Free Software Foundation, either version 3 of the License, or
+#	(at your option) any later version.
+#
+#	KeepYourHead is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#	GNU General Public License for more details.
+#
+#	You should have received a copy of the GNU General Public License
+#	along with KeepYourHead.  If not, see <http://www.gnu.org/licenses/>.
+
+
+module KeepYourHead
+module XmlAccessor
+	def xmlAccessorElementCDataRead( name, procRead )
+		parent = REXML::XPath.first( node, name )
+		ret = parent && parent.children.map{ |c|
+			case c
+			when REXML::Text
+				c.value
+			when REXML::CData
+				c.value
+			else
+				nil
+			end
+		}.compact.join("")
+		(procRead && procRead.call(self, ret) ) || ret
+	end
+
+	def xmlAccessorElementCDataWrite( name, notifyEvent, value, procWrite )
+		lastValue = (val = REXML::XPath.first( node, name )) && val.cdatas.map{ |cd| cd.value }.join("")
+		
+		
+		newValue = (procWrite && procWrite.call(self, value)) || value
+
+		node_ = REXML::XPath.first( node, name )
+		node_ ||= @node.add REXML::Element.new(name)
+
+		if lastValue != newValue then
+			node_.delete_at 0 while node_.length > 0
+
+			node_.add REXML::CData.new(newValue)
+
+			file.viewersSend notifyEvent, self if notifyEvent
+		end
+	end
+
+	def self.addElementCData( _class, functionName, elementName, notifyEvent, procRead = nil, procWrite = nil )
+		_class.my_define_method(functionName.to_sym) { 
+			xmlAccessorElementCDataRead elementName, procRead
+		}
+		_class.my_define_method( (functionName.to_s + "=").to_sym ) { |value| 
+			xmlAccessorElementCDataWrite elementName, notifyEvent, value, procWrite
+		}
+	end
+
+
+
+
+
+
+	def xmlAccessorAttributeRead( name, procRead )
+		ret = @node.attributes[name] 
+		(procRead && procRead.call(self, ret) ) || ret
+	end
+
+	def xmlAccessorAttributeWrite( name, notifyEvent, value, procWrite )
+		value = (procWrite && procWrite.call(self, value)) || value
+	
+		if @node.attributes[name] != value then
+			@node.attributes[name] = value
+
+			file.viewersSend notifyEvent, self if notifyEvent
+		end
+	end
+
+	def self.addAttribute( _class, functionName, elementName, notifyEvent, procRead = nil, procWrite = nil )
+		_class.my_define_method(functionName.to_sym) { 
+			xmlAccessorAttributeRead elementName, procRead
+		}
+		_class.my_define_method( (functionName.to_s + "=").to_sym ) { |value| 
+			xmlAccessorAttributeWrite elementName, notifyEvent, value, procWrite
+		}
+	end
+
+
+
+
+
+
+
+	def xmlAccessorElementTextRead( name, procRead )
+		n = REXML::XPath.first( node, name )
+		ret = n && n.text
+
+		(procRead && procRead.call(self,ret) ) || ret
+	end
+
+	def xmlAccessorElementTextWrite( name, notifyEvent, value, procWrite )
+		value = (procWrite && procWrite.call(self,value)) || value
+		
+		n = REXML::XPath.first( node, name )
+
+		if not n or n.text != value then
+			n ||= node.add REXML::Element.new(name)
+			n.text=value
+		
+			file.viewersSend notifyEvent, self if notifyEvent
+		end
+	end
+
+	def self.addElementText( _class, functionName, elementName, notifyEvent, procRead = nil, procWrite = nil )
+		_class.my_define_method(functionName.to_sym) { 
+			xmlAccessorElementTextRead elementName, procRead
+		}
+		_class.my_define_method( (functionName.to_s + "=").to_sym ) { |value| 
+			xmlAccessorElementTextWrite elementName, notifyEvent, value, procWrite
+		}
+	end
+	
+
+
+
+
+	
+	
+	def xmlAccessorElementListRead( name, procRead )
+		ret = @node.elements.select { |node| node.name =~ name }
+		ret.map! { |node|
+			(procRead && procRead.call(self,node) ) || node.name
+		}
+	end
+
+	def xmlAccessorElementListNext( name, procRead, other )
+		assert other.parent == self
+
+		ret = other.node
+		begin 
+			ret = ret.next_element
+		end while (ret and not ret.name =~ name)
+
+		return nil unless ret
+
+		(procRead && procRead.call(self,ret) ) || ret.name
+	end
+
+	def xmlAccessorElementListPrevious( name, procRead, other )
+		assert other.parent == self
+
+		ret = other.node
+		begin 
+			ret = ret.previous_element
+		end while ret and not ret.name =~ name
+
+		return nil unless ret
+
+		(procRead && procRead.call(self,ret) ) || ret.name
+	end
+
+	def xmlAccessorElementListRemove( name, notifyEvent, item )
+		assert item.node.name =~ name
+		assert item.parent == self
+		
+		file.viewersSend notifyEvent, item if notifyEvent
+
+		#node.delete_element item.node
+		item.node.remove
+		
+		item.node
+	end
+
+	def xmlAccessorElementListInsertFirst( name, notifyEvent, procRead, node )
+		assert node.kind_of?(REXML::Element)
+		assert node.name =~ name
+	
+		if self.node[0] then
+			self.node.insert_before self.node[0], node
+		else
+			self.node.add node
+		end 
+		
+		ret = (procRead && procRead.call(self,node) ) || node.name
+		
+		file.viewersSend notifyEvent, ret if notifyEvent
+
+		ret
+	end
+	
+	def xmlAccessorElementListInsertLast( name, notifyEvent, procRead, node )
+		assert node.kind_of?(REXML::Element)
+		assert node.name =~ name
+	
+		self.node.add node
+		
+		ret = (procRead && procRead.call(self,node) ) || node.name
+		
+		file.viewersSend notifyEvent, ret if notifyEvent
+
+		ret
+	end
+	
+	def xmlAccessorElementListInsertBefore( name, notifyEvent, procRead, node, other )
+		assert node.kind_of?(REXML::Element)
+		assert node.name =~ name
+		assert other
+
+		assert other.parent == self
+		other.node.parent.insert_before other.node, node
+#			other.node.previous_sibling = node
+		
+		ret = (procRead && procRead.call(self,node) ) || node.name
+		
+		file.viewersSend notifyEvent, ret if notifyEvent
+
+		ret
+	end
+	
+	def xmlAccessorElementListInsertAfter( name, notifyEvent, procRead, node, other )
+		assert node.kind_of?(REXML::Element)
+		assert node.name =~ name
+		assert other
+
+		assert other.parent == self
+		other.node.parent.insert_after other.node, node
+#		other.node.next_sibling = node
+		
+		ret = (procRead && procRead.call(self,node) ) || node.name
+		
+		file.viewersSend notifyEvent, ret if notifyEvent
+
+		ret
+	end
+	
+	def xmlAccessorElementListCreate( name, notifyEvent, procCreate )
+=begin
+		node = REXML::Element.new name
+
+		if self.node[0] then
+			self.node.insert_before self.node[0], node
+		else
+			self.node.add node
+		end 
+=end
+#			node = self.node.add_element name
+		node = self.node.add REXML::Element.new(name)
+
+		ret = (procCreate && procCreate.call(self,node)) || node.name
+	
+		file.viewersSend notifyEvent, ret if notifyEvent
+		
+		ret
+	end
+
+	class XmlAccessorElementList
+		attr_reader :_class, :functionName, :elementRegExp, :procRead
+		def initialize(_class, functionName, elementRegExp, procRead )
+			@_class, @functionName, @elementRegExp, @procRead =
+				_class, functionName, elementRegExp, procRead
+		end
+		def _addRead(elementRegExp,procRead)
+			_class.my_define_method((functionName.to_s + "s").to_sym) { 
+				xmlAccessorElementListRead elementRegExp, procRead
+			}
+			_class.my_define_method((functionName.to_s + "Next").to_sym) { |other|
+				xmlAccessorElementListNext elementRegExp, procRead, other
+			}
+			_class.my_define_method((functionName.to_s + "Previous").to_sym) { |other|
+				xmlAccessorElementListPrevious elementRegExp, procRead, other
+			}
+		end
+		def addRead
+			_addRead(elementRegExp, procRead)
+		end
+		def _addRemove(elementRegExp, notifyEvent)
+			_class.my_define_method((functionName.to_s + "Remove").to_sym) { |item|
+				xmlAccessorElementListRemove elementRegExp, notifyEvent, item
+			}
+		end
+		def addRemove(notifyEvent)
+			_addRemove(elementRegExp, notifyEvent)
+		end
+		def _addInsert(elementRegExp, procRead, notifyEvent)
+			_class.my_define_method((functionName.to_s + "InsertFirst").to_sym) { |node|
+				xmlAccessorElementListInsertFirst elementRegExp, notifyEvent, procRead, node
+			}
+			_class.my_define_method((functionName.to_s + "InsertLast").to_sym) { |node|
+				xmlAccessorElementListInsertLast elementRegExp, notifyEvent, procRead, node
+			}
+			_class.my_define_method((functionName.to_s + "InsertBefore").to_sym) { |node,other|
+				xmlAccessorElementListInsertBefore elementRegExp, notifyEvent, procRead, node, other
+			}
+			_class.my_define_method((functionName.to_s + "InsertAfter").to_sym) { |node,other|
+				xmlAccessorElementListInsertAfter elementRegExp, notifyEvent, procRead, node, other
+			}
+		end
+		def addInsert(notifyEvent)
+			_addInsert(elementRegExp, procRead, notifyEvent)
+		end
+		def addCreate(functionName, elementName, notifyEvent, procCreate)
+			_class.my_define_method((functionName.to_s + "Create").to_sym) { ||
+				xmlAccessorElementListCreate elementName, notifyEvent, procCreate
+			}
+		end
+	end
+end
+
+
+end
+