Drupal

This project seeks to provide a true compound field solution for Drupal 7. As much as I love Field collection, it still has to save actual entities, and can cause performance problems due to having to load all the referenced field collection entities on node, or parent entity load.

Related links

• http://drupal.org/project/combofield and https://github.com/yched/combo
• #939836: combofield / fieldentity / field-collection / embeddables
• http://drupal.org/project/flexifield
• Comparison of multifield modules
• #494100: State of the multigroup module
• http://drupal.org/project/subform
• http://drupal.org/project/composed_field
• http://drupal.org/project/double_field
• http://drupal.org/project/field_group_multiple
• http://drupal.org/project/form_builder

While ago i was looking for an slider module (implementation of JQuery UI slider module), surprisingly i couldn't find any solution except jSlider Form API which wasn't exactly what i was looking for. So i did what every good Drupal developer does, I wrote a generic slider module and shared it on Drupal.org (jQuery UI Slider Field). I even implemented "jSlider Form API" features.

Several months later and after i published several new minor versions, one of the users mentioned that there is in fact another slider module similar to mine!! SliderField and it was quite old too. He suggested joining forces to prevent duplicate modules. and that's what i did and even more.

read more

We're not talking about Darwin, but about the fact that a website project - even after delivery - will often stay in a state of evolution before becoming ‘stable’. The evolution itself isn’t the problem. Responding to that evolution is often what causes operational headaches. This article will not deal with the technical complexities of the Drupal development lifecycle, the CMI in Drupal 8 should solve that. Here we delve into the operational issues of website evolution.

Some definitionsAbout a decade ago, websites were constructed by ordinary people promoted from among their peers to the role of webmaster. Because websites weren’t used as the powerful marketing tools they are today, many websites remained under construction for a long time. Sometimes forever. Nowadays, websites can be under construction for a long time as well, but the construction phase is more accurately name; used by website engineers as they actually construct the website. Once the website is completed and delivered, it enters the maintenance phase. The actual go-live might happen overnight, but there’s often a fairly long time before development stops. The time between construction and maintenance is what’s called the evolution phase.  for ITIL lovers Within Application Maintenance Services our focus in this article is on Application (Drupal) Support.   Within Application Maintenance we can identify 4 types of Support. Corrective Support (eg. download link does not work), Adaptive Support (eg. make whole website work for new version of Internet Explorer),  Preventive Support (eg. perform security updates) and Perfective Support (eg. Add a carrousel to the new campaign page).     We rather use the term “Evolution” to denote the combination of Perfective and Preventive Support since it better fits the notion that we are talking about, more than ‘support’. ConstructionThe construction phase for websites is that period between having a neat idea, and bringing the resulting idea into production. The most important part of that phase is the concepting phase, while the largest part of that phase is the actual development project. The business model for development projects is fairly straightforward: sell as many development projects as there is capacity while keeping planning and efficiency (i.e. working billable hours at least 80% of the time). To fill the gaps between projects, you can take on smaller projects. The less downtime you have in your work schedule, the better. The resulting website will consist of everything that the client wants to start from. MaintenanceConstruction processes can be standardized to some extent, but it’s impossible to predict fallouts and failures, once software is running stably. The main problem of these fallouts is not the failure itself, it’s making sure you have resources available to fix the problem. So suppliers of modern-day equipment and services need to make sure they have enough permanent resources to address issues as they arise, in order to comply with their Service Level Agreements (SLA). Typically there are peaks moments and there are moments when everything is running smoothly. Only proactive maintenance tasks (e.g. upgrades, increasing memory) become plannable. But for this to be worthwhile, you need enough clients and enough resources to come up with usable heuristics. Once you have proper statistics, the maintenance business model becomes scalable, because it’s not people but statistics that are sold. In fact, resources can be sold multiple times when you’re dealing with small, unpredictable chunks of work. The resulting website will become  stronger and more stable by performing these maintenance tasks. EvolutionThe business model of maintenance is clear (enough resources + enough clients = scalable workflow), but starts to degrade as soon as these chunks of work become too big. This is what happens when the website is in evolution. During that evolution phase, the client will make feature requests that the development team needs to handle. But due to the nature of the request, the client will be unsatisfied if that request is handled as a project (ie. planned to happen in 5 weeks).  The resulting website will consist of improvements to adapt to changing business requirements, staying up to date with the newest technologies (e.g responsive design) or being ready for new marketing campaigns. What is the problem?If the evolution were handled as construction, clients would have to wait too long for small changes.If, on the other hand, it were handled as maintenance, the support team would lack experience  to complete all the engineering going on. Even if they did have the skills to handle those medium-sized chunks of work, accepting these requests would break the statistics of the business model. This could jeopardize the correct reaction time on more critical requests. What we are hearing from prospects and clients working with Drupal websites at the moment does indeed comply with our findings. We hear remarks like, “Yes, we have a support contract, our supplier reacts quickly and communicates well, but the quality of the fix is low or feature A gets implemented, while another existing feature B breaks down.” Or we hear, “Yes, we have a support contract, and the supplier delivers correct solution. They even bundled multiple requests into one release, but it takes weeks, sometimes months to get a small thing changed.”  Possible solutionsThere’s a list of possible ways to be able to deal with these situations, and the Wunderkraut support model currently handles all of them.  Fixed SupportReserve a few people from the development team for a number of days a week/month for a certain period of time, e.g. every Friday for six months, two developers will be available to react to client requests in the issue queue. The following problems arise with this solution:

• It’s very hard to predict how many resources will be needed and for how long, which will result in either too many or too few blocked resources.
• If these developers are unable to get a feature totally released on that Friday, they need to continue working on it, the next week - i.e. it is still slow.
• If the client does NOT have any requests, they will still be paying (maybe partially) for that unused time, and some clients don’t like that.

 Lower the billabiltyAnother option would be to decrease the billabilty of one or more dev-teams, e.g. only the dev-team is directly billable on projects for 60% of the time, so has extra room to handle these small chunks of works. But the problem here is pretty clear: the risk  is completely moved to the supplier. If in one month, none of the clients requests smaller work, the supplier has no income. This is in general not a good business model. On the other hand, this solution does not scale. If the supplier freed up some resources for each of his clients, the dev-team would just be ‘waiting’ for new features to come in, instead of working on new projects. Wunderkraut Evolution model (beta)We’ve finally managed to devise a model that combines the agility of the two weekly sprints of Scrum, with some warranties on reaction time for certain requests. We won't go into the details of the model, but the general idea is that we use a mix of fixed support and lower billability to spread the risk evenly between client and supplier, and at the same time allow small chunks of (evolutiove) development work to be added to the sprint backlog of a selected development team.  We are currently test-driving this solution for some clients, and will report back at a later time to talk about the results. Let’s discuss and learnIt may not come as a surprise that both clients and service agencies are dealing with complex issues as a result of this dilemma. In fact both parties are actually losing time and money in their search for the best solution. Therefore we would like to invite CTOs, CMOs and other company decision-makers and influencers to our round table discussion group in Belgium to exchange views on how to best solve this.  In an informal setting, a panel composed of a  Marketing Director (Kinepolis), a Technical Director (Cultuurnet) and a Supplier (Wunderkraut) will touch upon the different  aspects  of  the website evolutionary support.  The discussion will be moderated by Bart Gysens (project medewerker V-ICT-OR). If you are interested in joining this event please send an email to be.info@wunderkraut.com to register. 

Extends Webform & Drupal Commerce to provide enquiry cart functionality.

This module adds an extra field component to Webform allowing the storage of commerce orders. Order details can be emailed upon form submission, rendered in a table.

The intended use cases include pre launch shops, ambiguous goods & or services, new & or pre released goods.

Please provide feedback.

Read more

Automated installation of apachesolr multicore localy will save you valueable time.

How to automatically install apache solr multicore localy for drupalapachesolrsearchautomationSaturday, May 11, 2013 - 14:49

Attempt to provide an alternative IEF widget that renders the entities using a specific view mode. This has the added benefit of being able to re-use core's default multiple value widget handling.

Screenshot of the goals of this project:

Related Links:

• #1521274: Investigate a UI for configuring table columns (which fields and in what order)
• http://drupal.org/sandbox/rogical/1880826

• drupal 7.x
• views
• menu
• planet drupal

This article describes how to place a custom local task menu tab alongside the 'View' and 'Edit' tabs on a content type.

The Drupal.org infrastructure is a great resource for developers: A hub for development, with a combination of version control access, issue tracking, and automated testing.

Of course, it can be improved, and I don’t want to open a can of worms by saying it is perfect (it isn’t).

But I think the community does benefit from an environment that is designed especially for it.

Within this environment, we also have useful tools that help maintain quality in Drupal code.

1. The issue queues and workflow are set up to foster peer review, which (in line with the open source way) gives unlimited human eyes on a problem, rather than being siloed within a commercial organization.
    
2. Contributed projects such as dreditor allow fast, tangible reviews from reading through code, giving a clear comment for others to work from.
    
3. Automated tests mean that once you’ve set up code, you will automatically get the green or red light as to whether a change has unintentionally broken anything.
    
4. The coder module allows automatic reporting of code style, which helps bring the community towards common coding standards and accelerates the speed at which a contributor can become familiar with a new section of code. 

But these checks do add to the hassle of contributing a patch. Not good.

Formalising the process of review

On one of my projects, the Project Management Module, I was weighing up whether I should formalise the review process.

Previously, whilst a lot of the factors mentioned were taken into account (although not coder), it was a little haphazard, and I felt it wasn’t clear enough.

I wanted a contributor to know what the hurdles they were in advance, so that they could write a patch at the outset that solved the issues.

There are typically several patches undergoing review at the same time in the issues queue, so I also wanted to be able to speed up the review process to minimise the need for patch rerolls.

My biggest concern here was that I would alienate contributors to the project. This would not be an acceptable sacrifice, even if it meant that we were upholding the coding standards more precisely, etc.

Contributors come first

You’ll have got the message by now that one of the biggest risks to an Open Source project is (in my opinion) alienating your contributors.

So, whilst I’ve gone ahead and put a bit more structure in how I review patches, my focus has been on keeping the process easy and worthwhile – with a focus on the new element, coder reviews. 

Those regulars in the Project Management Module issue queue will keep me honest in the comments, I’m sure!

Is there a point to code style?

There are massive advantages to uniform code style among a community, but it is an investment made in a patch, with a longer term reward.

I’ve done two things to make coder patch reviews less painful:

1. Show the results: I’ve set up a developers website for the Project Management Module.
   
   You can see it at http://api.project-management-module.org.
   
   The aim here is for developers now to reap the benefits of the documentation that we’re adding to the code.
    
2. Lower the hurdle: I understand that not everyone has a test site running the coder module, and it adds a lot of time if you need to set that up each time.
   
   So I’ve opened up coder on the Project Management Module demo site.
   
   You can see it at http://drupal-7.project-management-module.org/admin/config/development/c....
   
   A check of a patch now takes a few seconds, and can be done before submitting on Drupal.org (in fact, you could use it for your patches too - it isn't module specific).

So far, I’m pleased with the results.

Nobody has complained about additional hurdle of coder reviews, and there have been some very positive comments about having an API site for all to see.

Conclusion

Alienating contributors is a real risk when formalising a process in an Open Source project, but it doesn’t mean that you shouldn’t try it.

Before implementing any change, think about how you will make the change worthwhile from the point of view of other contributors – whether by showing the point of it, reducing the pain, or both.

When have you tried to formalise a process in Open Source?

Has it worked?

What steps did you take to ensure contributors were not alienated? 

As always, I’d welcome your thoughts in the comments.

Category: WebsitesTags: DrupalDrupal PlanetMaintaining an Open Source ModuleOpen SourceCoderPatches

What is a million dollar house worth if it has bad wiring? Bad wiring means ripping out the drywall, getting it inspected by the city, and starting from scratch. If you have a builder that would allow something like that, as an owner you have to go from the bottom up and review what else they left lurking in your dream home.

Web application development is no different from a house. Sites require real estate, maintenance, and are living, functioning pieces. They require the occasional remodel to add more features as users needs change.

So why do so many web consultants often act like the McMansion builder of the web? Build it fast, cheap, charge as much as we can and walk out the door? Who do they think they're fooling? Maybe the clients, but will they be repeat clients?

Read more

This module creates a form with the ability to specify conditional fields.

Example:

I want to create a select field with options A, B, or C.

If the user selects option A, I can output another select field with options D, E, and F.

If the user selects option B, I can output another select field with options G, H, and J.

Etc.

What does it do?

This module enables the icecat open catalog for Drupal commerce.

Icecat is the world largest product database that is (partly) available for free.

It contains 1676636 up to date datasheets from 6430 different brands.

How does it work?

This module enables you to add some extra information when creating a product.
Upon saving the product this module will look up the icecat database for any matching product.

According to your settings it will auto complete the following information:

• Product title
• Product catalog
• Product images
• Product description
• Product specification
• Product ean, sku, brand

Sandbox project

You are all invited on Monday, May 20th, the first day of DrupalCon Portland, to honor Aaron Winborn's ongoing contributions to the Drupal community and to celebrate Drupal's power to make the world a better place.

I have to admit that I don't exactly know how to write about this event. I don't know Aaron personally. But like most of us, I've been working with his contributed code and following his writings on Drupal for several years. If you follow Aaron's blog, you know that he and his family are struggling with his ALS. You may have seen Aaron's G.D.O. post two weeks back looking for volunteers to help him continue to code in spite of the progression of his illness.

Two things are sure: Aaron loves Drupal, and Aaron loves our community.

One might argue, however, that Aaron's situation points to a challenge in open source software development: Aaron continues to simply give away his code, and in so doing he and his family won't benefit long-term from royalties or productization. In this situation, we have a responsibility, or at least a great opportunity, to show that we in open source take care of our own.

But I'm being melancholy. And based on my correspondence with Aaron about this event, he wouldn't want that. Aaron wishes that he could be at DrupalCon this year. He is excited for us to gather, of course to raise money for his family, but also just to get together and laugh and geek out together.

So on Monday night, the first night of DrupalCon, rather than go pay for beer at some bar, please consider making your way to the EcoTrust building (it's right on the streetcar) for this celebration, and donate that night's beer money to Aaron and his family.

We joke that "open source is free as in beer" - that we have an obligation to give back. Now it's time to prove it:

• Please register for the event at: http://pdxdrupaldogooders.eventbrite.com.
• If you cannot attend, please consider making a donation directly to Aaron's special needs trust.
• And Drupal firms, consider sponsoring the event.

So far, the generous sponsors of this event have raised over $4,000 for Aaron and his family. Let's keep the momentum going and hit the goal of raising $10,000 on this special night.

Tags: Drupal PlanetDrupal Givenonprofit techevents

Allow to link node title to an internal/external link using Link module instead node/[nid]

Here at Advomatic we've experimented with several approaches to responsive design over the past few years. I think the "mobile first" philosophy became popular right in the nick of time. There was a point when we'd detect if the user was on a mobile device and then deliver a separate mobile theme. This meant two instances of a site to develop for and maintain. I can't imagine doing that now, given the amount of device width/height possibilities and device-specific bugs that exist out there. So, now we work on layout with the goal of accommodating the content rather than the device. To accommodate a responsive and flexible layout, it's best to get your site on a grid. There are tons of options out there, but we've found one in particular helps you quickly get rolling and set up with a column layout that can adjust to whatever device you need your site to display on (and is fun to work with, too). Lately, it's been part of our holy trinity for responsive theming: Sass, Compass and Susy.

First things first: ditch pixels

One big first step to responsiveness in your site is to stop using pixel units for measurements. We use em units because they are proportional to any parent measurement, and therefore flexible and responsive. If we have a base font-size set on the body element of 16px, and our #footer is set to 1.6em, that #footer font-size will automatically scale up or down accordingly if the body's (or any parent element to #footer, for that matter) font-size changes.

To manually figure out exactly what em value you should be using for an element, you can use a commonly used formula: target ÷ context = result... or you could do it the easy way with a Sass function:

// Create em() for setting font-sizes in pixels.
@function em($target, $context: $base-font-size) {
   @if $target == 0 { @return 0 }
   @return $target / $context + 0em;
}

// Example usage: font-size: em(21px);
// This will set the font-size to 21px in relation to the browser's base font size if it has not been established in any parent element, or in relation to $base-font-size which is a variable you can set in your Sass.

// Example usage 2: font-size: em(12px, 10px);
// This will set the font-size to 12px in relation to a parent element's font-size of 10px.

Get on the grid

If you're doing front end development these days, you're probably familiar with the concept of grid-based design and translating a comp into a fully fluid or adaptive layout via HTML/CSS. We frequently use Zen 5 as a base theme and have been big fans over the years because it comes loaded with many of the best tools for front end/theme development, while also pretty lean as far as bloat goes. While it's important to be able to build themes for browsers that can handle fancy bells and whistles, we also need to support older browsers that don't. Zen 5 already has Sass and Compass integrated. As far as a grid framework goes, we use Susy instead of Zen Grids... this has just come down to personal preference. Zen Grids is also a great system.

Susy is a responsive grid framework/plugin for Compass, and it allows you to build on top of either a "magic", static or completely fluid grid.

• "Magic" grids are the default - they have an elastic container that responds to font sizes when set with em units, and is fluid on the inside. It's container size gets calculated according to the widths of your columns and gutters.
• Static grids are just that - all containers and column widths are not flexible and this is the traditional grid style. As such, it does not collapse when the viewport is smaller than the grid is wide. Even though you may specify pixel values for the column sizes, Susy converts to a percentage of the container size. The container size, like the magic grid, gets calculated according to the widths of your columns and gutters.
• Fluid grids are truly flexible layouts that respond to the width of the viewport. By default the container width is 100%. However, as with any grid type you choose, you can specify this with the $container-width variable (such as "$container-width: 70%").

Set it all up

To add Susy to your theme, there are a few things you'll need to do.

1. If you haven't already, install Sass and Compass. sudo apt-get install rubygems
   sudo gem update
   sudo gem install sass sudo gem install compass
2. Set up a Compass project in your theme directory.

   This is already done for you with Zen 5. If you're not using Zen 5 or a contrib theme that has this done already (look for a config.rb file in the theme directory), then set up your Compass project by going to your theme directory in your favorite command line interface and run:

   compass create nameofyourtheme

   This will add a "config.rb" file to your theme, and is where the Compass project settings are located.

3. Then, install Susy. sudo gem install susy
4. Require Susy in your Compass project.

   Open up the config.rb file and add the following (wherever "requires" are located):

   require "susy"
5. @include susy and add grid settings to your _base.scss (or equivalent "global" Sass file).

   We usually stick any of our grid settings in the _base.scss file that comes with Zen so that the grid variables set there are available to any other Sass stylesheet in the theme (because Zen's base gets @imported in them all). You'll also want to place them in whatever Sass file you're using that gets imported into any file where you'll be doing responsive styling/layout. For example:

   @import "susy";
   $total-columns: 12;             // a 12-column grid
   $column-width: 4em;            // each column is 4em wide
   $gutter-width: 1em;            // 1em gutters between columns
   $grid-padding: $gutter-width;  // grid-padding equal to gutters

After installing Susy, and getting your Compass project set up properly for the theme, you'll want to tweak those default grid settings that you just added (total columns, column width, grid padding, etc...) for the purpose of your own design. Using those settings, Susy will automatically figure out the math and put percentage widths on internal grid elements, as well as a max-width on the container (should you use a non-fluid grid). By default, all Susy grids are "magic." If you want to use one of the other types of grids, you would do that by setting the $container-style variable. For example, to build a 5 column-wide mobile first "magic" layout, we can do something like this:

$total-columns: 5;
$column-width: 3em;
$gutter-width: .75em;
$grid-padding: $gutter-width; Making things happen at different viewport sizes

Another handy part of Susy is its at-breakpoint() mixin. This can be used in replacement of a long and drawn out media query that targets specific pixel-based min-width or max-width values of the viewport. Something we do frequently for adaptive/responsive layouts (where there are established, comp-determined breakpoints for mobile, tablet, desktop), is set variables for different numbers of grid columns.

$mobile   : 5;
$tablet   : 11;
$desktop  : 16;

So if you're building in a mobile first manner like this, and you want something to happen at a certain breakpoint in your Sass, you can use at-breakpoint() with your column count variables as an argument.

#content {
  @include span-columns(5);
  @include at-breakpoint($desktop) {
    @include span-columns(13, $desktop);
    @include prefix(3, $desktop);
  }
}

In this situation, #content normally spans 5 columns wide, which is the default/mobile width of the grid in this example. When the viewport is at the desktop breakpoint (16 columns can fit in the viewport), the width of #content will change. span-columns(13, $desktop) means "make this 13 columns wide, out of 16 total columns". prefix(3, $desktop) means "add 3 columns of empty space beforehand." So #content becomes 16 columns wide in total, however only 13 columns of space are usable and contain content, since we added 3 columns of padding to the start.

A different, non-layout related way of using at-breakpoint() is to maybe change some kind of style at a given breakpoint.

padding-bottom: em(15px);
@include at-breakpoint($desktop) {
  padding-bottom: em(85px);
  background: url("bg-content.png") 162px 100% no-repeat;
}

Having at-breakpoint() at the ready is a great way of releasing yourself of the mindset and clutter of maintaining several pixel-based breakpoints in your site, and helps future-proof things since device sizes are fluctuating so wildly as time goes on. Since Sass supports code nesting, it has become standard operating procedure for us to use at-breakpoint() at the end of things in a selector's nested styles, so that they override any established defaults (which are usually the mobile version styles if we are building mobile-first).

Alternatively, Aurora

While we normally use Zen and add Susy in manually (replacing Zen Grids), some themes have Susy, Sass and Compass (and other front end goodies) baked in already. Aurora is also a Sass & Compass-powered minimalist theme with a focus on best practices for HTML5 and front end development within Drupal. It has a number of cool features like Google Chrome Frame and Typekit integration. Aurora encourages the use of Panels' HTML5 Sections layout instead of using the standard Drupal left/right sidebar block regions for sidebars. Aurora also suggests you use the Blockify module to turn all the little things on the page that normally get rendered in a page template variable into blocks that you can assign to regions via Drupal's block admin page. There are a number of features in Aurora which have been pulled out and put into a separate module, so that any theme can make use of them. That module is called Magic and some of it's best features are the ability to exclude certain CSS/JS from being included, exporting of theme settings, enhancement of CSS aggregation and adding a viewport width indicator - which is very helpful when developing a responsive site to check all your breakpoints and everything in between.

Conclusion

Susy provides a great way of quickly getting your site layout blocked out and can produce any kind of grid you need. What has your experience been like using Susy in Drupal?

The result of this module is the same as Feeds: Files, but instead of using a custom Feeds Processor we use the file_presave hook to convert URL -> URI when using the Entity Processor for Files in the unpublished Entity Processor Branch of the Feeds module.

Like Feeds: Files, the hope is that this module will become obsolete and the Entity Files Processor would support Media directly.

Jeff Eaton and Jason Scott discuss digital preservation, the historical importance of the web, and the utility of large hard drives.

• Sockington The Cat
• Textfiles.com
• MAKE.MONEY.FAST
• The Geocities Archive
• The Archive Team
• "Falling Hare" Looney Tunes Episode
• The Posterous Archive Project
• The Meme Hustler

The web is a part of our culture now, and perserving its history has value

DaCast Video Module for Drupal

The DaCast Streaming as a Service video platform allows broadcasters to offer live and on demand streaming content directly to their website, through using a robust CDN (Content Delievery Network) and optional, integrated monetization features, including Pay Per View and Subscriptions. The video platform gives business and website owners total control of their online video through a white label platform, easy site integration and advanced restriction and protection features to secure content.

The DaCast module integrates these professional services into Drupal. Through using it, you can add DaCast video streams to your content and access video information entered from your DaCast account

For Drupal 7

The current module is for Drupal 7.
Development for other versions of the CMS are coming.

Support

For additional support using the module, please login to your DaCast account and open a support ticket (clicking HELP and then SUPPORT) mentioning Drupal Module in the subject line.

Download

The latest release for Drupal 7 is found below:

Release 05-03-2013

This Module creates a Googlebase compliant product RSS feed.
A 'hard copy' .XML file with your products will be created which can then be read by the googlebase googlebots.
A few extra fields to the standard Ubercart installation are required, see module help once installed.

Scald Gallery is a gallery provider for Scald.

• The 1.x branch was started by slashrsm and is feature complete. It uses plupload for file upload, Galleria for gallery display, and only images can be used in a gallery. It needs a few clean up and will be released in the next few days.
• The 2.x branch, based on and is backward compatible with 1.x, leverages multiple upload types (soon to be available in Scald), supports any atom types, has better UI etc. and will be available in the next few weeks.

Scald Gallery is sponsored by Open Web Solutions and Le Figaro.