Planet Drupal

Subscribe to flux Planet Drupal - aggregated feeds in category Planet Drupal
Mis à jour : il y a 26 min 34 sec

InternetDevels: Drupal modules for social networks integration Part 2

mar, 10/03/2015 - 09:43

In our previous blog post we have presented a list of 7 popular and useful Drupal modules for integration with social networks. After that we've received some queries like "Are there some other modules of such kind?". Thus we've decided to make up a new list!

Read more
Catégories: Elsewhere

ShooFlyDesign: Drupal 7, Tags, Unpublished Content, and You

mar, 10/03/2015 - 02:29

Drupal has a very flexible taxonomy system for tagging and categorization content (and users, and anything else). This flexibility is one of its interesting differentiating features — you can create as many dimensions of categorization and tagging as you like, which is very attractive for librarians and other enthusiasts of organization. To keep that flexibility from totally bogging down the system, Drupal maintains an index table that maps those terms onto the pieces of content to which they're attached.

Read more
Catégories: Elsewhere

xjm: Contribution, Influence, and Drupal 8

lun, 09/03/2015 - 23:11
Contribution, Influence, and Drupal 8 Mon, Mar 09, 2015 - 17:11 xjm

In the most recent issue of Drupal Watchdog, Nedjo submitted an article on software freedom and social change in Drupal. While this article raises a number of thoughtful questions about the social implications of the Drupal community's evolution, it includes some misinformation (both because it misrepresents the data that are easily available and because it lacks data that are not easily available). In the first part of this post, I look at the specific information presented in the article and provide some more depth, including some first-hand information about Acquia, since I work in Acquia's Office of the CTO. In the second part, I explore how we can mitigate some of the concerns the article raises.

Who am I and why do I care?

I'm xjm. I started contributing to Drupal 8 core in 2011 when I was working as a part-time hourly at a university. Core contribution was a life-changing experience for me, and I've been high in the list for Drupal 8 patch commit mentions since late that year. I also led what later became the Core Contribution Mentoring initiative. I wanted to "pay it forward" and help make core contribution more accessible to other "outsiders" like myself. I guessed that I was not the only one who had an interest in participating in open source in general and Drupal in particular, but had not done so because of underconfidence, time limitations, lack of information, bad previous experiences, or that that same "outsider" feeling.

TCDrupal core mentoring sprint, 2012. Photo credit: xjm

In 2012, merlinofchaos invited me to be on the team for the Views in Drupal Core initiative. I cut my hours back at the university and started drawing a salary from the community chipin for that initiative. My budget was tight, but the opportunity to be paid for contributing to that project was an amazing privilege. Views was merged into Drupal 8 core in October of 2012.

In 2013, Dries offered me a position in Acquia's Office of the CTO (OCTO) to work on Drupal 8 full time. Last week was my two-year anniversary at Acquia. I spend almost all of my paid time doing release management for Drupal 8, and part of my job is gathering metrics to help the community make informed decisions about the codebase and the upcoming release. (For example, see the critical issue charts at Help Get Drupal 8 released!).

The Watchdog article's misleading chart (and corrections to it)

Under a header titled "Structured for Profit?", the Watchdog article tries to illustrate which individuals are involved in formal decision-making roles in Drupal, with the goal of asking whether current decision-making in Drupal is "enterprise-oriented" and with a specific focus on Acquia. The article describes the following "influential" roles:

  • Core committers These are the individuals who have final say over which particular changes are made to Drupal core. There is a single permanent core committer, Buytaert. For each major version of Drupal, Buytaert appoints one or more “branch maintainers” who commit changes to that version of the software. [reference]
  • Official Drupal 8 initiative leads Drupal 8 development was organized around a series of official initiatives, approved by Buytaert, who appointed an individual to lead each initiative. [reference] Official initiatives shaped the core directions and solutions adopted in Drupal 8.
  • The Drupal Association The Drupal Association is a nonprofit that, according to its mission, “fosters and supports the Drupal software project, the community and its growth.” [reference]
  • Drupal Working Groups Three Working Groups – Community, Documentation, and Technical – oversee key areas of the Drupal project. Individuals are appointed to these groups by Buytaert or his designate(s). [reference]
Beyond formal decision-making roles, the individuals whose code contributions are accepted also exert a significant influence on the software and, by extension, the Drupal project.

(For a background on the history of decision-making in Drupal, I recommend reading Randy Fay's article from three years ago: Drupal Governance. Two primary changes have occurred since Randy's post was written: Drupal 8 now has multiple branch maintainers who collaborate to provide quick feedback and strategic focus in core issues, and the Drupal Working Groups were added precisely to help address some of the concerns that Randy eloquently lays out in that post.)

The Watchdog article's summaries of these roles (each accurate on its own) are followed by a chart, which I at first found confusing, then found misrepresentative, and eventually (after close examination) decided was misleading:

Original image from Drupal Watchdog

Several of the misrepresentations in this chart are due simply to the fact that complete data are not easily available (especially historically), and I attempt to correct this by providing better data with this post. However, there is one particularly misleading distortion in the chart that obscures everything else, even with the data that are available, and I address that first below.

A contributor with two responsibilities is not two people

The first thing that made me squint at the illustration in the post was a claim that there were somehow 15 people from Acquia that were "Drupal decision makers and top contributors", but I could not account for anywhere near that many people who worked for Acquia in the categories described. Then I squinted more and noticed that there were two people counted for Chapter Three -- a Drupal core branch maintainer and, separately, a top 10 Drupal 8 contributor. Huh? While alexpott does enough work for two people, there are not actually two alexpotts (oh if only!).

The original graph is labeled as indicating the number of "individuals" in key roles, but many people are counted twice or even three times.

It wasn't until my third read of the article that I actually absorbed this bit in the text:

Particular individuals may fill multiple roles and therefore be counted more than once.

Aha. So it's not stated outright, but perhaps this was meant to illustrate the "size" of an individual's influence based on different ways they might be involved. In particular, Dries is undeniably more influential than any other person in the project, so perhaps counting him three times (once as the project founder, a second time as a Drupal Association board member, and a third time as a branch maintainer) is an attempt to represent that. Unfortunately, I don't think this is clear or effective, and it actually seems rather misleading. The axis on the left side of the chart is labeled "Number of individuals", and even though the note about multiple counting is right there in the text, I (and others) missed it and took the chart at face value.

Acquia does not actually employ 15 individuals who are currently "decision-makers" in the project; instead, there about 7 individuals currently at Acquia who hold or have held one or more roles as the Watchdog article lists them. Three Acquians in particular are counted for a total of 9 of the "individuals" indicated in the chart.

Three of the roles represented in the chart (core branch maintainers, initiative leads, and "top 10" patch contributors) reflect prominent participation in Drupal core development, and there is actually significant natural overlap between those roles. Our core development process also includes many checks to individual influence for all three roles. All patches must undergo peer review, and we have a culture of collaboration and consensus-building rather than overruling others' decisions. Even branch maintainers cannot commit patches that they contribute to in a nontrivial way (either as patch authors or by providing the "RTBC" or peer review signoff). Finally, when a patch contributor disagrees with a branch maintainer about a change, the branch maintainer consults others (either other patch contributors, or other branch maintainers).

For all these reasons, double-counting people for different aspects of their involvement in core development is particularly flawed. The Drupal 8 initiative leads contributed to many patches both directly and indirectly; the specific number of commits that mention them does not reflect or substantially add to their impact on Drupal 8's development. And all the branch maintainers (excluding Dries) are equal to each other, regardless of whether or not they also author many patches.

It's less clear to compare the influence of core contributors with the Drupal Association board or the working groups, because the responsibilities are so different, but double-counting still doesn't reflect reality. For example, webchick is arguably more influential than other members of the Community Working Group because she is a branch maintainer, but not more influential than other branch maintainers because she is a member of the Community Working Group. In summary, not all individuals on the chart have equal influence, but their influence is a function of their most significant role, not of the number of roles they hold.

Contributors change jobs

Drupal 8 has been under development for four years. Drupal Association board member terms are two and three years. Many people change jobs more frequently than that, so it's imbalanced to only represent contributors' current employers. For example, four of the seven Drupal 8 initiative leads have changed jobs since Drupal 8's feature completion deadline in February 2013. Their current employers weren't their employers when they were doing the work.

In the Drupal core commit log, branch maintainers mention all the individuals who contributed directly to a patch for an issue in its commit message. Generally, the more work an issue takes, the more people end up in the commit message (though this isn't always the case). The Watchdog article includes "top 10" patch contributors based on an open source script that parses and analyzes these "commit mentions". tim.plunkett and I both work at Acquia now, and are both in the top 10 patch contributors to Drupal 8 by commit mention, in part because of our work on the Views in Drupal Core initiative. Except... Views was in core before either of us started at Acquia, and most of our other contributions were made before then as well. To illustrate this, we can compare the commit log references to tim.plunkett before his first full day at Acquia, versus after it:
git log --before=2014-06-01 --after=2011-03-09 | grep "tim\.plunkett" | wc -l
git log --before=2015-03-01 --after=2014-06-01 | grep "tim\.plunkett" | wc -l

So not only is the chart overstating Acquia's influence by crediting them with all our previous contributions, it's also under-crediting Tim's previous employers, Zivtech and Stanford, as well as the hundreds of community contributors who gave money to the chipin that paid my salary in 2012 as I worked on Views in Core.

Views is in Drupal 8 core thanks to hundreds of contributors who gave money to the initiative. Photo credit: xjm

Another interesting aspect of this is that patch contributions are not immediate. In fact, 20% of Drupal core issues take over 6 months to complete. For most of the past two years, I've rarely contributed to patches directly. And yet, between March 2013 and now, I got many of my Drupal 8 commit mentions:
git log --before=2015-03-01 --pretty=oneline | grep "xjm" | wc -l
git log --before=2015-03-01 --after=2013-03-04 --pretty=oneline | grep "xjm" | wc -l

This disparity comes from the fact that lots of my work from 2011 and 2012 wasn't committed until later. Even if I left Acquia today, never visited again, and threw my laptop in Lake Monona, I would continue to get commit mentions for work I did in the past.

Contributors are usually volunteers

Acquia currently has six employees who are paid to be core contributors, all in the Office of the CTO: Gábor Hojtsy, Wim Leers, tim.plunkett, webchick, effulgentsia, and myself. During recent months, Wim, Tim, and Gábor are mostly full-time Drupal core engineers; their main role is to work on patches and do code review for issues that block Drupal 8's release. effulgentsia and I do a mix of code review, occasional patch work, issue management, and release management. We work on problems like:

  • How can we help get Drupal 8 done sooner and give people accurate information about it?
  • How do we make it easier for people to contribute to Drupal 8 criticals?
  • How do we unblock this nasty bug that no one is working on or that other contributors can't agree on how to solve?

webchick also currently works primarily on these sorts of problems, plus does code review and patch committing in her role as a branch maintainer. Dries (who is not full-time on core) sets the goals for what we work on in our paid time, though in practice, we have a lot of autonomy and we set our own objectives with Dries' feedback and approval.

On the other hand, pwolanin works for Acquia, but is not paid to contribute. He works on Drupal 8 in his free time. His efforts to lead the Princeton critical issue sprint were all his own volunteer contribution. He used paid vacation time to participate during the sprint. Does Acquia deserve the credit for his work?

Princeton critical issues sprint. Photo credit: xjm, taken with pwolanin's camera.

Branch maintainer catch works for Tag1. Tag1 does not typically pay their employees to contribute to core. Instead, according to catch, they have good employment practices that make it possible for him to spend more unpaid time contributing. Is Tag1 exerting influence over Drupal 8's direction by having good employment practices? Should Tag1 get the credit for work catch contributes as a volunteer?

catch and alexpott are both branch maintainers, but catch and other Tag1 contributors are volunteers, while alexpott is paid to contribute by Chapter Three.

Organizations can affect the contributions of the people affiliated with them in a variety of ways:

  • In rare cases (for the six of us in OCTO, for branch maintainer alexpott at Chapter Three, and for a number of others), the organization might employ the contributor to do open source contribution full time.
  • More commonly, companies give their employees some paid time where they can work on their own projects, outside their normal work responsibilities. Friday afternoons might be contribution time at the office, for example.
  • Most frequently, people run into a problem in the course of their day jobs, and contribute to a fix for it because this contribution also helps them solve their problem. This can be done entirely within working hours, though often the contributor might get intrigued by the issue and work on things related to it in their free time. For example, MD Systems is building and maintaining Drupal 8 sites and modules, so Berdir contributes to issues he encounters on those projects in addition to his extensive voluntary contributions.
  • Finally, organizations affect the individual indirectly. A contributor's day job affects what the contributor thinks about Drupal, what parts of it they know well, what seems important or good or bad. And, as described above, the organization's employment practices might make it easier or harder for the individual to contribute.

To examine the role of influence in contribution, and to acknowledge contribution with proper credit, we should avoid lumping together these different aspects. There is a set of features under development that will allow contributors to indicate when their contribution is sponsored by a particular organization, and when they are contributing on their own as volunteers. Until those data are available, it's up to us to consider the specifics, and to remember that contributors are usually volunteers.

Finally, none of the forms of influence above cause contributors to lose their own particular passions and interests, their own unique view and skills. People are individuals, not automatons operating within a corporate machine. Even the six of us in OCTO contribute outside of paid time, to things that are not part of our jobs but that we care about. Gábor leads the multilingual initiative because he wants to make Drupal support all languages; Acquia did not prioritize it. Tim voluntarily works on core problems that bug him based on experience building sites and contributed modules, in addition to critical issues Acquia pays him to help fix. And Acquia doesn't own what I think or what I do with my spare time. So while we should recognize the influences organizations may exert over contribution, we should give individuals the credit for their own work.

Counting the "top 10" patch contributors makes no sense

The Watchdog article's chart represents the "top 10" patch contributors by commit mention, but no others. If we treat one commit mention as a unit of work in Drupal 8 core (an imperfect, but not unreasonable metric), this means it provides no representation for over 75% of the work that has been done on Drupal 8. (source data)

Field API maintainers swentel, amateescu, and yched come in 13th, 14th, and 15th from the "top" respectively. They are each mentioned in around 300 commits. The have built and re-built what is perhaps the most fundamental Drupal API -- the one that makes Drupal, "Drupal" -- making fields compatible with new systems in Drupal 8 like the Configuration Management system and the APIs that support Web Services, doing the equivalent of an initiative's worth of work. Why aren't they counted in the graph? Are they really less important to Drupal 8 than me, such that I get a little blue rectangle and none of them do? I'd say the opposite is true--each one of these brilliant developers has done more for the codebase than I have. And all three of them are currently independent.

Drupal 8 core has over 2700 contributors (nearly three times as many as Drupal 7). This contribution follows a stark long tail distribution of commit mentions to individual:

The long tail of Drupal 8 contribution, March 1 2015

Inspecting the data and chart closely, there is a "head" on the distribution of a small group of individuals that account for a significant portion of the work done. I'd say it's about the top 50 people, those with 100 Drupal 8 commit mentions or more. Then there is a middle tier of regular contributors, the next 100 or so, who have between 20 and 100 commit mentions. And finally there's the "long tail", the 2500-some contributors with fewer than 20 commit mentions over the four years of Drupal 8's development. (Among them, 1200 contributors have worked on only one patch.)

By this metric, the "long tail" has done more than a quarter the work in Drupal 8. These are people from all over the world helping to improve the open source software they collectively own. By excluding the long tail, the article is not crediting a big chunk of the participatory, collective, "grassroots" audience that it seeks to encourage.

Finally, while "top" contributors indeed have disproportionate influence in a pure "do-ocracy", Drupal's top contributors cannot commit their own patches and do not have any particular decision-making authority. So counting patch contributors identically with people who actually have formal decision-making roles does not make sense.

Many kinds of contribution are not represented

A strength of the Watchdog article is that it includes two forms of non-code contribution (Drupal Association board membership and Drupal Working Group membership). However, it's important to keep in mind that there are many other essential influences in our community. As mentioned above, peer review is a required part of our core development process, but typically the Drupal core commit log only credits patch authors, not reviewers. (See the proposal to change this policy.) Furthermore, training, documentation, and mentoring are all essential Drupal contributions, as are the sponsorships and crowd-funding that make sprints and large initiatives feasible. This omission is understandable since these contributions aren't surfaced very well on, but it's important to remember that all are influential.

Finally, there's also no representation of contributed module development. This is reasonable for Drupal 8 since core does not yet have a stable release, but many 8.x branches of contributed modules are already under development using Drupal 8 betas, and these projects will play a bigger role following the release of 8.0.0. It's also worth noting that contributed module development also has its own formal decision-making role, since we have a contributed project application process where ultimately one of our Git administrators must approve each application.

A different picture

The following chart has several differences from the Watchdog article's:

  1. I'm representing the actual number of individuals rather than counting someone once per role, because influence is not a function of the number of roles.
  2. I list the organization the individual was actually in during the majority of their term in their role, because contributors change jobs. (I look more into how contributors move toward particular organizations later.) In cases where an individual has been at more than one organization during their active term, I provide an explanation for the organization used in the source data. (Sometimes it's close, but I think counting half-individuals would also be a bit confusing. If you see an error, please comment on the cell in the spreadsheet so I can correct it.)
  3. I'm excluding the top 10 patch contributors, because these individuals do not have any particular authority. (I illustrate patch contribution separately further down.)
  4. I'm not indicating the nature of each individual's role(s) on the graph, but you can see these in the source data.
  5. I'm using current data (the Watchdog article is from Sept. 2014).

Drupal contributors in formal decision-making roles by organization

Not all individuals on the chart have equal influence, as described earlier, but I think this illustration is less confusing than representing numerous individuals multiple times, and a better starting point for discussion. While it's still clear that Acquia has the most individuals involved in formal Drupal decision-making roles for a single company, it's a reasonable difference rather than an enormous imbalance.

Next I'll look at the Drupal 8 commit mentions for individuals while they were affiliated with a particular organization. This reduces the distortions related to my second point above (that contributors change jobs). Keep in mind, however:

To make this chart, I first crowdsourced information on which contributors worked where when. This information is from a variety of sources, like Twitter, Linkedin, personal knowledge, etc. (If you see an error in it, please leave a comment on the cell in the spreadsheet so I can correct it.) To keep this mini-project manageable, I limited this to contributors with 50 commit mentions or more (who collectively account for about 2/3 the commit mentions in Drupal 8). For less prolific contributors, I merged in "current organization" data from, gathered using a database query run on's staging servers. Finally, I adapted the drupalcores script to also parse the date that each commit was made, and then matched that date to the timeframes listed for each patch contributor.

Commit mentions and contributor affiliations, March 1 2015

Note that I've only represented the top 15 organizational affiliations and put the rest under "other". In reality, there are many other organizations that have people contributing prolifically, and I encourage examining the full data.

The first interesting thing here is that by far the most important group is that of independent contributors: people who are freelancers, self-employed, etc., or who list no affiliation on For the long tail, some of these people might be mis-categorized under "other", since there's no easy way for my query to distinguish between the name of someone's one-person freelance business and the name of a multinational corporation.

The second interesting thing is that we confirm that Acquia does indeed employ the most prolific contributors for a single company, even when the data are updated so employees' previous contributions are listed with their previous employers. However, other organizations also make a significant mark, and the individual contributors are still the most influential factor (compare the full organization data with the individual commit mentions). As tim.plunkett put it:

Two dawehners and an andypost == one Acquia.

So do we still need to worry about organizational influence?

Yes, we always should. In practice, Acquia does not direct my work for specific company interests, nor Chapter Three alexpott's. But theoretically they could. We are none of us immune to the organizational influences described above, nor are we above conflict of interest. And while independents and volunteers remain the lifeblood of the Drupal core community, professional contribution has been a very important part of the development of both Drupal 7 and 8, and numerous prominent volunteer contributors are choosing to work for certain organizations (like Acquia, Tag1, Lullabot, and PreviousNext) more than others.

The availability of these volunteer and professional resources is still a good thing--it means individuals and organizations are giving back and helping the project thrive, to the benefit of everyone who uses the software. Still, in order to benefit from these resources while protecting the community against any one group having too much influence, we need a diversity of perspectives. Professional developers building large-scale sites have valuable perspective and experience. So do freelancers who build small sites for local organizations. So do people who need a website and don't care what the code looks like inside, and just want something that works. What can we do to prove Drupal 8 is for everyone and to make sure that anyone can still contribute?

First, I recommend reading Ashe Dryden's thoughtful and well-researched article on The Ethics of Unpaid Labor and the OSS Community for perspective on why potential contributors have unequal resources and face unequal barriers to contribution. Then, here are specific steps we (as a community) and you (as someone in the community who cares) can take:

Lower barriers to volunteer contribution

As mentioned above, Drupal 8 core has had over 2700 patch contributors. The goal of the Core Contribution Mentoring initiative is to inspire, enable, and encourage new core contributors, regardless of background or affiliation, and to work on the core tools, process, and community to make it easier for new contributors to get involved. 

Mentors in orange shirts stand ready to help sprinters at the DrupalCon Sydney Community Tools Workshop, led by add1sun. The workshop prepared first-time sprinters to contribute to Drupal 8 core. add1sun is not referenced in the Drupal 8 commit log. Photo credit: xjm.

Over the past three years, core mentors have learned a lot about what makes contribution easier or harder for volunteer contributors, and we have lots of recommendations for improvements to that need work. You can also help by mentoring at DrupalCon Los Angeles, in IRC, or in your local community, or by joining the conversation at one of the proposed DrupalCon sessions (see changes to support first time contributors and mentors, How do we encourage repeat contributions to Drupal Core?, and Pain points of learning and contributing in the Drupal community).

Continue to improve Drupal's usability and accessibility

If Drupal itself is a barrier, then that's a barrier to contribution. Help with usability and accessibility issues on, or do usability and accessibility testing and report the results.

Credit and support all forms of contribution

The proposal to credit reviewers and other non-coders as first-class contributors will help highlight the impact of contributors in these roles, and the proposal for a new design for user profiles also highlights non-patch contributions more prominently. The work to provide credit to organizations is also essential to recognize how contributions are funded.

Project manager svettes helped run all of the official Drupal 8 initiatives. She is not referenced in the Drupal 8 commit log. Photo credit: xjm

Make it easier to sponsor contribution, and fund more contribution more diversely

Sustainable funding for Drupal core has been a topic of discussion throughout Drupal 8 development. Dries' DrupalCon Amsterdam keynote explores social theory and research related to how we sustain open source projects, and the core conversation on funding Drupal core from the same event discusses specifics for funding core in the near term.

In December, the Drupal Association announced the Drupal 8 Accelerate program to help fund critical work on Drupal 8. The fund makes it possible for independent contributors to receive grants for work that brings Drupal 8 closer to release. You can contribute to the fund financially by becoming a Drupal Association member or partner, or contact the Drupal Association about donating directly at Or, if you have an idea on how funding could help speed Drupal 8's release, read the program details and apply for a grant.

yched, Wim Leers, and pfrenssen sprint on critical issues in Ghent. The Ghent critical issue sprint was funded by a grant from the Drupal Association. Photo credit: xjm.

For information on how organizations can invest in contribution through their employees, read YesCT's thorough article on strategies for businesses to invest in Drupal 8. If you are a business owner, you might even consider whether you could join with Acquia, Chapter Three, Pantheon, BlackMesh, and other companies in employing full-time open source contributors.

Finally, the Drupal Core Gratipay Team exists to help fund regular contributors who are not paid for core work.

Adopt employment practices to make contribution both fair and feasible

Ashe's article (referenced already above) has lots of great recommendatons on fair employment practices that enable contribution.

Be transparent about governance and decision-making Flowchart for allowed changes during the Drupal 8 beta.

When the Drupal community was smaller, we didn't have the same need for formal structures for decision-making, because most core developers knew each other. That is no longer feasible; contributors shouldn't need to "know someone" to get something done. As our community grows, transparency is essential.

I was not involved during the development of Drupal 7, so I don't have firsthand experience of how the community responded to these challenges before 2011. Nonetheless, I think we've made a lot of progress in Drupal 8. For example, the introduction of the Working Groups improved the transparency of community decision-making. We've added the core gates, issue summaries, Drupal Core Updates, and beta evaluation criteria all to make core development and patch acceptance more transparent. Branch maintainers now also collaborate to give quicker feedback on issues, including regular triage of criticals so the community has accurate information on what is blocking Drupal 8's release.

None of these changes have completely resolved transparency problems around core development, and some of them have been rocky, especially at first. It's a struggle to scale core development without adding unneeded overhead. Our next challenge is definiting the roles of core component, topic, and branch maintainers more clearly.

Be transparent about volunteer and paid contribution

Finally, for all the reasons in this post, transparency about both volunteer and paid contribution is essential. The most important step is the work to provide credit on for organizations sponsoring development. This change will simultaneously provide fairer credit to all organizations--not just those employing full-time developers--and clarify what contributions are funded versus contributed by volunteers.

I'm glad Acquia invests directly in Drupal 8 core contribution the way that it does. After all, the fact that I'm getting paid to contribute full time is awesome and the entire reason I work for Acquia in the first place. I also think we need to talk more about all the other organizations that contribute in significant ways, and most especially the individuals who do. I still recognize that we are all prone to conflict of interest, and it's crucial that we maintain and expand Drupal's diversity to provide balance. Accurately representing the current diversity of contribution is the first step.

Thanks to YesCT, effulgentsia, catch, and alexpott for contributing to this post. All data are from March 1, 2015.

Feedback? Contact me on

Tags Comments
Catégories: Elsewhere

Drupal core announcements: This month in Drupal documentation (February 2015)

lun, 09/03/2015 - 22:09

Here's an update from the Documentation Working Group (DocWG) on what has been happening in Drupal Documentation in the last month or so. Because this is posted in the Core group as well as Documentation you can not comment on this post. If you have comments or suggestions, please see the DocWG home page for how to contact us.

Notable Documentation Updates

Most of the hook_help texts for the Drupal 8 core modules have been finished, but there are still a few that some review. If you can help, hop over to to find the remaining issues. Most of these help texts need to a review because they have been written over a course of two years and Drupal 8 has evolved since then. If you want to help reviewing them, check

Thanks for doocumenting

February 2015 was a extraordinary productive documentation month with 245 people revising and writing more than 1000 pages. The most active editors were:

Many thanks go out to everyone that helped improving Drupal's on line documentation.

Documentation Priorities

The Current documentation priorities page is always a good place to look to figure out what to work on, and has been updated recently.

The two meta issues to update and review of help texts currently have a high priority: Not only do we need them for a good user experience of Drupal 8, they also need to be translated once they are ready.
Working on them is also a good way to find out already how Drupal 8 will work for site builders and site administrators.

If you're new to contributing to documentation, these projects may seem a bit overwhelming -- so why not try out a New contributor task to get started?

Upcoming Events Report from the Working Group

In February, we met with the Drupal Association's Joshua and Tatiana who presented us the ideas for the future of on line documentation on It seems that in the future we will be able to use several different types of documentation on, most noticeably we will be able to have documentation that is much tighter integrated with contributed modules and themes. We were able to give useful feedback on the DA's plans and some of our long wished improvements, as outlined in seem to be going to be realised. Despite that, some of our requests have not been met yet and some doubts remain over the implementation of the DA's plans.

Catégories: Elsewhere

Four Kitchens: The Great Consolidation - migration case study presentation

lun, 09/03/2015 - 20:37

At 1am Pacific on January 29th, 2015, Entertainment Weekly quietly switched to Drupal 7. Ten WordPress VIP blogs and a monolithic Vignette V6 Content Suite were deprecated. Over a half million articles and images were migrated to a new design and modern publishing platform, and Four Kitchens led the development.

On February 27th, 2015, three of the web chefs on the project presented a migration case study to a full room at SANDcamp 2015. Myself, Matt and Patrick fielded questions about the project. While no recording was available, I’d like to share the presentation with you.

Projects Development Drupal Events
Catégories: Elsewhere

Drupal Association News: Voting is Open for the 2015 At-Large Board Elections

lun, 09/03/2015 - 16:13

Voting is now open for the 2015 At-Large Board positions for the Drupal Association! If you haven't yet, check out the candidate profiles and review the Meet the Candidate sessions (we ran three) that we held. Get to know your candidates, and then get ready vote.

Cast Your Vote!

How does voting work? Voting is open to all individuals who have a account by the time nominations open and who have logged in at least once in the past year. These individuals' accounts will be added to the voters list on and they will have access to the voting.

To vote, you will rank candidates in order of your preference (1st, 2nd, 3rd, etc.). The results will be calculated using an "instant runoff" method. For an accessible explanation of how instant runoff vote tabulation works, see the this video.

Elections will be held from 9 March through 20 March (midnight UTC) 2015. During this period, you can still review and comment on candidate profiles.

Have questions? Contact Drupal Association Executive Director Holly Ross.

Catégories: Elsewhere

Wuinfo: Easy Way Out Before Lost inside Views Maze

lun, 09/03/2015 - 13:30

As I have talked in my previous blog about importing large quantity of node without feeds module. Today, I will show you how to build complicated block views without using views module.

Did you have ever faced the situation that views can not solve the problem? I have a unique request from my client this week. We need to have a related video block for video node page. There are three levels of sorting. First show the episode videos from the same series. Then show the videos having same tag. At last, show the rest of the videos that are not in the same series and have no tags in common. What are those three requirements really means? We need to sort all video nodes according to current node's taxonomy tags. So, views block is not the solution since we select all the nodes. Even though, views is one of the most used modules among Drupal websites; it is not a medicine for everything. As a rule of thumb, if any problem can not solved by one SQL query, then we should look for a solution in other places. The problem we are solving is related to complicated sorting that views can not do it. It is one of the case.

It took me and another Drupal developer all most two days to make a view on it. We can not find a good way to sort them. In the end, we give up views and decide to make a custom module for it. Within couple hours, a customized block was built. I found that a custom block was easier to build. It is more efficient than the views block. Here I would like to show you how does it work.

There are three parts of the module. First, get a list of the nodes. Second, render the list of the nodes. Third part is using the ajax framework to add the load more button.

Most difficult part of the module is to get the list of the nodes. Since all the request of 3 levels of sort are all done with the list of nodes. It is where views is not able to accomplish it. But it is more related to the business logic. Different project may face different logic. There is one thing I want to mention on this part. We need to be careful when build query. We are adding more and more videos to the website. Try to avoid loading too many videos into memory will be the key point to make sure the system will running smoothly after the site grow big. Check blog "build website with a million nodes" for more detail on it.

Here are the codes for the rest of 2 parts.

Render the list of nodes into a block. We use node teaser displays for each node in the block.

* Render the list of nodes into HTML.
function related_videos_render_json($count = 7, $position = 0, $cur_nid = 0) {
  $nodes = related_videos_get_list($count, $position, $cur_nid);
  $nid = array();
  foreach ($nodes as $key => $node) {
    $nids[] = $node->nid;
  if (!empty($nids)) {
    if ($count > count($nids)) {
      $count = 0;
    $nodes = node_load_multiple($nids);
    $build = node_view_multiple($nodes);
    if ($count != 0) {
      $build['loadmore'] = array(
        '#prefix' => '<ul id="related_videos_link" class="load-more"><li>',
        '#suffix' => '</li></ul>',
        '#type' => 'link',
        '#title' => 'Load More',
        '#href' => 'related_videos/nojs/' . $count . '/' . ($position + $count) . '/' . $cur_nid,
        '#id' => 'videos_ajax_link',
        '#options' => array('attributes' => array('class' => array('use-ajax'))),
        '#ajax' => array(
          'wrapper' => 'related_videos_link',
          'method' => 'json',
  else {
    $build['no_content'] = array(
      '#prefix' => '<p>',
      '#markup' => t('There is currently no content.'),
      '#suffix' => '</p>',
  return render($build);

The function related_videos_get_list($count, $position, $cur_nid) is to get the list of node where we put our node sorting logic there.

Then we use two block hooks to create a block for the list of video.

* Implements hook_block_info().
function related_videos_block_info() {
  $blocks['related_videos_block'] = array(
    'info'    => t('Related videos block'),
    'cache' => DRUPAL_NO_CACHE,
  return $blocks;

* Implements hook_block_view().
function related_videos_block_view($delta = '') {
  switch ($delta) {
    case 'related_videos_block':
      $cur = related_videos_current_node();
      drupal_add_library('system', 'drupal.ajax');
      $block['subject'] = t("Related Videos");
      $block['content'] = '<section class="col-xs-12 col-sm-8 wv-contnet video-related-wrapper"><h2>Related Videos</h2>';
      $block['content'] .= related_videos_render_json(7, 0, $cur->nid);
      $block['content'] .= '</section>';
  return $block;

So, now we have a block can be assign to anywhere with Drupal block system, panel or context module.

The last part is to use Drupal Ajax framework to add a load more button. We load more videos without reload the page.

First, implements the hook_menu to define the callback link for ajax request.

* Implements hook_menu().
function related_videos_menu() {
  $items = array();
  $items['related_videos/ajax'] = array(
    'page callback' => 'related_videos_ajax',
    'access callback' => 'user_access',
    'delivery callback' => 'ajax_deliver',
    'access arguments' => array('access content'),
    'type' => MENU_CALLBACK,
  $items['related_videos/nojs'] = array(
    'page callback' => 'related_videos_nojs',
    'access callback' => 'user_access',
    'access arguments' => array('access content'),
    'type' => MENU_CALLBACK,
  return $items;

The second menu item items['related_videos/nojs'] is for the fall back of browser have javascript disabled. For more detail, check Ajax framework document.

Then we build the callback function related_videos_ajax. We use the callback function in the implementation of hook_menu.

* Ajax callback for related videos content.
function related_videos_ajax($count, $position, $cur) {
  $data = related_videos_render_json($count, $position, $cur);
  $commands = array();

  $commands[] = ajax_command_replace('#related_videos_ajax_link', $data);
  $page = array('#type' => 'ajax', '#commands' => $commands);
  return $page;

The function related_videos_render_json is the function we used to render the HTML. We use the same function for the initial block content. Here, we got the HTML of the list of the node and delivered to the browser in JSON format for the load more button. The parameters $count, $position, $cur was passed in from the URL. The URL of the load more link is defined by the related_videos_render_json function.

Those three parts formed a custom block display a uniquely ordered video nodes. Use the powerful Drupal theme function and Ajax framework, it is easy to build a block like this.

Catégories: Elsewhere

Josh Taylor: Automatically testing contrib modules when 8.0.x updates

lun, 09/03/2015 - 13:16

Many 8.0.x contrib modules are being developed on Github, due to the flexibility it offers whilst 8.0.x is being developed.

As the complexity of 8.0.x has grown, needing to test modules using Continuous Integration (CI) is critical. offers CI for modules, but we need custom steps each build.

For example, to build commerce 2.x the following steps are required:

  1. drush si –db-url=mysql://root:@ –account-name=admin –account-pass=admin – –site-name=”Commerce” –yes
  2. drush en -y composer_manager simpletest
  3. drush composer-manager-init
  4. cd core
  5. rm -rf vendor
  6. composer drupal-rebuild
  7. composer update –prefer-source -n –verbose
  8. cd ..
  9. drush en -y commerce commerce_product commerce_order
  10. php core/scripts/ –verbose –color –concurrency 4 –php `which php` –url http://localhost “commerce” | tee /tmp/test.txt; TEST_EXIT=${PIPESTATUS[0]}; echo $TEST_EXIT

As you can see, quite a few commands are needed. For the full command list, check out the .travis.yml file commerce uses.


So what exactly is Travis? Well, wikipedia says:

Travis CI is an open-source hosted, distributed continuous integration service used to build and test projects hosted at GitHub. Travis CI is configured by adding a file named .travis.yml, which is a YAML format text file, to the root directory of the GitHub repository.

Similar to, everytime a new Pull Request is added on, it is tested against Travis to make sure everything passes.

This is all fine and dandy, but what happens whenever 8.0.x updates? 8.0.x can update many times a day thanks to the tireless work of the contributors and core committers, and change records come in thick and fast with breaking changes often happening.

Travis doesn’t offer a feature to do new builds via API out of the box unfortunately, however there is a script called “travis-cron” which is a shell command to trigger rebuilding the latest build of a certain branch, so I use this to rebuild the 8.x-2.x branch of Drupal Commerce, as only merges are done on this branch.

To get this to work, I use an opensource tool called Huginn, which is very similar to IFTTT. IFTTT basically means “If this, than that”, so you can perform an action whenever something happens.

I use Huginn for this, because IFTTT doesn’t have Webhooks yet, and I also need to run a bash command anyway, so hosting on a small VPS ($5/month) is worthwhile.

The first thing we want to do is enable the RSS agent, which will allow us to know whenever core has updated. This can be found as a link on the Core Commits page, with the direct RSS link being here.

To create a new RSS agent in Huginn, click “Agents -> New Agent”

From here, you can add all the settings you need, such as the URL to parse, how often to check the RSS feed (I have mine set to every 5 minutes)

After this is done, we need to setup another Agent, that will react on whenever a feed item is added. Since we want to react on all feed changes, not just certain items, this is easy to do, just adding a ShellCommandAgent will do the trick. You can use “travis-cron” to do this, reacting on the “Drupal Core Updates” RSS item.

Now whenever core has updated, travis-ci will rebuild the branch you have chosen with travis-cron!

Catégories: Elsewhere

Liran Tal's Enginx: Apache Obfuscation by disabling trace and server tokens

lun, 09/03/2015 - 07:40

Apache Obfuscation can be achieved very easily and the benefits are great – it doesn’t disclose server information such as versions, OS, and does output verbose errors when ‘bad things happen’, and they happen.

Edit apache configuration, usually available here for RedHat based distributions: /etc/httpd/conf/httpd.conf

Make sure the following settings are present, save, and restart apache:

TraceEnable Off
ServerSignature Off
ServerTokens Prod
How do we test that this is actually working?

How to TraceEnable:
1. curl -v -X TRACE http://…
2. Confirm you get a forbidden response

How test ServerTokens:
1. Make a request to the website and check the response headers
2. Confirm the response contains only “Apache” information in the Server header

How to test ServerSignature:
1. Make a request to the website for a URL that should respond with Apache server error
2. Confirm you don’t see information about the apache server software version, OS, etc.


(adsbygoogle = window.adsbygoogle || []).push({});

The post Apache Obfuscation by disabling trace and server tokens appeared first on Liran Tal's Enginx.

Catégories: Elsewhere How we built a Drupal distribution for the Estonian Government, part 2 – functionality highlights

dim, 08/03/2015 - 20:42

A while back I wrote the Part I of how we built the Estonian Government web platform. I had all the intentions to quickly follow that up with Part 2 and 3, but as always, things got busy. The good news is, however, that all the sites are now live for several months and I can use live examples to illustrate my text here.

Part II is about some of the functionality we built and the technical solutions used for it. The development phase lasted throughout the second half of 2013 and first months of 2014 – 7 months of development means a lot of different stuff was built. Instead of trying to cover it all, I will try to focus on the parts that I feel characterize this project the best.

I already wrote about how we implemented the Google Site Search for the Government platform, which definitely was one of the big and complex parts of the project. But yet another big one was…

Integration with centralized state personnel database

Estonian Government is keeping the contact information of its employees – that is, the ministers, officials, department personnel, etc. – in a unified information system, based on SAP technologies. That is a good thing, as theoretically only a single integration is needed to show the public contact details of those people on the Government web platform sites. There was a lot of value there – over the 14 sites, that’s thousands of people, whose contact details, positions and careers within their organizations are in constant change, and keeping that information up to date would be a huge task for a lot of web editors. Instead, we were aiming to get all that data from internal systems, where it was kept up to date anyway.

But there were problems:

  1. Different organizations had different hierarchies – ie., Government Office had two levels of departments, while the Ministry of Economics had 4 levels.
  2. The SAP database did not contain or could not export all the information that was required to be displayed in the web.
  3. Different Ministries had slightly different practices about how they stored the contact information in the data fields, so there were a lot of exceptions of what could be directly presented to the public and what needed manual sanitation to get a more or less unified picture across all the Ministries.

The field lock checkboxes on Contact node edit page

It was clear quite fast that there were too many exceptions and some of those could not be predicted with 100% accuracy. So we needed some sort of a combination of having 95% of contacts automatically imported, but having the possibility to manually override – and making sure that manual work can be switched back to automatic or vice versa if needed.

The technical solution was to build a “field lock” functionality. A Feeds import made a daily automatic import that created or updated Contact nodes. Each node contained about 10 different fields of data for a person, such as Name, Position, Department, Education etc. If any of those fields needed manual adjustments, the editor could do so, and then use a special checkbox for that field to lock it from automatic overrides – so that when the next automatic import happened the next day, that field was not overwritten. If the data was later corrected in the backend SAP system, the lock could be removed and Feeds would resume writing into that field.

Examples of the views displaying those semi-automatic Contacts can be seen here and here.

WYSIWYG content templates

Government sites contain a lot of content, and it can get quite overwhelming for a visitor who needs to go through and get a sense of several topics fast. So the Government Office wanted each content page to be something more than just a wall of text, to have more structure, sections, visual data and differentiation. We needed a tool that would help content editors craft pages like that themselves, without having to learn HTML and CSS for many months.

So we used the Wysiwyg API template plugin module to add a template selector functionality for CKEditor. Our frontend wizard Hannes pre-baked some 10-15 nice content templates, and content editors only had to select the correct one from a popup, replace the dummy text, and enjoy a professional-looking, rich content experience. Content templates were WCAG 2.0 AA level compatible, fully responsive, and could even be used inside one another.

Template selector popup within CKEditor


Here are some examples of pages (in beautiful Estonian) made by content editors who probably didn’t have to write a single line of CSS: Ministry of Economic Affairs and Communications is writing about energetics, Ministry of Culture describes how they use foreign resources, Government Office introduces Estonian Presidency of the Council
of the European Union 2018.

Aggregating content between the sites

One goal of the Government platform was to unify the content across different Ministries. This included several behind-the-scenes processes, but also a technical solution to aggregate content across different sites into one central source.

Each Ministry had their own page for news, weekly schedule, and contacts. These in turn had RSS feed outputs, like this and this, which could be used for news readers, open data initiatives and other machine-reading purposes, and also for aggregation.

The central information source and aggregator was to be (translated,, which was also running on the Government platform and didn’t represent any physical institution per se, but the government as a whole. So weekly schedule, news, and contact search pages on the site would display content from all the Ministries, pulled in over RSS. You can see “Source” filters there, in case someone would need to focus on content from just a few of the Ministries.

Unfortunately, the RSS export-import has not yet been configured for all the sites and therefore there is no active aggregation yet – I’m planning to write more about the woes of deploying 13 big sites and the importance of follow-up phases in Part 3 of this series.

Tagged: case study, Drupal 7, integrations, planet drupal
Catégories: Elsewhere

Drupal for Government: 3d Printing Drupal Commerce Profile with Profiler Builder

dim, 08/03/2015 - 17:33

We're almost ready to release the site - not all of the features are working right now - I'm having some trouble with conversions of STL files in to the correct units.. PITA, but the Rules module and Joe Pontani have made the process a lot simpler = thanks Joe!  As part of the release we're putting the code up in github, and we're now using Profiler Builder to facilitate distribution = thanks btopro :)  we're also using it with the distribution... thanks for the feedback on github to improve this aspect of the work.  The first bit about profile builder is adding libraries, patches, and even the variable table to the profile.

Catégories: Elsewhere

Code Karate: Building a Dynamic display block with Minipanels

dim, 08/03/2015 - 06:19
Episode Number: 196

Sometimes you need to display something dynamically based on the page the user is currently viewing. Sure you can accomplish some of this with blocks, or even just panels, but sometimes it's nice to have the best of both worlds.

Tags: DrupalPanelsDrupal 7Layout ToolsSite BuildingDrupal Planet
Catégories: Elsewhere

valechatech: Tips to become a git administer on

sam, 07/03/2015 - 06:04

Previously we read how to be a webmaster on the , Now I became the git administer on the So I think to write a blog post so that others can benefit and also get to know how to become git administer.

In simple words: "Start Contributing". Git Administer privileges are granted to the users with proven record of contributions in the Project Applications issue queue. A solid history of consistent contributions on is a must to get consideration for an elevated role.

How to start contributing & where you can contribute :

  1. Join the code review group
  2. Read How to review full project applications
  3. Some helpful tools for reviewing :
  4. Learning Sources : 
  5. if you found any problem while contributing,just comment on the below post/ if you need immediate answer you can try and find one of the git administer on IRC - #drupal-codereview IRC channel on Freenode.
I would encourage you to learn more about that process and join the group of reviewers.
Next article:  A guide to review project applications
Catégories: Elsewhere This is how India is sending its best Drupaler to Drupalcon LA 2015!

sam, 07/03/2015 - 05:46

My colleague Prafful Nagwani and I recently launched a crowdsourcing campaign to send one of India’s finest Drupal contributors - Piyuesh Kumar - to Drupalcon LA, scheduled to happen in the second week of May 2015.



Thanks to Indiegogo, we were able to launch the campaign very quickly after the thought.


Our initial estimate for the trip came to ~$3500.


Thanks to Megan Sanicki and Drupal Association. We have now been promised a free Drupalcon ticket. So the estimated cost of travel came down to $3000.


One thing we did not consider initially when we estimated was the charge deducted by Indiegogo, which seems to come around to 10% of the total.


The campaign was fairly successful. We succeeded in raising $1892 of the estimated $3000 required.  So we clock a nice 63% on the target!



Thanks to all those who contributed.


(In random order. Pictures from taken from public profiles of the contributors. Anonymous contributions excluded. Some contributors could not be mapped to any public social profile by their name and hence might not appear on the collage above)


A Big Thanks to Mike Lamb and Drupal Mumbai & Pune communities, for promoting and contributing to the event during the recent Drupal Camp Mumbai!



Thanks to Megan, Rachel and Drupal Association (yeah, once again). This time for featuring the campaign on DA Newsletter that definitely helped a lot in giving the final push that was very much required for this campaign!



We definitely fall short of the required fund by around ~$1000. The good news is Qed-42 / Dipen Chaudhary, Piyuesh’s employer has come forward to cover any costs that would be required above the funds collected. Way to go Qed 42!

(Image generated by IQuelt from


One question that has repeatedly popped up is - Isn’t there a Drupalcon scholarship / grant already?


Well, there is one.  And as one of the earlier recipients of the scholarship, I have been there, done that!


But unfortunately when it comes to travelling to a US/Europe Drupalcon from India, the cap of $1000/€800 hardly covers 75% of economy airfare. We thought this guy deserves a fully covered trip to Drupalcon for his contribution to the Indian Drupal Community and hence was this campaign.


Thanks again to everyone who chipped in.


And another good news is that some of the contributors have proposed that we do this every year and send the most deserving person from the Indian Drupal Community on a fully sponsored trip to Drupalcon. That definitely would be the most awesome thing to do and I am all up for it!

Catégories: Elsewhere

Freelock : Ask Freelock: Build, embed, or integrate SaaS with Drupal?

sam, 07/03/2015 - 01:25

Mike, looking for information about integrating a data collection Software as a Service (SaaS) offering, asked:

I was a little surprised by your comment that the capabilities aren’t likely to be available in an existing widget.  I was under the (I guess incorrect) that Drupal was more sophisticated and locked down than WordPress, but that similar widgets could be found – even if the choice is more limited.  I’ve found WordPress widgets that offer some of the features, and that could be adapted.

Hi, Mike,

DrupalDrupal PlanetEmbedIntegration
Catégories: Elsewhere

Pixelite: Site preview - the holy grail of Drupal

sam, 07/03/2015 - 01:00
What is site preview

The ability to see (and have selected others see) changes to content and layout that is not yet visible to the general public

So recently I did a talk at DrupalSouth Melbourne on site preview solutions that exist within Drupal at present. I noticed that no one had managed to do a comparison between them as they stand at the moment, so I aimed to help out there.

Solutions compared in the talk:

  • Drupal 7 (stock)
  • SPS
  • CPS
  • Zariz
  • Live preview
  • What is coming in Drupal 8

I also wanted to introduce the new solution that was developed for the Ministry of Health New Zealand, that aimed to solve site preview in an entirely different manner.


Here are my full slides from the talk if you want to read about the above options in more detail.

How preview sync is different

Instead of try to take over your production site, and pollute it with complex revisioning and access control, and altering your EFQ and views using magic, it instead works with your existing workflow (workbench_moderation integration is OOTB), and aims to be a lightweight solution.

Preview sync, takes a live snapshot (optimised) of your production database, and imports this to a separate dedicated preview environment. Then a number of actions take place, all of which are entirely alterable, so you can add your own tasks in, and remove tasks you don’t need.

Example tasks in preview sync:

  • environment switch to preview, this allows you to enable and disable modules, perform actions (e.g. redirecting email to a log). This is a powerful hook.
  • publish the content currently in ‘Needs Review’, this allows your content approvers to see the content, including all surrounding content as if it was published on production, but in a safe and controlled environment
  • re-index solr, if your site is largely driven by Apache Solr (which is not uncommon), this will allow the newly published content above to be inserted into the preview Solr index. This is a unique feature
  • your task here, seriously, the task list is completely alterable, and any drush command can be remotely executed on the preview environment. Custom drush commands can be added. An example of which is the bundled workbench-moderation-publish drush command.

As all the complex access control is not needed on production (e.g. you are never sending un-published content to Solr), there is a huge security benefit to using preview sync. Access control to nodes is kept simple on production.

Also, as the preview environment is dedicated, you can lock down access, e.g. only allow access to your preview site from certain IPs. This way, your internal content approvers can still see the content, and no one else.


If preview sync sounds like it could be useful to you, I am keen to know - please leave a comment below. I am also keen to hear if

  • there is a missing feature that is needed for you to adopt preview sync
  • key integrations with other contributed modules are missing
Catégories: Elsewhere

Drupal for Government: (Ugly) solution for altering decimal field precision with phpMyAdmin

ven, 06/03/2015 - 22:33

Ugh...  added about 60 fields with 10 digit precision... didn't think about numbers larger than 99,999,999.99 being in the data set...  The thought of writing a module sounded lousy... probably correct, but lousy... no prob, though, right?  I'll fix it in the database... field_config is the table to look in.... but upon opening phpmyadmin all I saw were blob fields..(btw this is 4.3.7) 

after a bit of digging around I remembered running in to this before - and upon opening up a copy of the database locally with phpMyAdmin 4.2.5 I was at last able to edit my stinking blob files :)  This is a pretty ugly solution, but it works.... also good for editing the variable table directly.... 

$cfg['ProtectBinary'] = 'FALSE';

$cfg['ShowBlob']   = TRUE;

$cfg['Export']['sql_hex_for_binary'] = FALSE;

Catégories: Elsewhere

Drupal Easy: DrupalEasy Podcast 146: Dries' Baby Bird (Acquia Certifications - Peter Manijak)

ven, 06/03/2015 - 14:45
Download Podcast 146

Peter Manijak, Director of Certifications at Acquia joins Ted, Ryan and Mike to get an update on the various Acquia Certification exams at the 1-year anniversary of the program. We learn about the four available exams, the exam creation process, as well as some exclusive info! We also talk about if a "site builder" does only "site building", Drupal 8 caching, and our picks of the week!

read more

Catégories: Elsewhere How To Force Search API To Reindex a Node / an Entity

ven, 06/03/2015 - 14:06

By default Search API (Drupal 7) reindexes a node when the node gets updated. But what if you want to reindex a node / an entity on demand or via some other hook i.e. outside of update cycle? Turned out it is a quite simple exercise. You just need to ...

Read now

Catégories: Elsewhere Adding a custom extra field to entity / node display

ven, 06/03/2015 - 14:06

I had a case recently, where I needed to add custom data to the node display and wanted this data to behave like a field, however the data itself didn't belong to a field. By "behaving like a field" I mean you can that field at node display settings and ...

Read now

Catégories: Elsewhere