class Garment(item.Item, Enhancement): implements(iimaginary.IClothing, iimaginary.IDescriptionContributor) powerupInterfaces = (iimaginary.IClothing, iimaginary.IDescriptionContributor) thing = attributes.reference() # templated / constant stuff garmentSlots = attributes.textlist(allowNone=False) bulk = attributes.integer(allowNone=False, default=1) garmentDescription = attributes.text(doc=""" Description of this as an individual garment. """, allowNone=False) # transient / mutable stuff wearer = attributes.reference() wearLevel = attributes.integer(default=0) def conceptualize(self): return language.ExpressString(u'This can be worn.') def expressTo(self, observer): """ Describe the garment as it looks when it is worn. The garment's normal description is C{self.thing.description} or somesuch. """ return self.garmentDescription
class Product(Item): """ I represent a collection of powerups to install on a user store. When a user is to be endowed with the functionality described here, an Installation is created in its store based on me. """ types = textlist() def installProductOn(self, userstore): """ Creates an Installation in this user store for our collection of powerups, and then install those powerups on the user's store. """ def install(): i = Installation(store=userstore) i.types = self.types i.install() userstore.transact(install) def removeProductFrom(self, userstore): """ Uninstall all the powerups this product references and remove the Installation item from the user's store. Doesn't remove the actual powerups currently, but /should/ reactivate them if this product is reinstalled. """ def uninstall(): #this is probably highly insufficient, but i don't know the #requirements i = userstore.findFirst(Installation, Installation.types == self.types) i.uninstall() i.deleteFromStore() userstore.transact(uninstall) def installOrResume(self, userstore): """ Install this product on a user store. If this product has been installed on the user store already and the installation is suspended, it will be resumed. If it exists and is not suspended, an error will be raised. """ for i in userstore.query(Installation, Installation.types == self.types): if i.suspended: unsuspendTabProviders(i) return else: raise RuntimeError("installOrResume called for an" " installation that isn't suspended") else: self.installProductOn(userstore)
class KitchenSink(Item): """ An item with one of everything, more or less. """ t = text() i = integer() ts = timestamp() tl = textlist() d = ieee754_double() p1d = point1decimal() m = money()
class Installation(Item): """ I represent a collection of functionality installed on a user store. I reference a collection of powerups, probably designated by a Product. """ types = textlist() _items = textlist() suspended = boolean(default=False) def items(self): """ Loads the items this Installation refers to. """ for id in self._items: yield self.store.getItemByID(int(id)) items = property(items) def allPowerups(self): return set(chain(self.items, *[installedRequirements(self.store, i) for i in self.items])) allPowerups = property(allPowerups) def install(self): """ Called when installed on the user store. Installs my powerups. """ items = [] for typeName in self.types: it = self.store.findOrCreate(namedAny(typeName)) installOn(it, self.store) items.append(str(it.storeID).decode('ascii')) self._items = items def uninstall(self): """ Called when uninstalled from the user store. Uninstalls all my powerups. """ for item in self.items: uninstallFrom(item, self.store) self._items = []
class FlavorPermission(Item): """ I am associated with a top-level Blurb and specify the associated roles for all of its children. For example: if there is a top-level blurb X with the BLOG flavor, there might be a FlavorPermission associated with it that makes reference to a 'writer staff' role for the BLOG_POST flavor, which has permissions IViewable, ICommentable - but conspicuously omits IEditable. That collection of properties means that when posts are made on blog X they will be viewable and commentable by the writer staff, but not editable by them. A separate flavor permission might deal with the editorial staff. Each permission is a zope Interface object. """ # XXX "FlavorPermission" is a terrible name for this class, but I hope this # docstring is explanitory enough that someone else might help me think of # a better one. at any rate, it's *mainly* an implementation detail, # although there does need to be some UI for managing this. typeName = 'hyperbola_flavor_permission' flavor = text(doc=""" The 'flavor' attribute is the name of the flavor of a potential child of the blurb this permission applies to. For example, if this permission controls comments on a blurb that has the flavor FLAVOR.BLOG_POST, this attribute will be FLAVOR.BLOG_COMMENT. """) blurb = reference(doc=""" The 'blurb' attribute is a reference to a L{Blurb}, whose children this object is controlling the permissions of. """) role = reference(doc=""" The 'role' attribute is a reference to a L{Role}, which is the role that the permissions will be shared to. """) # XXX TODO -- right now sharing has a list of interfaces, axiom.dependecy # has a list of typeclasses, and hyperbola has this list of interfaces that # are slightly different than sharing's. we should implement a "list of # interface objects" attribute, and a "list of typeName" attribute, so the # logic around this can be more abstract. permissions = textlist(doc=""" A list of the names of Python interfaces that will be exposed to this permission's role. """)
class TaggedListyThing(Item): strlist = textlist()
class Dummy(Item): typeName = 'axiom_textlist_dummy' schemaVersion = 1 attribute = textlist(doc="a textlist")
class _DummyItem(Item): i = integer(default=5) t = text(doc=u'param t') tl = textlist(doc=u'param tl')
class IRCBotConfig(Item): typeName = 'eridanus_ircbotconfig' schemaVersion = 5 name = text(doc=""" The name of the network this config is for. """) hostname = bytes(doc=""" The hostname of the IRC server to connect to. """) portNumber = integer(doc=""" The port to connect to the IRC server on. """) nickname = text(doc=""" The bot's nickname. """) channels = textlist(doc=""" A C{list} of channels the bot should join. """, default=[]) ignores = textlist(doc=""" A C{list} of masks to ignore. """, default=[]) modes = bytes(doc=""" A string of user modes to set after successfully connecting to C{hostname}. """, default='B') def addChannel(self, channel): if channel not in self.channels: self.channels = self.channels + [channel] def removeChannel(self, channel): channels = self.channels while channel in channels: channels.remove(channel) self.channels = channels def isIgnored(self, mask): mask = util.normalizeMask(mask) for ignore in self.ignores: ignore = util.normalizeMask(ignore) if util.hostMatches(mask, ignore): return True return False def addIgnore(self, mask): mask = util.normalizeMask(mask) if mask not in self.ignores: self.ignores = self.ignores + [mask] return mask return None def removeIgnore(self, mask): def removeIgnores(mask): for ignore in self.ignores: normalizedIgnore = util.normalizeMask(ignore) if not util.hostMatches(normalizedIgnore, mask): yield ignore mask = util.normalizeMask(mask) newIgnores = list(removeIgnores(mask)) diff = set(self.ignores) - set(newIgnores) self.ignores = newIgnores return list(diff) or None
class Garment(item.Item, Enhancement): """ An enhancement for a L{Thing} representing its utility as an article of clothing. """ implements(iimaginary.IClothing, iimaginary.IDescriptionContributor, iimaginary.IMovementRestriction) powerupInterfaces = (iimaginary.IClothing, iimaginary.IDescriptionContributor, iimaginary.IMovementRestriction) thing = attributes.reference() # templated / constant stuff garmentSlots = attributes.textlist(allowNone=False) bulk = attributes.integer(allowNone=False, default=1) garmentDescription = attributes.text(doc=""" Description of this as an individual garment. """, allowNone=False) # transient / mutable stuff wearer = attributes.reference() wearLevel = attributes.integer(default=0) def contributeDescriptionFrom(self, paths): return language.ExpressString(u'This can be worn.') def expressTo(self, observer): """ Describe the garment as it looks when it is worn. The garment's normal description is C{self.thing.description} or somesuch. """ return self.garmentDescription def nowWornBy(self, wearer): """ This garment is now worn by the given wearer. As this garment is now on top, set its C{wearLevel} to be higher than any other L{Garment} related to the new C{wearer}. """ self.wearer = wearer self.wearLevel = wearer.store.query( Garment, Garment.wearer == wearer).getColumn("wearLevel").max(default=0) + 1 def noLongerWorn(self): """ This garment is no longer being worn by anyone. """ self.wearer = None self.wearLevel = None def movementImminent(self, movee, destination): """ Something is trying to move. Don't allow it if I'm currently worn. """ if self.wearer is not None and movee is self.thing: raise ActionFailure( ThatDoesntWork( # XXX I don't actually know who is performing the action # :-(. actor=self.wearer.thing, actorMessage=[ "You can't move ", language.Noun(self.thing).definiteNounPhrase(), " without removing it first." ]))