├── .gitignore
├── test
    └── om_sync
    │   └── core_test.clj
├── project.clj
├── src
    └── om_sync
    │   ├── util.cljs
    │   └── core.cljs
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
 1 | app.js
 2 | out
 3 | /target
 4 | /classes
 5 | /checkouts
 6 | pom.xml
 7 | pom.xml.asc
 8 | *.jar
 9 | *.class
10 | /.lein-*
11 | /.nrepl-port
12 | 


--------------------------------------------------------------------------------
/test/om_sync/core_test.clj:
--------------------------------------------------------------------------------
1 | (ns om-sync.core-test
2 |   (:require [clojure.test :refer :all]
3 |             [om-sync.core :refer :all]))
4 | 
5 | (deftest a-test
6 |   (testing "FIXME, I fail."
7 |     (is (= 0 1))))
8 | 


--------------------------------------------------------------------------------
/project.clj:
--------------------------------------------------------------------------------
 1 | (defproject om-sync "0.1.1"
 2 |   :description "A sync component for Om"
 3 |   :url "http://github.com/swannodette/om-sync"
 4 |   :license {:name "Eclipse Public License"
 5 |             :url "http://www.eclipse.org/legal/epl-v10.html"}
 6 | 
 7 |   :dependencies [[org.clojure/clojure "1.5.1"]
 8 |                  [org.clojure/clojurescript "0.0-2156" :scope "provided"]
 9 |                  [org.clojure/core.async "0.1.278.0-76b25b-alpha" :scope "provided"]
10 |                  [om "0.5.0" :scope "provided"]]
11 | 
12 |   :plugins [[lein-cljsbuild "1.0.2"]]
13 | 
14 |   :cljsbuild { 
15 |     :builds [{:id "test"
16 |               :source-paths ["src"]
17 |               :compiler {
18 |                 :output-to "app.js"
19 |                 :output-dir "out"
20 |                 :optimizations :none
21 |                 :source-map true}}]})
22 | 


--------------------------------------------------------------------------------
/src/om_sync/util.cljs:
--------------------------------------------------------------------------------
 1 | (ns om-sync.util
 2 |   (:require [cljs.reader :as reader]
 3 |             [goog.events :as events])
 4 |   (:import [goog.net XhrIo]
 5 |            goog.net.EventType
 6 |            [goog.events EventType]))
 7 | 
 8 | (defn popn [n v]
 9 |   (loop [n n res v]
10 |     (if (pos? n)
11 |       (recur (dec n) (pop res))
12 |       res)))
13 | 
14 | (defn sub [p0 p1]
15 |   (vec (drop (- (count p0) (count p1)) p0)))
16 | 
17 | (defn tx-tag [{:keys [tag] :as tx-data}]
18 |   (if (keyword? tag)
19 |     tag
20 |     (first tag)))
21 | 
22 | (defn subpath? [a b]
23 |   (= a (popn (- (count b) (count a)) b)))
24 | 
25 | (defn error? [res]
26 |   (contains? res :error))
27 | 
28 | (def ^:private meths
29 |   {:get "GET"
30 |    :put "PUT"
31 |    :post "POST"
32 |    :delete "DELETE"})
33 | 
34 | (defn edn-xhr [{:keys [method url data on-complete on-error]}]
35 |   (let [xhr (XhrIo.)]
36 |     (events/listen xhr goog.net.EventType.SUCCESS
37 |       (fn [e]
38 |         (on-complete (reader/read-string (.getResponseText xhr)))))
39 |     (events/listen xhr goog.net.EventType.ERROR
40 |       (fn [e]
41 |         (on-error {:error (.getResponseText xhr)})))
42 |     (. xhr
43 |       (send url (meths method) (when data (pr-str data))
44 |         #js {"Content-Type" "application/edn" "Accept" "application/edn"}))))
45 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # om-sync
 2 | 
 3 | A reusable synchronization component for
 4 | [Om](http://github.com/swannodette/om).
 5 | 
 6 | ## Example
 7 | 
 8 | `om-sync` leverages the new `:tx-listen` option allowed by
 9 | `om.core/root`. For example you can imagine setting up your
10 | application like so:
11 | 
12 | ```clj
13 | (let [tx-chan (chan)
14 |       tx-pub-chan (async/pub tx-chan (fn [_] :txs))]
15 |   (om-sync.util/edn-xhr
16 |     {:method :get
17 |      :url "/init"
18 |      :on-complete
19 |      (fn [res]
20 |        (reset! app-state res)
21 |        (om/root app-view app-state
22 |          {:target (gdom/getElement "app")
23 |           :shared {:tx-chan tx-pub-chan}
24 |           :tx-listen
25 |           (fn [tx-data root-cursor]
26 |             (put! tx-chan [tx-data root-cursor]))}))}))
27 | ```
28 | 
29 | We publish a transaction queue channel `:tx-chan` as a global service
30 | via `:shared` so that `om-sync` instances can listen in.
31 | 
32 | We can now take any application data and wrap it in an `om-sync`
33 | instance. Whenever application data changes `om-sync` will synchronize
34 | those changes via [EDN](http://github.com/edn-format/edn) requests to
35 | a server.
36 | 
37 | Notice in the following that `om-sync` can take an `:on-error`
38 | handler. This error handler will be given `tx-data` which contains
39 | enough information to roll back the entire application state if
40 | something goes wrong.
41 | 
42 | ```clj
43 | (defn app-view [app owner]
44 |   (reify
45 |     om/IWillUpdate
46 |     (will-update [_ next-props next-state]
47 |       (when (:err-msg next-state)
48 |         (js/setTimeout #(om/set-state! owner :err-msg nil) 5000)))
49 |     om/IRenderState
50 |     (render-state [_ {:keys [err-msg]}]
51 |       (dom/div nil
52 |         (om/build om-sync (:items app)
53 |           {:opts {:view items-view
54 |                   :filter (comp #{:create :update :delete} tx-tag)
55 |                   :id-key :some/id
56 |                   :on-success (fn [res tx-data] (println res))
57 |                   :on-error
58 |                   (fn [err tx-data]
59 |                     (reset! app-state (:old-state tx-data))
60 |                     (om/set-state! owner :err-msg
61 |                       "Ooops! Sorry something went wrong try again later."))}})
62 |          (when err-msg
63 |            (dom/div nil err-msg))))))
64 | ```
65 | 
66 | `om.core/transact!` and `om.core/update!` now support tagging
67 | transactions with a keyword or a vector that starts with a
68 | keyword. `om-sync` listens in on transactions labeled `:create`,
69 | `:update`, and `:delete`.
70 | 
71 | ```clj
72 | (defn foo [some-data owner]
73 |   (om.core/transact! some-data :foo (fn [_] :bar) :update))
74 | ```
75 | 
76 | If you are given some component that does not tag its transactions or
77 | the tags do not correspond to `:create`, `:update`, and `:delete` you
78 | can provide a `:tag-fn` via `:opts` to `om-sync` so that you can
79 | classify the transaction yourself.
80 | 
81 | ## Contributions
82 | 
83 | Pull requests welcome.
84 | 
85 | ## License
86 | 
87 | Copyright © 2014 David Nolen
88 | 
89 | Distributed under the Eclipse Public License either version 1.0 or (at
90 | your option) any later version.
91 | 


--------------------------------------------------------------------------------
/src/om_sync/core.cljs:
--------------------------------------------------------------------------------
  1 | (ns om-sync.core
  2 |   (:require-macros [cljs.core.async.macros :refer [go]])
  3 |   (:require [cljs.core.async :as async :refer [put! chan alts!]]
  4 |             [om.core :as om :include-macros true]
  5 |             [om.dom :as dom :include-macros true]
  6 |             [om-sync.util :refer [edn-xhr popn sub tx-tag subpath? error?]]))
  7 | 
  8 | (def ^:private type->method
  9 |   {:create :post
 10 |    :update :put
 11 |    :delete :delete})
 12 | 
 13 | (defn ^:private sync-server [url tag edn]
 14 |   (let [res-chan (chan)]
 15 |     (edn-xhr
 16 |       {:method (type->method tag)
 17 |        :url url
 18 |        :data edn
 19 |        :on-error (fn [err] (put! res-chan err))
 20 |        :on-complete (fn [res] (put! res-chan res))})
 21 |     res-chan))
 22 | 
 23 | (defn ^:private tag-and-edn [coll-path path tag-fn id-key tx-data]
 24 |   (let [tag (if-not (nil? tag-fn)
 25 |               (tag-fn tx-data)
 26 |               (tx-tag tx-data))
 27 |         edn (condp = tag
 28 |               :create (:new-value tx-data)
 29 |               :update (let [ppath (popn (- (count path) (inc (count coll-path))) path)
 30 |                             m (select-keys (get-in (:new-state tx-data) ppath) [id-key])
 31 |                             rel (sub path coll-path)]
 32 |                         (assoc-in m (rest rel) (:new-value tx-data)))
 33 |               :delete (-> tx-data :old-value id-key)
 34 |               nil)]
 35 |     [tag edn]))
 36 | 
 37 | (defn om-sync
 38 |   "ALPHA: Creates a reusable sync componet. Data must be a map containing
 39 |   :url and :coll keys. :url must identify a server endpoint that can
 40 |   takes EDN data via POST for create, PUT for update, and DELETE for
 41 |   delete. :coll must be a cursor into the application state. Note the
 42 |   first argument could of course just be a cursor itself.
 43 | 
 44 |   In order to function you must provide a subscribeable core.async
 45 |   channel that will stream all :tx-listen events. This channel must be
 46 |   called :tx-chan and provided via the :share option to om.core/root. It
 47 |   must be a channel constructed with cljs.core.async/pub with the topic
 48 |   :txs.
 49 | 
 50 |   Once built om-sync will act on any transactions to the :coll value
 51 |   regardless of depth. In order to identify which transactions to act
 52 |   on these transactions must be labeled as :create, :update, or
 53 |   :delete.
 54 | 
 55 |   om-sync takes a variety of options via the :opts passed to
 56 |   om.core/build:
 57 | 
 58 |   :view - a required Om component function to render the collection.
 59 | 
 60 |   :id-key - which property represents the server id for a item in the
 61 |     collection.
 62 | 
 63 |   :filter - a function which filters which tagged transaction to actually sync.
 64 | 
 65 |   :tag-fn - not all components you might want to interact with may
 66 |     have properly tagged their transactions. This function will
 67 |     receive the transaction data and return the determined tag.
 68 | 
 69 |   :on-success - a callback function that will receive the server
 70 |     response and the transaction data on success.
 71 | 
 72 |   :on-error - a callback function that will receive the server error
 73 |     and the transaction data on failure. The transaction data can
 74 |     easily be leveraged to rollback the application state.
 75 | 
 76 |   :sync-chan - if given this option, om-sync will not invoke
 77 |     sync-server instead it will put a map containing the :listen-path,
 78 |     :url, :tag, :edn, :on-success, :on-error, and :tx-data on the
 79 |     provided channel. This higher level operations such as server
 80 |     request batching and multiple om-sync component coordination."
 81 |   ([data owner] (om-sync data owner nil))
 82 |   ([{:keys [url coll] :as data} owner opts]
 83 |     (assert (not (nil? url)) "om-sync component not given url")
 84 |     (reify
 85 |       om/IInitState
 86 |       (init-state [_]
 87 |         {:kill-chan (chan)})
 88 |       om/IWillMount
 89 |       (will-mount [_]
 90 |         (let [{:keys [id-key filter tag-fn sync-chan]} opts
 91 |               {:keys [on-success on-error]} opts
 92 |               kill-chan (om/get-state owner :kill-chan)
 93 |               tx-chan (om/get-shared owner :tx-chan)
 94 |               txs (chan)
 95 |               coll-path (om/path coll)]
 96 |           (assert (not (nil? tx-chan))
 97 |             "om-sync requires shared :tx-chan pub channel with :txs topic")
 98 |           (async/sub tx-chan :txs txs)
 99 |           (om/set-state! owner :txs txs)
100 |           (go (loop []
101 |                 (let [[v c] (alts! [txs kill-chan])]
102 |                   (if (= c kill-chan)
103 |                     :done
104 |                     (let [[{:keys [path new-value new-state] :as tx-data} _] v]
105 |                       (when (and (subpath? coll-path path)
106 |                               (or (nil? filter) (filter tx-data)))
107 |                         (let [[tag edn] (tag-and-edn coll-path path tag-fn id-key tx-data)
108 |                               tx-data (assoc tx-data ::tag tag)]
109 |                           (if-not (nil? sync-chan)
110 |                             (>! sync-chan
111 |                               {:url url :tag tag :edn edn
112 |                                :listen-path coll-path
113 |                                :on-success on-success
114 |                                :on-error on-error
115 |                                :tx-data tx-data})
116 |                             (let [res (<! (sync-server url tag edn))]
117 |                               (if (error? res)
118 |                                 (on-error res tx-data)
119 |                                 (on-success res tx-data))))))
120 |                       (recur))))))))
121 |       om/IWillUnmount
122 |       (will-unmount [_]
123 |         (let [{:keys [kill-chan txs]} (om/get-state owner)]
124 |           (when kill-chan
125 |             (put! kill-chan (js/Date.)))
126 |           (when txs
127 |             (async/unsub (om/get-shared owner :tx-chan) :txs txs))))
128 |       om/IRender
129 |       (render [_]
130 |         (om/build (:view opts) coll)))))
131 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
  2 | LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
  3 | CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
  4 | 
  5 | 1. DEFINITIONS
  6 | 
  7 | "Contribution" means:
  8 | 
  9 | a) in the case of the initial Contributor, the initial code and
 10 | documentation distributed under this Agreement, and
 11 | 
 12 | b) in the case of each subsequent Contributor:
 13 | 
 14 | i) changes to the Program, and
 15 | 
 16 | ii) additions to the Program;
 17 | 
 18 | where such changes and/or additions to the Program originate from and are
 19 | distributed by that particular Contributor. A Contribution 'originates' from
 20 | a Contributor if it was added to the Program by such Contributor itself or
 21 | anyone acting on such Contributor's behalf. Contributions do not include
 22 | additions to the Program which: (i) are separate modules of software
 23 | distributed in conjunction with the Program under their own license
 24 | agreement, and (ii) are not derivative works of the Program.
 25 | 
 26 | "Contributor" means any person or entity that distributes the Program.
 27 | 
 28 | "Licensed Patents" mean patent claims licensable by a Contributor which are
 29 | necessarily infringed by the use or sale of its Contribution alone or when
 30 | combined with the Program.
 31 | 
 32 | "Program" means the Contributions distributed in accordance with this
 33 | Agreement.
 34 | 
 35 | "Recipient" means anyone who receives the Program under this Agreement,
 36 | including all Contributors.
 37 | 
 38 | 2. GRANT OF RIGHTS
 39 | 
 40 | a) Subject to the terms of this Agreement, each Contributor hereby grants
 41 | Recipient a non-exclusive, worldwide, royalty-free copyright license to
 42 | reproduce, prepare derivative works of, publicly display, publicly perform,
 43 | distribute and sublicense the Contribution of such Contributor, if any, and
 44 | such derivative works, in source code and object code form.
 45 | 
 46 | b) Subject to the terms of this Agreement, each Contributor hereby grants
 47 | Recipient a non-exclusive, worldwide, royalty-free patent license under
 48 | Licensed Patents to make, use, sell, offer to sell, import and otherwise
 49 | transfer the Contribution of such Contributor, if any, in source code and
 50 | object code form.  This patent license shall apply to the combination of the
 51 | Contribution and the Program if, at the time the Contribution is added by the
 52 | Contributor, such addition of the Contribution causes such combination to be
 53 | covered by the Licensed Patents. The patent license shall not apply to any
 54 | other combinations which include the Contribution. No hardware per se is
 55 | licensed hereunder.
 56 | 
 57 | c) Recipient understands that although each Contributor grants the licenses
 58 | to its Contributions set forth herein, no assurances are provided by any
 59 | Contributor that the Program does not infringe the patent or other
 60 | intellectual property rights of any other entity. Each Contributor disclaims
 61 | any liability to Recipient for claims brought by any other entity based on
 62 | infringement of intellectual property rights or otherwise. As a condition to
 63 | exercising the rights and licenses granted hereunder, each Recipient hereby
 64 | assumes sole responsibility to secure any other intellectual property rights
 65 | needed, if any. For example, if a third party patent license is required to
 66 | allow Recipient to distribute the Program, it is Recipient's responsibility
 67 | to acquire that license before distributing the Program.
 68 | 
 69 | d) Each Contributor represents that to its knowledge it has sufficient
 70 | copyright rights in its Contribution, if any, to grant the copyright license
 71 | set forth in this Agreement.
 72 | 
 73 | 3. REQUIREMENTS
 74 | 
 75 | A Contributor may choose to distribute the Program in object code form under
 76 | its own license agreement, provided that:
 77 | 
 78 | a) it complies with the terms and conditions of this Agreement; and
 79 | 
 80 | b) its license agreement:
 81 | 
 82 | i) effectively disclaims on behalf of all Contributors all warranties and
 83 | conditions, express and implied, including warranties or conditions of title
 84 | and non-infringement, and implied warranties or conditions of merchantability
 85 | and fitness for a particular purpose;
 86 | 
 87 | ii) effectively excludes on behalf of all Contributors all liability for
 88 | damages, including direct, indirect, special, incidental and consequential
 89 | damages, such as lost profits;
 90 | 
 91 | iii) states that any provisions which differ from this Agreement are offered
 92 | by that Contributor alone and not by any other party; and
 93 | 
 94 | iv) states that source code for the Program is available from such
 95 | Contributor, and informs licensees how to obtain it in a reasonable manner on
 96 | or through a medium customarily used for software exchange.
 97 | 
 98 | When the Program is made available in source code form:
 99 | 
100 | a) it must be made available under this Agreement; and
101 | 
102 | b) a copy of this Agreement must be included with each copy of the Program.
103 | 
104 | Contributors may not remove or alter any copyright notices contained within
105 | the Program.
106 | 
107 | Each Contributor must identify itself as the originator of its Contribution,
108 | if any, in a manner that reasonably allows subsequent Recipients to identify
109 | the originator of the Contribution.
110 | 
111 | 4. COMMERCIAL DISTRIBUTION
112 | 
113 | Commercial distributors of software may accept certain responsibilities with
114 | respect to end users, business partners and the like. While this license is
115 | intended to facilitate the commercial use of the Program, the Contributor who
116 | includes the Program in a commercial product offering should do so in a
117 | manner which does not create potential liability for other Contributors.
118 | Therefore, if a Contributor includes the Program in a commercial product
119 | offering, such Contributor ("Commercial Contributor") hereby agrees to defend
120 | and indemnify every other Contributor ("Indemnified Contributor") against any
121 | losses, damages and costs (collectively "Losses") arising from claims,
122 | lawsuits and other legal actions brought by a third party against the
123 | Indemnified Contributor to the extent caused by the acts or omissions of such
124 | Commercial Contributor in connection with its distribution of the Program in
125 | a commercial product offering.  The obligations in this section do not apply
126 | to any claims or Losses relating to any actual or alleged intellectual
127 | property infringement. In order to qualify, an Indemnified Contributor must:
128 | a) promptly notify the Commercial Contributor in writing of such claim, and
129 | b) allow the Commercial Contributor tocontrol, and cooperate with the
130 | Commercial Contributor in, the defense and any related settlement
131 | negotiations. The Indemnified Contributor may participate in any such claim
132 | at its own expense.
133 | 
134 | For example, a Contributor might include the Program in a commercial product
135 | offering, Product X. That Contributor is then a Commercial Contributor. If
136 | that Commercial Contributor then makes performance claims, or offers
137 | warranties related to Product X, those performance claims and warranties are
138 | such Commercial Contributor's responsibility alone. Under this section, the
139 | Commercial Contributor would have to defend claims against the other
140 | Contributors related to those performance claims and warranties, and if a
141 | court requires any other Contributor to pay any damages as a result, the
142 | Commercial Contributor must pay those damages.
143 | 
144 | 5. NO WARRANTY
145 | 
146 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON
147 | AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER
148 | EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR
149 | CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A
150 | PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the
151 | appropriateness of using and distributing the Program and assumes all risks
152 | associated with its exercise of rights under this Agreement , including but
153 | not limited to the risks and costs of program errors, compliance with
154 | applicable laws, damage to or loss of data, programs or equipment, and
155 | unavailability or interruption of operations.
156 | 
157 | 6. DISCLAIMER OF LIABILITY
158 | 
159 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
160 | CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
161 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
162 | LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
163 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
164 | ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
165 | EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
166 | OF SUCH DAMAGES.
167 | 
168 | 7. GENERAL
169 | 
170 | If any provision of this Agreement is invalid or unenforceable under
171 | applicable law, it shall not affect the validity or enforceability of the
172 | remainder of the terms of this Agreement, and without further action by the
173 | parties hereto, such provision shall be reformed to the minimum extent
174 | necessary to make such provision valid and enforceable.
175 | 
176 | If Recipient institutes patent litigation against any entity (including a
177 | cross-claim or counterclaim in a lawsuit) alleging that the Program itself
178 | (excluding combinations of the Program with other software or hardware)
179 | infringes such Recipient's patent(s), then such Recipient's rights granted
180 | under Section 2(b) shall terminate as of the date such litigation is filed.
181 | 
182 | All Recipient's rights under this Agreement shall terminate if it fails to
183 | comply with any of the material terms or conditions of this Agreement and
184 | does not cure such failure in a reasonable period of time after becoming
185 | aware of such noncompliance. If all Recipient's rights under this Agreement
186 | terminate, Recipient agrees to cease use and distribution of the Program as
187 | soon as reasonably practicable. However, Recipient's obligations under this
188 | Agreement and any licenses granted by Recipient relating to the Program shall
189 | continue and survive.
190 | 
191 | Everyone is permitted to copy and distribute copies of this Agreement, but in
192 | order to avoid inconsistency the Agreement is copyrighted and may only be
193 | modified in the following manner. The Agreement Steward reserves the right to
194 | publish new versions (including revisions) of this Agreement from time to
195 | time. No one other than the Agreement Steward has the right to modify this
196 | Agreement. The Eclipse Foundation is the initial Agreement Steward. The
197 | Eclipse Foundation may assign the responsibility to serve as the Agreement
198 | Steward to a suitable separate entity. Each new version of the Agreement will
199 | be given a distinguishing version number. The Program (including
200 | Contributions) may always be distributed subject to the version of the
201 | Agreement under which it was received. In addition, after a new version of
202 | the Agreement is published, Contributor may elect to distribute the Program
203 | (including its Contributions) under the new version. Except as expressly
204 | stated in Sections 2(a) and 2(b) above, Recipient receives no rights or
205 | licenses to the intellectual property of any Contributor under this
206 | Agreement, whether expressly, by implication, estoppel or otherwise. All
207 | rights in the Program not expressly granted under this Agreement are
208 | reserved.
209 | 
210 | This Agreement is governed by the laws of the State of Washington and the
211 | intellectual property laws of the United States of America. No party to this
212 | Agreement will bring a legal action under this Agreement more than one year
213 | after the cause of action arose. Each party waives its rights to a jury trial
214 | in any resulting litigation.
215 | 


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