Ideas list, 2015
This is the list of project ideas for Plone's participation in Google Summer of Code 2015. If you are a university student interested in working on these we highly recommend applying for the programme.
These ideas are guidelines only, please feel free to apply for any project you like. Get in touch with us on the core development mailing list.
We are participating in GSoC under the auspices of the Python Software Foundation. You will have to apply to the PSF to apply for a Plone project.
Note, most projects do not require the candidate to know Plone already, but we do expect applicants to have started to learn about Plone before applying. The specific technologies required for each project are listed alongside the title and in the details for the idea.
Better GenericSetup handlers
Summary
GenericSetup is used as a generic framework for import/export handlers in CMF and Plone. There are a good number of existing handlers that do useful imports and exports, but they contain various bugs and missing features that need to be addressed. Currently, the missing features are encouraging people to write their own single-use handlers.
Implementation
This will involve touching multiple Plone and CMF core packages, especially CMFCore. There are about 50 existing handlers spread around the Plone codebase, so the first step is to identify missing features in them by analyzing setuphandlers.py files in other products. For example, the portlet assignments handler only exports portlets on the site root, rather than ones anywhere in the site. This means the round-tripping of portlets has to be done manually, so is done in custom Python in practice.
Another example is that the structure handler for old and new style collections needs to be extended to use the same output format, so importing collections doesn't require implementation specific import configuration. This will also improve easy migrations between old and new style collections.
The existing handlers are also poor at remaining mutually consistent, existing handlers use purge=True attributes, .preserve files, etc as ways of marking configuration that should be excluded. These remove directives are never exported, as it's not possible to export that some configuration has been deleted, but poor design of the output formats makes it hard to make these stanzas manually.
Skills
Very good knowledge of Python and confidence with Zope features like catalogues and CMF's portal_setup.
Mentors
Matt Wilkes would love to mentor this.
Aims
Pull requests for Plone and CMF.
collective.cover JS improvements
Summary
collective.cover is a package that allows composition of page blocks into layouts, enabling administrators to define set ways pages look and delegating filling the blanks to content authors. This works great and is in production in many places, but it could do with some polish on the user interface. For example, it allows arbitrary numbers of columns within a row but they must all be the same size.
Implementation
Most of the polishing that's needed for cover is in CSS and Javascript, ensuring that all the admin pages look correct within Plone and that the content assignment system looks natural. Currently it uses multiple progress spinners, icons, etc that aren't used in other parts of Plone.
On top of that, the layout creation system only allows for rather basic layouts, without the ability to resize columns within the grid or assign arbitrary CSS. This section will require some Python to support the layout attributes, but it will also need some in-depth Javascript work to make sure the layout designer works correctly, intuitively and portably.
Skills
Excellent Javascript knowledge and basic Python.
Mentors
Héctor Velarde, Franco Pellegrini, Rob Gietema
Aims
A new release of collective.cover
Update PloneFormGen to use Dexterity
Summary
Products.PloneFormGen is a very commonly used add-on to Plone that allows people to build form logic into their websites. It is well maintained and well tested, and has had considerable effort expended on the user interface decisions, including past GSoC projects. The backend it uses is the content types framework introduced in Plone 2 which we are moving away from for performance reasons.
This project would be to use the Dexterity framework instead of Archetypes, but leave the rest of the product intact and working. Above all, it must be a smooth migration experience for existing users.
Implementation
Replace the core content types of PFG one at a time with Dexterity variants, using behaviors as required. This will involve planning out what behaviors are needed to minimise work and maximise reusability, then porting the types one at a time. They will need to retain their existing custom views, although any generic Plone UI that's archetypes specific can change if it's different in Dexterity.
Some parts of PloneFormGen use custom Archetypes fields, so these would need to be ported to be available in Dexterity, preferably by extending their package to add another, Dextrity based, field object rather than replacing them wholesale.
See Also
Skills
Basic Dexterity experience, some minor HTML and Javascript.
Mentors
Steve McMahon is the maintainer of PFG and would be the best mentor.
Aims
A branch of PFG for a new major release.
Improved Diff Viewer
Summary
Plone allows users to compare different versions of their content (and revert to previous versions, if required). However, the user interface for this is very technical and of limited use to most end-users. This project is to replace the current way of viewing diffs with one similar to tools users may experience elsewhere.
The biggest improvement that needs to be made is that of diffing HTML text. The current view is very colourful but not very useful. The changes behaviour for Wikipedia would be good to draw influence from, as would Microsoft Word's track changes feature.
In addition, many fields are not "inline-diffable", meaning the user has to switch to code view (which displays a poor side-by-side diff). One possible way of implementing this would be to re-use the UI of the edit form and highlight changes there.
Implementation
The functionality for generating diffs has been part of Plone for a long while. The main work here will be in designing a new UI that both accurately shows differences in field values and is easy to understand. This will, by necessity, be primarily a HTML and Javascript project, but some minor knowledge of Python will be needed. That's not to say you'd have a completely free hand in Javascript, though. The use of libraries in making this view would need to be cautious, as this is part of core Plone. Certainly no new JS frameworks could be introduced, but it would be good to explore diffing in javascript.
See Also
Skills
HTML, Javascript, minor Python use
Mentors
Hector Velarde
Aims
A pull request to be included in the next Plone release.
Improved text transforms
Summary
There is a system for converting data between mimetypes in Plone called portal_transforms. A previous GSoC project started a successor codebase, it requires integration into Plone and conversion of existing OOTB transforms. These transforms fall in to two major categories, those used for display (like text to HTML and HTML filtering), and those used for search (like PDF to text).
Implementation
Undoubtedly, the most important of these is the safe_html filter, as it is used on almost all Plone pages. It's very common for users to want to tweak its behaviour, allowing or disallowing certain tags. Currently this is very difficult indeed. A better implementation of the HTML filter using modern industry standards would be a great quick win here.
Following this, improvements to the general structure of the transforms is needed, to make them fit in with the rest of modern Plone and the component infrastructure. Much of this design work has already been done, but it can't be used until all the transforms have been ported across and the places that use transforms switched out to use the new API. Much of the difficult work in porting is done, so this phase of the project would be primarily about integration and verification of the new transforms.
Finally, some new transforms would be very much welcome in this project. There are many file formats that Plone handles opaquely, such as latex or ZIP files, which could potentially leverage the transforms architecture into improving searching. There are some really weird, blue sky thinking things that could be done here, such as example transforms for getting videos transcribed using mechanical turk, but that would be a stretch goal for students that do exceptionally well.
See Also
Skills
Python, Python and more Python! This is a Python heavyweight task that would involve good familiarity with file formats.
Mentors
Timo Stollenwerk
Aims
Firstly, an improved safe_html transform.
Then, a working Plone using plone.transforms exclusively. This would target Plone 6 eventually, so backwards compatibility isn’t a big issue. We'd want someone really motivated to help push this project into the core.
Dexterity schema specification through HTML
Summary
Dexterity content types are currently defined by a zope.schema based interface and/or an XML file. This is then used to generate a HTML form. This project would flip that around and take a HTML form definition and generate a dexterity type to back it.
Implementation
This would take a HTML5 form with supermodel hints in the data attributes of the form. It would need to be compatible with the other ways of generating dexterity types especially round-tripping TTW to the filesystem.
Specifically, it should also be possible to convert a pre-made dexterity form to a HTML page that would generate the same content type.
See Also
Skills
The Plone/Dexterity knowledge would be quite minimal as the supermodel package and associated code is quite clean and encapsulated. The documentation, however, is quite poor and a secondary objective would be to improve supermodel and autoform documentation.
Mentors
David Glick would be the perfect technical mentor/product owner, and a generalist as the first point of contact.
Aims
Extension to supermodel and dexterity that works with its release schedule.
Content Drafts
Summary
plone.app.drafts allows content that hasn't been finished yet to be auto-saved to a special location so that if the user has an issue with their browser or connection it's not lost.
Implementation
Integrate and extend plone.app.drafts into Plone with support for Archetypes and Dexterity. The back-end support is pretty much there but it needs a UI and integration with content type frameworks.
See Also
Skills
Plenty of Python and knowledge of Zope. Experience in dexterity would certainly be helpful.
Mentors
Ramon Navarro Bosch or Nathan van Gheem would be great mentors
Aims
Improvements of existing packages and PLIP for Plone 5
New theme pack
Summary
Diazo allows us to use HTML and Javascript mockups as themes relatively easily. We currently have very few good quality examples. This project would be to create HTML/JS themes for Plone which can later be converted to Diazo themes.
Implementation
This requires a series of zip files that contain working single-page HTML mockups that demonstrate the core Plone features. They should have support for portlets, a navigation bar, logo, etc.
Preferably these themes would have different colourways available, through compilation of LESS/SASS, as well as different styles for customers in different industries.
See Also
Skills
Javascript and HTML. No Python or Plone knowledge needed.
Mentors
Rob Gietema would be perfect for this.
Aims
Three or more themes to be packaged with the Unified Installer.
Better Microsoft/Open Office integration
Summary
Sometimes, people prefer to work offline. We should optionally support editing content in Microsoft Word. One way to do that is to generate a protected document that acts like a form, and parse the form on upload/save to extract the data.
Implementation
It should be possible to launch a desktop application from within the CMS (external editor) and also to save or drag-and-drop a document onto the desktop for offline editing and later re-attachment. Ideally, this should work on collections of documents (e.g. a whole folder). For this to be seamless, we also need the ability to check in/check out and invoke workflow transitions from within the application, via a special menu.
Zope has limited support for this already, but it is buggy and very un-userfriendly. It may be a good starting point, though.
See Also
Skills
Python, word/openoffice scripting.
Mentors
Martin Aspeli is most interested, but he won't have time to mentor. He'd be a good product owner, with a generalist as the mentor itself.
Aims
An add-on product in the collective
WebODF support
Summary
WebODF is a Javascript library that allows through-the-web editing of Open Document files possible. This would be an excellent addition to the Plone interface as a content type, allowing better collaborative document editing.
Implementation
A Javascript library that is licence compatible with Plone already exists. A new content type needs to be created that stores the ODF file, and a widget that displays the WebODF editor displayed. The display view should be the WebODF viewer. The type itself should act like a rich text object with a download option.
See Also
Skills
Python, Dexterity, Javascript
Mentors
Paul Roeland for the direction of the product and any Plone generalist as the main contact.
Aims
An add-on in the collective namespace.
Improvements to Patterns widgets
Summary
Patterns (and plone.app.widgets) is the new widget story for Plone that allows Javascript developers to create new widgets for Plone. There are some specific improvements that need to be made to the widget javascript:
Pick-a-date
Better keyboard-only-navigation of pick-a-date, with support for text-entry of dates and basic normalized, localized date parsing (using a wrapper around moment.js parsing). Recurrence-rule widget pattern, possibly based on work in plone.app.event? Add timezone picker based on select2 pattern as (a) distinct widget; (b) something that can be enabled as part of the date widget.
A "fullcalendar" replacement as a mockup pattern
Possibly based on D3.js and/or Vega; consumes mockup JSON calendar data irrespective of its source. Target deliverable would be pattern that consumes configuration options, JSON/iCalendar/xCal/hCalendar listings of event data and outputs weekly, monthly, or daily calendar (to time-scale) with ability to switch views without page reloads.
A subject/tags picker
Support for tree-like controlled vocabularies and/or ad-hoc keywords, and auto-complete; might re-use parts of related items widget; should support some eventual tool like possible successor ATVocabularyManager. Could use ICD.9, NAICS, IPTC, and other freely available vocabularies as data-sets for development.
Datagridfield
Something like the UI bits of collective.z3cform.datagridfield re-done using more modern code, look/feel, as a pattern.
Basic new widgets
color picker; slider/range input; likert-scale widget; add infinite scroll to Select2 pattern; location picker (search using map that pops up/down in overlay, gets normalized street addresses and/or geocoded latitude/longitude for pin); person-picker based on Select2 supports names/profile pictures; image-thumbnail picker.
Microformat support widgets
For use with TinyMCE 4 when editing rich text. e.g. an hCard entry form, a basic event entry form for (limited) hCalendar, a rel-license generator, location support for h-adr plus h-geo.
Implementation
HTML and Javascript mockups for the new widget designs, added to the mockups repository.
See Also
Skills
Javascript and HTML. No Python or Plone knowledge needed.
Mentors
Sean Upton (former GSoC) has expressed interest, Franco Pellegrini would also be great.
Aims
A contribution to Plone core
PyPy support for Zope
Summary
We would love to get Zope and Plone working on PyPy, not least for the performance improvements. We've started this work, but there are a fair few bits left that need significant work done.
Implementation
Firstly, you'll need to build a working buildout under PyPy and then work on making all tests pass. We have lots of branches that work under PyPy that are in progress, these will need to be extended and improved until they're at the state that they can be merged.
It's vital that the Zope codebase continues to run on Python 2.6 and 2.7, as well as this not interfering with the work on supporting Python 3.3
Skills
Very good knowledge of Python, use of the CPython API and PyPy is highly desirable.
Mentors
Matt Wilkes, David Glick, or any Zope core developer.
Aims
Pull requests for Zope.
Zope4: Integrate WebOb
Summary
Slow work has been happening to produce a newer version of Zope that's more modern. There are lots of GSoC sized projects. This one is removing the old HTTPRequest and HTTPResponse objects.
Implementation
Lots of Zope and Plone code relies on the HTTPRequest objects, but we want to be able to use more standard Python code, so we would like to replace them with WebOb. We might have to wrap WebOb with some extra methods to support the legacy code, but we should be able to move between the two within an application without worrying about compatibility.
Skills
To be successful at this project you'll need extensive Python experience and to be comfortable with exploring large code bases. This will involve a lot of core Zope development work.
Mentors
Ramon Navarro Bosch with assistance from an active Zope core developer
Aims
A pull request for Zope
Your own idea
Summary
We love your own suggestions! Ask us on the plone-developers mailing list and we'll help you polish the idea into something we love.
Implementation
As long as it benefits the Plone community it can be anything. Most likely the majority will be Python and direct to Plone, but we will also accept Zope, ZODB, WSGI, etc.
Skills
Tailor your idea to your own skills
Mentors
Don't worry about this, at Plone we think it's our responsibility to find you the right mentor.
Aims
A core contribution or an add-on, most likely.