Tag Archives: GSoC

collective.table, report #3

Work report

A week ago, myself and my mentor both participated in the Plone Sauna Sprint. It was an epic event, thanks to all sprinters for being that great throughout the week.

blog/rebooting-brain-on-sauna-sprintDuring the event my mentor and I discussed in great length how to approach challenges that collective.table presents. We want the table to be pluggable and reusable. We want to support having several tables on one page. We want to support having multiple backend data sources for our tables, with a dedicated configuration view for each data source.

Current status

Table works, we have one data source. Multiple sources are being supported, prototype for configuration view is ready.

Also, my brand new MacBook Pro died. Apparently RAM problems, or so they say at the repair shop. So now I am stuck using an old laptop, which hinders my ability to be productive.


First, I need to get my MacBook back from the repair shop to restore my normal working environment. Hopefully they can get it fixed in a couple of days.

Next thing on the menu is to polish and document configuration views for storages. Followed with tests for them.

After that, we’ll see how much more time we have until the GSoC deadline and decide priorities based on that.

collective.table alpha release


It’s now past the mid-term evaluation deadline for my Google Summer of Code project and it’s time to release my work out to the wider community to receive feedback and ideas on how to improve it.


During the last days I was focusing on polishing the first release: writing documentation, adding more comments, increasing test coverage and such. My plan was to have a public release just days before Sauna Sprint so I can start getting valuable feedback from the community on the progress and roadmap for the project.

But why did I chose Sauna Sprint as a deadline? Well, myself and my GSoC mentor Martijn Pieters will both be there for the entire sprint next week.Productivity will be through the roof if I can judge based on the number of Plone sprints I attended in the past. We’ll mainly be focusing on improving the UI and making our storage more scalable.

Give it a spin!

So: buckle-up, add collective.table to your eggs and give it a spin! Any and all feedback is greatly appreciated. The release is available on PyPI and code is available on GitHub.

collective.table GSoC report


It’s now been over a month since I started my Google Summer of Code project. It’s been a fun month, full of newly learned tricks, mostly courtesy of my mentor Martijn Pieters, Jarn AS.

Our goal is to have an ability in Plone to store arbitrary pieces of tabular data, in the same way that PHP CMSes often have their databases abused for other things. A simple intranet solution for everything that is now uploaded as Excel files: equipment lists, book loans, etc. It’s a list of items where members can add/edit columns and rows, and of course data.


Currently we are nearing the first alpha release, which should be out in about 10 days, when we have the GSoC mid-term report deadline. I already have the basic CRUD interface with data being stored in a dictionary as a simple zope annotation. Here’s a screenshot of how it looks in action:

blog/collective.table-screenshotAnyhow, I need to do some polishing first and to increase test coverage, then we’re ready for the first release!


By default collective.table comes with a simple zope annotation storage, called local storage that does not support advanced features, such as sorting and filtering.

For use-cases where sorting and filtering are needed, plus the dataset could be much bigger I plan to create another storage. I’m currently leaning towards using cornerstone.soup as a backend for this additional storage. In any case, collective.table is designed to support many pluggable data storages, so later on we can add SQL/NoSQL/whatever as a storage backend.

Also, for now we are focusing mostly on getting the base features working. In late July both myself and my mentor are attending this year’s Sauna Sprint where we plan to focus on UI and usability.

Collective SVN project -> GitHub

More and more Plone projects are being migrated over to GitHub for various reasons. Here’s a quick guide on how to import your Collective SVN project into GitHub.

GitHub can directly import SVN projects only by specifying a URL to the repository. However, for some reason this does not work for Collective SVN repositories. The import screen keeps processing but nothing happens. You are left with the manual approach of migrating a Collective SVN repository to GitHub.

GitHub account

Naturally, you first need an account at GitHub. Go register if you don’t already have one!

Git repository

Next you need to create a git repository. Login to GitHub and go to your Dashboard. Follow the New Repository button in the right-hand portlet and fill in the required fields. Click Create Repository. Great, your git repository is now ready!

Instead of creating a new git repository in your own account, you can also consider creating one in the unofficial “Collective” GitHub account – an experiment by a few fellow Plonistas to recreate the Collective spirit on GitHub.


Before proceeding you need to compile a list of people that committed code to your project. Do that by inspecting output of svn log http://svn.plone.org/svn/collective/<your.project>. Create a file called authors.txt where you map all SVN committers to GitHub users:

zupo = Nejc Zupan <[email protected]>

The format of the mapping is svn_username = git_username <git_email>. You can also generate this list automatically.

Using plone.org’s author page usually gives good enough results for connecting SVN usernames with real people:


First commit revision

The Collective SVN repository is huge. As of this writing, it has over 240k commits. Running “git svn clone” over the whole history takes quite some time. To speed things up, write down the revision number of the first commit in your Collective SVN repository. Inspecting the oldest entry of svn log http://svn.plone.org/svn/collective/<your.project> will give you this number.


There are many tools and approaches you one can use to perform migration from svn to git. This guide uses git-svn. While it has some limitations (branches and tags won’t be migrated) it does it’s job. All you need to do is run the following 4 commands:

$ git svn --authors-file=authors.txt clone -r<first_commit_revision>:HEAD -s \
http://svn.plone.org/svn/collective/<your.project> <your.project>
$ cd <your.project>
$ git remote add origin [email protected]:<your_git_username>/<your.project>.git
$ git push origin master

There, your project now happily lives inside a git repository on GitHub. Access it by pointing your browser to https://github.com/<your_git_username>/<your.project>.

Big thanks to Martijn Pieters of Jarn and Kai Lautaportti of HexagonIT for helping me out with my first steps using git and GitHub, you guys rock!

Useful links: