The blog of Anchal

GSoC'16 - Port Comment Alter Module - Week 11

2016-08-08T00:00:00+00:00

As part of GSoC’16 I’m working on Porting Comment Alter module to Drupal 8 under the mentorship of boobaa and czigor. This blog is an excerpt of the work which I did in the eleventh week of the coding period of GSoC’16. The blogpost for the work done in the tenth week can be found here.

In D7 the comment settings were present on the node and those settings were managed from node edit forms whereas in D8 comments settings became fields and they could be attached to any other entity type (see change record #2100015). In D7 version of the module all the comment related settings were present on that comment settings section of the node type edit/add form. So in D8 we could have added those settings to either the entity_type edit form or to the comment fields and we decided to go with the later one. This week I added all these settings and their implementations along with the tests for them (see commit1 and commit2).

During our weekly stand-up this week we had following discussions:

Both of my mentors are going to do a final review of the whole code and after all the corrections hopefully the module can be pushed to d.o. I’ve been provided with the required permissions to do so.
I’ll be creating a demo video this week. The demo video will cover comment_altering of node fields and it will cover all the comment related settings which governs working of the module.
Since the deadline of the final submission of our GSoC project is 23rd Aug we had a discussion about the final submission. Based on the Work Product Submission Guidelines, boobaa suggested me to do the following two things:
1. Prepare a blog post describing all the work which I did and what is left in that and why.
2. The link to the github repo on which I worked throughout this project. Also we will have the d.o. repo of the module.

Last week I added tests for most of the field types but as suggested by my mentors this week I also added tests for Entity Reference fields (see commit). As of now the module is working on Drupal 8.2.x and all the tests are also passing. Once the final review of the module is done we plan to push the code to d.o.

By the end of the week I completed tests for node reference fields and added comment_alter related settings and also added tests for them. For now I’ll work on adding documentation for the module. My mentors have already reviewed the code for the work which I did during this week. If anyone is interested, my progress can be followed in my GitHub repo.

GSoC'16 - Port Comment Alter Module - Week 10

2016-08-03T00:00:00+00:00

As part of GSoC’16 I’m working on Porting Comment Alter module to Drupal 8 under the mentorship of boobaa and czigor. This blog is an excerpt of the work which I did in the tenth week of the coding period of GSoC’16. The blogpost for the work done in the ninth week can be found here.

Since I was almost done with the base test class last week, this week I mainly focused on providing test cases for different fields and widget types. Also I added tests to the base class to check that the module is not breaking anything on a revision delete. I started this week by extending the tests for text fields which I completed last week to cover multi-valued text field altering. Then I added tests for list(string) fields which included several widget types like select list, checkboxes and radio buttons.

Later this week I added tests to check if the hook_entity_revision_delete() was working as intended, i.e. the module was not breaking anything in case a revision of the parent entity was deleted. After this I added tests for image fields and while doing this I came across an issue with multi-valued image/file fields which I corrected and it is working fine now, without breaking anything else.

Executing the automated tests

The module has PHPUnit tests and it is recommended to execute the unit tests using command line instead of the web interface provided by the SimpleTest module. More instructions can be found on the related drupal.org documentation page. Executing these web tests:

cd /path/to/drupal-8/core
export SIMPLETEST_DB=mysql://drupal-8:password@localhost/drupal-8
export SIMPLETEST_BASE_URL=http://drupal-8.localhost
../vendor/bin/phpunit --group comment_alter

When the user executing these functional tests is different than the one running the web server (apache for example), an exception is thrown and it’s not very clear what the problem is. Running these tests as root or changing permissions of files doesn’t have any effect on it. The recommended approach here is to change the user running the web server to the system user. Other way is to run these tests with the same user as the one running the web server, this can be achieved by using this command instead (see #2760905):

sudo -u apache ../vendor/bin/phpunit --group comment_alter

To execute any single test or a class the --filter tag can be used. Example: if we just want to run testOptionsSelectSingle then following command will do so:

../vendor/bin/phpunit --group comment_alter --filter testOptionsSelectSingle

By the end of the week I completed tests for single and multi-valued text, list(string) and image fields. As of now the module is passing all the tests and there are no known issues. My mentors have already reviewed the code for the work which I did during this week. If anyone is interested, my progress can be followed in my GitHub repo.

GSoC'16 - Port Comment Alter Module - Week 9

2016-07-26T00:00:00+00:00

As part of GSoC’16 I’m working on Porting Comment Alter module to Drupal 8 under the mentorship of boobaa and czigor. This blog is an excerpt of the work which I did in the ninth week of the coding period of GSoC’16. The blogpost for the work done in the eighth week can be found here.

This week I continued to work on providing test coverage for the module. Last week we decided to use EntityTest as our parent entity and check the functionality of the module over it but while writing tests I came to know that it didn’t support revisions. To write tests using revisionable entities we have to use EntityTestRev.

While using EntityTestRev entity I came across an issue: our alterable fields were not shown on the comment form. However, earlier when I used EntityTest it was displayed correctly and even the values got altered. It did not display the difference since it did not support revisions. I was stuck here for quite a while figuring out what the real problem was.

It turned out that it was a problem with cache invalidation. Field UI was disabled for the EntityTestRev entity thus the comment_alter_field_config_edit_form_alter() was not called, inside which the cache was deleted. Adding the following lines did the trick for me instead of having Field UI enabled for the parent entity.

    \Drupal::cache()->delete('comment_alter_fields:' . $this->entityType . ':' . $this->bundle);

After resolving this problem the test was working fine and the differences made from a comment were displayed. Later I worked on the assertCommentDiff() function which tested the differences displayed over the comment-alter-diff table were expected. For now we have tests for Text Field and I’ll cover other field types by next week (see commit).

So by the end of the week I completed the function assertCommentDiff() and tested it for single valued text fields. My mentors have already reviewed the code for the work which I did during this week. If anyone is interested, my progress can be followed in my GitHub repo.

GSoC'16 - Port Comment Alter Module - Week 8

2016-07-19T00:00:00+00:00

As part of GSoC’16 I’m working on Porting Comment Alter module to Drupal 8 under the mentorship of boobaa and czigor. This blog is an excerpt of the work which I did in the eighth week of the coding period of GSoC’16. The blogpost for the work done in the seventh week can be found here.

This week I worked on providing test coverage for the module and fixed some issues. We decided to split the test into multiple classes which would extend one base class. This week I worked on this base class. We are using the entity_test provided by core’s system module for testing purpose instead of any other ContentEntityType so that our tests could be as generic as possible (see commit).

As suggested by czigor we are using \Drupal\Tests\BrowserTestBase over \Drupal\simpletest\WebTestBase because the WebTestBase is provided by the simpletest module and they are not PHPUnit-based but built specially for Drupal and soon they will be deprecated (see phpunit).

To create PHPUnit-based functional test we need to extend the Drupal\Tests\BrowserTestBase. Test class files should be at my_module/tests/src/Functional/MyTest.php and the namespace should be Drupal\Tests\my_module\Functional.

Recently in D7 we came across an issue with the deletion of revision of the parent entity which was causing site failure because we were trying to compare an entity with a NULL value using Diff module. This issue was also addressed for this branch by adding an extra column in our existing schema and then implementing hook_entity_revision_delete() (see commit).

So by the end of the week I made some progress with the base test class and also fixed an issue related with the parent_entity_revision_delete. My mentors have already reviewed the code for the work which I did during this week. If anyone is interested, my progress can be followed in my GitHub repo.

GSoC'16 - Port Comment Alter Module - Week 7

2016-07-11T00:00:00+00:00

As part of GSoC’16 I’m working on Porting Comment Alter module to Drupal 8 under the mentorship of boobaa and czigor. This blog is an excerpt of the work which I did in the seventh week of the coding period of GSoC’16. The blogpost for the work done in the sixth week can be found here.

This week I worked on showing the differences made by a comment on the parent entity which involved using the Diff module. The differences are displayed only for parent entities supporting revisions (Node and Block Content in core). For the rest of the content entities comment alteration is supported but the differences are not shown.

Since we stored the old and new revision IDs along with the comment ID through which the parent entity was changed, we needed to compare the two revisions and display the differences on comment view.

At first I implemented hook_ENTITY_TYPE_load() for comments. It loads the old and new revision IDs of the parent entity for that particular comment from the DB and stores them in the CommentInterface $comment object.
After this I worked on comment_alter_get_changed_fields() which would return us a table showing the differences of the altered fields between the two revisions. This was achieved using the EntityComparisonBase::compareRevision() method of the Diff module.
Finally hook_ENTITY_TYPE_view() for comments was implemented which renders the table returned from the comment_alter_get_changed_fields(). I also added a stylesheet for the module.

By the end of the week we were able to display the differences on comments. My mentors have already reviewed the code for the work which I did during this week. If anyone is interested, my progress can be followed in my GitHub repo.

GSoC'16 - Port Comment Alter Module - Week 6

2016-07-04T00:00:00+00:00

As part of GSoC’16 I’m working on Porting Comment Alter module to Drupal 8 under the mentorship of boobaa and czigor. This blog is an excerpt of the work which I did in the sixth week of the coding period of GSoC’16. The blogpost for the work done in the fifth week can be found here.

Last week I worked on the submit and validate callback functions but in the submit function only the parent entity was stored. In order to show the changes made by a comment we need to create new revision of the parent entity and store the revision ID corresponding to that comment. A revision can be created using setNewRevision if the entity supports revisions. In case if entity is an instance of RevisionLogInterface we also set the revision_user_id and the creation time. (For e.g. See NodeForm::submitForm()).

There are some content entity type which doesn’t support revisions like the taxonomy term. For those entity we decided to allow altering of the comment alterable fields from the comment form. Though the changes made by a particular comment wouldn’t be available then as we are using revision for this. Later this week I tried to fix following issues related to the field widgets:

Multi-valued fields add more option: One of the issue was add_more option of any multi-valued field widget. Clicking the add_more button was resulting in an AJAX error and we were unable to add any extra fields to a multi-valued field. Fix to the issue was rather small, just removing the comment_alter_ prefix from the alterable field names solved this issue.(See commit)
Checkboxes/radio buttons and select list widget: In case when checkboxes were used as a field widget, Element::children() was giving a fatal error as there were no any children elements in the $form[$alterable_field][‘widget’] element. So, to fix this we needed to bail out early or get the column information from the #key_column property of the form element.

By the end of the week I was able to complete the comment_alter_form_comment_form_alter_submit() function and fixed some of the issues related to field widgets. My mentors have already reviewed the code for the work which I did during this week. If anyone is interested, my progress can be followed in my GitHub repo.

GSoC'16 - Port Comment Alter Module - Week 5

2016-06-28T00:00:00+00:00

As part of GSoC’16 I’m working on Porting Comment Alter module to Drupal 8 under the mentorship of boobaa and czigor. This blog is an excerpt of the work which I did in the fifth week of the coding period of GSoC’16. The blogpost for the work done in the fourth week can be found here.

This week I started working on submit callback function of the altered comment form which should save the changes made on the parent entity’s alterable fields present on our comment form. We can’t directly change these values in parent entity from our comment form so there was a nice trick to it. Build the entity display form again and then set the values of alterable fields in it from the comment form and then save the parent entity display form. So this way when submit function is called comment will be save and also our parent entity will be edited. (See commit).

After this I worked on validation callback and in similar manner i.e. by creating parent entity display form again and copying values of the comment form, validation for the form was done using EntityFormDisplayInterface::validateFormValues(). After completing this again I moved back to complete our submit callback function through which we are able to alter fields of parent entity from comment form.

In order to show those changes we need to create revisions and to save CPU cycles and memory we need to save data only if there was some change in the alterable field entities. So as next step I made sure that anything was saved only if there were some changes in the alterable fields which required to clean up comment form alterable field values and old values to remove any non alterable columns from them. (See commit).

By the end of the week I was able to complete the validate and submit function but there are still some issues with submit callback function which needs to be rectified before we proceed further. So, I would like to work on them this week. My mentors have already reviewed the code for the work which I did during this week. If anyone is interested, my progress can be followed in my GitHub repo.

GSoC'16 - Port Comment Alter Module - Week 4

2016-06-20T00:00:00+00:00

As part of GSoC’16 I’m working on Porting Comment Alter module to Drupal 8 under the mentorship of boobaa and czigor. This blog is an excerpt of the work which I did in the fourth week of the coding period of GSoC’16. The blogpost for the work done in the third week can be found here.

Fourth week of coding period has ended and this week I worked on completing the comment_form_alter() which is supposedly the toughest part of the comment_alter module. After implementing hook_entity_extra_field_info() last week, we needed to add field widgets for the pseudo fields added in the hook_entity_extra_field_info() implementation for the comment alterable fields.

Adding widgets for these fields could have been done either by adding them directly by specifying the type of the fields but that would lead to lots of validation checks or by getting the widget info directly from the parent entity. We are retrieving widgets information directly from the parent entity add/edit form. Earlier in D7 field_attach_form() was used for this and now we’ve used entity_get_form_display() and EntityFormDisplayInterface::buildForm for the same. (See commit and change record #2225801.)

Now, the fields should be provided with proper weights retrieved from the comment display form but it turns out that we don’t even need to set the weight of the added fields ourselves, it was taken care automatically for the corresponding fields. Further, all the necessary information which would be required later on were saved in the form element such as alterable fields and their values. (See commit.)

This also involved storing the column or sub-field information for any fields. Many fields have multiple sub-fields or columns like body field has “value” (the actual body), “summary” (the part that is usually displayed in the teaser) and “format” (the text format this field should be rendered with). Similarly, entity_reference fields stores “target_id” instead of values thus in order to tell if a field has changed or not in comment we are storing column information and value for all the alterable fields. (See commit).

By the end of the week I was able to complete the comment_form alter(). Now, we could see all comment alterable fields of the parent entity on the comment form with their default value as the one saved on parent entity. My mentors have already reviewed the code for the work which I did during this week. If anyone is interested, my progress can be followed in my GitHub repo.

GSoC'16 - Port Comment Alter Module - Week 3

2016-06-14T00:00:00+00:00

As part of GSoC’16 I’m working on Porting Comment Alter module to Drupal 8 under the mentorship of boobaa and czigor. This blog is an excerpt of the work which I did in the third week of the coding period of GSoC’16. The blogpost for the work done in the second week can be found here.

Since I was done with get_alterable_fields_function() last week, this week I started working on comment form alter. My mentors suggested me to port comment_alter_field_extra_fields() function first, which would add pseudo fields on comment_form for these extra comment_alterable_fields before adding widgets for these fields on the comment_form to expose some control over this to the UI. It would allow sitebuilders to re-order all the comment fields and the comment_alterable_fields. Also this function adds one extra pseudo field on comment_display so as to render the parent entity field changes for the comment in any particular place decided by the sitebuilder.

Pseudo fields are simple display/form fields whose position can be controlled from the display settings of a particular entity type. An example of such a field is the core Links field on the node or comment entities. This allows us to add extra fields for a particular entity which can be reordered.

For more information related to pseudo fields, I would recommend looking at hook_entity_extra_field_info() and also I came across this article which was helpful to me. This commit implements hook_entity_extra_field_info().

There were some major changes from D7 to D8 which affected the port of this function.The most important thing was that in D7 we had separate comment types for all content types so it was relatively easy to attach the extra fields of that particular content type to the comment. In D8 however any comment type can be attached to any entity type so we cannot know what extra fields we need o attach to the comment. (See change records #2100015 and #2285633.)

So, in order to attach the extra comment_alterable_fields of the parent entity to its comment types, we need to loop through all the comment types attached to our parent entity (as we may have more than one). I had some problem getting the comment bundle information of the comment fields attached to the parent entity which I later found in the FieldStorageDefinitions. Basically we wanted to know the comment bundle of the comment field attached to our parent entity but instead it was in FieldStorageDefinitions. (See commit.)

By the end of the week I was able to implement hook_entity_extra_field_info(). Now I have extra fields in my comment_type _form and _display which I can drag around using the UI. My mentors have already reviewed the code for the work which I did during this week. If anyone is interested, my progress can be followed in my GitHub repo.

GSoC'16 - Port Comment Alter Module - Week 2

2016-06-07T00:00:00+00:00

As part of GSoC’16 I’m working on Porting Comment Alter module to Drupal 8 under the mentorship of boobaa and czigor. This blog is an excerpt of the work which I did in the second week of the coding period of GSoC’16. The blogpost for the work done in the first week can be found here.

The second week of GSoC’16 coding period is over now. During this week I was able to accomplish following tasks:

Make sure that a comment alterable field of parent entity is not present in comment form: Now, in Drupal 8 this problem can arise only in one case i.e. when comment is parent entity because now fields are not shared across entity types only across the bundles of a given entity type. As upon discussion with my mentors we concluded that to avoid any unnecessary complications we would remove comment altering options from comment fields which would resolve this problem. This means comment fields can not be altered from comments now, which also doesn’t serve us any purpose.
Get comment alterable fields: After providing options to make a field comment alterable and making sure that parent entities fields are not present in comment, I started to work on a function which would return all the comment alterable fields attached to the parent entity. This required getting the ThirdPartySettings stored previously to check whether a field is comment alterable or not using the field definition. Also in the meantime I was able to learn about caching in Drupal specially about cache invalidation on which I did some mistakes in the beginning. Now, the function works and I’m able to get all the comment alterable fields attached to an entity.
Porting comment_alter_form_node_type_form_alter function: Procedural next step for me this week was to work on porting this function of Drupal 7 as it would affect the comment form. For now I provided this form alter for comment fields settings which needs to be moved to entity edit form.

By the end of the week, with this I was able to get the list of the comment alterable fields attached to parent entity. Adding the field widgets for the comment alterable fields in the comment form would be the next step for me. My mentors have already reviewed the code for the work which I did during this week. If anyone is interested, my progress can be followed in my GitHub repo.

GSoC'16 - Port Comment Alter Module - Week 1

2016-05-30T00:00:00+00:00

The coding period for GSoC 2016 started last week from 23rd May and now students are required to start coding for their respective projects. As part of GSoC’16 I have been working on Porting Comment Alter module to Drupal 8 under mentorship of boobaa and czigor.

The first week of GSoC’16 coding period is over now. During this week I was able to accomplish following tasks:

Creating schema for the module: I started out with preparing the schema for the module and created the .install file which implemented hook_schema to store comment ID, old and new revision ID for the parent entity. As pointed out by boobaa, storing the comment ID provided us with the flexibility of leaving out some column from database schema of the module. We can find the parent entity type and entity ID from comment table using the comment ID stored.
Creating a form_alter for settings screen: After writing schema for the module, I worked on the first function of our module which implements hook_form_FORM_ID_alter. This provides an interface to select any field we want to be altered by the comment and also hide alteration from diff. So by using the hook_form_FORM_ID_alter we could add these extra options on the field_config_edit_form but there was a change from the D7 version here. Earlier additional field properties were directly stored in the database just with the addition of those custom fields in the form_alter but now we need to use ThirdPartySettings to store the values.
Using ThirdPartySettings for storing form_altered values: I was stuck here for a while. I went through some of the issues and blogs related to ThirdPartySettings. Content_translation module in core was a good example which used ThirdPartySettings and it even also implemented hook_form_FORM_ID_alter for field_config_edit_form. There were two methods by which we could have used ThirdPartySettings in our module. The one we are using was to use the ThirdPartySettingsInterface provided for FieldConfigInterface. The other one was to create our own builder function. We are not using the other method because it will increase the complexity as we would have to add our own builder function inside which we would set the ThirdPartySettings to store our changes. But it would be independent and will not be affected if any other module also uses ThirdPartySettings.

Finally with the use of ThirdPartySettings we have completed our first function which provides an altered FieldConfigInterface. My mentors have already reviewed the code for the work which I did in this week. If anyone is interested, my progress can be followed here.

GSoC'16 - Community bonding period

2016-05-22T00:00:00+00:00

Google Summer of Code (GSoC) is a global program that matches students up with open source, free software and technology-related organizations to write code and get paid to do it! The organizations provide mentors who act as guides through the entire process, from learning about the community to contributing code. The idea is to get students involved in and familiar with the open source community and help them to put their summer break to good use. For any information related to GSoC I would recommend to visit the manual page.

The results of GSoC’16 came out on 23rd of April and and I was happy to find out that I was selected. I would like to thank my mentors - László Csécsy(boobaa) and Czövek András(czigor), slurpee and cs_shadow for providing necessary suggestions while preparing my proposal. Getting accepted for the Google Summer of Code marked the beginning of the Community bonding period. The community bonding period is all about, well, community bonding. Rather than jumping straight into coding, you’ve got some time to learn about your organization’s processes - release and otherwise - developer interactions, codes of conduct, etc.

Project: Porting Comment Alter module to Drupal 8.

Community Bonding Period I had my semester exams, projects and assignments so I couldn’t give it a lot of time but I remained in contact with my mentors (boobaa and czigor). We were in constant touch via mail and also we had a hangout meeting last Friday over which we had the following discussion:

I’ll be maintaining my code initially on github. The repo can be accessed here.
My mentors will be reviewing my code on daily basis during most of the working days and I’ll proceed function by function of the D7 module for the port as it was explained in the proposal in detail.

I went through some of the references as I mentioned in my proposal. These references covered Form API, Configuration API and Comment module in which I tried to cover the following things:

Form API: I created some small modules by using the Form API and also I tried to go through altering the forms using hooks which are to be used in the module.
Configuration API: In configurational API I went through the configuration schema part of it which will be used in the module for form_alter using third party settings.
menu_ui is one of the good examples which I found in core which implements hook_form_BASE_FORM_ID_alter by using third party settings.

I’m thankful to László Csécsy for providing me with exercises for the past couple of months which helped me getting a better understanding of Drupal and the module. I have created some modules which covered the basics of Form API. We used Acquia Cloud as our hosting solution where our work can be seen (Link to the page). I also went through a few issues related to the module and provided patch for it. Since the coding period has started now, the next blog will be on my progress over the first week of coding.