PageRenderTime 130ms queryTime 36ms sortTime 12ms getByIdsTime 32ms findMatchingLines 10ms

100+ results results for 'clojure' (130 ms)

Not the results you expected?
monokai.css https://gitlab.com/Mirros/jsdelivr | CSS | 127 lines
                    
18.lisp .hljs-title,
                    
19.clojure .hljs-built_in,
                    
20.nginx .hljs-title,
                    
                
googlecode.css https://gitlab.com/Mirros/jsdelivr | CSS | 146 lines
                    
21pre .list .title,
                    
22pre .clojure .built_in,
                    
23pre .nginx .title,
                    
66pre .css .function,
                    
67pre .clojure .attribute {
                    
68  color: #066;
                    
84pre .variable,
                    
85pre .clojure .title {
                    
86  color: #606;
                    
                
README.md https://github.com/michaelklishin/validateur.git | Markdown | 69 lines
                    
1# Validateur, a Clojure(Script) Validation Library
                    
2
                    
2
                    
3Validateur is a [Clojure(Script) validation library](http://clojurevalidations.info) inspired by Ruby's ActiveModel. Validateur is functional: validators are
                    
4functions, validation sets are higher-order functions, validation results are returned as values.
                    
6
                    
7## Supported Clojure versions
                    
8
                    
8
                    
9Validateur requires Clojure 1.7+/ClojureScript 0.0-2138+.
                    
10
                    
42
                    
43Please refer to the [documentation guides](http://clojurevalidations.info) for Validateur.
                    
44
                    
55Validateur uses [Leiningen 2](https://github.com/technomancy/leiningen/blob/master/doc/TUTORIAL.md). Make
                    
56sure you have it installed and then run tests against all supported Clojure versions and a recent release of ClojureScript using
                    
57
                    
                
beer_song_test.clj https://gitlab.com/lucacervello/exercism-clojure | Clojure | 47 lines
                    
1(ns beer-song-test
                    
2  (:require [clojure.test :refer [deftest is]]
                    
3            beer-song))
                    
                
far.css https://gitlab.com/blockbuster/react-router-2-with-hash-working-public | CSS | 113 lines
                    
35.tex .hljs-command,
                    
36.clojure .hljs-title,
                    
37.coffeescript .hljs-attribute {
                    
55.tex .hljs-special,
                    
56.clojure .hljs-built_in {
                    
57  color: #FFF;
                    
76.smalltalk .hljs-char,
                    
77.clojure .hljs-attribute {
                    
78  color: #0F0;
                    
                
factors_test.clj https://github.com/tavisrudd/trammel.git | Clojure | 72 lines
                    
3  (:use trammel.factors)
                    
4  (:use [clojure.test :only (deftest is are)]))
                    
5
                    
                
browse.clj https://github.com/cpulsford/clojure-contrib.git | Clojure | 51 lines
                    
1;;; browse.clj -- start a web browser from Clojure
                    
2
                    
14    :deprecated "1.2"
                    
15    :doc "Start a web browser from Clojure"}
                    
16  clojure.contrib.javadoc.browse
                    
16  clojure.contrib.javadoc.browse
                    
17  (:require [clojure.contrib.shell :as sh]) 
                    
18  (:import (java.net URI)))
                    
31  (try 
                    
32    (when (clojure.lang.Reflector/invokeStaticMethod "java.awt.Desktop" 
                    
33      "isDesktopSupported" (to-array nil))
                    
33      "isDesktopSupported" (to-array nil))
                    
34      (-> (clojure.lang.Reflector/invokeStaticMethod "java.awt.Desktop" 
                    
35            "getDesktop" (to-array nil))
                    
45  ; this fixes a bug on mac os x where requiring repl-utils turns the process into a GUI app
                    
46  ; see http://code.google.com/p/clojure-contrib/issues/detail?id=32
                    
47  (require 'clojure.contrib.javadoc.browse-ui)
                    
                
test_util.clj https://github.com/cpulsford/clojure-contrib.git | Clojure | 69 lines
                    
10;;
                    
11;;  A Clojure implementation of Datalog -- Utilities Tests
                    
12;;
                    
15
                    
16(ns clojure.contrib.datalog.tests.test-util
                    
17  (:use clojure.test
                    
17  (:use clojure.test
                    
18	clojure.contrib.datalog.util)
                    
19  (:use [clojure.contrib.except :only (throwf)]))
                    
                
pprint.clj https://github.com/cpulsford/clojure.git | Clojure | 48 lines
                    
1;;; pprint.clj -- Pretty printer and Common Lisp compatible format function (cl-format) for Clojure
                    
2
                    
15    ^{:author "Tom Faulhaber",
                    
16      :doc "A Pretty Printer for Clojure
                    
17
                    
17
                    
18clojure.pprint implements a flexible system for printing structured data
                    
19in a pleasing, easy-to-understand format. Basic use of the pretty printer is 
                    
23Out of the box, pprint supports a simple structured format for basic data 
                    
24and a specialized format for Clojure source code. More advanced formats, 
                    
25including formats that don't look like Clojure data at all like XML and 
                    
31cl-format, it supports very concise custom dispatch. It also provides
                    
32a more powerful alternative to Clojure's standard format function.
                    
33
                    
34See documentation for pprint and cl-format for more information or 
                    
35complete documentation on the the clojure web site on github.",
                    
36       :added "1.2"}
                    
                
singleton.clj https://github.com/cpulsford/clojure-contrib.git | Clojure | 54 lines
                    
25     :doc "Singleton functions"}
                    
26  clojure.contrib.singleton)
                    
27
                    
                
test_db.clj https://github.com/Plummtw/jinrou_clojure.git | Clojure | 49 lines
                    
1
                    
2(ns jinrou-clojure.test.model.test-db
                    
3  (:refer-clojure)
                    
3  (:refer-clojure)
                    
4  (:use clojure.test
                    
5        [jinrou-clojure.model.db :reload true]))
                    
                
voice.clj https://github.com/sethtrain/clj-twilio.git | Clojure | 48 lines
                    
2  (:use [twilio.twiml.voice] :reload)
                    
3  (:use [clojure.test]
                    
4        [twilio.twiml.core]))
                    
                
strings.clj https://gitlab.com/jimador/clojure-studies | Clojure | 68 lines
                    
1  (ns clojure-koans.strings
                    
2  (:require [clojure.string :as string]))
                    
                
Stream.java https://github.com/jabley/clojure.git | Java | 88 lines
                    
12
                    
13package clojure.lang;
                    
14
                    
                
trace.clj https://github.com/duck1123/lamina.git | Clojure | 66 lines
                    
12    [lamina.trace.core :only (probe-channels probe-switches)]
                    
13    [clojure test]))
                    
14
                    
                
layout.html https://github.com/tomfaulhaber/autodoc.git | HTML | 48 lines
                    
6    <link rel="shortcut icon" href="static/favicon.png">
                    
7    <link rel="stylesheet" href="static/clojure.css" type="text/css" media="all" />
                    
8    <link rel="stylesheet" href="static/wiki.css" type="text/css" media="all" />
                    
12<!--
                    
13This document was auto-generated from the source by the clojure autodoc system.
                    
14To report errors or ask questions about the overall documentation structure, formatting,
                    
21      <div id="Header">
                    
22	<a href="index.html" id="Logo"><img src="static/clojure-icon.gif" width="100" height="100" alt="Clojure" /></a>
                    
23	<h1><a href="index.html" id="page-header"
                    
43      <div id="DesignedBy">Logo &amp; site design by <a href="http://www.tomhickey.com" title="Visit Tom Hickey's website.">Tom Hickey</a>.<br />
                    
44      Clojure auto-documentation system by Tom Faulhaber.</div>
                    
45    </div>
                    
                
tree.clj https://github.com/odyssomay/seesaw.git | Clojure | 60 lines
                    
13
                    
14(def source "http://www.4clojure.com/problems/rss")
                    
15
                    
16; Make a tree model for some XML using same arguments (branch? and childnre) 
                    
17; as (clojure.core/tree-seq)
                    
18(defn load-model []
                    
21    (comp seq :content)
                    
22    (clojure.xml/parse source)))
                    
23
                    
                
meta.js https://gitlab.com/vikash.patel/qwertyu | JavaScript | 143 lines
                    
20    {name: "C#", mime: "text/x-csharp", mode: "clike", ext: ["cs"]},
                    
21    {name: "Clojure", mime: "text/x-clojure", mode: "clojure", ext: ["clj"]},
                    
22    {name: "CoffeeScript", mime: "text/x-coffeescript", mode: "coffeescript", ext: ["coffee"]},
                    
                
test_responses.clj git://github.com/malcolmsparks/plugboard.git | Clojure | 54 lines
                    
18  (:use
                    
19   clojure.test
                    
20   compojure.core
                    
21   plugboard.demos.jetty-fixture
                    
22   clojure.data.zip.xml
                    
23   plugboard.util)
                    
26   [ring.util.codec :as codec]
                    
27   [clojure.string :as string]
                    
28   plugboard.demos.forms.configuration))
                    
                
project.clj https://github.com/kulasama/cake.git | Clojure | 237 lines
                    
7        [uncle.core :only [fileset-seq]]
                    
8        [clojure.string :only [split join trim-newline]]
                    
9        [clojure.java.shell :only [sh]]
                    
12        [useful.fn :only [given]]
                    
13        [clojure.java.io :only [reader]])
                    
14  (:import [java.io File]))
                    
54                    (require 'bake.reload)
                    
55                    (require 'clojure.main))))
                    
56    (prn paths)))
                    
58(defn set-classpath!
                    
59  "Set the JVM classpath property to the current clojure classloader."
                    
60  [classloader]
                    
170(defn group [dep]
                    
171  (if ('#{clojure clojure-contrib} dep)
                    
172    "org.clojure"
                    
                
ex2_67.clj git://github.com/grinnbearit/sicp.git | Clojure | 104 lines
                    
3
                    
4;;; Clojure has better alternatives for dynamic dispatch, [protocols](http://clojure.org/protocols)
                    
5
                    
                
README.markdown https://github.com/Purrrrrr/Dotvim.git | Markdown | 296 lines
                    
82
                    
83  [`vim-clojure-highlight`](https://github.com/guns/vim-clojure-highlight) is
                    
84  a fireplace.vim plugin that extends syntax highlighting to local, referred,
                    
94using an interactive
                    
95[Clojure REPL plugin](https://github.com/guns/vim-clojure-static/wiki/Clojure-REPL-Plugins).
                    
96
                    
122
                    
123[`vim-clojure-highlight`](https://github.com/guns/vim-clojure-highlight) uses
                    
124these variables to highlight extra vars when connected to a REPL.
                    
147
                    
148### `g:clojure_fuzzy_indent`, `g:clojure_fuzzy_indent_patterns`, `g:clojure_fuzzy_indent_blacklist`
                    
149
                    
176
                    
177`g:clojure_fuzzy_indent_patterns` and `g:clojure_fuzzy_indent_blacklist` are
                    
178lists of patterns that will be matched against the unqualified symbol at the
                    
                
test.clj https://github.com/thickey/enlive.git | Clojure | 215 lines
                    
13  (:require [net.cgrand.xml :as xml])
                    
14  (:require [clojure.zip :as z])
                    
15  (:require [net.cgrand.enlive-html.state-machine :as sm])
                    
15  (:require [net.cgrand.enlive-html.state-machine :as sm])
                    
16  (:use [clojure.contrib.test-is :as test-is :only [set-test is are]]))
                    
17
                    
91    true (attr= :href "http://cgrand.net/")
                    
92    false (attr= :href "http://clojure.org/")
                    
93    false (attr= :href "http://cgrand.net/" :name "home") 
                    
                
core.clj git://github.com/leadtune/clj-drmaa.git | Clojure | 54 lines
                    
1(ns clj-drmaa.core
                    
2  (use [clojure.contrib
                    
3         [def :only [defn-memo defnk]]])
                    
                
test_x86.clj git://github.com/mikedouglas/MiniJava.git | Clojure | 49 lines
                    
1(ns minijava.test-x86
                    
2  (:use clojure.test
                    
3        minijava.access
                    
                
README.md git://github.com/darrenaustin/euler-clojure.git | Markdown | 65 lines
                    
1# euler-clojure
                    
2
                    
3My solutions to the [Project Euler][1] problems written in the
                    
4[Clojure][2] programming language.  I am doing this for fun and
                    
5profit.  But mostly fun.  It is a great way to learn a new programming
                    
9Given that, these are just my solutions to the problems.  There may be
                    
10cleaner, or more idiomattic ways to do this in Clojure (if so, please
                    
11drop me a line and let me know).  I am learning as I go, so some of
                    
22
                    
23Currently this project requires Clojure 1.2.  I will update it to 1.3
                    
24sometime soon.  I use `lein swank` to get a REPL up and running with the 
                    
50I originally started with Project Euler as a way to learn Ruby.  I
                    
51have migrated most of my original solutions over to Clojure.  Although
                    
52in many cases the Clojure solution is very different from how I solved
                    
53it in Ruby.  Here is my migration TODO list.  Problems I have solved
                    
54in Ruby, but not yet in Clojure:
                    
55
                    
                
event_handlers.clj git://github.com/samaaron/monome-serial.git | Clojure | 58 lines
                    
1(ns monome-serial.event-handlers
                    
2  (:use [clojure.core.incubator :only [dissoc-in]]))
                    
3
                    
                
fn.clj git://github.com/cjfrisz/clojure-tco.git | Clojure | 66 lines
                    
8;; Defines the Fn record type for representing 'fn' expressions in the
                    
9;; Clojure TCO compiler.
                    
10;;
                    
                
cgol.clj git://github.com/VivienBarousse/cgol.git | Clojure | 99 lines
                    
1(use '[clojure.string :only (split-lines)])
                    
2
                    
                
craig.clj git://github.com/alvinlai/vision.git | Clojure | 77 lines
                    
2  (:import java.net.URL)
                    
3  (:require [clojure.contrib.string :as str-utils :only (substring? lower-case)])
                    
4  (:use hiccup.core
                    
                
project.clj git://github.com/cemerick/url.git | Clojure | 37 lines
                    
1(defproject com.cemerick/url "0.1.2-SNAPSHOT"
                    
2  :description "Makes working with URLs in Clojure a little more pleasant."
                    
3  :url "http://github.com/cemerick/url"
                    
5            :url "http://www.eclipse.org/legal/epl-v10.html"}
                    
6  :dependencies [[org.clojure/clojure "1.5.1"]
                    
7                 [pathetic "0.5.0"]
                    
7                 [pathetic "0.5.0"]
                    
8                 [org.clojure/clojurescript "0.0-1835" :optional true]]
                    
9
                    
13                          "cljsbuild" "once," "cljsbuild" "test"]}
                    
14  :profiles {:dev {:dependencies [[com.cemerick/clojurescript.test "0.0.4"]
                    
15                                  [com.keminglabs/cljx "0.3.0"]
                    
                
tuple_test.clj git://github.com/nathanmarz/storm.git | Clojure | 51 lines
                    
16(ns backtype.storm.tuple-test
                    
17  (:use [clojure test])
                    
18  (:import [backtype.storm.tuple Tuple])
                    
                
welcome.html git://github.com/semperos/clj-webdriver.git | HTML | 49 lines
                    
8  <li class="even">form.html</li>
                    
9  <li class="last odd">clojure.html</li>
                    
10</ol>
                    
29    <tr>
                    
30      <td>clojure.html (row 3, cell 1)</td>
                    
31      <td>Test window handling (row 3, cell 2)</td>
                    
34
                    
35<p>By the way, Clojure <a href="/clojure" target="_blank">is amazing!</a> for the following reasons:</p>
                    
36
                    
36
                    
37<ul id="clojure-reasons">
                    
38  <li>It's fun (<em>really</em> fun)</li>
                    
39  <li>It's a Lisp</li>
                    
40  <li>It's simple (thanks Lisp, see <a href="http://clojure.blip.tv/file/4824610/">Stuart</a> for more details)
                    
41  <li>It's hosted on the JVM and has excellent interop</li>
                    
                
2010-06-01-path-finding-using-astar-in-clojure.org https://github.com/nakkaya/nakkaya.com.git | Org | 277 lines
                    
1#+title: Path Finding Using A-Star in Clojure
                    
2#+tags: clojure path-finding
                    
3
                    
4For a recent project, I had to implement A* (A-Star) in Clojure, since
                    
5it's a very popular path finding algorithm used in gaming I thought it
                    
45
                    
46#+begin_src clojure
                    
47  (def maze1 [[0 0 0 0 0 0 0]
                    
56
                    
57#+begin_src clojure
                    
58  (defn manhattan-distance [[x1 y1] [x2 y2]]
                    
74
                    
75#+begin_src clojure
                    
76  (defn edges [map width height closed [x y]]
                    
93
                    
94#+begin_src clojure
                    
95  (defn path [end parent closed]
                    
                
account.clj git://github.com/weavejester/capra.git | Clojure | 71 lines
                    
2  "Access and manage accounts on a Capra server."
                    
3  (:refer-clojure :exclude [get list])
                    
4  (:use capra.base64)
                    
                
ClassNode.java http://enclojure-clojure-lib.googlecode.com/svn/trunk/ | Java | 281 lines
                    
29 */
                    
30package org.enclojure.ide.asm.tree;
                    
31
                    
31
                    
32import org.enclojure.ide.asm.Attribute;
                    
33import org.enclojure.ide.asm.ClassVisitor;
                    
33import org.enclojure.ide.asm.ClassVisitor;
                    
34import org.enclojure.ide.asm.MethodVisitor;
                    
35import org.enclojure.ide.asm.FieldVisitor;
                    
53    /**
                    
54     * The class's access flags (see {@link org.enclojure.ide.asm.Opcodes}). This
                    
55     * field also indicates if the class is deprecated.
                    
60     * The internal name of the class (see
                    
61     * {@link org.enclojure.ide.asm.Type#getInternalName() getInternalName}).
                    
62     */
                    
                
test-helper.el git://github.com/technomancy/clojure-mode.git | Emacs Lisp | 59 lines
                    
1;;; test-helper.el --- Clojure Mode: Non-interactive unit-test setup  -*- lexical-binding: t; -*-
                    
2
                    
32  ;; Load the file under test
                    
33  (load (expand-file-name "clojure-mode" source-directory)))
                    
34
                    
34
                    
35(defmacro with-clojure-buffer (text &rest body)
                    
36  "Create a temporary buffer, insert TEXT, switch to clojure-mode and evaluate BODY."
                    
40     (insert ,text)
                    
41     (clojure-mode)
                    
42     ,@body))
                    
54  `(it ,description
                    
55     (with-clojure-buffer ,before
                    
56       ,@body
                    
                
to_widget.clj https://github.com/KevinKelley/seesaw.git | Clojure | 65 lines
                    
43
                    
44(def-widget-creational-coercion clojure.lang.Keyword 
                    
45  [v] 
                    
50
                    
51(def-widget-creational-coercion clojure.lang.IPersistentVector 
                    
52  [[v0 v1 v2]]
                    
                
IPersistentCollection.cs https://github.com/101v/clojure-clr.git | C# | 56 lines
                    
19
                    
20namespace clojure.lang
                    
21{
                    
                
template.clj https://gitlab.com/hcaty/clojure | Clojure | 55 lines
                    
26       :author "Stuart Sierra"}
                    
27  clojure.template
                    
28  (:require [clojure.walk :as walk]))
                    
                
home_view_test.clj https://github.com/mderosa/nimcram.git | Clojure | 48 lines
                    
2  (:use pelrapeire.views.projects.uid.home-view
                    
3	clojure.contrib.trace
                    
4	clojure.test))
                    
                
mail_test.clj https://github.com/mderosa/nimcram.git | Clojure | 54 lines
                    
1(ns pelrapeire.repository.mail.mail-test
                    
2  (:use clojure.test
                    
3	clojure.contrib.trace
                    
                
run_tests_i.clj git://github.com/richhickey/clojure-clr.git | Clojure | 60 lines
                    
1(ns clojure.test-clojure (:require clojure.test))
                    
2
                    
3(def test-namespaces '[
                    
4clojure.test-clojure.agents
                    
5;;;clojure.test-clojure.annotations
                    
6clojure.test-clojure.atoms
                    
7clojure.test-clojure.clojure-set
                    
8clojure.test-clojure.clojure-walk                       
                    
8clojure.test-clojure.clojure-walk                       
                    
9;;;clojure.test-clojure.clojure-xml
                    
10clojure.test-clojure.clojure-zip
                    
10clojure.test-clojure.clojure-zip
                    
11clojure.test-clojure.compilation
                    
12clojure.test-clojure.control
                    
12clojure.test-clojure.control
                    
13clojure.test-clojure.data
                    
14clojure.test-clojure.data-structures
                    
                
encodings.clj https://github.com/burke/skyway.git | Clojure | 66 lines
                    
11  (:use skyway.str-utils)
                    
12  (:use clojure.contrib.duck-streams)
                    
13  (:import java.net.URLEncoder)
                    
48(defn marshal
                    
49  "Serialize a Clojure object in a base64-encoded string."
                    
50  [data]
                    
53(defn unmarshal
                    
54  "Unserialize a Clojure object from a base64-encoded string."
                    
55  [marshaled]
                    
                
load_all.clj https://github.com/digash/clojure-contrib.git | Clojure | 91 lines
                    
15;; This file simple attempts to "require" every library in
                    
16;; clojure-contrib.  The names of all contrib libs (minus the
                    
17;; "clojure.contrib" part) are in *all-contrib-libs*.  Libraries which
                    
18;; throw errors when loading under the latest trunk SVN revisions of
                    
19;; Clojure and clojure-contrib are commented out.
                    
20;;
                    
24;;
                    
25;; (clojure.test/run-all-tests)
                    
26;;
                    
29
                    
30(ns clojure.contrib.load-all)
                    
31
                    
90(doseq [name *all-contrib-libs*]
                    
91  (require (symbol (str "clojure.contrib." name))))
                    
92
                    
                
prerequisites.clj https://github.com/dnaumov/Midje.git | Clojure | 42 lines
                    
11                                            tack-on__then__at-rightmost-expect-leaf]])
                    
12  (:require [clojure.zip :as zip]))
                    
13
                    
                
parse_test.clj https://github.com/phosphene/cascading-clojure.git | Clojure | 60 lines
                    
1(ns cascading.clojure.parse-test
                    
2  (:use clojure.test
                    
2  (:use clojure.test
                    
3        (cascading.clojure parse testing))
                    
4  (:import cascading.tuple.Fields))
                    
15(deftest test-parse-fn-spec-simple
                    
16  (is (= ["cascading.clojure.parse-test" "example"]
                    
17    (parse-fn-spec #'example))))
                    
19(deftest test-parse-fn-spec-hof
                    
20  (is (= ["cascading.clojure.parse-test" "example" 3]
                    
21    (parse-fn-spec [#'example 3]))))
                    
27(deftest test-parse-args-everything
                    
28  (is (= {:fn-spec ["cascading.clojure.parse-test" "example"]
                    
29          :<       (fields "foo")
                    
34(deftest test-parse-args-everything-multiple-ins
                    
35  (is (= {:fn-spec ["cascading.clojure.parse-test" "example"]
                    
36          :<       (fields ["foo" "bat"])
                    
                
token_navigator.clj https://github.com/EricThorsen/enclojure.git | Clojure | 58 lines
                    
17
                    
18(ns org.enclojure.ide.nb.actions.token-navigator
                    
19  (:use
                    
19  (:use
                    
20    org.enclojure.ide.navigator.token-nav
                    
21    )
                    
22  (:require
                    
23    [org.enclojure.commons.c-slf4j :as logger]
                    
24    )
                    
                
issue.clj https://gitlab.com/dzaporozhets/checked.git | Clojure | 69 lines
                    
1(ns checked.models.issue
                    
2  (:require [clojure.java.jdbc :as sql]
                    
3            [environ.core :refer [env]]))
                    
                
devbuild.clj https://gitlab.com/wunderwaffle/atompit | Clojure | 59 lines
                    
1(ns atompit.devbuild
                    
2  (:require [clojure.java.io :as io]
                    
3            [me.raynes.conch.low-level :as sh]
                    
                
dispatch.clj https://github.com/cgrand/sandbox.git | Clojure | 58 lines
                    
11(ns net.cgrand.dispatch
                    
12  (:use [clojure.contrib.test-is :as test-is :only [set-test with-test is]]))
                    
13
                    
                
soy.clj https://github.com/duck1123/closure-templates-clj.git | Clojure | 66 lines
                    
2  closure.templates.soy
                    
3  (:refer-clojure :exclude (replace))
                    
4  (:import java.io.File java.net.URL java.net.URI)
                    
4  (:import java.io.File java.net.URL java.net.URI)
                    
5  (:use [clojure.contrib.def :only (defvar)]
                    
6        [clojure.string :only (blank? replace)]
                    
                
README.markdown https://github.com/tcrayford/compojure.git | Markdown | 62 lines
                    
1Compojure is an open source web framework for the [Clojure](http://clojure.org)
                    
2programming language. It emphasizes a thin I/O layer and a functional approach
                    
28
                    
29* The [Clojure](http://clojure.org) programming language
                    
30* The [Clojure-Contrib](http://code.google.com/p/clojure-contrib/) library
                    
                
core.clj https://github.com/whacked/pdfblastaxoj.git | Clojure | 64 lines
                    
23   )
                    
24  (:require [clojure.java.io :as io]
                    
25            [clojure.string :as s]
                    
                
test_test.clj git://github.com/aphyr/riemann.git | Clojure | 55 lines
                    
5            [riemann.time.controlled :refer :all]
                    
6            [clojure.test :refer :all]))
                    
7
                    
                
overview.html https://github.com/thickey/contrib-autodoc.git | HTML | 57 lines
                    
1<h1 id="toc0">An Overview of the Clojure Core API</h1>
                    
2<h4>This is API documentation for the latest committed checkin of the Clojure core.</h4>
                    
2<h4>This is API documentation for the latest committed checkin of the Clojure core.</h4>
                    
3<h3>Important Clojure resources</h3>
                    
4<ul>
                    
4<ul>
                    
5  <li>The official source code for clojure is on the
                    
6    <a href="http://github.com/richhickey/clojure/">
                    
6    <a href="http://github.com/richhickey/clojure/">
                    
7      Clojure GitHub source page
                    
8    </a>.
                    
9  </li>
                    
10  <li>Issues and other information for clojure are maintained in the
                    
11    <a href="http://www.assembla.com/spaces/dashboard/index/clojure">
                    
11    <a href="http://www.assembla.com/spaces/dashboard/index/clojure">
                    
12      Clojure Assembla space
                    
13    </a>.
                    
                
TheVarExpr.cs https://github.com/christianblunden/clojure-clr.git | C# | 91 lines
                    
23
                    
24namespace clojure.lang.CljCompiler.Ast
                    
25{
                    
                
core.clj https://bitbucket.org/nickday/pubcrawler-clj | Clojure | 63 lines
                    
1(ns wwmm.pubcrawler.core
                    
2  (:require [com.twinql.clojure.http :as http])
                    
3  (:import 
                    
                
core.clj https://github.com/topher200/rsa-cryptography.git | Clojure | 62 lines
                    
2  (:use [rsa-cryptography.core] :reload)
                    
3  (:use [clojure.test]))
                    
4
                    
                
steganography.clj https://github.com/strogo/nakkaya.com.git | Clojure | 71 lines
                    
1(ns steganography
                    
2  (:use clojure.contrib.seq-utils)
                    
3  (:import (javax.imageio ImageIO)
                    
                
2018-12-11-Amazon.md https://github.com/github/dmca.git | Markdown | 25 lines
                    
10
                    
11https://github.com/rebcabin/ClojureProjects/blob/master/ws-intro/traffic.json
                    
12
                    
                
build.gradle https://github.com/jondistad/vimclojure.git | Gradle | 83 lines
                    
1usePlugin 'clojure'
                    
2
                    
2
                    
3group = 'vimclojure'
                    
4version = '2.2.0-SNAPSHOT'
                    
8gradleHomeRepo repositories
                    
9clojureSnapshotsRepo repositories
                    
10
                    
15configurations {
                    
16    clojure {
                    
17        visible = false
                    
17        visible = false
                    
18        description = 'Compile only configuration for clojure'
                    
19    }
                    
22dependencies {
                    
23    clojure 'org.clojure:clojure:1.0.0'
                    
24}
                    
                
README.md https://github.com/fukamachi/leiningen.git | Markdown | 211 lines
                    
8
                    
9Leiningen is a build tool for Clojure designed to not set your hair on fire.
                    
10
                    
12
                    
13Building Clojure projects with tools designed for Java can be an
                    
14exercise in frustration. If you use Ant, you end up copying around a
                    
20
                    
21With Leiningen, you describe your build with Clojure.
                    
22
                    
80      :url "http://github.com/technomancy/leiningen"
                    
81      :dependencies [[org.clojure/clojure "1.1.0"]
                    
82                     [org.clojure/clojure-contrib "1.1.0"]
                    
84                     [org.apache.maven/maven-ant-tasks "2.0.10"]]
                    
85      :dev-dependencies [[swank-clojure "1.2.1"]])
                    
86
                    
                
core.clj https://github.com/trydionel/misc.clj.git | Clojure | 79 lines
                    
4	analytics.clj.routing
                    
5	clojure.contrib.str-utils
                    
6	[clojure.contrib.duck-streams :only [pwd]])
                    
                
week-202.snip.markdown https://github.com/freerange/site.git | Markdown | 22 lines
                    
4
                    
5Working on [Inside Government](https://www.gov.uk/government) has been a big commitment, and has taken a bit of energy out of us as a company.  So for at least the next month we're going to concentrate on our own projects.  For the most part that means improving and promoting [Harmonia](https://harmonia.io), but also includes writing some more blog posts, attending more developer events (such as Clojure eXchange on Thursday) and organising our Christmas.
                    
6
                    
                
io.clj https://github.com/purcell/incanter.git | Clojure | 327 lines
                    
1;;; io.clj -- Data I/O library for Clojure built on CSVReader
                    
2
                    
27-ability to pretty print reports of various models
                    
28-read in clojure and json literals in different ways; files, classpath resources, etc.
                    
29-support for csv and sql
                    
31
                    
32http://stackoverflow.com/questions/613929/how-do-i-connect-to-a-mysql-database-from-clojure
                    
33
                    
64	 :only [decode-from-reader decode-from-str encode-to-str]])
                    
65  (:use [clojure.contrib.duck-streams :only [reader read-lines spit]])
                    
66  (:use [incanter.chrono :only [joda-date]])
                    
66  (:use [incanter.chrono :only [joda-date]])
                    
67  (:use [clojure.contrib.pprint :only [pprint]])
                    
68  (:use [incanter.classification :only [model-from-maps]])
                    
69  (:use [incanter.transformations :only [sort-map-of-maps all-keys]])
                    
70  (:use [clojure.contrib.java-utils :only [file]])
                    
71  (:use [clojure.contrib.sql 
                    
                
doc-1217.html https://github.com/mmcgrana/clj-doc.git | HTML | 33 lines
                    
1<div class="doc-item" id="doc-1217"><h2 class="doc-item-name">join<span class="namespace">(clojure.set)</span></h2><ul class="var-arglists"><li>(<span class="var-name">join</span> xrel yrel)</li><li>(<span class="var-name">join</span> xrel yrel km)</li></ul><div class="var-docstring"><p>When passed 2 rels, returns the rel corresponding to the natural
                    
2  join. When passed an additional keymap, joins on the corresponding
                    
                
euler19.clj https://github.com/chrisrisenhoover/Clojure-Euler.git | Clojure | 97 lines
                    
1(ns clojure-euler.euler19)
                    
2
                    
                
helpers_test.clj https://github.com/jwhitlark/tools.nrepl.git | Clojure | 48 lines
                    
10       :author "Chas Emerick"}
                    
11  clojure.tools.nrepl.helpers-test
                    
12  (:import (java.io File))
                    
12  (:import (java.io File))
                    
13  (:use [clojure.tools.nrepl-test :only (def-repl-test repl-server-fixture)]
                    
14    clojure.test)
                    
15  (:require
                    
16    [clojure.tools.nrepl :as nrepl]
                    
17    [clojure.tools.nrepl.helpers :as helpers]))
                    
38  (repl-receive (helpers/load-file-command
                    
39                  (File. "load-file-test/clojure/tools/nrepl/load_file_sample.clj")
                    
40                  (File. "load-file-test")))
                    
41  (repl-receive (helpers/load-file-command
                    
42                  (.getAbsolutePath (File. "load-file-test/clojure/tools/nrepl/load_file_sample.clj"))
                    
43                  (File. "load-file-test")))
                    
                
ob-clojure.el https://github.com/MassimoLauria/dotemacs.git | Emacs Lisp | 253 lines
                    
34
                    
35;; For clojure-mode, see https://github.com/clojure-emacs/clojure-mode
                    
36;; For cider, see https://github.com/clojure-emacs/cider
                    
49(declare-function inf-clojure-cmd "ext:inf-clojure" (project-type))
                    
50(declare-function inf-clojure-eval-string "ext:inf-clojure" (code))
                    
51(declare-function inf-clojure-project-type "ext:inf-clojure" ())
                    
172  (add-hook 'comint-preoutput-filter-functions
                    
173	    #'ob-clojure-inf-clojure-output)
                    
174  (setq ob-clojure-inf-clojure-tmp-output nil)
                    
178  (remove-hook 'comint-preoutput-filter-functions
                    
179	       #'ob-clojure-inf-clojure-output)
                    
180  ;; And return the result
                    
187		s))
                    
188	    (reverse ob-clojure-inf-clojure-tmp-output)))))
                    
189
                    
                
googlecode.css https://github.com/craveytrain/craveytrain.com.git | CSS | 144 lines
                    
65.css .hljs-function,
                    
66.clojure .hljs-attribute {
                    
67	color: #066;
                    
                
subscriptions.clj https://github.com/shenfeng/rssminer.git | Clojure | 52 lines
                    
4        [rssminer.database :only [mysql-insert-and-return]]
                    
5        [clojure.tools.logging :only [info]])
                    
6  (:require [rssminer.db.subscription :as db]
                    
7            [rssminer.db.feed :as fdb]
                    
8            [clojure.string :as str]))
                    
9
                    
                
README.md https://gitlab.com/alexkeramidas/gitlab-ce | Markdown | 84 lines
                    
23- **Scala**: [Test a Scala application](test-scala-application.md)
                    
24- **Clojure**: [Test a Clojure application](test-clojure-application.md)
                    
25- **Elixir**:
                    
                
ClojureActivatorTest.java https://github.com/Salaboy/components.git | Java | 55 lines
                    
20 */
                    
21package org.switchyard.component.clojure.deploy;
                    
22
                    
35/**
                    
36 * Functional test for ClojureActivator.
                    
37 * 
                    
41@RunWith(SwitchYardRunner.class)
                    
42@SwitchYardTestCaseConfig(config = "switchyard-clojure.xml", mixins = CDIMixIn.class)
                    
43public class ClojureActivatorTest {
                    
                
ClojureFacet.java https://github.com/Salaboy/components.git | Java | 55 lines
                    
19
                    
20package org.switchyard.tools.forge.clojure;
                    
21
                    
30/**
                    
31 * Forge facet for Clojure implementation.
                    
32 * 
                    
34 */
                    
35@Alias("switchyard.clojure")
                    
36@RequiresFacet({ DependencyFacet.class, PackagingFacet.class })
                    
37@RequiresPackagingType(PackagingType.JAR)
                    
38public class ClojureFacet extends AbstractFacet {
                    
39    
                    
39    
                    
40    private static final String CLOJURE_MAVEN_ID = "org.switchyard.components:switchyard-component-clojure";
                    
41    
                    
                
storage_test.clj https://github.com/diogok/clj-diogok-sandbox.git | Clojure | 50 lines
                    
3  (:use clj-diogok-sandbox.serializer)
                    
4  (:use [clojure.test]))
                    
5
                    
                
clojure.vim https://github.com/dzuchows/vimrc.git | Vim Script | 142 lines
                    
51
                    
52for ns in [ "clojure.core", "clojure.inspector", "clojure.java.browse",
                    
53			\ "clojure.java.io", "clojure.java.javadoc", "clojure.java.shell",
                    
53			\ "clojure.java.io", "clojure.java.javadoc", "clojure.java.shell",
                    
54			\ "clojure.main", "clojure.pprint", "clojure.repl", "clojure.set",
                    
55			\ "clojure.stacktrace", "clojure.string", "clojure.template",
                    
56			\ "clojure.test", "clojure.test.tap", "clojure.test.junit",
                    
57			\ "clojure.walk", "clojure.xml", "clojure.zip" ]
                    
58	call vimclojure#AddCompletions(ns)
                    
67
                    
68		if vimclojure#SynIdName() =~ 'clojureParen\d' && vimclojure#Yank('l', 'normal! "lyl') == '('
                    
69			return 1
                    
71
                    
72		if searchpairpos('(', '', ')', 'bWr', 'vimclojure#SynIdName() !~ "clojureParen\\d"') != [0, 0]
                    
73			return 1
                    
                
ai_test.clj https://github.com/jennifersmith/aichallenge-ants-clj.git | Clojure | 54 lines
                    
4        environment
                    
5        clojure.test
                    
6        midje.sweet))
                    
                
project.clj https://gitlab.com/snoonan99/map18xx | Clojure | 106 lines
                    
8
                    
9  :dependencies [[org.clojure/clojure "1.8.0"]
                    
10                 [org.clojure/clojurescript "1.8.51"]
                    
15  :plugins [[lein-figwheel "0.5.4-7"]
                    
16            [lein-cljsbuild "1.1.3" :exclusions [[org.clojure/clojure]]]]
                    
17
                    
90 
                    
91  ;; setting up nREPL for Figwheel and ClojureScript dev
                    
92  ;; Please see:
                    
                
eval.clj https://github.com/cemerick/leiningen.git | Clojure | 243 lines
                    
3  (:require [classlojure.core :as cl]
                    
4            [clojure.java.io :as io]
                    
5            [clojure.string :as string]
                    
79(defn- as-str [x]
                    
80  (if (instance? clojure.lang.Named x)
                    
81    (name x)
                    
105      ~@(get arch-options (:arch project))
                    
106      ~@(map d-property {:clojure.compile.path (:compile-path project)
                    
107                         (str (:name project) ".version") (:version project)
                    
108                         :file.encoding (or (System/getProperty "file.encoding") "UTF-8")
                    
109                         :clojure.debug (boolean (or (System/getenv "DEBUG")
                    
110                                                     (:debug project)))})
                    
140(defn sh
                    
141  "A version of clojure.java.shell/sh that streams out/err."
                    
142  [& cmd]
                    
                
bean.clj https://github.com/bmabey/clj-cache.git | Clojure | 58 lines
                    
11;;
                    
12;;  Modify bean attributes in clojure. Inspired by lancet.
                    
13;;
                    
18    #^{:author "Justin Balthrop"
                    
19       :doc "Modify bean attributes in clojure."}
                    
20  clj-cache.bean
                    
44
                    
45(use 'clojure.pprint)
                    
46
                    
                
entity.clj https://github.com/m0smith/topoged.git | Clojure | 292 lines
                    
1(ns topoged.test.entity  
                    
2  (:use [clojure.java.io :only [reader writer input-stream output-stream]]
                    
3	[clojure.contrib.seq-utils :only (find-first)]
                    
3	[clojure.contrib.seq-utils :only (find-first)]
                    
4	[clojure.pprint :only (pprint)]
                    
5	[topoged.file :only (copy-md5)]
                    
                
InternalNginxOutputBuffer.java https://gitlab.com/nginx-modules/nginx-clojure | Java | 155 lines
                    
11
                    
12import nginx.clojure.NginxHttpServerChannel;
                    
13
                    
                
candidate-snps.clj https://github.com/jandot/bavs.git | Clojure | 49 lines
                    
39;; diseaseA
                    
40(clojure.contrib.duck-streams/with-out-writer "analyses/candidate-snps-diseaseA.txt"
                    
41  (doseq [ind diseaseA-individuals] 
                    
47      (doseq [snp (sort-by :gene (second gene))]
                    
48        (println (clojure.string/join "\t" ["" (:group snp) (:vartype snp) (:locus snp) (:consequence snp)]))))))
                    
49
                    
                
client_middleware_test.clj https://github.com/ztellman/aleph.git | Clojure | 169 lines
                    
2  (:require [aleph.http.client-middleware :as middleware]
                    
3    [clojure.test :as t :refer [deftest is]])
                    
4  (:import java.net.URLDecoder))
                    
                
Vector`1.htm https://bitbucket.org/EHotwagner/fsharpstarterpack | HTML | 236 lines
                    
151Ordering is by insertion history.
                    
152Original F# adaptation from the clojure implementation by Steffen Forkmann. 
                    
153			</div>
                    
                
README.md https://gitlab.com/rajeshponnala/packages | Markdown | 63 lines
                    
2[](dependency)
                    
3```clojure
                    
4[cljsjs/jqgrid "5.0.1-1"] ;; latest release
                    
8This jar comes with `deps.cljs` as used by the [Foreign Libs][flibs] feature
                    
9of the Clojurescript compiler. After adding the above dependency to your project
                    
10you can require the packaged library like so:
                    
11
                    
12```clojure
                    
13(ns application.core
                    
62
                    
63[flibs]: https://github.com/clojure/clojurescript/wiki/Packaging-Foreign-Dependencies
                    
64
                    
                
security.clj https://github.com/toocito/Dark-Exchange.git | Clojure | 86 lines
                    
1(ns test.darkexchange.model.security
                    
2  (:require [clojure.contrib.logging :as logging]) 
                    
3  (:use [darkexchange.model.security])
                    
3  (:use [darkexchange.model.security])
                    
4  (:use [clojure.test])
                    
5  (:import [java.security KeyPair]))
                    
                
core.clj https://github.com/liquidz/plojuctor.git | Clojure | 91 lines
                    
2  (:use [plojuctor core sentence] :reload-all)
                    
3  (:use [clojure.test]))
                    
4
                    
                
SPANDistributionState.java https://github.com/kbagstad/aries.git | Java | 144 lines
                    
16
                    
17import clojure.lang.IFn;
                    
18
                    
33	
                    
34	public SPANDistributionState(IConcept type, int rows, int cols, IFn clojure, IContext context) {
                    
35		super(type, rows*cols, context);
                    
35		super(type, rows*cols, context);
                    
36		this.closure  = clojure;
                    
37		this.rows = rows;
                    
42		// TODO make it lazy by computing values only when getDataAsDoubles is called
                    
43		computeValues(clojure);
                    
44	}
                    
45
                    
46	private void computeValues(IFn clojure) {
                    
47		
                    
                
core_test.clj https://github.com/bertschneider/GameOfLife.git | Clojure | 58 lines
                    
2  (:use [kata4.core] :reload-all)
                    
3  (:use [clojure.test]))
                    
4
                    
                
SlurpForwardsAction.java https://github.com/jevgeni/clojure-plugin.git | Java | 57 lines
                    
15 */
                    
16package org.jetbrains.plugins.clojure.actions.editor;
                    
17
                    
22import com.intellij.psi.util.PsiTreeUtil;
                    
23import org.jetbrains.plugins.clojure.psi.ClojurePsiElement;
                    
24import org.jetbrains.plugins.clojure.psi.api.ClBraced;
                    
24import org.jetbrains.plugins.clojure.psi.api.ClBraced;
                    
25import org.jetbrains.plugins.clojure.psi.util.ClojurePsiUtil;
                    
26
                    
33 */
                    
34public final class SlurpForwardsAction extends ClojureEditorAction {
                    
35
                    
47    protected void executeWriteAction(ClBraced sexp, Editor editor, Project project, DataContext dataContext) {
                    
48      PsiElement slurpee = PsiTreeUtil.getNextSiblingOfType(sexp, ClojurePsiElement.class);
                    
49      if (slurpee == null) { return; }
                    
                
invariant_tests.clj https://github.com/goodmike/trammel.git | Clojure | 55 lines
                    
1;;; invariant_tests.clj -- Contracts programming library for Clojure
                    
2
                    
15  (:use [trammel.core :only [defconstrainedrecord]])
                    
16  (:use [clojure.test :only [deftest is]]))
                    
17
                    
36
                    
37;; testing default clojure pre/post maps
                    
38
                    
                
clojure.vim https://github.com/whalec/dotfiles.git | Vim Script | 147 lines
                    
51
                    
52for ns in [ "clojure.core", "clojure.inspector", "clojure.java.browse",
                    
53			\ "clojure.java.io", "clojure.java.javadoc", "clojure.java.shell",
                    
53			\ "clojure.java.io", "clojure.java.javadoc", "clojure.java.shell",
                    
54			\ "clojure.main", "clojure.pprint", "clojure.repl", "clojure.set",
                    
55			\ "clojure.stacktrace", "clojure.string", "clojure.template",
                    
56			\ "clojure.test", "clojure.test.tap", "clojure.test.junit",
                    
57			\ "clojure.walk", "clojure.xml", "clojure.zip" ]
                    
58	call vimclojure#AddCompletions(ns)
                    
64
                    
65	if vimclojure#util#SynIdName() =~ 'clojureParen\d' && vimclojure#util#Yank('l', 'normal! "lyl') == '('
                    
66		return 1
                    
68
                    
69	if searchpairpos('(', '', ')', 'bWr', 'vimclojure#util#SynIdName() !~ "clojureParen\\d"') != [0, 0]
                    
70		return 1
                    
                
README.md https://github.com/leadtune/clj-cache.git | Markdown | 121 lines
                    
51
                    
52This package assumes all keys and values in the cache are `java.io.Serializable`. This covers most clojure datastructures but means that different versions of clojure (e.g 1.1 and 1.2) shouldn't share the same distributed cache.
                    
53
                    
53
                    
54Internally, clj-cache uses features found in clojure to limit the number of calls to slow functions on a cache miss. Ehcache can also do this using locking. Locking in Ehcache is relatively new, requires an additional package and is not well documented. Because of this clj-cache does not yet support locking with Ehcache. However, if there is interest, locking can be added at a later date.
                    
55
                    
61default configuration or the given cache configuration.
                    
62The config can be a object of class [net.sf.ehcache.config.CacheConfiguration](http://ehcache.org/apidocs/net/sf/ehcache/config/CacheConfiguration.html) or a clojure map containing keys that correspond to the setters
                    
63of the Cache configuration. The keys are converted to camelCase internally
                    
71
                    
72Creates a new cache manager. The config can be a filename string, URL object or an InputStream containing an XML configuration. To set the configuration without using an external XML file, a clojure [prxml](http://richhickey.github.com/clojure-contrib/prxml-api.html#clojure.contrib.prxml/prxml) style datastructure can be used.
                    
73
                    
                
client_test.clj https://github.com/maxweber/clj-http.git | Clojure | 292 lines
                    
1(ns clj-http.client-test
                    
2  (:use clojure.test) 
                    
3  (:require [clj-http.client :as client]
                    
4            [clj-http.util :as util]
                    
5            [clojure.contrib.io  :as io])
                    
6  (:import (java.util Arrays)))
                    
                
project.clj https://github.com/jaycfields/expectations.git | Clojure | 45 lines
                    
4            :url "https://opensource.org/licenses/BSD-3-Clause"}
                    
5  :url "https://github.com/clojure-expectations/expectations"
                    
6  :scm {:name "git"
                    
6  :scm {:name "git"
                    
7        :url "https://github.com/clojure-expectations/expectations"}
                    
8  :jar-name "expectations.jar"
                    
10  :java-source-paths ["src/java"]
                    
11  :source-paths ["src/cljc" "src/clojure" "src/cljs"]
                    
12  :test-paths ["test/cljc" "test/clojure" "test"]
                    
21
                    
22  :profiles {:dev {:dependencies [[org.clojure/clojure "1.8.0"]
                    
23                                  [org.clojure/clojurescript "1.8.51" :scope "provided"]]
                    
                
database.clj https://github.com/andrewvc/engulf.git | Clojure | 67 lines
                    
5            [cheshire.core :as json]
                    
6            [clojure.java.jdbc :as jdbc]
                    
7            [clojure.walk :as walk])
                    
                
EditorUtils.js https://bitbucket.org/hanson/brackets.git | JavaScript | 151 lines
                    
42    require("thirdparty/CodeMirror2/mode/coffeescript/coffeescript");
                    
43    require("thirdparty/CodeMirror2/mode/clojure/clojure");
                    
44    require("thirdparty/CodeMirror2/mode/perl/perl");
                    
124        case "clj":
                    
125            return "clojure";
                    
126
                    
                
index.html https://github.com/Gonzih/gonzih.github.com.git | HTML | 114 lines
                    
35  <script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.6.0/languages/go.min.js"></script>
                    
36  <script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.6.0/languages/clojure.min.js"></script>
                    
37  <script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.6.0/languages/vim.min.js"></script>
                    
                
 

Source

Language