Necoro’s Blog

Blog? Blog? There is no blog…

Archive for the ‘Howtos’ Category

Matching web-fonts with fontconfig

with 2 comments

I had a small issue today: A font used on a webpage and loaded via CSS was not rendered as it should be. I searched quite some time to find out if it is matched by font-config, and if so, how. So here is the answer: it is matched against the name defined in the CSS prepended by a @font-face:. With this I was able to add stuff like the following to my ~/.fonts.conf:

<match target="font">
  <test name="family">
    <string>@font-face:Thesis</string>
  </test>
  <edit name="hintstyle" mode="assign">
    <const>hintslight</const>
  </edit>
 </match>

Written by Necoro

April 29, 2013 at 22:30

Posted in Howtos

Tagged with , , ,

Subscribing to Google Group without needing a Google account

leave a comment »

More and more projects host their mailinglists on google groups. This is nothing bad per se. But it is not quite easy to find out how one can subscribe there w/o needing a google account. But it is easy: If the mailinglist you want to subscribe to is named foo-bar@googlegroups.com, you just have to send a normal subscription message (i.e. an empty one) to foo-bar+subscribe@googlegroups.com.

This is also documented on Google, but somewhat hidden.

Hopefully someone finds this useful :)

Written by Necoro

April 21, 2010 at 21:11

Posted in Howtos

Tagged with ,

Managing your configuration files with Git and StGit. Revisited #2

leave a comment »

Ok … I wrote about using Git and StGit and about how I ditched StGit and used plain Git. So – just a short update: I reverted back to using StGit :D. I updated the two mentioned posts.

Oh – and for my convenience, I wrote a “small” function in zsh which does the “pop, commit, push, push” cycle needed if you want to have a patch applied directly in Git and not in StGit. You can find it here (function “cci”) … or below.

cci ()
{
    if [[ $# == 0 ]]; then
        echo "No message given. Aborting."
        return 1
    fi

    local message=$1
    local tok=__cci__

    pushd -q ~

    cstg diff
    echo -n "Is this ok? [y/n] "
    
    if ! read -q; then
        echo
        echo "I would have done the wrong thing ... aborting!"
        return 2
    fi

    echo ">> Creating new patch"
    cstg new $tok -m "$message"
    
    echo ">> Refreshing"
    cstg refresh

    if [[ -z $(cstg files) ]]; then
        echo
        echo "Ehm - this patch is empty. Narf. Aborting!"
        echo "Deleting useless patch"
        cstg del $tok
        return 3
    fi

    echo ">> Committing"
    cstg commit $tok
    
    if [[ -n $(cstg series --applied) ]]; then
        echo
        echo "Urgs! Something went wrong. There are still patches applied."
        echo "Clean up for yourself. Aborting here!"
        return 4
    fi
    
    echo ">> Pushing to remote"
    config push

    echo ">> Re-apply patches"
    cstg push -a

    echo ">> Done"

    popd -q
}

Written by Necoro

March 27, 2010 at 15:28

Managing your configuration files with Git. Revisited.

leave a comment »

I showed a way of managing the configuration files with git and StGit in the post two days ago. But this has two disadvantages:

  1. StGit is not installed on all systems. And though it is only some Python-Code which is not hard to install in your home directory, it is something I’d like to avoid.
  2. Using two commands (config and cstg) is not the best thing. Having only one command would be better…

So I tried the more natural way (often I tend to think way too complex) of using git branches. I created a “local” branch, which is used for the local changes (hah – you could not guess it :P). And then I only use rebasing to pull global changes.

Update: In the meantime I switched back to using stgit … it just worked somewhat better. But the approach mentioned here still works pretty good :)

Compared to the older method, the approach is now:

  1. Same as the old one.
  2. Create local branch and use it:
    config checkout -b local
    # hack hack hack
    config commit -a
    # ...
    
  3. Change to master and work there
    config checkout master
    # make changes
    config commit -a
    config push
    config checkout local
    config rebase master
    
  4. Same (except step 7 of course).

Written by Necoro

October 10, 2009 at 02:26

Managing your configuration files with Git and StGit

with one comment

This is propably a wide known problem: You want your personal config files (for ViM, Emacs, $SHELL, …) on all the boxes you have to deal with. The solution here is often: Use some distributed VCS/SCM like git, bzr, hg, whatever and be happy. But it might happen (and it will surely happen quite often), that the boxes have different versions installed for some packages. Or there are other differences (for example: I have to use other font sizes on my laptop than on my PC). This not a problem, if the config files you are using allow importing other ones — you have your global options and override them with some local additions. Well, unfortunately, this is not always supported (e.g. I do not know of a way to import something into .gitconfig). So we have to find a solution…

And I guess, I found one: Use Git to manage the global stuff — and use StGit to manage a stack of patches for the local boxes :)

Read the rest of this entry »

Written by Necoro

October 8, 2009 at 01:52