bigeasy / sequester Goto Github PK

• empty index.js.
• Add contribution guide.
• README.md with just one sentence.
• Minimal package.json.
• MIT LICENSE with correct year.
• .gitignore.
• Create an empty diary.md.
• Add a change log note to the diary.md about the initial commit.
• Create a single test.
• Create an Issue to publish 0.0.0 to NPM.

Implement a getter that returns the count of locks held by a specific lock instance.

• create gh-pages.
• create pages directory.
• create Makefile.
• create pages/index.html.
• copy README.md into edify.js.
• create a pedestrian README.
• create a project edify.js.
• create a package.json.
• create a .nojekyll.
• create a GitHub Pages README.
• create .gitignore.

A count down latch would be any number of shared followed by an exclusive that unlatches itself.

• Delete LICENSE.
• Update README.
• Add COPYING.
• Add COPYING.LESSER.
• Update package.json.
• Update release.md.

Discussion of Sequester and what it should be in its initial release.

Using Proof unit tests, create some examples of how to implement different locking operations with Sequester. Start with a simple mutex.

Import from Strata get it to export a class of some kind.

A latch would simply be calling exclusive before handing the lock off to someone else.

Simplifies the implementation of latches.

Allows for different ownership strategies.

To implement individual locks that can track the locks and unlocks a specific "thread" of execution we implement the queue as a common queue where locks are instances of locks that insert functions into the queue with an identifier that will track which locks did not completely release their locks or called unlock when locks were not held.

Submit coverage to Coveralls.

One simply calls the shared lock immediately upon entering the exclusive lock and before the next tick.

Primary reason to release 0.0.2 is the bug fix in #15.

Build on Travis CI.

We're not using nextTick, so we can do this directly in order.

When disposing a lock instance the instance asserts that it has no locks outstanding. The lock identifier is recycled.

• Update the Issue number in this Issue.
• Update change log.
• Create a release-0.0.0 branch using git checkout -b release-0.0.0.
• Update package.json version to 0.0.0.
• Commit with message git commit -a -m "Release 0.0.0.".
• Get the timestamp with git greenwich. (My own little git extension.)
• Add timestamp in README.md.
• Commit timestamp in previous commit with git commit --amend -a.
• Add "Closes #3." to commit git commit --amend -a.
• Clean the working directory of cruft using npm-cleanup. (My own little extension.)
• Publish with npm publish.
• Tag with git tag v0.0.0.
• Push to GitHub with git push origin v0.0.0.
• Checkout master with git checkout master.
• Merge with git splice release-0.0.0.
• Push to GitHub with git push origin HEAD.
• Delete branch with git branch -d release-0.0.0.

Calling shared from within an exclusive lock does not downgrade the lock, not if there has been a call to exclusive while the exclusive lock was held.

Should just redirect for now.

I find that if a resumed callback unlocks the lock, it will truncate the resume array and forEach will skip a callback.

Finding it useful to be able to specify the parameters passed to a shared function in the constructor when using Sequester to create a latch. The use case is when a latch is sometimes necessary but not always necessary, and when it is not always necessary you create a dummy latch that is already open, but in order to do so you must provide the value to the constructor that would have been provided by exclusive action of the latch.