One thing it doesn’t have, though, is tab completion. Or rather, it didn’t, until now.

What does it do?

It’s the same thing you get in Stata’s Command window: you type part of a variable name, press tab, and the name is completed as far as it can be without ambiguity.

For example, I type —

— I press tab —

— and the variable name is completed, leaving the cursor one space to the right and ready to keep typing. (Note that my use of Stata’s tab[le] command in these examples is an unfortunate coincidence and has nothing to do with tab completion! I could just as well have written regress fr. Sorry.)

In fact, proper tab completion (as found in Unixy shells, for file names, but not in Stata’s Command window) goes a little further than this: if you press tab at the end of an ambiguous name stem, it prompts you with all the possible endings.

And so it is with this TextMate bundle addition. I type —

— I press tab —

— and the name is completed up to the next ambiguity. So I press tab again —

— and I get a tooltip list of options. I add an ’s’ (just enough to pick one option out) —

— press tab again —

— and bingo!

How does it work?

Each time you press tab, the bundle asks Stata to run a simple .do file; this exports your current data set with an if 0 condition, meaning that all the actual data is excluded, and we just get the variable names. (For detail, check the Ruby script).

A slightly unfortunate effect of this is that your Stata Results window (and log, if you’re keeping one) fills up with these outsheet commands. I hope that’s not a deal-breaker. If only Stata would provide some basic AppleScript support (please?) I might be able to do something about this.

How do I get it?

At some point I may roll this into a new bundle file to make installation easier (there are also a few fixes I’ve made to the original bundle). But in the meantime, you can add it to the bundle yourself.

Open the bundle editor (Bundles > Bundle Editor > Show Bundle Editor) and select the Stata bundle. Click the ‘+’ button and select ‘New Command’. Give the command a name. Then, on the right, select Save: Nothing, Input: Selected Text or Word and Output: Replace Selected Text. Choose Activation: Key Equivalent: and a hotkey (I use Ctrl-Tab).

Then paste in the following Ruby script:

#!/usr/bin/env ruby
 
require ENV['TM_SUPPORT_PATH'] + '/lib/exit_codes.rb'
dofile = '/tmp/textmatestatavars.do'
varfile = '/tmp/textmatestatavars.tsv'
 
stem = ENV['TM_CURRENT_WORD']
stem = '' if stem.nil? || stem.match(/\s$/)
stem = stem.lstrip
 
TextMate.exit_discard if stem.match(/[^a-z0-9_]/im)
 
open(dofile, 'w') do |f| 
  f.print %{set notifyuser off\noutsheet #{stem}* using "#{varfile}" if 0, noquote\n}
end
 
File.unlink(varfile) if File.exist?(varfile)
`osascript -e 'tell application "Stata" to open POSIX file "#{dofile}"'`
 
unless File.exist?(varfile)
  print 'No variables found'	
  TextMate.exit_show_tool_tip
end
 
vars = open(varfile) { |f| f.read.chomp.split("\t") }
 
if vars.length == 1
  print vars.first + ' '
  exit
end
 
v1, v2 = vars.sort.values_at(0, -1).sort_by { |v| v.length }
common_prefix = (0...(v1.length)).each do |i|
  break v1[0, i] unless v1[i, 1] == v2[i, 1]
end
common_prefix = v1 unless common_prefix.is_a?(String)
 
if stem == common_prefix
  print vars.join("\n")
  TextMate.exit_show_tool_tip
else
  print common_prefix
end

It should look like this:

Many UK academics can access the data via institutional subscription to EDINA Digimap. I’m using it in my research into subjective wellbeing and environmental quality.

This post shows how to:

1. import the data files into a PostGIS database; and
2. de-normalise the data into a single table, where there’s a one-to-one mapping of postcodes to rows, and each row contains either all geographical locations covered by a postcode (as a single geometry column, of type multipolygon) or the reason why no such location is available

Why de-normalise?

Step 2 above is required for my purposes because Code-Point data is supplied in a number of separate files per postcode area:

• a .shp file (and associated .shx and .dbf) mapping postcodes and ‘vertical streets’ to the locations they cover;
• an accompanying text file mapping postcodes to ‘vertical streets’; and
• another text file listing postcodes with no associated locations, either because they represent PO boxes or because the data just isn’t available.

Vertical streets generally represent high-rise buildings, where one location in 2D space may be associated with multiple postcodes. Vertical streets are also a serious pain: not only may one vertical street be associated with many postcodes, but one postcode may be associated with many vertical streets and with non-vertical-street locations too.

Import the data files

Download and unzip the Code-Point with Polygons data, in ESRI .shp format, for the regions you want (where indicative query timings are provided later, these are for whole-UK data — 120 postcode areas — on a 2Ghz Intel iMac).

Dump everything in the same directory. For each postcode area XX you should have the following five files:

• XX.shp, XX.shx and XX.dbf
• XX_vstreet_lookup.txt
• XX_discard.txt

If you don’t already have one you want to use for this purpose, create a PostGIS-enabled PostgreSQL database (in this post, the database is named geo). If you’re not running PostgreSQL 8.4 or later you may need to fiddle with some fsm_ settings in the Postgres .conf file in order to cope with a data set this large.

Execute the following SQL to create the tables for discards and vertical streets (e.g. from within pgAdmin):

create table cpp_vertical_streets (
  postcode character varying(8),
  vstreet character varying(8)
);
 
create table cpp_discards (
  postcode character varying(8),
  reason character varying(7)
);

Next we need to create the table for the .shp-file polygons. We switch to Ruby for this — you can just enter the commands in an IRB terminal session:

path = '/path/to/CodePoint polygons'
`/usr/local/pgsql/bin/shp2pgsql "#{path}/ab.shp" cpp_polygons -p -D -s 27700 | /usr/local/pgsql/bin/psql -d geo -U postgres`

The -p flag to shp2pgsql just creates a table structure, and the -s 27700 gives it the EPSG code to tell it we’re using the OSGB36 datum. You can use any of the .shp files you’ve downloaded — it need not be the AB area one.

Now to do the import into the three tables. Still in Ruby, execute the following loop:

Dir["#{path}/*.shp"].each do |f|
  puts f
  `/usr/local/pgsql/bin/shp2pgsql "#{f}" cpp_polygons -a -D -s 27700 | /usr/local/pgsql/bin/psql -d geo -U postgres`
  `echo "copy cpp_vertical_streets from '#{f.sub(/\.shp$/, '_vstreet_lookup.txt')}' csv;" | /usr/local/pgsql/bin/psql geo postgres`
  `echo "copy cpp_discards from '#{f.sub(/\.shp$/, '_discard.txt')}' csv;" | /usr/local/pgsql/bin/psql geo postgres`
end

Back in SQL, add some boolean flags we’ll use later on, then create an index on the postcode column, which will save a lot of time later:

alter table cpp_polygons add column discard boolean;
alter table cpp_polygons add column vstreet boolean;
alter table cpp_polygons add column vstreet_and_std boolean;
 
create index pc_index on cpp_polygons (postcode);
 
vacuum analyze cpp_polygons;

If you like, you can confirm here that there’s only one row per postcode — this query should return nothing:

select * 
from cpp_polygons a 
inner join cpp_polygons b 
on a.postcode = b.postcode 
where a.gid <> b.gid;

So, we now have all the OS data held in three separate tables. In the rest of the post, we’ll be merging the data in the discards and vertical streets tables into the main table, cpp_polygons.

Discards

We’re going to create a new table, with the same structure as cpp_polygons, to hold the discarded postcode data. These postcodes will have a NULL geometry column, and a TRUE discard column (one of the booleans we added earlier). Later, we’ll insert the contents of this table into cpp_polygons.

Run the following SQL:

create sequence cpp_discard_seq start with 2000000;
 
create table cpp_discard_polys as (
select 
  nextval('cpp_discard_seq') as gid, 
  postcode,
  cast(null as character varying(20)) as upp, 
  substring(postcode from '^[A-Z][A-Z]?') as pc_area, 
  cast(null as geometry) as the_geom, 
  true as discard, 
  false as vstreet,
  false as vstreet_and_std
from cpp_discards
);

Vertical streets

Similarly, we’re now going to create a new table with the same structure as cpp_polygons to map vertical street postcodes to the right polygons. This requires a left join of the vertical streets data with some of the geometry data in cpp_polygons.

set enable_seqscan = false; 
-- (otherwise pg sometimes fails to use the index)
 
create sequence cpp_vstreet_seq start with 3000000;
 
create table cpp_vstreet_polys as (
  select 
    nextval('cpp_vstreet_seq') as gid, 
    max(v.postcode) as postcode, 
    cast(null as varchar(20)) as upp, 
    max(pc_area) as pc_area, 
    st_union(the_geom) as the_geom, 
    false as discard,
    true as vstreet,
    false as vstreet_and_std
  from cpp_vertical_streets v 
  left join cpp_polygons p 
  on v.vstreet = p.postcode
  group by v.postcode
);

Our last new table is for postcodes that are associated with both standard polygons and vertical street polygons.

create sequence cpp_vstreet_and_std_seq start with 4000000;
 
create table cpp_vstreet_and_std_polys as (
select 
  nextval('cpp_vstreet_and_std_seq') as gid, 
  p.postcode as postcode,
  cast(null as varchar(20)) as upp, 
  p.pc_area as pc_area,
  st_multi(st_union(p.the_geom, v.the_geom)) as the_geom, 
  false as discard, 
  false as vstreet,
  true as vstreet_and_std
from cpp_polygons p
inner join cpp_vstreet_polys v
on p.postcode = v.postcode
);

Cleaning and merging

Now we need to remove the vertical streets and polygons we just merged into a new table from their respective source tables.

delete from cpp_polygons where postcode in (select postcode from cpp_vstreet_and_std_polys);
-- the above could take around 25 mins
delete from cpp_vstreet_polys where postcode in (select postcode from cpp_vstreet_and_std_polys);

And, finally, to merge our three new tables into the main table.

insert into cpp_polygons select * from cpp_discard_polys;
insert into cpp_polygons select * from cpp_vstreet_polys;
insert into cpp_polygons select * from cpp_vstreet_and_std_polys;

In order to join my own data with this data, I find it easiest to format the postcodes on which the join is made with no spaces. So I add and index the following extra column.

alter table cpp_polygons add column postcode_no_sp character varying(8);
update cpp_polygons set postcode_no_sp = replace(postcode, ' ', ''); 
-- the above could take 10 - 15 mins
create index pcns_index on cpp_polygons (postcode_no_sp);
 
vacuum analyze cpp_polygons;

You might also want to remove the original vertical street rows, where the postcode column begins with a ‘V’, from the cpp_polygons table — I didn’t have any need for this.

This is somewhat annoying — the site’s original design has it communicating independently with Amazon (using Amazon’s XSLT API feature to transform their XML data into JSON), and that’s no longer possible with the use of a private key. But it’s not unfixable. The site now sends its API call first to my server, which returns a signed version, and then forwards the signed call on to Amazon.

I found most of what I needed for this on Chris Roos’ blog, but his version still wasn’t quite working for me (the two problems I recall are that Ruby’s CGI.escape doesn’t quite follow Amazon’s requirements, and that times need converting to GMT).

Anyway, in case you’re looking to do the same, here’s what I ended up with:

#!/usr/bin/env ruby
 
# Note: You need hmac.rb and hmac-sha2.rb from http://deisui.org/~ueno/ruby/hmac.html 
# somewhere in your require paths. ruby-hmac is currently broken under Ruby 1.9.
 
%w(rubygems cgi time hmac-sha2 base64).each { |lib| require lib }
 
ACCESS_IDENTIFIER = 'YOUR_PUBLIC_ID'
SECRET_IDENTIFIER = 'YOUR_PRIVATE_ID'
 
def aws_escape(s)
  s.gsub(/[^A-Za-z0-9_.~-]/) { |c| '%' + c[0].to_s(16).upcase }  
  # for 1.9, you'd replace [0] with .ord -- but ruby-hmac seems broken under 1.9
end
 
cgi = CGI.new
params = cgi.params.dup
 
amazon_endpoint = params.delete('amazon_endpoint')
amazon_path = params.delete('amazon_path')
js_callback = params.delete('js_callback')
 
signing_params = {
  'AWSAccessKeyId' => ACCESS_IDENTIFIER,
  'Timestamp' => Time.now.gmtime.iso8601
}
 
params.merge!(signing_params)
 
canonical_querystring = params.sort.collect do |key, value| 
  [aws_escape(key.to_s), aws_escape(value.to_s)].join('=') 
end.join('&')
 
string_to_sign = "GET\n#{amazon_endpoint}\n#{amazon_path}\n#{canonical_querystring}"
 
hmac = HMAC::SHA256.new(SECRET_IDENTIFIER)
hmac.update(string_to_sign)
signature = Base64.encode64(hmac.digest).chomp
 
params['Signature'] = signature
querystring = params.sort.collect do |key, value| 
  [aws_escape(key.to_s), aws_escape(value.to_s)].join('=') 
end.join('&')
 
signed_url = "http://#{amazon_endpoint}#{amazon_path}?#{querystring}"
 
cgi.out('type' => 'text/javascript') { "#{js_callback}('#{signed_url}');" }

You can test this locally by feeding key/value parameters to CGI, followed by Ctrl-D. These, for example:

amazon_endpoint=ecs.amazonaws.com
amazon_path=/onca/xml
js_callback=do_stuff
Service=AWSECommerceService
Version=2009-03-31
Operation=ItemSearch
SearchIndex=Books
Keywords=george+monbiot

So: free modem. No further commitment. And the opportunity to buy access a day at a time for £2, on a train journey, for example, or in an airport lounge, where the cheapest paid-for WiFi option is rarely less than £5, and often nearer £10. Handy.

Update. O2 is no longer doing the modem at half price, but the Quidco cashback has increased so that it still fully covers the modem and a £15 top-up.

The dongle

The dongle, a Huawei E160, is a fairly pretty white thing, and it supports my Mac. So far so good. Unfortunately, the software and instructions have crack-smoking hobos written all over them. Huawei “Mobile Connect” is ugly, crash-prone, writes logs to the console like there’s no tomorrow (literally thousands of messages per minute), and has never yet successfully connected me.

Luckily, you don’t need to use Mobile Connect: once the drivers are installed, you can connect using the menu item for the modem. Or rather, once the drivers are installed and you’ve taken the following counter-intuitive and undocumented step you can.

Making it work

When it installed, my dongle was configured as Vendor: Other, Model: Huawei Mobile Connect – 3G modem (this is under System Preferences > Network > HUAWEI mobile > Advanced…). This sounds good, but it doesn’t work: there’s nowhere to enter your APN.

Instead, after much fiddling, I found I had to switch Vendor to Generic and Model to GPRS (GSM/3G). Although confusingly less right, this does seem to do the trick.

I also ended up downloading new drivers from the Huawei site. (Not for the E160. That would be too simple. The ‘Mac’ drivers for the E160 turn out to be a Windows .exe file. The drivers I’m using are supposedly for the E220). I’m not sure if this step was necessary or even well-advised, but it might be worth trying if you’re not having any luck.

Listen up, O2

Which brings us to the suggestion to O2. O2: I have an iPhone. It’s on your network. It supports tethering. I’m not about to pay you an extra £15 a month for the once or twice a month I want to use it. Let me use it for pay-as-you-go mobile broadband!

In this case you’d have saved yourself the full cost of a modem dongle — and generally, you’d be saving yourself the support costs and return costs associated with everyone who can’t get the horrible thing working. You’d have saved the world the cost of the resources and pollution required in manufacturing it. And you’d have saved me the pain of several hours fiddling with System Preferences, the inconvenience of another gadget to pack for every trip, and probable future kernel panics associated with Huawei’s flaky drivers.

Still, just one more copy of your data, in just one more continent, surely can’t do any harm, right? One that won’t burn down with your house, but also isn’t just wafting vaguely in the Cloud at someone else’s whim. One that elevates your backup system from sensibly paranoid to borderline OCD. One, in this case, brought to you by rsync, find and Growl.

What it does

This script does the following:

• recursive, incremental, remote backup of the contents of folders you choose
• safely archiving anything that changed since last time
• and excluding things by name or folder (all this is just rsync so far)
• and also excluding anything unfeasibly big (this is down to find)
• all the while using Growl to keep you apprised of the situation, as exemplified below (thanks to growlnotify).

On the remote server, you end up with a file structure as below, with your current files under Current and any files that have moved, changed, or been deleted in a dated folder under Archive:

What you’ll need

You’ll need:

• a remote backup server you have rsync access to, with (passwordless) public key authentication set up.
• Growl installed, obviously, and also growlnotify (by running ./install.sh in the Extras folder on the Growl installation .dmg).
• a way to schedule the script to run — iCal, cron, or launchd (for the management of which last I recommend Lingon).

The script

There’s some rather superstitious quoting. Even then, it’ll probably still bite you in case of spaces.

#!/bin/bash
 
# --- Set backup parameters ---
 
# What local files/folders are we backing up?
SRC="/Users/gjm06/Development /Users/gjm06/Documents /Users/gjm06/Sites"
 
# What server are we backing up to?
DESTSERVER="george.example.com"
 
# What's our user name on the server?
SSHUSER="george"
 
# What's the remote shell command for this server 
# (slight obscurity/security by avoiding port 22)
RSH="ssh -p 2244"
 
# What location on the server shall we back up to?
DESTPATH="/home/george/backups"
 
# Any non-valuable stuff to exclude by name/location?
EXCLUDE=".DS_Store,.svn/,.Trash/,tmp/,log/,vendor/"
 
# Exclude things that are *how* big? 
# e.g. I don't want GBs of virtual machines going over the wire
# (NB. this is in bytes)
MAXFILESIZE=100000
 
 
# --- Set Growl parameters ---
 
# What will this script be called in the Growl prefpane?
GROWLNAME="Remote backup script"
 
# And what app's icon will appear in Growl notifications?
APPICON="Time Machine"
 
 
# --- Do it! ---
 
echo Checking not already running 
 
PROCS=`ps -A -o "pid=,command="`
MYNAME="$0"
MYBASENAME=`basename $MYNAME`
MYPID=$$
 
# The next line works like so:
# * take the process list (for all users),
# * filter *in* processes named like this script (making sure we're on word boundaries),
# * filter *out* (-v) the one that *is* this script (by PID), and finally
# * filter *out* the grep commands themselves.
 
MERUNNING=`echo "$PROCS" | grep -E -e "\b$MYBASENAME\b" \
  | grep -E -v "\b$MYPID\b" | grep -v grep`
 
# Then, if anything's left (i.e. MERUNNING isn't a zero-length string...)
 
if [ ! -z "$MERUNNING" ]; then
  /usr/local/bin/growlnotify --name "$GROWLNAME" --appIcon "$APPICON" \
    --message "Another backup seems to be in progress" \
    "Ignoring scheduled backup"
  exit 1
fi
 
 
echo Finding large files to exclude...
 
OVERSIZELIST="/tmp/files_over_backup_limit"
find $SRC -size +$MAXFILESIZE > $OVERSIZELIST
 
# If you ever want to know what's excluded -- and you should! -- just do
# a 'cat /tmp/files_over_backup_limit' in the Terminal
 
# Next, 'wc -l' counts the *lines* in our oversize list, and we extract 
# just the number from the output
 
NUMOVERSIZE=`wc -l "$OVERSIZELIST" | grep -o -E [0123456789]+`
 
 
echo Rsyncing...
 
# date makes up the name for our archive folders, while
# eval is used to invoke shell expansion on the list of file names to exclude,
# turning them into a list of --exclude= statements
 
BDATE=`date "+%y_%m_%d-%H.%M.%S"`
EXPEXCLUDES=`eval "echo --exclude={$EXCLUDE} "`
ERRORS="/tmp/rsync_backup_errors"
 
# The && and || operators give us a simple way to respond to zero and 
# non-zero (= error) rsync exit codes, thanks to lazy evaluation by the shell
 
rsync --rsh="$RSH" \
  --recursive --partial --delete --delete-excluded \
  --links --times --relative --compress \
  --backup --backup-dir="$DESTPATH/Archive/$BDATE/" \
  --exclude-from="$OVERSIZELIST" \
  $EXPEXCLUDES \
  $SRC \
  $SSHUSER@$DESTSERVER:"$DESTPATH/Current/" \
  2>"$ERRORS" \
&& 
/usr/local/bin/growlnotify --name "$GROWLNAME" --appIcon "$APPICON" \
  --message "Backed up to $DESTSERVER, $NUMOVERSIZE oversized files excluded" \
  "Completed backup" \
|| \
/usr/local/bin/growlnotify --name "$GROWLNAME" --appIcon "$APPICON" -s \
  --message "`cat "$ERRORS"`" \
  "Failed backup"

Hope it’s useful in your own paranoid backup endeavours. And, by the way, if you ever hear me say “surely a simple Bash script couldn’t take that long”, please don’t stop reminding me just how much I hate Bash until I change my mind.

Equally, though, I’ve not wanted to give up the ability to log in to the servers from anywhere to fix things in an emergency, so I didn’t want to turn password authentication off and rely on public keys alone.

Until now, that is. I realised yesterday that, since I have iSSH on the iPhone, which does public key authentication, I can log into my servers from anywhere, even with password authentication turned off. Granted, doing anything serious on a tiny screen and slow connection is difficult. But all I actually need to be able to do from there is temporarily turn password authentication back on.

And to make this easy, I’ve put two ultra-simple scripts in ~/bin:

pwd_login_on.sh

#!/bin/bash
sudo sed -r -e 's/^PasswordAuthentication no$/PasswordAuthentication yes/' \
  -i.previous /etc/ssh/sshd_config
sudo /etc/init.d/ssh restart

pwd_login_off.sh

#!/bin/bash
sudo sed -r -e 's/^PasswordAuthentication yes$/PasswordAuthentication no/' \
  -i.previous /etc/ssh/sshd_config
sudo /etc/init.d/ssh restart

(These paths are suitable for Ubuntu 8.04).

Lovely.

These include:

• Caslon Pro
• Chaparral Pro
• Garamond Pro
• Minion Pro
• Myriad Pro

If you don’t want to actually install InDesign, you can get to the fonts like so (if you’re a Mac user):

• Mount (double-click) the downloaded disk image
• Mount another disk image found on the newly mounted disk, at Adobe InDesign CS4/payloads/AdobeFontsAll/AdobeFontsAll.dmg
• The fonts are inside /Assets/contents on this second disk

Note that these fonts may well be covered by a very restrictive licence: I haven’t checked.

This is brilliant for Mac users who need to test websites in IE, because you get a real installation of each browser in its home environment, with the right JavaScript engine and working conditional comments, plug-ins, Windows Media Player, and so on. With the alternatives, such as running under Wine or using Multiple IEs in a single Windows virtual machine, one or more of these things tends to be missing.

Unfortunately, the images are supplied as self-extracting .exe files, which of course are Windows programs. But happily, the Mac ports of Wine, the open-source Windows emulation software, can run them.

• Get hold of the self-extracting archives from Microsoft. I find XP+IE6 and XP+IE8 a useful combination.
• Install Darwine.
• Open /Applications/Darwine/WineHelper, choose File > Open… and pick one of the .exe files you downloaded in the last step.
• Ignore any Darwine messages about needing to install Mozilla, and click Next/Agree/etc. as necessary in the installer to extract the .vhd file. (I understand the free VirtualBox will take such a .vhd directly, but I’ve not tried this myself).
• Download Q. This is a largely useless program for Intel Mac users, since its purpose is to emulate the CPU you already have. But bear with me: it includes a very handy utility.
• Open /Applications/Utilities/Terminal, and paste in the following command, substituting in the correct path to your .vhd file and a path of your choice for the .vmdk file it will be converted to:

/Applications/Q.app/Contents/MacOS/qemu-img convert \
  -f vpc -O vmdk path_to_old.vhd path_to_new.vmdk

• Nothing will appear to be happening for a few minutes, but don’t worry. Wait for the prompt to reappear.
• Create a new Virtual Machine in Fusion, based on the new .vmdk you just created. Agree to Fusion’s request to convert the format of the disk.
• Before starting up the new machine, remove its USB controller, sound card and serial port, and disable 3D graphics (this is all optional, but it reduces the number of requests for drivers you’ll have to deny later).
• Start the virtual machine, canceling any requests for driver disks or Windows Update attempts.
• Install VMWare Tools. I find everything works except the mouse, so at this point I choose the custom installation and deselect the mouse driver.
• Reboot and you’re done.
• Don’t forget to move the original .exe and .vhd files to the Trash: they’re big and completely useless now.

Happily, you can fix this with a strategically named and placed AppleScript. Open /Applications/AppleScript/Script Editor, and paste in the following lines:

tell application "Microsoft Word" 
  paste special (text object of selection) data type paste text
end tell

Save in /Users/YourUserName/Documents/Microsoft User Data/Word Script Menu Items as Paste unformatted\mosV.scpt (the backslashed bit at the end of the filename provides the shortcut). Restart Word and you can now paste without importing extraneous styles with Apple-Alt-Shift-V.

Update

You might also try this alternative approach (via a handy comment elsewhere):

try
  set theClip to Unicode text of (the clipboard as record)
  tell application "Microsoft Word" to tell selection to type text text theClip
end try

This has the advantage of leaving the cursor where you expect, at the end of the pasted text — the original script fragment leaves it at the beginning. And no, type text text is sadly not a typo: that’s really how Word likes to be addressed.

You have to create a ‘component’, which entails a fair chunk of unintelligible boilerplate code (well, unintelligible unless you’re much better acquainted with Firefox’s innards than developing a basic extension generally requires you to be).

Plenty of places will tell you roughly how to do it. But, after some experimentation, let me show you exactly how.

• Copy this JavaScript file into your extension’s /components directory (if that directory doesn’t exist yet, create it).
• Use it from elsewhere in your extension like so:

own_path = Components.classes["@mackerron.com/get_ext_dir;1"]
  .createInstance().wrappedJSObject.get_ext_dir();

And that’s it. Let me know if it helps you out.