As I've written about in the past, Platform.sh's Makefile build system is pretty sweet. One of the things that confuse me the most, however, is how to make a change to a distribution (such as adding a patch) without making things even more complicated.
Hat tip to Tavi Toporjinschi for writing the original example this is based off of.
Let's say for a moment that you want to add a patch to a module included in a distribution. If you're just starting out, you could actually just override the module and add it to
sites/default/modules by including it within your existing file like so:
projects[commerce_paypal][version] = \"2.3\" projects[commerce_paypal][patch] = \"https://www.drupal.org/files/issues/2082691-24-support_paypal_adaptive_payments_-chained_0.patch\"
However, if you're wanting to change a module that you've already been using, you'll want to modify the distribution directly from within your Makefile.
To do this, start by grabbing a copy of the distribution's git repository (and make sure you're working from the same version that you're using in your Makefile!). Here's instructions for Commerce Kickstart. Once you've done that, open up
drupal-org.make which is the main Makefile for Commerce Kickstart.
projects[commerce_message][version] = 1.0-rc3
It will now read:
projects[commerce_message][version] = 1.0-rc4
Now that I've got my change and I've tested it (which I'm skipping for now), it's time to add it back into my project. To do this, we'll grab a diff of the change:
commerce_message_to_rc4.patch will look something like this:
diff --git a/drupal-org.make b/drupal-org.make index 45fef75..b497a53 100644 --- a/drupal-org.make +++ b/drupal-org.make @@ -48,7 +48,7 @@ projects[commerce_moneybookers][patch] = \"http://drupal.org/files/commerce_mon projects[commerce_paypal][version] = 2.3 projects[commerce_paypal][patch] = \"https://www.drupal.org/files/issues/commerce_paypal-addressfield-default-values-2458721-1.patch\" projects[commerce_backoffice][version] = 1.5 -projects[commerce_message][version] = 1.0-rc3 +projects[commerce_message][version] = 1.0-rc4 projects[commerce_search_api][version] = 1.4 projects[commerce_add_to_cart_confirmation][version] = 1.0-rc2 projects[commerce_kiala][version] = 1.0-rc1
To add this to my project, we'll create a
patches/ directory within the project (if it doesn't already exist) and copy that patch into the directory.
Now, we just need to patch the distribution within the Makefile. How do we do that? With a patch, of course! You probably have a line like this in your makefile:
projects[commerce_kickstart][type] = core
This downloads the "core" version of Commerce Kickstart. This is the one that you get when you download directly from Commerce Kickstart's module page or when you download
commerce_kickstart-7.x-2.33-core.tar.gz from the releases page.
This will then be replaced with the following:
projects[drupal][type] = core projects[commerce_kickstart][type] = profile ; Use dev git version with patch. projects[commerce_kickstart][download][type] = git projects[commerce_kickstart][download][branch] = 7.x-2.x projects[commerce_kickstart][patch] = \"patches/commerce_message_to_rc4.patch\"
And... breaking it down:
projects[drupal][type] = core signals that we're using Drupal core as the base install. Then, we're installing
commerce_kickstart as a profile on top of that (
projects[commerce_kickstart][type] = profile). When installing the profile, we specify
git as the download type and the branch (
7.x-2.x) that we are working on so that we get the correct version of the code that we worked on up above (which include's its Makefile). Finally,
projects[commerce_kickstart][patch] = \"patches/commerce_message_to_rc4.patch\" patches the distribution so that it downloads the
-rc4 version of Commerce Message.
Now, build the project, if everything is correct, as the build goes by, you'll see the correct module being downloaded:
>> commerce_authnet-7.x-1.1 downloaded. [ok] >> commerce_message-7.x-1.0-rc4 downloaded. [ok] >> commerce_physical cloned from [ok] http://git.drupal.org/project/commerce_physical.git.
And there we go. Now, push it up to your repository, and you're all set!Continue reading...
Recently, I tried to run some tests locally and the test runner kept silently failing. Ultimately, it was just giving up during bootstrap. The problem was eventually traced to Acquia's frustrating modification of the settings.php file; it only loads when
$_SERVER['DEVDESKTOP_DRUPAL_SETTINGS_DIR'] is defined.
So in order to make it run, you'll need to:
DEVDESKTOP_DRUPAL_SETTINGS_DIRin your CLI environment or:
run-tests.shto populate that value in
$_SERVERbefore bootstrapping Drupal:
Then the test runner will actually do something useful.Continue reading...
I believe the future of technology is very much a return to simplicity that it seems like every generation or two we end up harkening back to. Modernity, for all of its marvels, feels like it is teetering on collapse. Personally, I see this in all over our society which can't seem to make up it's mind on what it wants. And if modern society could be defined by anything at this time, it'd be by a form of self-opposing delusion. People want security guaranteed by the government and also personal privacy. People want full personal autonomy to live their life as they see fit yet and yet feel obliged to force other's hands using the government when they find it hard to do so. We want the government to be a club for our cause yet so many forget the truth source and purpose of that government.
As it is with society, so also with technology with which society is so intertwined. We want blazing fast, ubiquitous, uninterrupted service but we want it delivered to us without any of the hard work which is required to build and maintain those services. And when a company like AT&T, Time Warner, or Grande Communications provides those services, someone will inevitably complain and emphatically declare what they want and why they are right and why they, the customer, is always right. I suppose we do truly live in an age of consumerism—where the customer is always right. And guess what? We are all customers now.
The pendulum has swung away from the BBSes of old: where groups of individuals combined their efforts to create autonomous, distributed, and personal networks of systems that were capable of transferring email across the world before the internet was in every home, so now it beckons to swing back the other direction. Yes, the pendulum is now seemingly at the very opposite of end of its swing. Where we are now is in an age of consumer demanded centralization: give me one store, one medium, one device that does everything. If it stops working or breaks, I'll throw it away and find another. And if I want it to continue to work, I'll pay exorbitant sums so that someone else can take care of it.
And what do we get for this? Little (if any) privacy. Being at the whim of masked men who wield digital armies and can take down your business for seemingly any reason.Continue reading...
So I was reading through some blogs this weekend and came across an article about VW on the Clean Code blog. It's a short post and I suppose if you wanted a summary blurb, it would be this:
I think that argument is even more asinine than Michael Horn's. They knew. And if they didn't know, they should have known. They had a responsibility to know.
All too often, we tend to separate the code we write from what it does. In writing open-source Drupal modules, it might be very easy to try to say that there is a certain neutrality about what we do. Take for instance, one of my lowly modules Permission Report. All this module does it take existing information and display it to the user. It doesn't modify any values. And you could say that what it doesn't isn't good or bad—that it's morally neutral.
However, if something were wrong with my program, people would say something. If it were hiding certain roles or providing bad information, it could be an innocent mistake or it could be something malicious. But it would be flawed. The code itself would be bad. And we are no longer in neutral territory. If the code doesn't get changed, the code will be marked as such and it will eventually be replaced or forgotten by the community.
My point is, we don't do this for code that is "morally neutral." All code has some moral capacity in it. This parallels tangible objects such as cars, knives, and baseball bats which have a particular purpose but can be wielded in negligent or malicious ways. Likewise, open source code projects that have modules can be likewise wielded in ways that might align with or otherwise diverge from what we as individuals consider to be good, right, or true.
Now, for a module in a particular open source project that does a particular purpose: sending emails or handling a transaction, it could be used in a project that ultimately disagrees with our own worldview. However, the module itself with it's general quality, tests, and other functionality might be considered morally good, but the resulting use of it might be considered likewise to be morally wrong. But the point is that we didn't write the resulting use, we wrote the intended use and someone else wrote the final moral component. That doesn't change the fact that what we wrote was morally good, just that someone took something good and misused it. There is a difference between creating something good and having it's usage corrupted by circumstances and crafting the corrupting circumstances.
Circling back to the VW article, I'd like to make two points, then:
- As a programmer, we have a right—perhaps even a responsibility—to understand what the purpose is for what we are building. I think this is clear from what the author is saying. I would agree with this statement.
- Therefore, as a programmer, we have a right to decline work which we personally disagree with. While not stated explicitly, if the argument is that a programmer can and should be held responsible for code they wrote, then they should have the ability to decline to do so on the basis of legal or personal moral dissonance.
Programming, then, is a moral activity and should be treated as such by all who engage in it. Are we ready for this discussion?Continue reading...
So I needed to recreate a truncated users table to stop the Drupal admin from barfing all over the admin... the url_alias table has the UID and the user names in it... so why not?
I didn't need the emails to be anything useful.Continue reading...
Acquia DevDesktop can be pretty slick at times for development, but if you're trying to work with a site that has domain access AND internationalization, you may be scratching your head a bit.
First off, you must correct the entries for the default site (or whichever site you're testing) in the domain and languages tables.
You'll need this patch since Drupal 7.x Core doesn't handle port numbers properly.
Then your site will work!Continue reading...
Here's a quick script I wrote to test redirects. Useful if you're trying to... test if your redirects are working properly.<script src=\"https://gist.github.com/nvahalik/d07a27666b0ac0112e01.js\"></script> Continue reading...
I'm probably the last person who should be writing something like this, seeing as how my interest in Drupal is and has always been one from a perspective that it was the best tool for the job. In many ways, I'm part of the (probably) unquantified mass of people who use Drupal on a daily basis, depending on it for my livelihood but being altogether indifferent toward the community. I mean, it's not that I don't like community, but in general I tend to associate with communities who have a particular purpose or shared interest and whose values end goals are reflect my own. This is probably why my local church and amateur radio club get the most attention of my time when I'm on my own time—so I'll be honest and just say that in general I'm indifferent to the community that surrounds Drupal.
Why is that? Well to be fair the mission, means, and goals of both my local church and amateur radio club are pretty similar when you think about it. In a nutshell, they both have a mission to be community-focused, with a purpose to spread a particular message and offering members the ability to grow in knowledge and wisdom, with a goal of growing and making the world a better place. The only difference is what drives them. One is driven by a communal love for the gospel of Jesus Christ while the other a love for emergency preparedness and awesome toys. Both have discrete membership rules, codes of conduct, and a hierarchy that is respected and trusted.
Because let's face it, FOSS isn't something you just limit to some sort of "day job mentality" where things are generally where you left them and a particular hierarchy is set up and enforced. And while there are people who can manage that, I'm not one of those kinds of people and I'm okay with that.Continue reading...
Want some quick and easy code blocks in Google Docs? Just do this:
- Make a table.
- Remove the border (make it 0px), and add your background color.
- Add a numbered list.
- Right click on the list and choose "Edit prefix and suffix..."
A while back I was doing a bit of research on web standards. Specifically, I was looking at the number of documents that were published by the W3C over time. The last several years have seen an explosion of new recommendations with everything from CSS to Web Telephony. Let's face it, the web is here to stay. Technology points to the web. The Internet of Things surrounds us.
The number of technologies that power those things seem to grow every day. Because the internet changes so rapidly, new variants of existing languages pop up, new frameworks are created and destroyed. Optimization occurs. Repos get branched. Integrations get built. New SaaS platforms get launched. Every ounce of ROI gets squeezed out.
Why is this the case?
- Websites being built are getting more complex and intricate because a bigger internet means you must differentiate yourself.
- The code bases and toolsets required to build those complex and intricate things are getting larger and more diverse.
- The knowledge required to use those code bases is also expanding, but perhaps not as rapidly since frameworks help to make interop better.
The one-man-custom shop is slowly dying. You can still do well focusing on a particular piece of the puzzle, but the expectation that one person can do it all is quickly becoming less of a reality. It's a full-time job just to keep up with the changes, let alone spending the time to actually implement them.
So the conundrum that I see right now is that while things are getting easier to build, they are requiring more complexity. And that complexity seems to be winning in terms of where the "how much do I have to know to build this" gauge is moving.
Sometimes I yearn for something simpler: Needing only a language or two. Solid, one-way approaches to implementation. Solving real problems instead of trying to figure out how to not pull your hair while accomplishing something that should be simple.Continue reading...