How to use .dir-locals.el with Projectile?

Question

I'm trying to ignore some file patterns while performing helm-projectile-grep and some with helm-projectile-find-file. I've found that it could be achieved using .dir-locals.el here.
Following this chunk of documentation I've made my .dir-locals.el looks like:

((nil
  (grep-find-ignored-files . '("*.log"))
  (projectile-globally-ignored-files . '("*.log"))))

When helm-projectile-grep is called it yields an error in helm-projectile:

Error running timer `helm-projectile-grep-or-ack': (wrong-type-argument stringp quote)

Since both emacs manual and projectile docs are sketchy about .dir-locals.el and it's usage I have few questions?

• How .dir-locals.el works? Does it merge global and dir-local value of an variable? If I have a variable a which is '("a" "b") and set it in dir-local to '("c"), what is its value that Emacs use when I perform an operation in certain scope of .dir-locals.el?
• What kind of structure is expected in .dir-locals.el for grep-find-ignored-files and projectile-globally-ignored-files?

On Projectile itself:

• Why Projectile helm-projectile-grep and helm-projectile-find-file don't ignore file patterns which are already ignored in .gitignore? Is it turned off somewhere in my config?

Solution

According to accepted answer, if you want to ignore e.g all the .md files from Projectile operations in your project using .dir-locals.el you should do something like this:

((nil
  (eval . (set (make-local-variable 'projectile-globally-ignored-files)
               (append projectile-globally-ignored-files
                       (f-entries (projectile-project-root)
                                  (lambda (f) (string-match "\\.md$" f)) t))))))

Answer 1

1. .dir-locals.el does not care about the meaning of the variables that it sets, nor does it assume their values are lists (they do not have to be.) So it does not perform any merge or other processing. The only thing that's been taken into account is precedence which is described in the documentation you have linked to.

2. The values are interpreted as-is, emacs uses read function to get them, so they are unevaluated. That's what causes the error - do not use a quote, use straight values.

3. To get the effect of merging, you need to do it yourself, and since the values are unevaluated you need to use a special variable eval, like this:

((nil
   (eval . (setq a-variable-you-need-to-merge (add-to-list whatever-you-need))))

Update: as pointed out in the comments, using setq in eval will change the global value of the variable (unless of course the variable was declared local to begin with.) To make the change local, make-local-variable can be used, so for example changing projectile-globally-ignored-files locally can be done like this:

((nil
   (eval . 
         (set 
          (make-local-variable 'projectile-globally-ignored-files)
          (push "SOME-VALUE" projectile-globally-ignored-files)))))

It is a bit sloppy, and can certainly be done shorter, but I just wanted to make a point of using make-local-variable.

(I would definitely make a helper out of this kind of functions and put it in init.el and just called from .dir-locals.el)

4. As I said, .dir-locals.el does not assume anything about the variables, so the requirements are the same as if they were set in any other way. And as far as I can tell from looking at projectile source, projectile-globally-ignored-files does not expect blobs (asterisks etc.) but rather single file names, so you will have to either list them all or write an expression that calculates them and use eval with it.

5. You should have gotten a warning from Emacs about some local variables not being safe (because of *.) Make sure you haven't ignored the variable list, otherwise your .dir-locals.el will have no effect.

Update regarding .gitignore:

Seems that Projectile takes .gitignore file into account only if the project is indeed under git, that is, a git repository exists.