clementine 0.0.1 → 0.0.2

data/ext/clojure-clojurescript-bef56a7/test/cljs/cljs/import_test.cljs

@@ -0,0 +1,11 @@
+(ns cljs.import-test
+  (:import goog.math.Long
+           cljs.import-test.foo.Bar
+           cljs.import-test.foo.Quux))
+
+(defn test-import []
+  (assert (fn? Long))
+  (assert (.equals (Long. 4 6) (.add (Long. 1 2) (Long. 3 4))))
+  (assert (= "12" (Long/fromInt 12)))
+  (assert (= 12 (.-x (Bar. 12))))
+  (assert (= 12 (.-x (Quux. 12)))))

data/ext/clojure-clojurescript-bef56a7/test/cljs/cljs/import_test/foo.cljs

@@ -0,0 +1,5 @@
+(ns cljs.import-test.foo)
+
+(defrecord Bar [x])
+
+(deftype Quux [x])

data/ext/clojure-clojurescript-bef56a7/test/cljs/cljs/letfn_test.cljs

@@ -0,0 +1,19 @@
+(ns cljs.letfn-test)
+
+(defn test-letfn []
+  (letfn [(ev? [x]
+            (if (zero? x)
+              true
+              (od? (dec x))))
+          (od? [x]
+            (if (zero? x)
+              false
+              (ev? (dec x))))]
+    (assert (ev? 0))
+    (assert (ev? 10))
+    (assert (not (ev? 1)))
+    (assert (not (ev? 11)))
+    (assert (not (od? 0)))
+    (assert (not (od? 10)))
+    (assert (od? 1))
+    (assert (od? 11))))

data/ext/clojure-clojurescript-bef56a7/test/cljs/cljs/macro_test.cljs

@@ -0,0 +1,6 @@
+(ns cljs.macro-test
+  (:refer-clojure :exclude [==])
+  (:use-macros [cljs.macro-test.macros :only [==]]))
+
+(defn test-macros []
+  (assert (= (== 1 1) 2)))

data/ext/clojure-clojurescript-bef56a7/test/cljs/cljs/macro_test/macros.clj

@@ -0,0 +1,5 @@
+(ns cljs.macro-test.macros
+  (:refer-clojure :exclude [==]))
+
+(defmacro == [a b]
+  `(+ ~a ~b))

data/ext/clojure-clojurescript-bef56a7/test/cljs/cljs/ns_test.cljs

@@ -0,0 +1,14 @@
+(ns cljs.ns-test
+  (:refer-clojure :exclude [+])
+  (:require [cljs.ns-test.foo :refer [baz]])
+  (:use [cljs.ns-test.bar :only [quux]]))
+
+(def + -)
+
+(defn test-ns []
+  (assert (= 4 (clojure.core/+ 2 1 1)))
+  (assert (= 0 (cljs.ns-test/+ 2 1 1)))
+  (assert (= 0 (+ 2 1 1)))
+  (assert (= 123 (baz)))
+  (assert (= 123 (quux)))
+  :ok)

data/ext/clojure-clojurescript-bef56a7/test/cljs/cljs/ns_test/bar.cljs

@@ -0,0 +1,3 @@
+(ns cljs.ns-test.bar)
+
+(defn quux [] 123)

data/ext/clojure-clojurescript-bef56a7/test/cljs/cljs/ns_test/foo.cljs

@@ -0,0 +1,7 @@
+(ns cljs.ns-test.foo)
+
+(defn baz [] 123)
+
+(def kw ::foo)
+
+(assert (= (str kw) ":cljs.ns-test.foo/foo"))

data/ext/clojure-clojurescript-bef56a7/test/cljs/cljs/reader_test.cljs

@@ -0,0 +1,124 @@
+(ns cljs.reader-test
+  (:require [cljs.reader :as reader]
+            [goog.object :as o]))
+
+(deftype T [a b])
+(defrecord R [a b])
+
+(defn test-reader
+  []
+  (assert (= 1 (reader/read-string "1")))
+  (assert (= 2 (reader/read-string "#_nope 2")))
+  (assert (= -1 (reader/read-string "-1")))
+  (assert (= -1.5 (reader/read-string "-1.5")))
+  (assert (= [3 4] (reader/read-string "[3 4]")))
+  (assert (= "foo" (reader/read-string "\"foo\"")))
+  (assert (= :hello (reader/read-string ":hello")))
+  (assert (= 'goodbye (reader/read-string "goodbye")))
+  (assert (= #{1 2 3} (reader/read-string "#{1 2 3}")))
+  (assert (= '(7 8 9) (reader/read-string "(7 8 9)")))
+  (assert (= '(deref foo) (reader/read-string "@foo")))
+  (assert (= '(quote bar) (reader/read-string "'bar")))
+  (assert (= 'foo/bar (reader/read-string "foo/bar")))
+  (assert (= \a (reader/read-string "\\a")))
+  (assert (= {:tag 'String} (meta (reader/read-string "^String {:a 1}"))))
+  (assert (= [:a 'b #{'c {:d [:e :f :g]}}]
+               (reader/read-string "[:a b #{c {:d [:e :f :g]}}]")))
+  (assert (= :foo/bar (reader/read-string ":foo/bar")))
+  (assert (= nil (reader/read-string "nil")))
+  (assert (= true (reader/read-string "true")))
+  (assert (= false (reader/read-string "false")))
+  (assert (= "string" (reader/read-string "\"string\"")))
+  (assert (= "escape chars \t \r \n \\ \" \b \f" (reader/read-string "\"escape chars \\t \\r \\n \\\\ \\\" \\b \\f\"")))
+
+  ;; queue literals
+  (assert (= cljs.core.PersistentQueue/EMPTY
+             (reader/read-string "#queue []")))
+
+  (assert (= (-> cljs.core.PersistentQueue/EMPTY (conj 1))
+             (reader/read-string "#queue [1]")))
+
+  (assert (= (into cljs.core.PersistentQueue/EMPTY [1 2])
+             (reader/read-string "#queue [1 2]")))
+
+  ;; inst
+  (let [est-inst (reader/read-string "#inst \"2010-11-12T13:14:15.666-05:00\"")
+        utc-inst (reader/read-string "#inst \"2010-11-12T18:14:15.666-00:00\"")]
+
+    (assert (= (.valueOf (js/Date. "2010-11-12T13:14:15.666-05:00"))
+               (.valueOf est-inst)))
+
+    (assert (= (.valueOf est-inst)
+               (.valueOf (reader/read-string (pr-str est-inst)))))
+
+    (assert (= (.valueOf est-inst)
+               (.valueOf utc-inst)))
+
+    (doseq [month (range 1 13) day (range 1 29) hour (range 1 23)]
+      (let [s (str "#inst \"2010-" month "-" day "T" hour ":14:15.666-06:00\"")]
+        (assert (= (-> s reader/read-string .valueOf)
+                   (-> s reader/read-string pr-str reader/read-string .valueOf))))))
+
+  ;; uuid literals
+  (let [u (reader/read-string "#uuid \"550e8400-e29b-41d4-a716-446655440000\"")]
+    (assert (= u (reader/read-string "#uuid \"550e8400-e29b-41d4-a716-446655440000\"")))
+
+    (assert (not (identical? u (reader/read-string "#uuid \"550e8400-e29b-41d4-a716-446655440000\""))))
+
+    (assert (= u (-> u pr-str reader/read-string))))
+  
+  ;; new tag parsers
+
+  (reader/register-tag-parser! 'foo identity)
+
+  (assert (= [1 2] (reader/read-string "#foo [1 2]")))
+
+  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+  ;; Unicode Tests
+
+  ; sample unicode strings, symbols, keywords
+  (doseq [unicode
+          ["اختبار"     ; arabic
+           "ทดสอบ"      ; thai
+               "こんにちは"     ; japanese hiragana
+           "你好"        ; chinese traditional
+           "אַ גוט יאָר"  ; yiddish
+           "cześć"      ; polish
+           "привет"     ; russian
+
+           ;; RTL languages skipped below because tricky to insert
+           ;;  ' and : at the "start"
+
+           'ทดสอบ
+               'こんにちは
+           '你好
+           'cześć
+           'привет
+
+           :ทดสอบ
+               :こんにちは
+           :你好
+           :cześć
+           :привет
+
+         ;compound data
+         {:привет :ru "你好" :cn}
+         ]]
+    (let [input (pr-str unicode)
+          read  (reader/read-string input)]
+      (assert (= unicode read)
+              (str "Failed to read-string \"" unicode "\" from: " input))))
+
+  ; unicode error cases
+  (doseq [unicode-error
+          ["\"abc \\ua\""           ; truncated
+           "\"abc \\x0z  ...etc\""  ; incorrect code
+           "\"abc \\u0g00 ..etc\""  ; incorrect code
+           ]]
+    (let [r (try
+              (reader/read-string unicode-error)
+              :failed-to-throw
+              (catch js/Error e :ok))]
+      (assert (= r :ok) (str "Failed to throw reader error for: " unicode-error))))
+
+  :ok)

data/ext/clojure-clojurescript-bef56a7/test/cljs/clojure/data_test.cljs

@@ -0,0 +1,22 @@
+(ns clojure.data-test
+  (:require [clojure.data :refer [diff]]))
+
+(defn test-data []
+  (assert (= [nil nil nil] (diff nil nil)))
+  (assert (= [1 2 nil] (diff 1 2)))
+  (assert (= [nil nil [1 2 3]] (diff [1 2 3] '(1 2 3))))
+  (assert (= [1 [:a :b] nil] (diff 1 [:a :b])))
+  (assert (= [{:a 1} :b nil] (diff {:a 1} :b)))
+  (assert (= [:team #{:p1 :p2} nil] (diff :team #{:p1 :p2})))
+  (assert (= [{0 :a} [:a] nil] (diff {0 :a} [:a])))
+  (assert (= [nil [nil 2] [1]] (diff [1] [1 2])))
+  (assert (= [nil nil [1 2]] (diff [1 2] (into-array [1 2]))))
+  (assert (= [#{:a} #{:b} #{:c :d}] (diff #{:a :c :d} #{:b :c :d})))
+  (assert (= [nil nil {:a 1}] (diff {:a 1} {:a 1})))
+  (assert (= [{:a #{2}} {:a #{4}} {:a #{3}}] (diff {:a #{2 3}} {:a #{3 4}})))
+  (assert (= [nil nil [1 2]] (diff [1 2] (into-array [1 2]))))
+  (assert (= [nil nil [1 2]] (diff (into-array [1 2]) [1 2])))
+  (assert (= [{:a {:c [1]}} {:a {:c [0]}} {:a {:c [nil 2] :b 1}}]
+             (diff {:a {:b 1 :c [1 2]}} {:a {:b 1 :c [0 2]}})))
+  (assert (= [{:a nil} {:a false} {:b nil :c false}]
+             (diff {:a nil :b nil :c false} {:a false :b nil :c false}))))

data/ext/clojure-clojurescript-bef56a7/test/cljs/clojure/string_test.cljs

@@ -0,0 +1,97 @@
+(ns clojure.string-test
+  (:require [clojure.string :as s]))
+
+(defn test-string
+  []
+  ;; reverse
+  (assert (= "" (s/reverse "")))
+  (assert (= "tab" (s/reverse "bat")))
+  ;; replace
+  (assert (= "faabar" (s/replace "foobar" \o \a)))
+  (assert (= "barbarbar" (s/replace "foobarfoo" "foo" "bar")))
+  (assert (= "FOObarFOO" (s/replace "foobarfoo" #"foo" s/upper-case)))
+  (assert (= "barbar)foo" (s/replace "foo(bar)foo" "foo(" "bar")))
+  ;; join
+  (assert (= "" (s/join nil)))
+  (assert (= "" (s/join [])))
+  (assert (= "1" (s/join [1])))
+  (assert (= "12" (s/join [1 2])))
+  (assert (= "1,2,3" (s/join \, [1 2 3])))
+  (assert (= "" (s/join \, [])))
+  (assert (= "1 and-a 2 and-a 3" (s/join " and-a " [1 2 3])))
+  ;; capitalize
+  (assert (= "FOOBAR" (s/upper-case "Foobar")))
+  (assert (= "foobar" (s/lower-case "FooBar")))
+  (assert (= "Foobar" (s/capitalize "foobar")))
+  (assert (= "Foobar" (s/capitalize "FOOBAR")))
+  ;; split
+  (assert (= ["a" "b"] (s/split "a-b" #"-")))
+  (assert (= ["a" "b" "c"] (s/split "a-b-c" #"-" -1)))
+  (assert (= ["a" "b" "c"] (s/split "a-b-c" #"-" 0)))
+  (assert (= ["a-b-c"] (s/split "a-b-c" #"-" 1)))
+  (assert (= ["a" "b-c"] (s/split "a-b-c" #"-" 2)))
+  (assert (= ["a" "b" "c"] (s/split "a-b-c" #"-" 3)))
+  (assert (= ["a" "b" "c"] (s/split "a-b-c" #"-" 4)))
+  (assert (vector? (s/split "abc" #"-")))
+  (assert (= ["a-b-c"] (s/split "a-b-c" #"x" 2)))
+  ;; split-lines
+  (let [result (s/split-lines "one\ntwo\r\nthree")]
+    (assert (= ["one" "two" "three"] result))
+    (assert (vector? result)))
+  (assert (= (list "foo") (s/split-lines "foo")))
+  ;; blank
+  (assert (s/blank? nil))
+  (assert (s/blank? ""))
+  (assert (s/blank? " "))
+  (assert (s/blank? " \t \n  \r "))
+  (assert (not (s/blank? "  foo  ")))
+  ;; escape
+  (assert (= "<foo&bar>"
+             (s/escape "<foo&bar>" {\& "&amp;" \< "&lt;" \> "&gt;"})))
+  (assert (= " \\\"foo\\\" "
+             (s/escape " \"foo\" " {\" "\\\""})))
+  (assert (= "faabor"
+             (s/escape "foobar" {\a \o, \o \a})))
+  ;; replace-first
+  (assert (= "barbarfoo" (s/replace-first "foobarfoo" "foo" "bar")))
+  (assert (= "barbarfoo" (s/replace-first "foobarfoo" #"foo" "bar")))
+  (assert (= "z.ology" (s/replace-first "zoology" \o \.)))
+  (assert (= "FOObarfoo" (s/replace-first "foobarfoo" #"foo" s/upper-case)))
+  ;; trim
+  (assert (= "foo " (s/triml " foo ")))
+  (assert (= "" (s/triml "   ")))
+  (assert (= " foo" (s/trimr " foo ")))
+  (assert (= "" (s/trimr "   ")))
+  (assert (= "foo" (s/trim "  foo  \r\n")))
+  ;; trim-newline
+  (assert (= "foo" (s/trim-newline "foo\n")))
+  (assert (= "foo" (s/trim-newline "foo\r\n")))
+  (assert (= "foo" (s/trim-newline "foo")))
+  (assert (= "foo\r " (s/trim-newline "foo\r ")))
+  (assert (= "" (s/trim-newline "")))
+  :ok)
+
+(comment
+
+(deftest char-sequence-handling
+  (are [result f args] (let [[^CharSequence s & more] args]
+                         (= result (apply f (StringBuffer. s) more)))
+       "paz" s/reverse ["zap"]
+       "foo:bar" s/replace ["foo-bar" \- \:]
+       "ABC" s/replace ["abc" #"\w" s/upper-case]
+       "faa" s/replace ["foo" #"o" (StringBuffer. "a")]
+       "baz::quux" s/replace-first ["baz--quux" #"--" "::"]
+       "baz::quux" s/replace-first ["baz--quux" (StringBuffer. "--") (StringBuffer. "::")]
+       "zim-zam" s/replace-first ["zim zam" #" " (StringBuffer. "-")]
+       "Pow" s/capitalize ["POW"]
+       "BOOM" s/upper-case ["boom"]
+       "whimper" s/lower-case ["whimPER"]
+       ["foo" "bar"] s/split ["foo-bar" #"-"]
+       "calvino" s/trim ["  calvino  "]
+       "calvino  " s/triml ["  calvino  "]
+       "  calvino" s/trimr ["  calvino  "]
+       "the end" s/trim-newline ["the end\r\n\r\r\n"]
+       true s/blank? [" "]
+       ["a" "b"] s/split-lines ["a\nb"]
+       "fa la la" s/escape ["fo lo lo" {\o \a}]))
+)

data/ext/clojure-clojurescript-bef56a7/test/cljs/foo/ns_shadow_test.cljs

@@ -0,0 +1,9 @@
+(ns foo.ns-shadow-test)
+
+(defn bar [] 1)
+
+(defn quux [foo]
+  (+ (foo.ns-shadow-test/bar) foo))
+
+(defn test-shadow []
+  (assert (= (quux 2) 3)))

data/ext/clojure-clojurescript-bef56a7/test/cljs/test_runner.cljs

@@ -0,0 +1,26 @@
+(ns test-runner
+  (:require [cljs.core-test :as core-test]
+            [cljs.reader-test :as reader-test]
+            [cljs.binding-test :as binding-test]
+            [cljs.ns-test :as ns-test]
+            [clojure.string-test :as string-test]
+            [clojure.data-test :as data-test]
+            [cljs.macro-test :as macro-test]
+            [cljs.letfn-test :as letfn-test]
+            [foo.ns-shadow-test :as ns-shadow-test]))
+
+(set! *print-fn* js/print)
+
+(core-test/test-stuff)
+(reader-test/test-reader)
+(string-test/test-string)
+(data-test/test-data)
+(binding-test/test-binding)
+(ns-test/test-ns)
+(macro-test/test-macros)
+(letfn-test/test-letfn)
+(ns-shadow-test/test-shadow)
+
+(println "Tests completed without exception")
+
+

data/lib/clementine.rb

@@ -1,27 +1,6 @@
 require 'rubygems'
 require "clementine/version"
 require 'clementine/options'
-
-if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-  require "java"
-
-  CLOJURESCRIPT_HOME = File.dirname(__FILE__) + "/../vendor/assets"
-  $: << CLOJURESCRIPT_HOME + "/lib"
-  require 'clojure'
-
-  %w{compiler.jar goog.jar js.jar}.each {|name| $CLASSPATH << CLOJURESCRIPT_HOME + "/lib/" + name}
-  %w{clj cljs}.each {|path| $CLASSPATH << CLOJURESCRIPT_HOME + "/src/" + path}
-
-  require "clementine/clojurescript_engine"
-  require "clementine/clojurescript_template"
-  require "clementine/clementine_rails" if defined?(Rails)
-end
-if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby"
-  CLOJURESCRIPT_HOME = File.dirname(__FILE__) + "/../vendor/assets"
-  CLASSPATH = []
-  %w{clojure.jar compiler.jar goog.jar js.jar}.each {|name| CLASSPATH << CLOJURESCRIPT_HOME + "/lib/" + name}
-  %w{clj cljs}.each {|path| CLASSPATH << CLOJURESCRIPT_HOME + "/src/" + path}
-  require "clementine/clojurescript_engine_mri"
-  require "clementine/clojurescript_template"
-  require "clementine/clementine_rails" if defined?(Rails)
-end
+require 'clementine/clojurescript_engine'
+require "clementine/clojurescript_template"
+require "clementine/clementine_rails" if defined?(Rails)

data/lib/clementine/clojurescript_engine.rb

@@ -1,49 +1,10 @@
-%w{RT Keyword PersistentHashMap}.each do |name|
-  java_import "clojure.lang.#{name}"
+CLOJURESCRIPT_HOME = File.join(File.dirname(__FILE__), "../../ext/clojure-clojurescript-bef56a7")
+CLOJURESCRIPT_LIB = File.join(File.dirname(__FILE__), "../")
+
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+  require "clementine/clojurescript_engine/jruby"
+elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby"
+  require "clementine/clojurescript_engine/mri"
+else
+  raise LoadError, "No ClojureScriptEngine implementation for this ruby."
 end
-
-module Clementine
-
-  class ClojureScriptEngine
-    def initialize(file, options)
-      @file = file
-      @options = options
-    end
-
-    def compile
-      @options = Clementine.options if @options.empty?
-      cl_opts = PersistentHashMap.create(convert_options(@options))
-      RT.loadResourceScript("cljs/closure.clj")
-      builder = RT.var("cljs.closure", "build")
-      builder.invoke(@file, cl_opts)
-    end
-
-    #private
-    def convert_options(options)
-      opts = {}
-      options = options.empty? ? default_opts : options
-      options.each do |k, v|
-        cl_key = Keyword.intern(Clementine.ruby2clj(k.to_s))
-        case
-          when (v.kind_of? Symbol)
-            cl_value = Keyword.intern(Clementine.ruby2clj(v.to_s))
-          else
-            cl_value = v
-        end
-        opts[cl_key] = cl_value
-      end
-      opts
-    end
-
-    def default_opts
-      key = "output_dir"
-      value = ""
-      if defined?(Rails)
-        value = File.join(Rails.root, "app", "assets", "javascripts", "clementine")
-      else
-        value = Dir.pwd
-      end
-      {key => value}
-    end
-  end
-end