def _create_schema_item(self,view):
mkParcel = self._get_parcel_factory(view)
if isinstance(mkParcel, ItemClass):
# Avoid circular dependency if parcel kind might be inside parcel
try:
item = Base("tmp_"+self.name, view, None)
except ValueError:
print "failed creation of",self
raise
item.__class__ = mkParcel
return item
from application.Parcel import Parcel
kind = itemFor(Parcel, view)
return mkParcel(self.name, self.getParent(view), kind)
def __init__(self, path, parent, view):
ContentHandler.__init__(self)
self.path = path
self.cwd = [os.path.dirname(path)]
self.parent = [parent]
self.view = view
self.hooks = []
packs = view.getRoot('Packs')
if packs is None:
packs = Item('Packs', view, None)
self.packs = packs
def testSubAttributes(self):
"""Test attributes which have sub attributes (subAttributes and superAttribute attributes)"""
itemKind = self._find('//Schema/Core/Item')
self.assert_(itemKind is not None)
item = Item('item1', self.rep, itemKind)
attrKind = itemKind.itsParent['Attribute']
# subattributes are created by assigning the "parent" attribute
# to the superAttribute attribute of the "child" attribute
issuesAttr = itemKind.getAttribute('issues')
criticalSubAttr = Attribute('critical', issuesAttr, attrKind)
criticalSubAttr.superAttribute = issuesAttr
self.assert_(criticalSubAttr.superAttribute is issuesAttr)
self.assert_(criticalSubAttr in issuesAttr.subAttributes)
# now do it by assigning to the subAttributes list to ensure that
# the bidirectional ref is getting updated.
normalSubAttr = Attribute('normal', issuesAttr, attrKind)
issuesAttr.subAttributes.append(normalSubAttr)
self.assert_(normalSubAttr.superAttribute is issuesAttr)
self.assert_(normalSubAttr in issuesAttr.subAttributes)
# now do it by callin addValue on the Attribute item
minorSubAttr = Attribute('minor', issuesAttr, attrKind)
issuesAttr.addValue('subAttributes', minorSubAttr)
self.assert_(minorSubAttr.superAttribute is issuesAttr)
self.assert_(minorSubAttr in issuesAttr.subAttributes)
# now write what we've done and read it back
self._reopenRepository()
item = self._find('//item1')
itemKind = item.itsKind
issuesAttr = itemKind.getAttribute('issues')
attMap = {}
for i in issuesAttr.subAttributes:
attMap[i.itsName] = i
criticalSubAttr = attMap['critical']
normalSubAttr = attMap['normal']
minorSubAttr = attMap['minor']
self.assert_(criticalSubAttr.superAttribute is issuesAttr)
self.assert_(criticalSubAttr in issuesAttr.subAttributes)
self.assert_(normalSubAttr.superAttribute is issuesAttr)
self.assert_(normalSubAttr in issuesAttr.subAttributes)
self.assert_(minorSubAttr.superAttribute is issuesAttr)
self.assert_(minorSubAttr in issuesAttr.subAttributes)
def packStart(self, attrs):
if attrs.has_key('cwd'):
self.cwd[-1] = os.path.join(self.cwd[-1], attrs['cwd'])
if attrs.has_key('file'):
if not self.view.find(Path('//', 'Packs', attrs['name'])):
try:
self.view.loadPack(
os.path.join(self.cwd[-1], attrs['file']),
self.parent[-1])
except:
self.saveException()
return
else:
self.name = attrs['name']
self.pack = Item(self.name, self.packs, None)
self.hooks.append([])
def testLiteralAttributes(self):
"""Test basic features of literal attributes"""
kind = self._find('//Schema/Core/Kind')
itemKind = self._find('//Schema/Core/Item')
self.assert_(itemKind is not None)
kind1 = Item('kind1', self.rep, kind)
self.assert_(kind1 is not None)
item1 = Item('item1', self.rep, itemKind)
self.assert_(item1 is not None)
#Test hasAttributeAspect and getAttributeAspect
self.assert_(kind1.hasAttributeAspect('attributes','cardinality') and
kind1.getAttributeAspect('attributes','cardinality') == 'list')
self.assert_(kind1.hasAttributeAspect('superKinds','cardinality') and
kind1.getAttributeAspect('superKinds','cardinality') == 'list')
self.assert_(kind1.hasAttributeAspect('classes','cardinality') and
kind1.getAttributeAspect('classes','cardinality') == 'dict')
# up to here displayName is an unset Chandler attribute
self.failUnlessRaises(AttributeError, lambda: item1.displayName)
# now set the attribute
item1.setAttributeValue('displayName', 'myName')
self.assertEquals(item1.displayName, 'myName')
#test __getattr__ and getAttributeValue() access
self.assertEquals(item1.displayName, item1.getAttributeValue('displayName'))
# now remove attribute value
item1.removeAttributeValue('displayName')
self.failUnlessRaises(AttributeError, lambda: item1.displayName)
#TODO need a test for list valued literal attribute
# test dict valued literal attribute
self.assert_(kind.classes['python'] is not None)
def __init__(self, name, parent, kind):
Item.__init__(self, name, parent, kind)
self.initCalled = True
def _logChange(self, item, version, status, values, references):
logger = item.itsView.logger
logger.info("%s %d 0x%0.4x\n values: %s\n refs: %s",
Item.__repr__(item), version, status, values, references)
def testLiteralAttributes(self):
"""Test basic features of literal attributes"""
kind = self._find('//Schema/Core/Kind')
itemKind = self._find('//Schema/Core/Item')
self.assert_(itemKind is not None)
kind1 = Item('kind1', self.rep, kind)
self.assert_(kind1 is not None)
item1 = Item('item1', self.rep, itemKind)
self.assert_(item1 is not None)
#Test hasAttributeAspect and getAttributeAspect
self.assert_(
kind1.hasAttributeAspect('attributes', 'cardinality') and
kind1.getAttributeAspect('attributes', 'cardinality') == 'list')
self.assert_(
kind1.hasAttributeAspect('superKinds', 'cardinality') and
kind1.getAttributeAspect('superKinds', 'cardinality') == 'list')
self.assert_(
kind1.hasAttributeAspect('classes', 'cardinality')
and kind1.getAttributeAspect('classes', 'cardinality') == 'dict')
# up to here displayName is an unset Chandler attribute
self.failUnlessRaises(AttributeError, lambda: item1.displayName)
# now set the attribute
item1.setAttributeValue('displayName', 'myName')
self.assertEquals(item1.displayName, 'myName')
#test __getattr__ and getAttributeValue() access
self.assertEquals(item1.displayName,
item1.getAttributeValue('displayName'))
# now remove attribute value
item1.removeAttributeValue('displayName')
self.failUnlessRaises(AttributeError, lambda: item1.displayName)
#TODO need a test for list valued literal attribute
# test dict valued literal attribute
self.assert_(kind.classes['python'] is not None)
def _logChange(self, item, version, status, values, references):
logger = item.itsView.logger
logger.info("%s %d 0x%0.4x\n values: %s\n refs: %s", Item.__repr__(item), version, status, values, references)
def testItemParentChild(self):
"""Test basic attribute functionality, focusing on parent-child relationships"""
# Test find()
kind = self._find("//Schema/Core/Item")
self.assert_(kind is not None)
# Test getItemDisplayName
self.assertEquals(kind.getItemDisplayName(), "Item")
# Test itsPath
self.assertEquals(str(kind.itsPath), "//Schema/Core/Item")
# Test simple item construction
item = Item("test", self.rep, kind)
self.assert_(item is not None)
self.assert_(item.isItemOf(kind))
self.failIf(item.isRemote())
self.failIf(item.hasChildren())
self.assertEquals(item.getItemDisplayName(), "test")
self.assertItemPathEqual(item, "//test")
self.assertEquals(item.refCount(), 0)
self.assert_(item.isNew())
self.assert_(item.isDirty())
self.failIf(item.isDeleted())
self.failIf(item.isStale())
self.assertEquals(self.rep.view, item.itsView)
# TODO test toXML
out = StringIO()
generator = XMLPrettyGenerator(XMLGenerator(out))
itemWriter = XMLItemWriter(generator)
generator.startDocument()
itemWriter.writeItem(item, item.getVersion())
generator.endDocument()
xml = out.getvalue()
out.close()
self.failIf(xml is None)
# Test to see that item became a respository root
self.rep.commit()
roots = list(self.rep.iterRoots())
self.assert_(item in roots)
self.failIf(item.isDirty())
# Test placing children
child1 = Item("child1", item, kind)
self.assertEquals(child1.getItemDisplayName(), "child1")
self.assertItemPathEqual(child1, "//test/child1")
self.assert_(item.hasChildren())
self.assert_(item.hasChild("child1"))
item.placeChild(child1, None)
self.assert_(item.hasChild("child1"))
self.failIf(item.isNew())
self.assert_(item.isDirty())
child2 = Item("child2", item, kind)
self.assertEquals(child2.getItemDisplayName(), "child2")
self.assertItemPathEqual(child2, "//test/child2")
self.assert_(item.hasChildren())
self.assert_(item.hasChild("child1"))
self.assert_(item.hasChild("child2"))
item.placeChild(child2, child1)
self.assert_(item.hasChild("child2"))
self.failIf(item.isNew())
self.assert_(item.isDirty())
self.assertEqual(item.getItemChild("child1"), child1)
self.assertEqual(item.getItemChild("child2"), child2)
self.assertEqual(child1.itsParent, item)
self.assertEqual(child2.itsParent, item)
# Test iterating over child items
iter = item.iterChildren()
self.assertEqual(item.getItemChild("child1"), iter.next())
self.assertEqual(item.getItemChild("child2"), iter.next())
# self.failUnlessRaises(StopIteration, lambda: iter.next())
# now write what we've done and read it back
self._reopenRepository()
item = self._find("//test")
child1 = item["child1"]
child2 = item["child2"]
self.assertIsRoot(item)
self.assert_(item.hasChildren())
self.assert_(item.hasChild("child1"))
self.assert_(item.hasChild("child2"))
# Test item renaming, itsName
kind = self._find("//Schema/Core/Item")
child3 = Item("busted", item, kind)
self.assertEqual(child3.itsName, "busted")
child3.itsName = "busted"
self.assertEqual(child3.itsName, "busted")
child3.itsName = "child3"
self.assertEqual(child3.itsName, "child3")
# Test that placing affects iteration order
item.placeChild(child3, child1)
iter = item.iterChildren()
iter.next()
self.assertEqual(child3, iter.next())
self.assertItemPathEqual(child3, "//test/child3")
self.assertIsRoot(child3.itsRoot)
# Test item movement to same parent
oldParent = child3.itsParent
child3.itsParent = child3.itsParent
self.assertEqual(oldParent, child3.itsParent)
self.assertItemPathEqual(child3, "//test/child3")
self.assertIsRoot(child3.itsRoot)
# Test item movement to leaf item
child3.itsParent = child2
self.assertEqual(child2, child3.itsParent)
self.assertItemPathEqual(child3, "//test/child2/child3")
self.assertIsRoot(child3.itsRoot)
# now write what we've done and read it back
self._reopenRepository()
item = self._find("//test")
child1 = item["child1"]
child2 = item["child2"]
child3 = child2["child3"]
self.assertEqual(child2, child3.itsParent)
self.assertItemPathEqual(child3, "//test/child2/child3")
self.assertIsRoot(child3.itsRoot)
# Test item movement to root
child3.itsParent = self.rep
self.assertIsRoot(child3)
self.assertItemPathEqual(child3, "//child3")
self.assertIsRoot(child3.itsRoot)
# now write what we've done and read it back
self._reopenRepository()
item = self._find("//test")
child1 = item["child1"]
child2 = item["child2"]
child3 = self.rep["child3"]
self.assert_(child3 in list(self.rep.iterRoots()))
self.assertItemPathEqual(child3, "//child3")
self.assertIsRoot(child3.itsRoot)
def testItemParentChild(self):
"""Test basic attribute functionality, focusing on parent-child relationships"""
# Test find()
kind = self._find('//Schema/Core/Item')
self.assert_(kind is not None)
# Test getItemDisplayName
self.assertEquals(kind.getItemDisplayName(), 'Item')
# Test itsPath
self.assertEquals(str(kind.itsPath), '//Schema/Core/Item')
# Test simple item construction
item = Item('test', self.rep, kind)
self.assert_(item is not None)
self.assert_(item.isItemOf(kind))
self.failIf(item.isRemote())
self.failIf(item.hasChildren())
self.assertEquals(item.getItemDisplayName(), 'test')
self.assertItemPathEqual(item, '//test')
self.assertEquals(item.refCount(), 0)
self.assert_(item.isNew())
self.assert_(item.isDirty())
self.failIf(item.isDeleted())
self.failIf(item.isStale())
self.assertEquals(self.rep.view, item.itsView)
#TODO test toXML
out = StringIO()
generator = XMLPrettyGenerator(XMLGenerator(out))
itemWriter = XMLItemWriter(generator)
generator.startDocument()
itemWriter.writeItem(item, item.getVersion())
generator.endDocument()
xml = out.getvalue()
out.close()
self.failIf(xml is None)
# Test to see that item became a respository root
self.rep.commit()
roots = list(self.rep.iterRoots())
self.assert_(item in roots)
self.failIf(item.isDirty())
# Test placing children
child1 = Item('child1', item, kind)
self.assertEquals(child1.getItemDisplayName(), 'child1')
self.assertItemPathEqual(child1, '//test/child1')
self.assert_(item.hasChildren())
self.assert_(item.hasChild('child1'))
item.placeChild(child1, None)
self.assert_(item.hasChild('child1'))
self.failIf(item.isNew())
self.assert_(item.isDirty())
child2 = Item('child2', item, kind)
self.assertEquals(child2.getItemDisplayName(), 'child2')
self.assertItemPathEqual(child2, '//test/child2')
self.assert_(item.hasChildren())
self.assert_(item.hasChild('child1'))
self.assert_(item.hasChild('child2'))
item.placeChild(child2, child1)
self.assert_(item.hasChild('child2'))
self.failIf(item.isNew())
self.assert_(item.isDirty())
self.assertEqual(item.getItemChild('child1'), child1)
self.assertEqual(item.getItemChild('child2'), child2)
self.assertEqual(child1.itsParent, item)
self.assertEqual(child2.itsParent, item)
# Test iterating over child items
iter = item.iterChildren()
self.assertEqual(item.getItemChild('child1'), iter.next())
self.assertEqual(item.getItemChild('child2'), iter.next())
# self.failUnlessRaises(StopIteration, lambda: iter.next())
# now write what we've done and read it back
self._reopenRepository()
item = self._find('//test')
child1 = item['child1']
child2 = item['child2']
self.assertIsRoot(item)
self.assert_(item.hasChildren())
self.assert_(item.hasChild('child1'))
self.assert_(item.hasChild('child2'))
# Test item renaming, itsName
kind = self._find('//Schema/Core/Item')
child3 = Item('busted', item, kind)
self.assertEqual(child3.itsName, 'busted')
child3.itsName = 'busted'
self.assertEqual(child3.itsName, 'busted')
child3.itsName = 'child3'
self.assertEqual(child3.itsName, 'child3')
# Test that placing affects iteration order
item.placeChild(child3, child1)
iter = item.iterChildren()
iter.next()
self.assertEqual(child3, iter.next())
self.assertItemPathEqual(child3, '//test/child3')
self.assertIsRoot(child3.itsRoot)
# Test item movement to same parent
oldParent = child3.itsParent
child3.itsParent = child3.itsParent
self.assertEqual(oldParent, child3.itsParent)
self.assertItemPathEqual(child3, '//test/child3')
self.assertIsRoot(child3.itsRoot)
# Test item movement to leaf item
child3.itsParent = child2
self.assertEqual(child2, child3.itsParent)
self.assertItemPathEqual(child3, '//test/child2/child3')
self.assertIsRoot(child3.itsRoot)
# now write what we've done and read it back
self._reopenRepository()
item = self._find('//test')
child1 = item['child1']
child2 = item['child2']
child3 = child2['child3']
self.assertEqual(child2, child3.itsParent)
self.assertItemPathEqual(child3, '//test/child2/child3')
self.assertIsRoot(child3.itsRoot)
# Test item movement to root
child3.itsParent = self.rep
self.assertIsRoot(child3)
self.assertItemPathEqual(child3, '//child3')
self.assertIsRoot(child3.itsRoot)
# now write what we've done and read it back
self._reopenRepository()
item = self._find('//test')
child1 = item['child1']
child2 = item['child2']
child3 = self.rep['child3']
self.assert_(child3 in list(self.rep.iterRoots()))
self.assertItemPathEqual(child3, '//child3')
self.assertIsRoot(child3.itsRoot)
def mkdir(parent, name, child):
if child is not None:
return child
return Item(name, parent, None)
def __init__(self, name, parent, kind):
Item.__init__(self, name, parent, kind)
self.initCalled = True
