Vipul Sharma

GSoC 2015: Coding Period (End)

Friday, August 21, 2015

I got my threaded comments feature finally working :D Struggled a lot for implementing a comment tree structure but fortunately, it is working quite nicely now. It was very important as without creating a comment-tree structure, we would have ended making queries for every single comment to get it's replies. It's obviously an inefficient way and for a large number of comments/reply thread this would've been a bad method.

I was made quite clear by my mentors about how this should be implemented. Now, every comment is made to refer to the ticket's item id. Therefore, using a single whoosh query, all the comments concerned with a particular ticket item are obtained. So, I get all the comments which looks something like this:

                     comments = { 'comment1':['reply1', 'reply2', 'reply3'],
                                  'reply1':['reply4', 'reply5'],
                                  'reply4':['reply6'],
                                  'reply2':[],
                                  'reply3':[],
                                  'reply5':[],
                                  'reply6':[],
                                  'comment2':[],
                                }

The above representation is for:

Every comment also has an additional reply_to field which contains the id of the parent comment i.e. comment to which the reply is made. So, I tried this field to create a comment/reply tree. Initially, I tried creating a tree using nested list implementation. For above example I intended to do something like this:

       ['reply1', ['reply4', ['reply6', []], 'reply5', []], 'reply2', [], 'reply3', []]

But I failed to implement this. Later on after few paper-pencil hours I got the exact thing which I wanted but I got another way of creating indented threads of comments. I used the same recursive function I used to get above results and just altered it a bit to create a list of comments along with their indentation levels. Something like this:

 [['reply1', 10], ['reply4', 20], ['reply6', 30], ['reply5', 20], ['reply2', 10], ['reply3', 10]]

In this way , only single level list is created and now there's neither a need to parse the old list based tree in the templates nor any other tree parsing python code is needed.

After this, I did a little UI improvements of the comments to make it look pretty, wrote few lines of CSS and now it looks nice.

I also worked on improving the Advanced Search feature. Implemented it more like the exisitng /+search view so it looks quite familiar. It has a search bar and extra search options: effort, difficulty, severity, priority, tags, assigned to and author which are initially collapsed like the options are listed in /+search view.

In the last week I worked on making my open CRs working, fixed issues, tested the code in both: basic and modernized theme and made sure that it works fine in both the themes, made the patch ready to be committed. I've committed the working code which can be viewed here:

https://bitbucket.org/vipul-sharma/moin-2.0/commits/branch/default
and all the CRs are listed here: https://codereview.appspot.com/user/vipul

End of GSoC 2015 Coding Period

This has been an amazing three months of learning for me :) It was a great experience and thanks to my mentors: Thomas and Saurabh for their constant support and guidance throughout this program. I learned a lot about this project and about Open Source development from them. I would love to continue my contribution to MoinMoin in future :D and would love to contribute more to Open Source. There is lot more to learn !

Commits

Duplicate ticket suggestions commit
UI improvement of submit/modify view commit
File upload feature in submit/modify view commit
Advanced search feature to filter tickets commit
Threaded comments in ticket modify view commit

GSoC 2015: Coding Period

Tuesday, August 04, 2015

GSoC 2015: Coding Period

Tuesday, July 14, 2015

GSoC 2015: Coding Period (7th June - 22nd June)

Monday, June 22, 2015

GSoC 2015: Coding Period (25th May - 7th June)

Sunday, June 07, 2015

GSoC 2015: Improving the Issue Tracker of MoinMoin 2.0

Sunday, May 24, 2015

MoinMoin is an open source, advanced, easy to use wiki engine implemented in Python. It is a collaborative software that runs a wiki which allows users to create and edit web pages collaboratively. Some of the sites using MoinMoin wiki engine includes: Python, Mercurial, Apache, Ubuntu, Debian, Wireshark and many more.

In GSoC 2015, I'll be working on improving the issue tracker of MoinMoin 2.0.

Project Details

MoinMoin 2.0 has an existing implementation of a simple issue tracker. The current issue tracker requires some improvement in its UI/UX and few more features which would be good to have for better use.

Implementation

For improvement of the current issue tracker, the implementation of the task can be divided into 3 parts:

Creation of new tickets
View containing ticket list, searching / filtering of tickets
Ticket update view

Creation of new tickets

Enter title to the issue
Search for possible duplicates: This can be implemented by providing auto suggestion of existing tickets based on the title of new ticket which the use wants to create. Currently, MoinMoin 2.0 uses Whoosh for searching queries, we can use this and jQuery for displaying real time suggestions of existing tickets if the title of new ticket to be created matches with any of the existing tickets.
Improve metadata fields and add new fields
File upload: add a feature to allow user to add upload a screenshot, media or a patch file

Wireframe for ticket creation view:

View containing ticket list (/+tickets), searching / filtering of tickets

Currently the /+tickets view lists all the tickets with some options including few important

filters like "all", open, "closed" and "tags". Also, the current view consist of an option for creating a new ticket and a search box to find tickets. In this view, we can include an "Advanced Search" feature where we can add additional filters for filtering tickets based on a particular "author", "tags", "assignee", "difficulty", "effort", "severity" and "priority".

For "Advanced Search" option, a new view /+tickets/query will be created, where additional filters will be provided through which we will filter the results based in the query applied in the view: /+tickets?<query_type>=<query>. We will also allow to apply multiple filters in our advanced search.

Wireframe for ticket list view and advanced search view:

Ticket update view

The update ticket view is similar to ticket create view. In this view, the comment mechanism can be improved by adding feature to reply to any comment, delete any comment, adding Markdown formatting syntax and posting comments after any updates in the meta data of the ticket.

Wireframe for update ticket view:

Community Bonding

In the community bonding period, I reviewed my proposal again and discussed with my mentors about what features are necessary, how things should be implemented and cleared my doubts. I read the documentation, read the code to understand the flow of execution and how things have been implemented.

I learned about form processing using Flatland, and its really cool :) as explained in their website:

Flatland maps between rich, structured Python application data and the string-oriented flat namespace of web forms, key/value stores, text files and user input. Flatland provides a schema-driven mapping toolkit with optional data validation.

I allows DWIM (Do What I Mean) binding. Here is a run-of-the-mill example to explain:

>>> from flatland.out.markup import Generator
>>> from flatland import Form, String
>>> html = Generator()
>>> class Name(Form):
...     firstname = String
...     lastname = String
...
>>> form = Login({'firstname': 'Vipul'})

"Do What I Mean" binding:

>>> print html.input(form['firstname'])
<input name="firstname" value="Vipul" />

I also read about Jinja2 template engine, a beautiful full featured template engine for Python. Having tried my hands on Django, I was a little familiar with Django template language which was also the inspiration for Jinja2. I read how macros work in Jinja2. Macros can be compared to functions in programming languages. Its a nice tool to promote DRY (Don't Repeat Yourself) principle while writing templates. The most often used elements can be written in a reusable function i.e. a macro which can be called like a function in the templates.

A small example to demonstrate how to render a form element:

    {% macro render_input(n, value='', type='text', size=20) -%}
        <input type="{{ type }}" name="{{ n }}" value="{{ value|e }}" size="{{ size }}">
    {%- endmacro %}

This macro can be called like a function:

    <p>{{ render_input('firstname') }}</p>
    <p>{{ render_input('lastname') }}</p>

I also read about Whoosh. Its an amazing and quite robust searching library implemented purely in Python. Programmers can use it to add searching functionality in their applications and websites. Whoosh allows indexing of free-form or structured text and quick retrieval of matching documents based on simple or complex queries. The speed of Whoosh in processing queries fascinates me very much. it is pretty fast in processing even some complex queries.

How I started contributing to Open Source

Friday, May 08, 2015

I started my open source journey from December' 2014. I am quite fascinated with the concept of open source, I love contributing to code and it feels great to see my contribution doing something good for the community. You learn everyday, I've learned that it doesn't matter how big is your contribution or how much code you write, you'll still learn a lot. I met with some great people on IRC who were very generous and helped me a lot and even replied to my silliest doubts.

In December' 2014, I searched for open source projects where I can use my Python/Django skills. Then I heard about www.openhatch.org. I contacted with the mentors through IRC and they were really helpful. I deployed the development version of the website (https://github.com/openhatch/oh-mainline/) and started to solve some easy bugs and write some documentations. After few easy tasks, I thought of writing some bigger feature. I wrote a tutorial on "Using the command line shell" (http://openhatch.org/missions/shell/about). I got great support and guidance from the openhatch community and I am really thankful for their help in introducing me and getting me started to open source.

One of my college senior (GSoCer 2014) told me about Google Summer of Code, and asked me to search for an organization which works on Python and submit a proposal for GSoC 2015. I looked at PSF's summer of code wiki page: https://wiki.python.org/moin/SummerOfCode/2015
where I found MoinMoin pretty interesting (MoinMoin runs that wiki page :)
I looked at its ideas page: https://moinmo.in/GoogleSoc2015/InitialProjectIdeas
and I got even more interested to contribute to its code. I thought, I can use my knowledge in Python to contribute to its code.

I read its code, read the documentation, deployed the development environment and started to look to fix some easy bugs. I discussed about the code with the mentors and they were really helpful. I wrote a proposal to "Improve the Issue Tracker" of MoinMoin-2.0. I discussed with my mentors about what can be done to improve the issue tracker, new features, UI/UX improvements etc. and I am grateful for their guidance.

I am really happy tell that my proposal got selected for GSoC, 2015 :)
And this was all because of the mentors who helped me in getting me started with opensource development and helped me to understand moin-2.0. Though I am not very proficient in Python but, I will try hard to work out every task. Its just a start and I will work hard to implement the project idea with the guidance of my mentors :)

Currently, its the "Community Bonding" period and I am discussing with my mentors about the implementation of the issue tracker, reading the documentation, understanding the technology stack used, understanding the code to be worked upon and find out what more can be done. I will post more about the "community bonding" phase in my next blog post.