├── .gitignore
├── CHANGES
├── MOTIVATION
├── README.md
├── TODO
├── project.clj
├── src
    └── flutter
    │   ├── core.clj
    │   ├── html4.clj
    │   ├── html4
    │       ├── input_fields.clj
    │       ├── select.clj
    │       └── text_area.clj
    │   ├── html5.clj
    │   ├── labels.clj
    │   ├── params.clj
    │   ├── parse_shortcuts.clj
    │   ├── selected.clj
    │   ├── shortcuts.clj
    │   └── value.clj
└── test
    └── flutter
        ├── html4
            ├── test_input_fields.clj
            └── test_select.clj
        ├── test_html4.clj
        ├── test_labels.clj
        ├── test_selected.clj
        ├── test_shortcuts.clj
        └── test_value.clj


/.gitignore:
--------------------------------------------------------------------------------
1 | *~
2 | *#
3 | lib
4 | 


--------------------------------------------------------------------------------
/CHANGES:
--------------------------------------------------------------------------------
 1 | CHANGES for flutter.
 2 | 
 3 | Unreleased:
 4 | * update to clojure 1.3.0
 5 | 
 6 | v0.0.6:
 7 | * option/label fixes
 8 | 
 9 | v0.0.5:
10 | * More inline docs and marginalia improvements
11 | * Moved most of the README inline
12 | 
13 | v0.0.4:
14 | * removed dev dependency on swank-clojure
15 | 
16 | v0.0.3:
17 | * added :value and :h / :html types
18 | 
19 | v0.0.2:
20 | 
21 | * added :text-area type
22 | * split out html4 field types into flutter.html4.* sub-packages
23 | * added wrap-html4-fields & html4-fields convenience functions
24 | * added html5 input types
25 | * added hiccup style shortcuts for class and id
26 | * added more shortcuts to wrap-params
27 | * fixed bug that prevented unrecognized types from throwing exceptions
28 | * added some more documentation and a few simple examples
29 | 
30 | v0.0.1:
31 | 
32 | * initial release
33 | 


--------------------------------------------------------------------------------
/MOTIVATION:
--------------------------------------------------------------------------------
 1 | Flutter: Hiccup based HTML form fields for clojure.
 2 | 
 3 | I want forms, and I suspect you do too.
 4 | 
 5 | Things I want:
 6 | 
 7 | * All the standard HTML 4 elements with full customizing; I want to be
 8 |   able to specify classes, IDs, obscure and non-standard attributes,
 9 |   preferably with hiccup/css style #id and .class short cuts.
10 | 
11 | * Pick, choose and modify: I might not like a particular element's
12 |   generator function, so I need to be able to replace or extend it.
13 | 
14 | * Wrappers / HTML decoration: I want to be able to wrap <label>s and
15 |   validation messages around elements automatically, but sometimes I
16 |   don't want that, or I may want "loose" labels referring to IDs, and
17 |   I don't want any option to be especially cumbersome.
18 | 
19 | * HTML 5 elements and custom elements. I want the same interface to
20 |   work for current, future and custum UI elements.
21 | 
22 | * Fool proof customizable parameter/value/error passing. Give me a
23 |   simple way of passing a form-full of data to a view without a lot of
24 |   annoying (and thread-specific) bindings. And give me the option of
25 |   passing in that data in a different format without having to
26 |   re-write the core functions.
27 | 
28 | * Let me do all of the above using whatever mixture of static and
29 |   dynamic constructs are useful for the job.
30 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Flutter: Hiccup based HTML form fields for clojure.
 2 | 
 3 | Read the `MOTIVATION` file for why.
 4 | 
 5 | ## DETAILED DOCUMENTATION IS INLINE
 6 | 
 7 | This file is intended to give an overview of the design of the library
 8 | and to give a few hints on expected use cases.
 9 | 
10 | An online copy of the documentation, generated using the excellent
11 | Marginalia tool is at http://joodie.github.com/flutter/
12 | 
13 | All the useful details of the flutter API are documented as inline
14 | documention on their respective wrappers and namespaces, so please
15 | pull up the inline docs in your favorite development environment or
16 | just browse the source code if you want to know the specifics.
17 | 
18 | ## DISCLAIMER
19 | 
20 | This is a work in progress. The API may change, read the CHANGES file
21 | when upgrading. This code almost certainly contains bugs. If you find
22 | one, check the latest release or the master branch on 
23 | http://github.com/joodie/flutter and if it's not been fixed, please
24 | report any issues - preferably using a pull request on github.
25 | 
26 | ## COPYRIGHT AND LICENSE
27 | 
28 | (c) 2011 Joost Diepenmaat, Zeekat Softwareontwikkeling
29 | 
30 | http://joost.zeekat.nl/  - joost@zeekat.nl
31 | 
32 | Distributed under the Eclipse Public License, the same as Clojure.
33 | 
34 | 
35 | 


--------------------------------------------------------------------------------
/TODO:
--------------------------------------------------------------------------------
1 | TODO:
2 | 
3 | Write tests for all of the new functions.
4 | Provide lots of examples
5 | 


--------------------------------------------------------------------------------
/project.clj:
--------------------------------------------------------------------------------
1 | (defproject flutter "0.0.7"
2 |   :description "consistent, extensible, hiccup-based HTML form fields"
3 |   :dependencies [[org.clojure/clojure "1.3.0"]
4 |                  [hiccup "0.3.8"]])
5 | 
6 | 


--------------------------------------------------------------------------------
/src/flutter/core.clj:
--------------------------------------------------------------------------------
  1 | (ns flutter.core
  2 |   "## API CONCEPTS
  3 | 
  4 | There are two important concepts in the design of this library:
  5 | field functions and wrappers.
  6 | 
  7 | ### FIELD FUNCTION
  8 | 
  9 | A field function is a function that takes 5 arguments, including a
 10 | name and a value and returns a snippet of html in [hiccup](https://github.com/weavejester/hiccup) format.
 11 | 
 12 |     (field type attributes name opts value) -> snippet
 13 | 
 14 | #### arguments
 15 | 
 16 | `type` is the type of field. If you're using
 17 | `flutter.html4/html4-fields`, the recognized types are:
 18 | 
 19 |      :input, :text, :radio, :checkbox, :text-area, :select
 20 |      :hidden, :submit, :button and :image 
 21 | 
 22 | `attributes` is a map of html element attributes, that are generally
 23 | passed on to the form element that implements the field type. most
 24 | field functions modify the attributes based on the other arguments
 25 | too. For instance, field type `:text` will result in an element-name
 26 | of `:input` with additional attributes
 27 | `{:type :text :name name :value value}`. This argument may be `nil`.
 28 | 
 29 | `name` is the name of the input element for this field.
 30 | 
 31 | `opts` is type-specific. For `:radio` and `:checkbox` types, this is
 32 | the value of the value attribute. For the `:select` type as
 33 | implemented by `hiccup.html4.select/wrap-select`, it can be a rather
 34 | complex collection representing options and optgroups. This argument
 35 | may be `nil`, and is not used by all field types. Wrappers that
 36 | implement types that do require an `opts` argument should be
 37 | documented as such.
 38 | 
 39 | `value` is the value (or set, or sequence of values) associated with
 40 | name for this form. for `:radio` and `:checkbox`, this means that if opts
 41 | is in value, the input element is checked.
 42 | 
 43 | #### return value
 44 |   
 45 | For a single element, the returned hiccup snippet looks like
 46 | 
 47 |     [element-name attributes content*]
 48 | 
 49 | but fields may return something more complex.
 50 | 
 51 | ### WRAPPER FUNCTIONS
 52 | 
 53 | Like the [ring API](https://github.com/mmcgrana/ring/blob/master/SPEC), almost all functionality in flutter is implemented
 54 | in wrapper functions. In fact, the flutter.core/field function just
 55 | throws an exception when called to indicate that the requested field
 56 | is not implemented.
 57 | 
 58 | Wrapper functions can add field types, implement a more logical
 59 | interface to some existing types, change the user-visible API etc.
 60 | 
 61 | Wrapper functions can make the user-visible API a bit nicer to
 62 | look at:
 63 | 
 64 |     (ns flutter.test-shortcuts
 65 |       (:use [flutter shortcuts html4]))
 66 | 
 67 |     (let [field (-> html4-fields
 68 |                     wrap-shortcuts)]
 69 | 
 70 |        ;; generate a text input field with name \"my-name\", value
 71 |        ;; and id \"my-id\"
 72 |        (field :text#my-id \"my-name\" \"some text value\"))
 73 | 
 74 | See `flutter.html4/html4-fields` and `flutter.shortcuts/wrap-shortcuts`.
 75 | 
 76 | There's also a wrapper that can be used to provide values for field
 77 | names:
 78 | 
 79 |     (ns flutter.test-shortcuts
 80 |       (:use [flutter shortcuts html4 params]))
 81 | 
 82 |     (let [field (-> html4-fields
 83 |                     wrap-shortcuts
 84 |                     (wrap-params {:myname \"some value\")]
 85 | 
 86 |        ;; generate a text input field with name myname,
 87 |        ;; class \"my-class\" and value from params
 88 |        (field :text.my-class :myname))
 89 | 
 90 | If you create your wrapped field function in the route/controller code,
 91 | you can then pass it on to the view to provide values for the generated
 92 | form. See `flutter.params/wrap-params`.")
 93 | 
 94 | (defn field
 95 |   "throw an exception when called. can be used as the end point of
 96 | the wrapper functions"
 97 |   [type attrs name opts value]
 98 |   (throw (Exception. (str "Cannot process field with spec "
 99 |                           [type attrs name opts value]))))
100 | 
101 | 


--------------------------------------------------------------------------------
/src/flutter/html4.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.html4
 2 |   "convenience functions providing all the standard HTML fields"
 3 |   (:use flutter.core
 4 |         flutter.html4.input-fields
 5 |         flutter.html4.select
 6 |         flutter.html4.text-area))
 7 | 
 8 | (defn wrap-html4-fields
 9 |   "Provides all the HTML 4 form fields in a sane way. Includes
10 | 
11 | wrap-basic-input-fields, wrap-html4-input-fields,
12 | wrap-radio-and-checkbox, wrap-select and wrap-text-area"
13 |   [f]
14 |   (-> f
15 |       wrap-basic-input-fields
16 |       wrap-html4-input-fields
17 |       wrap-radio-and-checkbox
18 |       wrap-select
19 |       wrap-text-area))
20 | 
21 | (def html4-fields
22 |   ^{:doc "wrap-html4-fields, pre-wrapped in the core `field'"}
23 |   (wrap-html4-fields field))
24 | 


--------------------------------------------------------------------------------
/src/flutter/html4/input_fields.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.html4.input-fields
 2 |   (:use flutter.selected))
 3 | 
 4 | ;;;;
 5 | ;;;; minimal input fields that provide a given name => value pair
 6 | ;;;;
 7 | 
 8 | (defn wrap-basic-input-fields
 9 |   "accept type :input and translate straight to a hiccup [:input] element,
10 | adding name and value in attributes (which probably should include
11 |   a :type). ignores opts."
12 |   [f]
13 |   (fn [type attrs name opts value]
14 |     (if (= type :input)
15 |       [:input (assoc attrs :name name :value value)]
16 |       (f type attrs name opts value))))
17 | 
18 | (defn wrap-html4-input-fields
19 |   "provides the standard HTML 4 input types: translates types
20 |  :text :password :checkbox :radio :submit :reset :file :hidden
21 |  :image and :button to type :input.
22 | 
23 | If you want the full set of HTML 4 form fields, use `wrap-html4-fields'
24 | instead."
25 |   [f]
26 |   (fn [type attrs name opts value]
27 |     (if (#{:text :password :checkbox :radio :submit :reset
28 |            :file :hidden :image :button} type)
29 |       (f :input (assoc attrs :type type) name nil value)
30 |       (f type attrs name opts value))))
31 | 
32 | ;;;;
33 | ;;;; elements that can be used to select one or more values for a name.
34 | ;;;; 
35 | 
36 | (defn wrap-radio-and-checkbox
37 |   "provides semantics for radio and check boxes: opts
38 |  is the value given for this particular input, sets the
39 |  :checked attribute if that value is (in) the current value(s)"
40 |   [f]
41 |   (fn [type attrs name opts values]
42 |     (if (#{:radio :checkbox} type)
43 |       (f type (if (selected? opts values)
44 |                 (assoc attrs :checked :checked)
45 |                 attrs) name nil opts)
46 |       (f type attrs name opts values))))
47 | 


--------------------------------------------------------------------------------
/src/flutter/html4/select.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.html4.select
 2 |   (:use flutter.selected))
 3 | 
 4 | ;;;;
 5 | ;;;; code for &lt;select&gt; elements and its descendents
 6 | ;;;;
 7 | 
 8 | (defn- make-option*
 9 |   ([values attrs my-value label]
10 |      [:option (apply assoc attrs
11 |                 :value my-value
12 |                 (if (selected? my-value values) [:selected :selected]))
13 |       label])
14 |   ([values my-value label]
15 |      (make-option* values {} my-value label))
16 |   ([values my-value]
17 |      (make-option* values {} my-value my-value)))
18 | 
19 | (declare make-option)
20 | 
21 | (defn- make-optgroup
22 |   ([value attrs label options]
23 |      (into [:optgroup (assoc attrs :label label)]
24 |            (map #(make-option value %) options)))
25 |   ([value label options]
26 |      (make-optgroup value {} label options)))
27 | 
28 | ;; option examples:
29 | ;; [:option attrs value label ]
30 | ;; [:option value label ]
31 | ;; [:option value ]
32 | ;; :value
33 | ;; [:optgroup attrs label options ]
34 | ;; [:optgroup label options ]
35 | 
36 | (defn- make-option
37 |   [value spec]
38 |   (if (sequential? spec)
39 |     (let [type (first spec)]
40 |       (case type
41 |             :optgroup (apply make-optgroup value (rest spec))
42 |             :option   (apply make-option*  value (rest spec))))
43 |     (make-option* value spec)))
44 | 
45 | (defn wrap-select
46 |   "procide :select field. opts is a sequence of option specs:
47 | 
48 | option spec can be:
49 | 
50 |   [:option attrs value label]
51 |   [:option value label]
52 |   [:option value]
53 |   value
54 |   [:optgroup attrs label option-specs]
55 |   [:optgroup label option-specs]"
56 |   [f]
57 |   (fn [type attrs name opts value]
58 |     (if (= :select type)
59 |       (into [:select (assoc attrs :name name)]
60 |             (map #(make-option value %) opts))
61 |       (f type attrs name opts value))))
62 | 


--------------------------------------------------------------------------------
/src/flutter/html4/text_area.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.html4.text-area
 2 |   (:use [hiccup.core :only [escape-html]]))
 3 | 
 4 | (defn wrap-text-area
 5 |   "provides the :text-area element type, value is placed as the content
 6 |   and opts is ignored"
 7 |   [f]
 8 |   (fn [type attrs name opts value]
 9 |     (if (= type :text-area)
10 |       [:textarea (assoc attrs :name name) (escape-html value)]
11 |       (f type attrs name opts value))))
12 | 


--------------------------------------------------------------------------------
/src/flutter/html5.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.html5
 2 |   "HTML5 input type support")
 3 | 
 4 | (defn wrap-html5-input-fields
 5 |   "provide html5 input types:
 6 | 
 7 | :email :url :range :date :month :week :time :datetime
 8 | :datetime-local :search and :color."
 9 |   [f]
10 |   (fn [type attrs name opts value]
11 |     (if (#{:email :url :range :date :month
12 |            :week :time :datetime :datetime-local
13 |            :search :color} type)
14 |       (f :input (assoc attrs :type type) name opts value)
15 |       (f type attrs name opts value))))
16 | 


--------------------------------------------------------------------------------
/src/flutter/labels.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.labels)
 2 | 
 3 | (defn wrap-labels
 4 |   "given a labels function, wrap a [:label] tag around each field
 5 | containing the content returned by (labels name), followed by the
 6 | field. Doesn't wrap fields for which (labels name) is nil."
 7 |   [f labels]
 8 |   (fn [type attrs name opts value]
 9 |     (if-let [content (labels name)]
10 |       [:label content (f type attrs name opts value)]
11 |       (f type attrs name opts value))))
12 | 


--------------------------------------------------------------------------------
/src/flutter/params.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.params)
 2 | 
 3 | (defn wrap-params
 4 |   "given a map of name => value pairs, provide values for each field.
 5 | like wrap-optionals, attrs and opts are optional, but attrs must be a map.
 6 | 
 7 | when given the full five parameters, override the values in the params map."
 8 |   [f params]
 9 |   (fn
10 |     ([type attrs name opts value]
11 |        (f type attrs name opts value))
12 |     ([type attrs name opts]
13 |        (f type attrs name opts (params name)))
14 |     ([type a2 a3]
15 |        (if (map? a2) 
16 |          (f type a2 a3 nil (params a3))
17 |          (f type nil a2 a3 (params a2))))
18 |     ([type name]
19 |        (f type nil name nil (params name)))))
20 | 


--------------------------------------------------------------------------------
/src/flutter/parse_shortcuts.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.parse-shortcuts)
 2 | 
 3 | ;; code adapted from hiccup.core
 4 | 
 5 | (def ^{:doc "Regular expression that parses a CSS-style id and class from a tag name."}
 6 |   re-tag
 7 |   #"([^\s\.#]+)(?:#([^\s\.#]+))?(?:\.([^\s#]+))?")
 8 | 
 9 | 
10 | (defn parse-shortcuts
11 |   "Parse #id and .classes in a keyword. Returns [tag, id, classes]"
12 |   [tagname]
13 |   (let [[_ tag id class] (re-matches re-tag (name tagname))]
14 |     [(keyword tag) id (if class (.replace ^String class "." " "))]))
15 | 


--------------------------------------------------------------------------------
/src/flutter/selected.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.selected
 2 |   "tools for handling multi-valued parameters")
 3 | 
 4 | (defn selected?
 5 |   "if values is sequential or a set, check if values contains value
 6 | otherwise, check if value is equal to values"
 7 |   [value values]
 8 |   (if (sequential? values)
 9 |     (contains? (set values) value)
10 |     (if (set? values)
11 |       (contains? values value)
12 |       (= values value))))
13 | 


--------------------------------------------------------------------------------
/src/flutter/shortcuts.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.shortcuts
 2 |   "provide shortened function signatures with hiccup-style shortcuts for classes and ids"
 3 |   (:use flutter.parse-shortcuts))
 4 | 
 5 | (defn wrap-id-and-class-shortcuts
 6 |   "parse css-style #id and .class from the field type, like hiccup."
 7 |   [f]
 8 |   (fn [type attrs & args]
 9 |     (let [[tag id class] (parse-shortcuts type)
10 |           attr-with-id (if id (assoc attrs :id id) attrs)
11 |           attr-with-classes (if class (assoc attr-with-id :class class) attr-with-id)]
12 |       (apply f tag attr-with-classes args))))
13 | 
14 | (defn wrap-optionals
15 |   "make attrs and opts optional
16 | 
17 |  (f type name value) -> (f type nil name nil value)
18 | 
19 |  if attrs is a map:
20 |  (f type attrs name value) -> (f type attr name nil value)
21 |  else:
22 |  (f type name opts value) -> (f type nil name opts value)"
23 |   [f]
24 |   (fn
25 |     ([type attr name opts value]
26 |        (f type attr name opts value))
27 |     ([type name value]
28 |        (f type nil name nil value))
29 |     ([type a2 a3 value]
30 |        (if (map? a2)
31 |          (f type a2 a3 nil value)
32 |          (f type nil a2 a3 value)))))
33 | 
34 | (defn wrap-shortcuts
35 |   "make attrs and opts optional and allows hiccup-style #id and .class
36 | shortcuts for type.
37 | See wrap-optionals and wrap-id-and-class-shortcuts"
38 |   [f]
39 |   (-> f
40 |       wrap-id-and-class-shortcuts
41 |       wrap-optionals))
42 | 


--------------------------------------------------------------------------------
/src/flutter/value.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.value
 2 |   (:use [hiccup.core :only [escape-html]]))
 3 | 
 4 | (defn wrap-value
 5 |   "Adds flutter type :value, which just returns the value passed in"
 6 |   [f]
 7 |   (fn [type attrs name opts value]
 8 |     (if (= type :value)
 9 |       value
10 |       (f type attrs name opts value))))
11 | 
12 | (defn wrap-value-as-html
13 |   "Adds flutter types :html and :h, returning the given value, html-encoded"
14 |   [f]
15 |   (fn [type attrs name opts value]
16 |     (if (or (= type :h)
17 |             (= type :html))
18 |       (escape-html value)
19 |       (f type attrs name opts value))))
20 | 


--------------------------------------------------------------------------------
/test/flutter/html4/test_input_fields.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.html4.test-input-fields
 2 |   (:use flutter.core
 3 |         flutter.html4.input-fields
 4 |         clojure.test))
 5 | 
 6 | (deftest basic
 7 |   (let [field (-> field
 8 |                   wrap-basic-input-fields)]
 9 |     (is (= (field :input {:type :text} :my-name nil :my-value)
10 |            [:input {:type :text :name :my-name :value :my-value}]))
11 | 
12 |     (is (thrown? Exception (field :no-such-type {} :name :value)))))
13 | 
14 | (deftest input-types
15 |   (let [field (-> field
16 |                   wrap-basic-input-fields
17 |                   wrap-html4-input-fields
18 |                   wrap-radio-and-checkbox)]
19 |     (is (= (field :radio {} :my-name :val :val)
20 |            [:input {:type :radio :name :my-name
21 |                     :value :val :checked :checked}]))
22 |     (is (= (field :checkbox {} :my-name :val [:val1 :val2])
23 |            [:input {:type :checkbox :name :my-name
24 |                     :value :val}]))
25 |     (is (= (field :checkbox {} :my-name :val [:val1 :val2 :val])
26 |            [:input {:type :checkbox :name :my-name
27 |                     :value :val :checked :checked}]))))
28 | 


--------------------------------------------------------------------------------
/test/flutter/html4/test_select.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.html4.test-select
 2 |   (:use flutter.html4.select
 3 |         flutter.core
 4 |         clojure.test))
 5 | 
 6 | (deftest select
 7 |   (let [field (-> field
 8 |                   wrap-select)]
 9 |     (is (= (field :select
10 |                   {}
11 |                   :my-name
12 |                   [:v1 :v2 :v3]
13 |                   :v2)
14 |            [:select {:name :my-name}
15 |             [:option {:value :v1} :v1]
16 |             [:option {:value :v2 :selected :selected} :v2]
17 |             [:option {:value :v3} :v3]]))
18 |     (is (= (field :select
19 |                   {}
20 |                   :my-name
21 |                   [:v0 [:optgroup :label [:v1 :v2 :v3]]]
22 |                   :v2)
23 |            [:select {:name :my-name}
24 |             [:option {:value :v0} :v0]
25 |             [:optgroup {:label :label}
26 |              [:option {:value :v1} :v1]
27 |              [:option {:value :v2 :selected :selected} :v2]
28 |              [:option {:value :v3 } :v3]]]))
29 |     
30 |     (is (= (field :select {:multiple :multiple}
31 |                   :my-name
32 |                   [:v1
33 |                    [:option :v2]
34 |                    [:option {:class :my-class} :v3 :my-label]
35 |                    [:optgroup :group-label
36 |                     [:v4
37 |                      [:option :v5]
38 |                      [:option {:class :my-class} :v6 :my-label]]]]
39 |                   [:v2 :v6])
40 |            [:select {:name :my-name :multiple :multiple}
41 |             [:option {:value :v1} :v1]
42 |             [:option {:value :v2 :selected :selected} :v2]
43 |             [:option {:value :v3 :class :my-class} :my-label]
44 |             [:optgroup {:label :group-label}
45 |              [:option {:value :v4} :v4]
46 |              [:option {:value :v5} :v5]
47 |              [:option {:value :v6 :class :my-class
48 |                        :selected :selected} :my-label]]]))))


--------------------------------------------------------------------------------
/test/flutter/test_html4.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.test-html4
 2 |   (:use flutter.html4
 3 |         clojure.test))
 4 | 
 5 | (deftest html4
 6 |   (let [field html4-fields]
 7 |     (is (= (field :text-area nil :my-name nil "<content>")
 8 |            [:textarea {:name :my-name} "&lt;content&gt;"]))
 9 |     (is (thrown? Exception (field :no-such-type nil :name nil nil)))))
10 | 
11 | 
12 | 


--------------------------------------------------------------------------------
/test/flutter/test_labels.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.test-labels
 2 |   (:use clojure.test
 3 |         flutter.core
 4 |         flutter.html4.input-fields
 5 |         flutter.labels))
 6 | 
 7 | (deftest labels
 8 |   (let [field (-> field
 9 |                   wrap-basic-input-fields
10 |                   (wrap-labels {:my-name "Label"}))]
11 |     (is (= (field :input {:type :text} :my-name nil "val")
12 |            [:label "Label" [:input {:type :text :name :my-name :value "val"}]]))
13 |     (is (= (field :input {:type :text} :other-name nil "val")
14 |            [:input {:type :text :name :other-name :value "val"}]))))
15 | 
16 | 


--------------------------------------------------------------------------------
/test/flutter/test_selected.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.test-selected
 2 |   (:use flutter.selected
 3 |         clojure.test))
 4 | 
 5 | (deftest selected
 6 |   (is (selected? :val :val))
 7 |   (is (selected? :val [:val]))
 8 |   (is (selected? :val [:v1 :v2 :val]))
 9 |   (is (selected? :val #{:v1 :v2 :val}))
10 |   (is (not (selected? :val :v2)))
11 |   (is (not (selected? :val [])))
12 |   (is (not (selected? :val [:v1 :v2])))
13 |   (is (not (selected? :val #{:v2 :v1}))))
14 | 
15 | 


--------------------------------------------------------------------------------
/test/flutter/test_shortcuts.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.test-shortcuts
 2 |   (:use [flutter shortcuts html4 params]
 3 |         clojure.test))
 4 | 
 5 | (deftest shortcuts
 6 |   (let [field (-> html4-fields
 7 |                   wrap-shortcuts)]
 8 |     (is (= (field :text#my-id.my-class {:onclick "click"} :my-name nil :my-value)
 9 |            [:input {:class "my-class"
10 |                  :id "my-id"
11 |                  :type :text
12 |                  :onclick "click"
13 |                  :name :my-name
14 |                  :value :my-value}]))
15 |     (is (= (field :input {:type :text} :my-name nil :my-value)
16 |            [:input {:type :text
17 |                  :name :my-name
18 |                  :value :my-value}]))
19 | 
20 |     (is (= (field :text-area#my-id nil :my-name nil "content")
21 |            [:textarea {:id "my-id" :name :my-name} "content"]))
22 | 
23 |     (is (= (field :submit.special :my-name :val)
24 |            [:input {:type :submit :name :my-name
25 |                     :class "special" :value :val}]))))
26 | 
27 | 
28 | (deftest with-params
29 |   (let [field (-> html4-fields
30 |                   wrap-shortcuts
31 |                   (wrap-params {:my-name :my-val
32 |                                 :other-name 2}))]
33 |     (is (= (field :text :my-name)
34 |            [:input {:type :text :name :my-name :value :my-val}]))
35 |     (is (= (field :text.cls {:onclick "click"} :other-name)
36 |            [:input {:type :text :class "cls" :onclick "click"
37 |                     :name :other-name :value 2}]))
38 |     (is (= (field :radio :other-name 2)
39 |            [:input {:type :radio :name :other-name
40 |                     :value 2 :checked :checked}]))))
41 | 
42 | 


--------------------------------------------------------------------------------
/test/flutter/test_value.clj:
--------------------------------------------------------------------------------
 1 | (ns flutter.test-value
 2 |   (:use flutter.value
 3 |         flutter.core
 4 |         clojure.test))
 5 | 
 6 | (deftest value
 7 |   (let [f (wrap-value field)]
 8 |     (is (= "foo<bar>" (f :value nil nil nil "foo<bar>")))))
 9 | 
10 | 
11 | (deftest html
12 |   (let [f (wrap-value-as-html field)]
13 |     (is (= "foo&lt;bar&gt;" (f :h nil nil nil "foo<bar>")))))
14 | 
15 | 


--------------------------------------------------------------------------------