CounLinesOfCode.hs

import System.Directory
import Control.Monad (filterM, mapM, liftM)
import System.FilePath ((</>))

getDirsRec :: FilePath -> IO [FilePath]
getDirsRec d = do
    dirContents <- getDirectoryContents d
    let dirContents' = [ d </> x | x <- dirContents, x /= ".", x /= ".." ]
    dirs' <- mapM dirRec dirContents'
    return (concat dirs' ++ [d])
    where
        dirRec n = do
            isDir <- doesDirectoryExist n
            if isDir then getDirsRec n
            else return []

getFiles :: FilePath -> IO [FilePath]
getFiles d = do
    dirContents <- getDirectoryContents d
    filterM doesFileExist (map (d </>) dirContents)

getLOC :: FilePath -> IO Int
getLOC f = (length . lines) `fmap` readFile f

main = liftM sum (getDirsRec "." >>= mapM getFiles >>= mapM getLOC . concat)

CountLinesOfCode.lua

------------------------------------
-- Author: Nikola Minoski - June 2014
-- Done in competition with Kex
-- Competition: Swift vs Lua
------------------------------------
require("lfs")

if #arg < 2 then print "Usange: count_src_lines.lua <path_to_project_src_dir> <src_code_ext1> [<src_code_ext2 [...]]" os.exit() end

local dst, allowedFiles, sourceLinesCount, sourceFiles = arg[1], {}, 0, 0
for i=2,#arg do allowedFiles[arg[i]:lower()] = true end

if not lfs.chdir(dst) then print("Wrong src directory: '" .. dst .. "'") os.exit() end

function checkDir(folder)
	for file in lfs.dir(folder) do
		if file:sub(1, 1) ~= "." then
			local path = folder .. "/" .. file
			if lfs.attributes(path,"mode") == "file" then
				if allowedFiles[file:match(".(%w-)$"):lower()] then	--check for allowed extensions
					sourceFiles = sourceFiles + 1
					for line in io.lines(path) do
						if line:gsub("%s+", ""):len() > 0 then sourceLinesCount = sourceLinesCount + 1 end
					end
				end
		    elseif lfs.attributes(path,"mode")== "directory" then checkDir(path) end
		end
	end
end

checkDir(dst)

print("Files: ", sourceFiles)
print("Source Lines: ", sourceLinesCount)

CountLinesOfCode.py

import os

def generate_file_paths(path):
    for dirpath, dirlist, filelist in os.walk(path):
        for f in filelist:
            yield os.path.join(dirpath, f)

def create_filter(extension):
    def filter_f(path):
        return path.endswith(extension)
    return filter_f

def lines(file_handle):
    return sum(1 for line in file_handle)

paths = generate_file_paths('..') # sys.argv[1]
filt = create_filter('.js') # sys.argv[2]

s = 0
for f_path in paths:
    if not filt(f_path):
        continue
    s += lines(open(f_path))

print s

CountLinesOfCode.swift

// Playground - noun: a place where people can play
// Done in competition with Nikola
// Competition: Swift vs Lua


import Cocoa

let fileManager:NSFileManager = NSFileManager.defaultManager()

let currentFilePath = "/Users/aleksandartrpeski/Documents/TMP/smashicons/BadIcons/BadIcons"

let paths:AnyObject[] = fileManager.subpathsAtPath(currentFilePath)

var linesOfCode = 0;
var files = 0;

for path:AnyObject in paths {
    
    let filePath = currentFilePath.stringByAppendingPathComponent(path as String)
    
    if filePath.pathExtension == "h" ||
        filePath.pathExtension == "m" ||
        filePath.pathExtension == "plist"{
            
            let text:AnyObject = NSString.stringWithContentsOfFile(filePath)
            
            let count = text.componentsSeparatedByString("\n").count
            
            linesOfCode += count
            files++
            
//            println("\(count)\t\(text)")
    }
}

println("\nLines of Code: \(linesOfCode)\n Files:\(files)")

LocCounter.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace LocCounter
{
    class Program
    {
        static void Main(string[] args)
        {
            
            Console.WriteLine("Total LoC: {0}", countLines(args[0]);
            Console.Read();
        }

        static long countLines(String directory)
        {
            try
            {
                if(Directory.Exists(directory.ToString()))
                {
                    var query = from file in Directory.EnumerateFiles(directory.ToString(), "*.cs", SearchOption.AllDirectories)
                                from line in File.ReadLines(file)
                                where line.Trim().Length > 0 && !line.Trim().StartsWith("//")
                                select line;

                    return query.Count();    
                }

                return 0;
                
            }
            catch (IOException kex)
            {
                if(kex.Source != null)
                {
                    Console.WriteLine("Kex e kriv. {0}", kex.Source);
                }
                throw;
            }
        }
    }
}

LoCCounter.java

package mk.ol.playground.loc;

import java.io.IOException;
import java.nio.file.*;
import java.util.*;

public final class LoCCounter {

    private static final Set<String> allowedExtensions = new HashSet<>(Arrays.asList(".java", ".txt"));

    public static void main(final String[] args) {
        System.out.println("Total LoC: " + process(Paths.get(args[0])));
    }

    private static long process(final Path root) {
        try {
            if (Files.isDirectory(root)) {
                return Files.list(root)
                            .filter(LoCCounter::isSourceFile)
                            .mapToLong(LoCCounter::process)
                            .sum();
            }
            return Files.lines(root)
                        .filter(s -> !s.trim().isEmpty() && !s.trim().startsWith("//"))
                        .count();
        } catch (IOException e) { throw new RuntimeException(e); }
    }

    private static boolean isSourceFile(final Path path) {
        final String filePath = path.toFile().getAbsolutePath();
        return Files.isDirectory(path)
                || allowedExtensions.contains(filePath.substring(filePath.lastIndexOf('.')));
    }
}