GSoC 2013 Projects

From PmaWiki
Jump to: navigation, search

This page lists all Google Summer of Code 2013 projects at phpMyAdmin. You can follow the progress on aggregated feed at http://planet.phpmyadmin.net/.

Contents

[edit] AJAX error reporting

A javascript client side that provides error reports for the javascript code. And a server side which aggregates the errors and displays them visually.

Student: Mohamed Ashraf

Mentor: User:Roccivic

Co-mentor: User:Ruleant

Blog: http://m0hamedashraf.wordpress.com/

Git:


Proposal: https://www.google-melange.com/gsoc/proposal/review/google/gsoc2013/m0hamed/16001

Updated Schedule:

  • week 1: create the function that takes an exception and gets all the required info, then anonymizes it. A view is created with the relevant data asking the user to authorize the sending of the report to our servers.
  • week 2: add try and catch statements to the js parts of the code and send it to the function making sure not to disrupt the normal operation in the code.
  • week 3: A simple server is created that accepts the JSON request containing the data sent by the client side. The view sends data to the server and then informs the user if it has arrived.
  • week 4: A add authentication system using github integration so that only committers can get access.
  • week 5: display each error report with the relevant information available in the error report
  • week 6: Connecting sourceforge bug tracker to the reporting server to allow bugs to be automatically submitted
  • week 7-8: Add a tagging system to reports to mark reports as related and get similar reports to allow grouping of related reports
  • week 9-10: Add the charts and visual stats to the reports to show the files that show most errors, and for each group of reports the different things in the configurations that were on in the system which had errors.
  • week 11-12: Add documentation and tests to all the code that was created so that it could be maintained later on

[edit] Automated Testing - Adam

PMA is a popular web based database management tool. It usually undergoes new releases, bug fixes, new feature development and refactoring. Since the PMA production code is changed frequently and our code is finished by developers from all over the world, in order to guarantee the production quality, it is very necessary to run Unit testing on Jenkins (Hudson). Unit Tests have several benefits to us. It allows us changing code quickly under full testing. By running unit tests, a developer can identify whether his latest changes to the code base has broken anything. Unit Tests can also help new developers really understand the design of the code and it can give our developers visual feedback about which lines are covered. From PMA CI Page, Currently, the code coverage of PMA is 18.3%. More code coverage means more guarantee to production. Goal: 1. Increase the code coverage to a reasonable percentage (80%) 2. Set up the necessary scripts to automate unit testing. 3. Help other developers to set up their unit test cases. 4. Functional test case to cover render issue Strategy: we should cover core code to a high level (90%) at firstly and then spent some time on the other stuff.

Libraries to be covered by unit tests by Adam:

  • Schema designer (libraries/schema)
  • Import (libraries/plugins/import)
  • Transformations (libraries/plugins/transformations)
  • DBI (libraries/dbi)
  • Relations (libraries/relation*)
  • SQL parser/analyzer (libraries/sqlparser, libraries/parse*)
  • IP allow/deny rules (libraries/ip_allow*)
  • Table operations (libraries/Table*)

Student: Adam Kang

Mentor: User:Nijel

Blog: http://adamgsoc.blogspot.com/

Git: https://github.com/adamgsoc2013

Proposal: https://www.google-melange.com/gsoc/proposal/review/google/gsoc2013/adam_kang/1

[edit] Automated Testing - Ayush

The aim of the project is to increase the code coverage of phpMyAdmin by setting up more unit tests. This project would also involve setting up Selenium Tests to write automated user-interface tests that run in real browser instances.

Libraries to be covered by unit tests by Ayush:

  • Plugin system (libraries/plugins/Plugin*, libraries/properties/*)
  • Export (libraries/plugins/export)
  • Authentication (libraries/plugins/auth)
  • Setup script + user configuration (libraries/config, setup, libraries/user_pref*)
  • Tracker (libraries/Tracker)
  • String manipulations (libraries/string*)
  • Charset conversions (libraries/char*, libraries/iconv*, libraries/kanji*)

Student: Ayush Chaudhary

Mentor: User:Madhuracj

Co-mentor: User:Nijel

Blog: http://www.ayushchd.com/gsoc2013/

Git: http://www.github.com/ayushchd/phpmyadmin/

Proposal: https://www.google-melange.com/gsoc/proposal/review/google/gsoc2013/ayushchd/1

[edit] Interface improvements

phpMyAdmin is quite a matured project with more than 14 years of history behind it. It possesses almost all the major features required for a database administrative tool and there is very little that can be added in this front. However there is always room for small and medium scale new features. This is evident from the huge backlog of feature requests requested in the project’s feature request tracker. In this proposal, I propose a number of small to medium scale improvements chosen from the feature request tracker, majority of them selected by the developers of the project themselves and listed in the GSoC 2013 project ideas list.

Student: Kasun Chathuranga

Mentor: User:Ibennetch

Blog: http://kasunstechblog.blogspot.com/

Git: https://github.com/kasunchathuranga/phpmyadmin

Proposal: https://www.google-melange.com/gsoc/proposal/review/google/gsoc2013/kasunchathu/1

[edit] Re-factoring: server view

While reading some server view source code of PMA, I found that the source code has some problems: not easy read, not easy reusable, full of long function, full of long file. Because PMA is a big project which is developed by a lot of Programmers from all over the world, we should enhance the maintainability to let more developers join in. From other side, in a project’s life cycle, sometimes we need to re-factor the code if the code starts smelling bad and it’s hard to maintain and even harder to add new features. By enhancing the readability and maintainability of code, re-factoring makes it easier for us to deal with the code. This idea aims to re-factor the code on “Server view” and make the code easy to understand and easy to reuse. It won't involve changing the existing functionality of these scripts, nor would it introduce new functionality.

Student: Bin Zu

Mentor: User:Lem9

Blog: http://xmujay.wordpress.com/

Git: https://github.com/xmujay/phpmyadmin.git

Proposal: https://www.google-melange.com/gsoc/proposal/review/google/gsoc2013/xmujay/27004

Updated schedule:

  • June 1 - June 16: Refactor following files: (also the included file in PHP)
    • server_binlog.php, server_plugins.php, server_collations.php, server_status_monitor.php
  • June 17 - June 30: Refator following files: (also the included file in PHP)
    • server_databases.php, server_replication.php, server_engines.php, server_status_variables.php
  • July 1 - July 14: Write unit tests for newly refactored functions.
  • July 15- July 28: Refator following files: (also the included file in PHP)
    • server_export.php, server_status.php, server_import.php, server_status_advisor.php
  • July 29 - August 11: Refactor following files:
    • server_privileges.php, server_status_queries.php, server_sql.php, server_variables.php
  • August 12 - August 25:
    • server_privileges.php, server_status_queries.php, server_sql.php, server_variables.php
  • August 26 - Sept 6: Refator following files:
    • server_common.inc.php, server_privileges.lib.php, server_variables_doc.php
  • Sept 7 - Sept 16: Write unit tests for newly refactored functions.
  • Sept 16 - Sept 23: Buffers & Some other refator & Final evaluations

[edit] Refactoring: SQL Executor, Column's Structure Manipulation

The goal of this project is to refactor the SQL executor and Column's structure manipulation code. To improve the readability, reduce the complexity, and to improve the maintainability I am suggesting to refactor the SQL executor and Column's structure manipulation code using better approaches. The code will be refactored according to various code refactoring techniques mainly focusing on componentization and extract method.

Student: Supun Nakandala

Mentor: User:Lem9

Blog: http://scnakandala.blogspot.com/

Git: https://github.com/scnakandala/phpmyadmin.git

Proposal: https://www.google-melange.com/gsoc/proposal/review/google/gsoc2013/scnakandala/1

Personal tools