remodel 0.1.0 → 0.1.1

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/docs/docco.css

@@ -0,0 +1,185 @@
+/*--------------------- Layout and Typography ----------------------------*/
+body {
+  font-family: 'Palatino Linotype', 'Book Antiqua', Palatino, FreeSerif, serif;
+  font-size: 16px;
+  line-height: 24px;
+  color: #252519;
+  margin: 0; padding: 0;
+}
+a {
+  color: #261a3b;
+}
+  a:visited {
+    color: #261a3b;
+  }
+p {
+  margin: 0 0 15px 0;
+}
+h1, h2, h3, h4, h5, h6 {
+  margin: 40px 0 15px 0;
+}
+  h3, h4, h5, h6 {
+    margin-top: 20px;
+  }
+#container {
+  position: relative;
+}
+#background {
+  position: fixed;
+  top: 0; left: 580px; right: 0; bottom: 0;
+  background: #f5f5ff;
+  border-left: 1px solid #e5e5ee;
+  z-index: -1;
+}
+#jump_to, #jump_page {
+  background: white;
+  -webkit-box-shadow: 0 0 25px #777; -moz-box-shadow: 0 0 25px #777;
+  -webkit-border-bottom-left-radius: 5px; -moz-border-radius-bottomleft: 5px;
+  font: 10px Arial;
+  text-transform: uppercase;
+  cursor: pointer;
+  text-align: right;
+}
+#jump_to, #jump_wrapper {
+  position: fixed;
+  right: 0; top: 0;
+  padding: 5px 10px;
+}
+  #jump_wrapper {
+    padding: 0;
+    display: none;
+  }
+    #jump_to:hover #jump_wrapper {
+      display: block;
+    }
+    #jump_page {
+      padding: 5px 0 3px;
+      margin: 0 0 25px 25px;
+    }
+      #jump_page .source {
+        display: block;
+        padding: 5px 10px;
+        text-decoration: none;
+        border-top: 1px solid #eee;
+      }
+        #jump_page .source:hover {
+          background: #f5f5ff;
+        }
+        #jump_page .source:first-child {
+        }
+table td {
+  border: 0;
+  outline: 0;
+}
+  td.docs, th.docs {
+    max-width: 500px;
+    min-width: 500px;
+    min-height: 5px;
+    padding: 10px 25px 1px 50px;
+    vertical-align: top;
+    text-align: left;
+  }
+    .docs pre {
+      margin: 15px 0 15px;
+      padding-left: 15px;
+    }
+    .docs p tt, .docs p code {
+      background: #f8f8ff;
+      border: 1px solid #dedede;
+      font-size: 12px;
+      padding: 0 0.2em;
+    }
+    .octowrap {
+      position: relative;
+    }
+      .octothorpe {
+        font: 12px Arial;
+        text-decoration: none;
+        color: #454545;
+        position: absolute;
+        top: 3px; left: -20px;
+        padding: 1px 2px;
+        opacity: 0;
+        -webkit-transition: opacity 0.2s linear;
+      }
+        td.docs:hover .octothorpe {
+          opacity: 1;
+        }
+  td.code, th.code {
+    padding: 14px 15px 16px 50px;
+    width: 100%;
+    vertical-align: top;
+    background: #f5f5ff;
+    border-left: 1px solid #e5e5ee;
+  }
+    pre, tt, code {
+      font-size: 12px; line-height: 18px;
+      font-family: Monaco, Consolas, "Lucida Console", monospace;
+      margin: 0; padding: 0;
+    }
+
+
+/*---------------------- Syntax Highlighting -----------------------------*/
+td.linenos { background-color: #f0f0f0; padding-right: 10px; }
+span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }
+body .hll { background-color: #ffffcc }
+body .c { color: #408080; font-style: italic }  /* Comment */
+/*body .err { border: 1px solid #FF0000 }         /* Error */
+body .k { color: #954121 }                      /* Keyword */
+body .o { color: #666666 }                      /* Operator */
+body .cm { color: #408080; font-style: italic } /* Comment.Multiline */
+body .cp { color: #BC7A00 }                     /* Comment.Preproc */
+body .c1 { color: #408080; font-style: italic } /* Comment.Single */
+body .cs { color: #408080; font-style: italic } /* Comment.Special */
+body .gd { color: #A00000 }                     /* Generic.Deleted */
+body .ge { font-style: italic }                 /* Generic.Emph */
+body .gr { color: #FF0000 }                     /* Generic.Error */
+body .gh { color: #000080; font-weight: bold }  /* Generic.Heading */
+body .gi { color: #00A000 }                     /* Generic.Inserted */
+body .go { color: #808080 }                     /* Generic.Output */
+body .gp { color: #000080; font-weight: bold }  /* Generic.Prompt */
+body .gs { font-weight: bold }                  /* Generic.Strong */
+body .gu { color: #800080; font-weight: bold }  /* Generic.Subheading */
+body .gt { color: #0040D0 }                     /* Generic.Traceback */
+body .kc { color: #954121 }                     /* Keyword.Constant */
+body .kd { color: #954121; font-weight: bold }  /* Keyword.Declaration */
+body .kn { color: #954121; font-weight: bold }  /* Keyword.Namespace */
+body .kp { color: #954121 }                     /* Keyword.Pseudo */
+body .kr { color: #954121; font-weight: bold }  /* Keyword.Reserved */
+body .kt { color: #B00040 }                     /* Keyword.Type */
+body .m { color: #666666 }                      /* Literal.Number */
+body .s { color: #219161 }                      /* Literal.String */
+body .na { color: #7D9029 }                     /* Name.Attribute */
+body .nb { color: #954121 }                     /* Name.Builtin */
+body .nc { color: #0000FF; font-weight: bold }  /* Name.Class */
+body .no { color: #880000 }                     /* Name.Constant */
+body .nd { color: #AA22FF }                     /* Name.Decorator */
+body .ni { color: #999999; font-weight: bold }  /* Name.Entity */
+body .ne { color: #D2413A; font-weight: bold }  /* Name.Exception */
+body .nf { color: #0000FF }                     /* Name.Function */
+body .nl { color: #A0A000 }                     /* Name.Label */
+body .nn { color: #0000FF; font-weight: bold }  /* Name.Namespace */
+body .nt { color: #954121; font-weight: bold }  /* Name.Tag */
+body .nv { color: #19469D }                     /* Name.Variable */
+body .ow { color: #AA22FF; font-weight: bold }  /* Operator.Word */
+body .w { color: #bbbbbb }                      /* Text.Whitespace */
+body .mf { color: #666666 }                     /* Literal.Number.Float */
+body .mh { color: #666666 }                     /* Literal.Number.Hex */
+body .mi { color: #666666 }                     /* Literal.Number.Integer */
+body .mo { color: #666666 }                     /* Literal.Number.Oct */
+body .sb { color: #219161 }                     /* Literal.String.Backtick */
+body .sc { color: #219161 }                     /* Literal.String.Char */
+body .sd { color: #219161; font-style: italic } /* Literal.String.Doc */
+body .s2 { color: #219161 }                     /* Literal.String.Double */
+body .se { color: #BB6622; font-weight: bold }  /* Literal.String.Escape */
+body .sh { color: #219161 }                     /* Literal.String.Heredoc */
+body .si { color: #BB6688; font-weight: bold }  /* Literal.String.Interpol */
+body .sx { color: #954121 }                     /* Literal.String.Other */
+body .sr { color: #BB6688 }                     /* Literal.String.Regex */
+body .s1 { color: #219161 }                     /* Literal.String.Single */
+body .ss { color: #19469D }                     /* Literal.String.Symbol */
+body .bp { color: #954121 }                     /* Name.Builtin.Pseudo */
+body .vc { color: #19469D }                     /* Name.Variable.Class */
+body .vg { color: #19469D }                     /* Name.Variable.Global */
+body .vi { color: #19469D }                     /* Name.Variable.Instance */
+body .il { color: #666666 }                     /* Literal.Number.Integer.Long */

data/docs/remodel.html

@@ -0,0 +1,269 @@
+<!DOCTYPE html>  <html> <head>   <title>remodel.rb</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               remodel.rb             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-1">#</a>               </div>                            </td>             <td class="code">               <div class="highlight"><pre><span class="nb">require</span> <span class="s1">&#39;rubygems&#39;</span>
+<span class="nb">require</span> <span class="s1">&#39;redis&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-2">#</a>               </div>               <p>Use the superfast <a href="http://github.com/brianmario/yajl-ruby">YAJL</a> lib to parse <a href="http://json.org/">JSON</a>, if available.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">begin</span>
+  <span class="nb">require</span> <span class="s1">&#39;yajl/json_gem&#39;</span>
+<span class="k">rescue</span> <span class="no">LoadError</span>
+  <span class="nb">require</span> <span class="s1">&#39;json&#39;</span>
+<span class="k">end</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-3">#</a>               </div>               <h3>Monkey patches</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-4">#</a>               </div>               <p>Define <code>Boolean</code> as the superclass of <code>true</code> and <code>false</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">module</span> <span class="nn">Boolean</span><span class="p">;</span> <span class="k">end</span>
+<span class="kp">true</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="no">Boolean</span><span class="p">)</span> 
+<span class="kp">false</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="no">Boolean</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-5">#</a>               </div>               <p>Find the <code>Class</code> object for a given class name, which can be a <code>String</code> or <code>Symbol</code> (or <code>Class</code>).</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">def</span> <span class="nc">Class</span><span class="o">.</span><span class="nf">[]</span><span class="p">(</span><span class="n">clazz</span><span class="p">)</span>
+  <span class="k">return</span> <span class="n">clazz</span> <span class="k">if</span> <span class="n">clazz</span><span class="o">.</span><span class="n">nil?</span> <span class="ow">or</span> <span class="n">clazz</span><span class="o">.</span><span class="n">is_a?</span><span class="p">(</span><span class="no">Class</span><span class="p">)</span>
+  <span class="n">clazz</span><span class="o">.</span><span class="n">to_s</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">&#39;::&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">inject</span><span class="p">(</span><span class="no">Kernel</span><span class="p">)</span> <span class="p">{</span> <span class="o">|</span><span class="n">mod</span><span class="p">,</span> <span class="nb">name</span><span class="o">|</span> <span class="n">mod</span><span class="o">.</span><span class="n">const_get</span><span class="p">(</span><span class="nb">name</span><span class="p">)</span> <span class="p">}</span>
+<span class="k">end</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-6">#</a>               </div>               <h3>Remodel</h3>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">module</span> <span class="nn">Remodel</span>
+  </pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-7">#</a>               </div>               <p>By default, we expect to find the redis server on <code>localhost:6379</code> &mdash;
+otherwise you will have to set <code>Remodel.redis</code> to a suitably initialized redis client.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">redis</span>
+    <span class="vi">@redis</span> <span class="o">||=</span> <span class="no">Redis</span><span class="o">.</span><span class="n">new</span>
+  <span class="k">end</span>
+
+  <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">redis</span><span class="o">=</span><span class="p">(</span><span class="n">redis</span><span class="p">)</span>
+    <span class="vi">@redis</span> <span class="o">=</span> <span class="n">redis</span>
+  <span class="k">end</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-8">#</a>               </div>               <p>Custom errors</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">class</span> <span class="nc">Error</span> <span class="o">&lt;</span> <span class="o">::</span><span class="no">StandardError</span><span class="p">;</span> <span class="k">end</span>
+  <span class="k">class</span> <span class="nc">EntityNotFound</span> <span class="o">&lt;</span> <span class="no">Error</span><span class="p">;</span> <span class="k">end</span>
+  <span class="k">class</span> <span class="nc">EntityNotSaved</span> <span class="o">&lt;</span> <span class="no">Error</span><span class="p">;</span> <span class="k">end</span>
+  <span class="k">class</span> <span class="nc">InvalidKeyPrefix</span> <span class="o">&lt;</span> <span class="no">Error</span><span class="p">;</span> <span class="k">end</span>
+  <span class="k">class</span> <span class="nc">InvalidType</span> <span class="o">&lt;</span> <span class="no">Error</span><span class="p">;</span> <span class="k">end</span>
+  </pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-9">#</a>               </div>               <h3>Mapper</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-10">#</a>               </div>               <p>A mapper converts a given value into a native JSON value &mdash;
+<em>nil</em>, <em>true</em>, <em>false</em>, <em>Number</em>, <em>String</em>, <em>Hash</em>, <em>Array</em> &mdash; via <code>pack</code>,
+and back again via <code>unpack</code>.</p>
+
+<p>Without any arguments, <code>Mapper.new</code> returns the identity mapper, which maps every value into itself.
+If <code>clazz</code> is set, the mapper rejects any value which is not of the given type.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">class</span> <span class="nc">Mapper</span>
+    <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">clazz</span> <span class="o">=</span> <span class="kp">nil</span><span class="p">,</span> <span class="n">pack_method</span> <span class="o">=</span> <span class="kp">nil</span><span class="p">,</span> <span class="n">unpack_method</span> <span class="o">=</span> <span class="kp">nil</span><span class="p">)</span>
+      <span class="vi">@clazz</span> <span class="o">=</span> <span class="n">clazz</span>
+      <span class="vi">@pack_method</span> <span class="o">=</span> <span class="n">pack_method</span>
+      <span class="vi">@unpack_method</span> <span class="o">=</span> <span class="n">unpack_method</span>
+    <span class="k">end</span>
+    
+    <span class="k">def</span> <span class="nf">pack</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
+      <span class="k">return</span> <span class="kp">nil</span> <span class="k">if</span> <span class="n">value</span><span class="o">.</span><span class="n">nil?</span>
+      <span class="k">raise</span><span class="p">(</span><span class="no">InvalidType</span><span class="p">,</span> <span class="s2">&quot;</span><span class="si">#{</span><span class="n">value</span><span class="o">.</span><span class="n">inspect</span><span class="si">}</span><span class="s2"> is not a </span><span class="si">#{</span><span class="vi">@clazz</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">)</span> <span class="k">if</span> <span class="vi">@clazz</span> <span class="o">&amp;&amp;</span> <span class="o">!</span><span class="n">value</span><span class="o">.</span><span class="n">is_a?</span><span class="p">(</span><span class="vi">@clazz</span><span class="p">)</span>
+      <span class="vi">@pack_method</span> <span class="p">?</span> <span class="n">value</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="vi">@pack_method</span><span class="p">)</span> <span class="p">:</span> <span class="n">value</span>
+    <span class="k">end</span>
+    
+    <span class="k">def</span> <span class="nf">unpack</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
+      <span class="k">return</span> <span class="kp">nil</span> <span class="k">if</span> <span class="n">value</span><span class="o">.</span><span class="n">nil?</span>
+      <span class="vi">@unpack_method</span> <span class="p">?</span> <span class="vi">@clazz</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="vi">@unpack_method</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span> <span class="p">:</span> <span class="n">value</span>
+    <span class="k">end</span>
+  <span class="k">end</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-11">#</a>               </div>               <p>So let's define some handy mappers for common types, and a way to look them up.
+If no mapper is defined for a given class, the identity mapper is used.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">mapper_by_class</span>
+    <span class="vi">@mapper_by_class</span> <span class="o">||=</span> <span class="no">Hash</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="no">Mapper</span><span class="o">.</span><span class="n">new</span><span class="p">)</span><span class="o">.</span><span class="n">merge</span><span class="p">(</span>
+      <span class="no">Boolean</span> <span class="o">=&gt;</span> <span class="no">Mapper</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="no">Boolean</span><span class="p">),</span>
+      <span class="nb">String</span> <span class="o">=&gt;</span> <span class="no">Mapper</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="nb">String</span><span class="p">),</span>
+      <span class="nb">Integer</span> <span class="o">=&gt;</span> <span class="no">Mapper</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="nb">Integer</span><span class="p">),</span>
+      <span class="nb">Float</span> <span class="o">=&gt;</span> <span class="no">Mapper</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="nb">Float</span><span class="p">),</span>
+      <span class="nb">Array</span> <span class="o">=&gt;</span> <span class="no">Mapper</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="nb">Array</span><span class="p">),</span>
+      <span class="no">Hash</span> <span class="o">=&gt;</span> <span class="no">Mapper</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="no">Hash</span><span class="p">),</span>
+      <span class="no">Date</span> <span class="o">=&gt;</span> <span class="no">Mapper</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="no">Date</span><span class="p">,</span> <span class="ss">:to_s</span><span class="p">,</span> <span class="ss">:parse</span><span class="p">),</span>
+      <span class="no">Time</span> <span class="o">=&gt;</span> <span class="no">Mapper</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="no">Time</span><span class="p">,</span> <span class="ss">:to_i</span><span class="p">,</span> <span class="ss">:at</span><span class="p">)</span>
+    <span class="p">)</span>
+  <span class="k">end</span>
+
+  <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">mapper_for</span><span class="p">(</span><span class="n">clazz</span><span class="p">)</span>
+    <span class="n">mapper_by_class</span><span class="o">[</span><span class="no">Class</span><span class="o">[</span><span class="n">clazz</span><span class="o">]]</span>
+  <span class="k">end</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-12">#</a>               </div>               <h3>HasMany</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-13">#</a>               </div>               <p>Represents the many-end of a many-to-one or many-to-many association.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">class</span> <span class="nc">HasMany</span> <span class="o">&lt;</span> <span class="nb">Array</span>
+    <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">this</span><span class="p">,</span> <span class="n">clazz</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">reverse</span> <span class="o">=</span> <span class="kp">nil</span><span class="p">)</span>
+      <span class="k">super</span> <span class="n">_fetch</span><span class="p">(</span><span class="n">clazz</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
+      <span class="vi">@this</span><span class="p">,</span> <span class="vi">@clazz</span><span class="p">,</span> <span class="vi">@key</span><span class="p">,</span> <span class="vi">@reverse</span> <span class="o">=</span> <span class="n">this</span><span class="p">,</span> <span class="n">clazz</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">reverse</span>
+    <span class="k">end</span>
+
+    <span class="k">def</span> <span class="nf">create</span><span class="p">(</span><span class="n">attributes</span> <span class="o">=</span> <span class="p">{})</span>
+      <span class="n">add</span><span class="p">(</span><span class="vi">@clazz</span><span class="o">.</span><span class="n">create</span><span class="p">(</span><span class="n">attributes</span><span class="p">))</span>
+    <span class="k">end</span>
+
+    <span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="n">entity</span><span class="p">)</span>
+      <span class="n">_add_to_reverse_association_of</span><span class="p">(</span><span class="n">entity</span><span class="p">)</span> <span class="k">if</span> <span class="vi">@reverse</span>
+      <span class="n">_add</span><span class="p">(</span><span class="n">entity</span><span class="p">)</span>
+    <span class="k">end</span>
+
+  <span class="kp">private</span>
+
+    <span class="k">def</span> <span class="nf">_add</span><span class="p">(</span><span class="n">entity</span><span class="p">)</span>
+      <span class="nb">self</span> <span class="o">&lt;&lt;</span> <span class="n">entity</span>
+      <span class="no">Remodel</span><span class="o">.</span><span class="n">redis</span><span class="o">.</span><span class="n">rpush</span><span class="p">(</span><span class="vi">@key</span><span class="p">,</span> <span class="n">entity</span><span class="o">.</span><span class="n">key</span><span class="p">)</span>
+      <span class="n">entity</span>
+    <span class="k">end</span>
+
+    <span class="k">def</span> <span class="nf">_remove</span><span class="p">(</span><span class="n">entity</span><span class="p">)</span>
+      <span class="n">delete_if</span> <span class="p">{</span> <span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="n">x</span><span class="o">.</span><span class="n">key</span> <span class="o">=</span> <span class="n">entity</span><span class="o">.</span><span class="n">key</span> <span class="p">}</span>
+      <span class="no">Remodel</span><span class="o">.</span><span class="n">redis</span><span class="o">.</span><span class="n">lrem</span><span class="p">(</span><span class="vi">@key</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">entity</span><span class="o">.</span><span class="n">key</span><span class="p">)</span>
+    <span class="k">end</span>
+
+    <span class="k">def</span> <span class="nf">_add_to_reverse_association_of</span><span class="p">(</span><span class="n">entity</span><span class="p">)</span>
+      <span class="k">if</span> <span class="n">entity</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="vi">@reverse</span><span class="p">)</span><span class="o">.</span><span class="n">is_a?</span> <span class="no">HasMany</span>
+        <span class="n">entity</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="vi">@reverse</span><span class="p">)</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="ss">:_add</span><span class="p">,</span> <span class="vi">@this</span><span class="p">)</span>
+      <span class="k">else</span>
+        <span class="n">entity</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="s2">&quot;_</span><span class="si">#{</span><span class="vi">@reverse</span><span class="si">}</span><span class="s2">=&quot;</span><span class="p">,</span> <span class="vi">@this</span><span class="p">)</span>
+      <span class="k">end</span>
+    <span class="k">end</span>
+
+    <span class="k">def</span> <span class="nf">_fetch</span><span class="p">(</span><span class="n">clazz</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
+      <span class="n">keys</span> <span class="o">=</span> <span class="no">Remodel</span><span class="o">.</span><span class="n">redis</span><span class="o">.</span><span class="n">lrange</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
+      <span class="n">values</span> <span class="o">=</span> <span class="n">keys</span><span class="o">.</span><span class="n">empty?</span> <span class="p">?</span> <span class="o">[]</span> <span class="p">:</span> <span class="no">Remodel</span><span class="o">.</span><span class="n">redis</span><span class="o">.</span><span class="n">mget</span><span class="p">(</span><span class="n">keys</span><span class="p">)</span>
+      <span class="n">keys</span><span class="o">.</span><span class="n">zip</span><span class="p">(</span><span class="n">values</span><span class="p">)</span><span class="o">.</span><span class="n">map</span> <span class="k">do</span> <span class="o">|</span><span class="n">key</span><span class="p">,</span> <span class="n">json</span><span class="o">|</span>
+        <span class="n">clazz</span><span class="o">.</span><span class="n">restore</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">json</span><span class="p">)</span> <span class="k">if</span> <span class="n">json</span>
+      <span class="k">end</span><span class="o">.</span><span class="n">compact</span>
+    <span class="k">end</span>
+  <span class="k">end</span>
+  </pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-14">#</a>               </div>               <h3>Entity</h3>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-15">#</a>               </div>               <p>The superclass of all persistent remodel entities.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">class</span> <span class="nc">Entity</span>
+    <span class="kp">attr_accessor</span> <span class="ss">:key</span>
+    
+    <span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">attributes</span> <span class="o">=</span> <span class="p">{},</span> <span class="n">key</span> <span class="o">=</span> <span class="kp">nil</span><span class="p">)</span>
+      <span class="vi">@attributes</span> <span class="o">=</span> <span class="p">{}</span>
+      <span class="vi">@key</span> <span class="o">=</span> <span class="n">key</span>
+      <span class="n">attributes</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="nb">name</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+        <span class="nb">send</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">=&quot;</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span> <span class="k">if</span> <span class="nb">respond_to?</span> <span class="s2">&quot;</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">=&quot;</span>
+      <span class="k">end</span>
+    <span class="k">end</span>
+    
+    <span class="k">def</span> <span class="nf">save</span>
+      <span class="vi">@key</span> <span class="o">=</span> <span class="nb">self</span><span class="o">.</span><span class="n">class</span><span class="o">.</span><span class="n">next_key</span> <span class="k">unless</span> <span class="vi">@key</span>
+      <span class="no">Remodel</span><span class="o">.</span><span class="n">redis</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="vi">@key</span><span class="p">,</span> <span class="n">to_json</span><span class="p">)</span>
+      <span class="nb">self</span>
+    <span class="k">end</span>
+    
+    <span class="k">def</span> <span class="nf">reload</span>
+      <span class="k">raise</span> <span class="no">EntityNotSaved</span> <span class="k">unless</span> <span class="vi">@key</span>
+      <span class="kp">initialize</span><span class="p">(</span><span class="nb">self</span><span class="o">.</span><span class="n">class</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="nb">self</span><span class="o">.</span><span class="n">class</span><span class="o">.</span><span class="n">fetch</span><span class="p">(</span><span class="vi">@key</span><span class="p">)),</span> <span class="vi">@key</span><span class="p">)</span>
+      <span class="nb">instance_variables</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">var</span><span class="o">|</span>
+        <span class="n">remove_instance_variable</span><span class="p">(</span><span class="n">var</span><span class="p">)</span> <span class="k">if</span> <span class="n">var</span> <span class="o">=~</span> <span class="sr">/^@association_/</span>
+      <span class="k">end</span>
+      <span class="nb">self</span>
+    <span class="k">end</span>
+
+    <span class="k">def</span> <span class="nf">to_json</span>
+      <span class="no">JSON</span><span class="o">.</span><span class="n">generate</span><span class="p">(</span><span class="nb">self</span><span class="o">.</span><span class="n">class</span><span class="o">.</span><span class="n">pack</span><span class="p">(</span><span class="vi">@attributes</span><span class="p">))</span>
+    <span class="k">end</span>
+    
+    <span class="k">def</span> <span class="nf">inspect</span>
+      <span class="n">properties</span> <span class="o">=</span> <span class="vi">@attributes</span><span class="o">.</span><span class="n">map</span> <span class="p">{</span> <span class="o">|</span><span class="nb">name</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span> <span class="s2">&quot;</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">: </span><span class="si">#{</span><span class="n">value</span><span class="o">.</span><span class="n">inspect</span><span class="si">}</span><span class="s2">&quot;</span> <span class="p">}</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="s1">&#39;, &#39;</span><span class="p">)</span>
+      <span class="s2">&quot;</span><span class="se">\#</span><span class="s2">&lt;</span><span class="si">#{</span><span class="nb">self</span><span class="o">.</span><span class="n">class</span><span class="o">.</span><span class="n">name</span><span class="si">}</span><span class="s2">(</span><span class="si">#{</span><span class="n">key</span><span class="si">}</span><span class="s2">) </span><span class="si">#{</span><span class="n">properties</span><span class="si">}</span><span class="s2">&gt;&quot;</span>
+    <span class="k">end</span>
+
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">create</span><span class="p">(</span><span class="n">attributes</span> <span class="o">=</span> <span class="p">{})</span>
+      <span class="kp">new</span><span class="p">(</span><span class="n">attributes</span><span class="p">)</span><span class="o">.</span><span class="n">save</span>
+    <span class="k">end</span>
+  
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">find</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
+      <span class="n">restore</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">fetch</span><span class="p">(</span><span class="n">key</span><span class="p">))</span>
+    <span class="k">end</span>
+
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">restore</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">json</span><span class="p">)</span>
+      <span class="kp">new</span><span class="p">(</span><span class="n">parse</span><span class="p">(</span><span class="n">json</span><span class="p">),</span> <span class="n">key</span><span class="p">)</span>
+    <span class="k">end</span>
+    </pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-16">#</a>               </div>               <h3>DSL for subclasses</h3>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="kp">protected</span>
+
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">set_key_prefix</span><span class="p">(</span><span class="n">prefix</span><span class="p">)</span>
+      <span class="k">raise</span><span class="p">(</span><span class="no">InvalidKeyPrefix</span><span class="p">,</span> <span class="n">prefix</span><span class="p">)</span> <span class="k">unless</span> <span class="n">prefix</span> <span class="o">=~</span> <span class="sr">/^[a-z]+$/</span>
+      <span class="vi">@key_prefix</span> <span class="o">=</span> <span class="n">prefix</span>
+    <span class="k">end</span>
+
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">property</span><span class="p">(</span><span class="nb">name</span><span class="p">,</span> <span class="n">options</span> <span class="o">=</span> <span class="p">{})</span>
+      <span class="nb">name</span> <span class="o">=</span> <span class="nb">name</span><span class="o">.</span><span class="n">to_sym</span>
+      <span class="n">mapper</span><span class="o">[</span><span class="nb">name</span><span class="o">]</span> <span class="o">=</span> <span class="no">Remodel</span><span class="o">.</span><span class="n">mapper_for</span><span class="p">(</span><span class="n">options</span><span class="o">[</span><span class="ss">:class</span><span class="o">]</span><span class="p">)</span>
+      <span class="n">define_method</span><span class="p">(</span><span class="nb">name</span><span class="p">)</span> <span class="p">{</span> <span class="vi">@attributes</span><span class="o">[</span><span class="nb">name</span><span class="o">]</span> <span class="p">}</span>
+      <span class="n">define_method</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">=&quot;</span><span class="p">)</span> <span class="p">{</span> <span class="o">|</span><span class="n">value</span><span class="o">|</span> <span class="vi">@attributes</span><span class="o">[</span><span class="nb">name</span><span class="o">]</span> <span class="o">=</span> <span class="n">value</span> <span class="p">}</span>
+    <span class="k">end</span>
+    
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">has_many</span><span class="p">(</span><span class="nb">name</span><span class="p">,</span> <span class="n">options</span><span class="p">)</span>
+      <span class="n">var</span> <span class="o">=</span> <span class="s2">&quot;@association_</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">to_sym</span>
+      
+      <span class="n">define_method</span><span class="p">(</span><span class="nb">name</span><span class="p">)</span> <span class="k">do</span>
+        <span class="k">if</span> <span class="n">instance_variable_defined?</span> <span class="n">var</span>
+          <span class="nb">instance_variable_get</span><span class="p">(</span><span class="n">var</span><span class="p">)</span>
+        <span class="k">else</span>
+          <span class="n">clazz</span> <span class="o">=</span> <span class="no">Class</span><span class="o">[</span><span class="n">options</span><span class="o">[</span><span class="ss">:class</span><span class="o">]]</span>
+          <span class="nb">instance_variable_set</span><span class="p">(</span><span class="n">var</span><span class="p">,</span> <span class="no">HasMany</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="nb">self</span><span class="p">,</span> <span class="n">clazz</span><span class="p">,</span> <span class="s2">&quot;</span><span class="si">#{</span><span class="n">key</span><span class="si">}</span><span class="s2">:</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">,</span> <span class="n">options</span><span class="o">[</span><span class="ss">:reverse</span><span class="o">]</span><span class="p">))</span>
+        <span class="k">end</span>
+      <span class="k">end</span>
+    <span class="k">end</span>
+    
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">has_one</span><span class="p">(</span><span class="nb">name</span><span class="p">,</span> <span class="n">options</span><span class="p">)</span>
+      <span class="n">var</span> <span class="o">=</span> <span class="s2">&quot;@association_</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">to_sym</span>
+      
+      <span class="n">define_method</span><span class="p">(</span><span class="nb">name</span><span class="p">)</span> <span class="k">do</span>
+        <span class="k">if</span> <span class="n">instance_variable_defined?</span> <span class="n">var</span>
+          <span class="nb">instance_variable_get</span><span class="p">(</span><span class="n">var</span><span class="p">)</span>
+        <span class="k">else</span>
+          <span class="n">clazz</span> <span class="o">=</span> <span class="no">Class</span><span class="o">[</span><span class="n">options</span><span class="o">[</span><span class="ss">:class</span><span class="o">]]</span>
+          <span class="n">value_key</span> <span class="o">=</span> <span class="no">Remodel</span><span class="o">.</span><span class="n">redis</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="n">key</span><span class="si">}</span><span class="s2">:</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">)</span>
+          <span class="nb">instance_variable_set</span><span class="p">(</span><span class="n">var</span><span class="p">,</span> <span class="n">clazz</span><span class="o">.</span><span class="n">find</span><span class="p">(</span><span class="n">value_key</span><span class="p">))</span> <span class="k">if</span> <span class="n">value_key</span>
+        <span class="k">end</span>
+      <span class="k">end</span>
+      
+      <span class="n">define_method</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">=&quot;</span><span class="p">)</span> <span class="k">do</span> <span class="o">|</span><span class="n">value</span><span class="o">|</span>
+        <span class="nb">send</span><span class="p">(</span><span class="s2">&quot;_reverse_association_of_</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">=&quot;</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span> <span class="k">if</span> <span class="n">options</span><span class="o">[</span><span class="ss">:reverse</span><span class="o">]</span>
+        <span class="nb">send</span><span class="p">(</span><span class="s2">&quot;_</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">=&quot;</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
+      <span class="k">end</span>
+      
+      <span class="n">define_method</span><span class="p">(</span><span class="s2">&quot;_</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">=&quot;</span><span class="p">)</span> <span class="k">do</span> <span class="o">|</span><span class="n">value</span><span class="o">|</span>
+        <span class="k">if</span> <span class="n">value</span>
+          <span class="nb">instance_variable_set</span><span class="p">(</span><span class="n">var</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
+          <span class="no">Remodel</span><span class="o">.</span><span class="n">redis</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="n">key</span><span class="si">}</span><span class="s2">:</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">,</span> <span class="n">value</span><span class="o">.</span><span class="n">key</span><span class="p">)</span>
+        <span class="k">else</span>
+          <span class="n">remove_instance_variable</span><span class="p">(</span><span class="n">var</span><span class="p">)</span> <span class="k">if</span> <span class="n">instance_variable_defined?</span> <span class="n">var</span>
+          <span class="no">Remodel</span><span class="o">.</span><span class="n">redis</span><span class="o">.</span><span class="n">del</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="n">key</span><span class="si">}</span><span class="s2">:</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">)</span>
+        <span class="k">end</span>
+      <span class="k">end</span><span class="p">;</span> <span class="kp">private</span> <span class="s2">&quot;_</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">=&quot;</span>
+      
+      <span class="k">if</span> <span class="n">options</span><span class="o">[</span><span class="ss">:reverse</span><span class="o">]</span>
+        <span class="n">define_method</span><span class="p">(</span><span class="s2">&quot;_reverse_association_of_</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">=&quot;</span><span class="p">)</span> <span class="k">do</span> <span class="o">|</span><span class="n">value</span><span class="o">|</span>
+          <span class="k">if</span> <span class="n">value</span>
+            <span class="n">association</span> <span class="o">=</span> <span class="n">value</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="n">options</span><span class="o">[</span><span class="ss">:reverse</span><span class="o">]</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">)</span>
+            <span class="k">if</span> <span class="n">association</span><span class="o">.</span><span class="n">is_a?</span> <span class="no">HasMany</span>
+              <span class="n">association</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="s2">&quot;_add&quot;</span><span class="p">,</span> <span class="nb">self</span><span class="p">)</span>
+            <span class="k">else</span>
+              <span class="n">value</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="s2">&quot;_</span><span class="si">#{</span><span class="n">options</span><span class="o">[</span><span class="ss">:reverse</span><span class="o">]</span><span class="si">}</span><span class="s2">=&quot;</span><span class="p">,</span> <span class="nb">self</span><span class="p">)</span>
+            <span class="k">end</span>
+          <span class="k">else</span>
+            <span class="k">if</span> <span class="n">old_value</span> <span class="o">=</span> <span class="nb">send</span><span class="p">(</span><span class="nb">name</span><span class="p">)</span>
+              <span class="n">association</span> <span class="o">=</span> <span class="n">old_value</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="n">options</span><span class="o">[</span><span class="ss">:reverse</span><span class="o">]</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">)</span>
+              <span class="k">if</span> <span class="n">association</span><span class="o">.</span><span class="n">is_a?</span> <span class="no">HasMany</span>
+                <span class="n">association</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="s2">&quot;_remove&quot;</span><span class="p">,</span> <span class="nb">self</span><span class="p">)</span>
+              <span class="k">else</span>
+                <span class="n">old_value</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="s2">&quot;_</span><span class="si">#{</span><span class="n">options</span><span class="o">[</span><span class="ss">:reverse</span><span class="o">]</span><span class="si">}</span><span class="s2">=&quot;</span><span class="p">,</span> <span class="kp">nil</span><span class="p">)</span>
+              <span class="k">end</span>
+            <span class="k">end</span>
+          <span class="k">end</span>
+        <span class="k">end</span><span class="p">;</span> <span class="kp">private</span> <span class="s2">&quot;_reverse_association_of_</span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">=&quot;</span>
+      <span class="k">end</span>
+    <span class="k">end</span>
+    </pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-17">#</a>               </div>               <h3>Helper methods</h3>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="kp">private</span>
+  
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">fetch</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
+      <span class="no">Remodel</span><span class="o">.</span><span class="n">redis</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="n">key</span><span class="p">)</span> <span class="o">||</span> <span class="k">raise</span><span class="p">(</span><span class="no">EntityNotFound</span><span class="p">,</span> <span class="s2">&quot;no </span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2"> with key </span><span class="si">#{</span><span class="n">key</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">)</span>
+    <span class="k">end</span>
+  </pre></div>             </td>           </tr>                               <tr id="section-18">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-18">#</a>               </div>               <p>Each entity has its own counter to generate a sequence of keys.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">next_key</span>
+      <span class="n">counter</span> <span class="o">=</span> <span class="no">Remodel</span><span class="o">.</span><span class="n">redis</span><span class="o">.</span><span class="n">incr</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">#{</span><span class="n">key_prefix</span><span class="si">}</span><span class="s2">:seq&quot;</span><span class="p">)</span>
+      <span class="s2">&quot;</span><span class="si">#{</span><span class="n">key_prefix</span><span class="si">}</span><span class="s2">:</span><span class="si">#{</span><span class="n">counter</span><span class="si">}</span><span class="s2">&quot;</span>
+    <span class="k">end</span>
+  </pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-19">#</a>               </div>               <p>Default key prefix is the first letter of the class name, in lowercase.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">key_prefix</span>
+      <span class="vi">@key_prefix</span> <span class="o">||=</span> <span class="nb">name</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">&#39;::&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">last</span><span class="o">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="o">].</span><span class="n">downcase</span>
+    <span class="k">end</span>
+    
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">parse</span><span class="p">(</span><span class="n">json</span><span class="p">)</span>
+      <span class="n">unpack</span><span class="p">(</span><span class="no">JSON</span><span class="o">.</span><span class="n">parse</span><span class="p">(</span><span class="n">json</span><span class="p">))</span>
+    <span class="k">end</span>
+  
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">pack</span><span class="p">(</span><span class="n">attributes</span><span class="p">)</span>
+      <span class="n">result</span> <span class="o">=</span> <span class="p">{}</span>
+      <span class="n">attributes</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="nb">name</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+        <span class="n">result</span><span class="o">[</span><span class="nb">name</span><span class="o">]</span> <span class="o">=</span> <span class="n">mapper</span><span class="o">[</span><span class="nb">name</span><span class="o">].</span><span class="n">pack</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
+      <span class="k">end</span>
+      <span class="n">result</span>
+    <span class="k">end</span>
+    
+    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">unpack</span><span class="p">(</span><span class="n">attributes</span><span class="p">)</span>
+      <span class="n">result</span> <span class="o">=</span> <span class="p">{}</span>
+      <span class="n">attributes</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="nb">name</span><span class="p">,</span> <span class="n">value</span><span class="o">|</span>
+        <span class="nb">name</span> <span class="o">=</span> <span class="nb">name</span><span class="o">.</span><span class="n">to_sym</span>
+        <span class="n">result</span><span class="o">[</span><span class="nb">name</span><span class="o">]</span> <span class="o">=</span> <span class="n">mapper</span><span class="o">[</span><span class="nb">name</span><span class="o">].</span><span class="n">unpack</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
+      <span class="k">end</span>
+      <span class="n">result</span>
+    <span class="k">end</span>
+    </pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="octowrap">                 <a class="octothorpe" href="#section-20">#</a>               </div>               <p>Lazy init</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">mapper</span>
+      <span class="vi">@mapper</span> <span class="o">||=</span> <span class="p">{}</span>
+    <span class="k">end</span>
+  <span class="k">end</span>
+    
+<span class="k">end</span>
+
+</pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 

data/lib/remodel.rb

@@ -1,15 +1,59 @@
 require 'rubygems'
 require 'redis'
-require 'yajl'
+require 'date'
+
+# Use the superfast [YAJL][yajl] lib to parse [JSON][json], if available.
+#
+# [yajl]: http://github.com/brianmario/yajl-ruby
+# [json]: http://json.org/
+begin
+  require 'yajl/json_gem'
+rescue LoadError
+  require 'json'
+end
+
+#### Monkey patches
+
+# Define `Boolean` as the superclass of `true` and `false`.
+module Boolean; end
+true.extend(Boolean) 
+false.extend(Boolean)
+
+# Find the `Class` object for a given class name, which can be a `String` or `Symbol` (or `Class`).
+def Class.[](clazz)
+  return clazz if clazz.nil? or clazz.is_a?(Class)
+  clazz.to_s.split('::').inject(Kernel) { |mod, name| mod.const_get(name) }
+end
+
+#### Remodel
 
 module Remodel
+  
+  # By default, we expect to find the redis server on `localhost:6379` —
+  # otherwise you will have to set `Remodel.redis` to a suitably initialized redis client.
+  def self.redis
+    @redis ||= Redis.new
+  end
 
+  def self.redis=(redis)
+    @redis = redis
+  end
+
+  # Custom errors
   class Error < ::StandardError; end
   class EntityNotFound < Error; end
   class EntityNotSaved < Error; end
   class InvalidKeyPrefix < Error; end
   class InvalidType < Error; end
   
+  #### Mapper
+
+  # A mapper converts a given value into a native JSON value &mdash;
+  # *nil*, *true*, *false*, *Number*, *String*, *Hash*, *Array* &mdash; via `pack`,
+  # and back again via `unpack`.
+  #
+  # Without any arguments, `Mapper.new` returns the identity mapper, which maps every value into itself.
+  # If `clazz` is set, the mapper rejects any value which is not of the given type.
   class Mapper
     def initialize(clazz = nil, pack_method = nil, unpack_method = nil)
       @clazz = clazz
@@ -28,44 +72,66 @@ module Remodel
       @unpack_method ? @clazz.send(@unpack_method, value) : value
     end
   end
-  
+
+  # So let's define some handy mappers for common types, and a way to look them up.
+  # If no mapper is defined for a given class, the identity mapper is used.
+  def self.mapper_by_class
+    @mapper_by_class ||= Hash.new(Mapper.new).merge(
+      Boolean => Mapper.new(Boolean),
+      String => Mapper.new(String),
+      Integer => Mapper.new(Integer),
+      Float => Mapper.new(Float),
+      Array => Mapper.new(Array),
+      Hash => Mapper.new(Hash),
+      Date => Mapper.new(Date, :to_s, :parse),
+      Time => Mapper.new(Time, :to_i, :at)
+    )
+  end
+
+  def self.mapper_for(clazz)
+    mapper_by_class[Class[clazz]]
+  end
+
+  #### HasMany
+
+  # Represents the many-end of a many-to-one or many-to-many association.
   class HasMany < Array
     def initialize(this, clazz, key, reverse = nil)
-      super fetch(clazz, key)
+      super _fetch(clazz, key)
       @this, @clazz, @key, @reverse = this, clazz, key, reverse
     end
-    
+
     def create(attributes = {})
       add(@clazz.create(attributes))
     end
-    
+
     def add(entity)
-      add_to_reverse_association_of(entity) if @reverse
+      _add_to_reverse_association_of(entity) if @reverse
       _add(entity)
     end
 
   private
-  
+
     def _add(entity)
       self << entity
       Remodel.redis.rpush(@key, entity.key)
       entity
     end
-    
+
     def _remove(entity)
       delete_if { |x| x.key = entity.key }
       Remodel.redis.lrem(@key, 0, entity.key)
     end
-    
-    def add_to_reverse_association_of(entity)
+
+    def _add_to_reverse_association_of(entity)
       if entity.send(@reverse).is_a? HasMany
         entity.send(@reverse).send(:_add, @this)
       else
         entity.send("_#{@reverse}=", @this)
       end
     end
-  
-    def fetch(clazz, key)
+
+    def _fetch(clazz, key)
       keys = Remodel.redis.lrange(key, 0, -1)
       values = keys.empty? ? [] : Remodel.redis.mget(keys)
       keys.zip(values).map do |key, json|
@@ -74,6 +140,9 @@ module Remodel
     end
   end
   
+#### Entity
+
+  # The superclass of all persistent remodel entities.
   class Entity
     attr_accessor :key
     
@@ -85,12 +154,21 @@ module Remodel
       end
     end
     
+    def id
+      key && key.split(':').last.to_i
+    end
+    
     def save
       @key = self.class.next_key unless @key
       Remodel.redis.set(@key, to_json)
       self
     end
     
+    def update(properties)
+      properties.each { |name, value| send("#{name}=", value) }
+      save
+    end
+    
     def reload
       raise EntityNotSaved unless @key
       initialize(self.class.parse(self.class.fetch(@key)), @key)
@@ -99,14 +177,19 @@ module Remodel
       end
       self
     end
+    
+    def delete
+      raise EntityNotSaved unless @key
+      Remodel.redis.del(@key)
+    end
 
     def to_json
-      Yajl::Encoder.encode(self.class.pack(@attributes))
+      JSON.generate(self.class.pack(@attributes))
     end
     
     def inspect
       properties = @attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(', ')
-      "\#<#{self.class.name}(#{key}) #{properties}>"
+      "\#<#{self.class.name}(#{id}) #{properties}>"
     end
 
     def self.create(attributes = {})
@@ -114,13 +197,24 @@ module Remodel
     end
   
     def self.find(key)
+      key = "#{key_prefix}:#{key}" if key.kind_of? Integer
       restore(key, fetch(key))
     end
+    
+    def self.all
+      keys = Remodel.redis.keys("#{key_prefix}:*").select { |k| k =~ /:[0-9]+$/ }
+      values = keys.empty? ? [] : Remodel.redis.mget(keys)
+      keys.zip(values).map do |key, json|
+        restore(key, json) if json
+      end.compact
+    end
 
     def self.restore(key, json)
       new(parse(json), key)
     end
     
+#### DSL for subclasses
+
   protected
 
     def self.set_key_prefix(prefix)
@@ -142,7 +236,7 @@ module Remodel
         if instance_variable_defined? var
           instance_variable_get(var)
         else
-          clazz = Remodel.find_class(options[:class])
+          clazz = Class[options[:class]]
           instance_variable_set(var, HasMany.new(self, clazz, "#{key}:#{name}", options[:reverse]))
         end
       end
@@ -155,7 +249,7 @@ module Remodel
         if instance_variable_defined? var
           instance_variable_get(var)
         else
-          clazz = Remodel.find_class(options[:class])
+          clazz = Class[options[:class]]
           value_key = Remodel.redis.get("#{key}:#{name}")
           instance_variable_set(var, clazz.find(value_key)) if value_key
         end
@@ -174,10 +268,8 @@ module Remodel
           remove_instance_variable(var) if instance_variable_defined? var
           Remodel.redis.del("#{key}:#{name}")
         end
-      end
+      end; private "_#{name}="
       
-      private "_#{name}="
-
       if options[:reverse]
         define_method("_reverse_association_of_#{name}=") do |value|
           if value
@@ -197,29 +289,31 @@ module Remodel
               end
             end
           end
-        end
-        
-        private "_reverse_association_of_#{name}="
+        end; private "_reverse_association_of_#{name}="
       end
     end
     
+#### Helper methods
+
   private
   
     def self.fetch(key)
       Remodel.redis.get(key) || raise(EntityNotFound, "no #{name} with key #{key}")
     end
   
+    # Each entity has its own sequence to generate unique ids.
     def self.next_key
-      counter = Remodel.redis.incr("#{key_prefix}:seq")
-      "#{key_prefix}:#{counter}"
+      id = Remodel.redis.incr("#{key_prefix}:seq")
+      "#{key_prefix}:#{id}"
     end
   
+    # Default key prefix is the first letter of the class name, in lowercase.
     def self.key_prefix
       @key_prefix ||= name.split('::').last[0,1].downcase
     end
     
     def self.parse(json)
-      unpack(Yajl::Parser.parse(json))
+      unpack(JSON.parse(json))
     end
   
     def self.pack(attributes)
@@ -239,41 +333,10 @@ module Remodel
       result
     end
     
+    # Lazy init
     def self.mapper
       @mapper ||= {}
     end
   end
-  
-  def self.redis=(redis)
-    @redis = redis
-  end
-
-  def self.redis
-    @redis ||= Redis.new
-  end
-  
-private
-
-  # converts String, Symbol or Class into Class
-  def self.find_class(clazz)
-    return nil unless clazz
-    clazz.to_s.split('::').inject(Kernel) { |mod, name| mod.const_get(name) }
-  end
-
-  def self.mapper_for(clazz)
-    mapper_by_class[find_class(clazz)]
-  end
-  
-  def self.mapper_by_class
-    @mapper_by_class ||= Hash.new(Mapper.new).merge(
-      String => Mapper.new(String),
-      Integer => Mapper.new(Integer),
-      Float => Mapper.new(Float),
-      Array => Mapper.new(Array),
-      Hash => Mapper.new(Hash),
-      Date => Mapper.new(Date, :to_s, :parse),
-      Time => Mapper.new(Time, :to_i, :at)
-    )
-  end
-  
+    
 end

data/remodel.gemspec

@@ -1,15 +1,15 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{remodel}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tim Lossen"]
-  s.date = %q{2010-03-23}
+  s.date = %q{2010-04-28}
   s.default_executable = %q{redis-monitor.rb}
   s.description = %q{build your domain model in ruby, persist your objects to redis.}
   s.email = %q{tim@lossen.de}
@@ -25,6 +25,8 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "bin/redis-monitor.rb",
+     "docs/docco.css",
+     "docs/remodel.html",
      "example/book.rb",
      "lib/remodel.rb",
      "remodel.gemspec",
@@ -33,6 +35,7 @@ Gem::Specification.new do |s|
      "test/test_many_to_many.rb",
      "test/test_many_to_one.rb",
      "test/test_mappers.rb",
+     "test/test_monkeypatches.rb",
      "test/test_one_to_many.rb",
      "test/test_one_to_one.rb"
   ]
@@ -47,6 +50,7 @@ Gem::Specification.new do |s|
      "test/test_many_to_many.rb",
      "test/test_many_to_one.rb",
      "test/test_mappers.rb",
+     "test/test_monkeypatches.rb",
      "test/test_one_to_many.rb",
      "test/test_one_to_one.rb"
   ]

data/test/test_entity.rb

@@ -20,39 +20,15 @@ class TestEntity < Test::Unit::TestCase
       foo = Foo.new :z => 3
       assert foo.instance_eval { !@attributes.key? :z }
     end
-  end
-  
-  context "reload" do
-    setup do
-      @foo = Foo.create :x => 'hello', :y => true
-    end
-
-    should "reload all properties" do
-      redis.set @foo.key, %q({"x":23,"y":"adios"})
-      @foo.reload
-      assert_equal 23, @foo.x
-      assert_equal 'adios', @foo.y
-    end
     
-    should "keep the key" do
-      key = @foo.key
-      @foo.reload
-      assert_equal key, @foo.key
+    should "not set the key" do
+      foo = Foo.new :x => 23
+      assert_equal nil, foo.key
     end
     
-    should "stay the same object" do
-      id = @foo.object_id
-      @foo.reload
-      assert_equal id, @foo.object_id
-    end
-    
-    should "raise EntityNotFound if the entity does not exist any more" do
-      redis.del @foo.key
-      assert_raise(Remodel::EntityNotFound) { @foo.reload }
-    end
-    
-    should "raise EntityNotSaved if the entity was never saved" do
-      assert_raise(Remodel::EntityNotSaved) { Foo.new.reload }
+    should "not set the id" do
+      foo = Foo.new :x => 23
+      assert_equal nil, foo.id      
     end
   end
   
@@ -72,6 +48,12 @@ class TestEntity < Test::Unit::TestCase
       assert_equal 'b:2', Bar.create.key
     end
     
+    should "give the entity an id which is unique per entity class" do
+      assert_equal 1, Foo.create.id
+      assert_equal 1, Bar.create.id
+      assert_equal 2, Bar.create.id
+    end
+    
     should "store the entity under its key" do
       foo = Foo.create :x => 'hello', :y => false
       assert redis.exists(foo.key)
@@ -115,33 +97,127 @@ class TestEntity < Test::Unit::TestCase
     end
   end
   
-   context "#set_key_prefix" do
-     should "use the given key prefix" do
-       class Custom < Remodel::Entity; set_key_prefix 'my'; end
-       assert_match /^my:\d+$/, Custom.create.key
-     end
-     
-     should "ensure that the prefix is letters only" do
-       assert_raise(Remodel::InvalidKeyPrefix) do
-         class InvalidPrefix < Remodel::Entity; set_key_prefix '666'; end
-       end
-     end
-   end
+  context "reload" do
+    setup do
+      @foo = Foo.create :x => 'hello', :y => true
+    end
+
+    should "reload all properties" do
+      redis.set @foo.key, %q({"x":23,"y":"adios"})
+      @foo.reload
+      assert_equal 23, @foo.x
+      assert_equal 'adios', @foo.y
+    end
+    
+    should "keep the key" do
+      key = @foo.key
+      @foo.reload
+      assert_equal key, @foo.key
+    end
+    
+    should "stay the same object" do
+      id = @foo.object_id
+      @foo.reload
+      assert_equal id, @foo.object_id
+    end
+    
+    should "raise EntityNotFound if the entity does not exist any more" do
+      redis.del @foo.key
+      assert_raise(Remodel::EntityNotFound) { @foo.reload }
+    end
+    
+    should "raise EntityNotSaved if the entity was never saved" do
+      assert_raise(Remodel::EntityNotSaved) { Foo.new.reload }
+    end
+  end
+  
+  context "update" do
+    setup do
+      redis.flushdb
+      @foo = Foo.create :x => 'Tim', :y => true
+    end
+    
+    should "set the given properties" do
+      @foo.update(:x => 12, :y => 'Jan')
+      assert_equal 12, @foo.x
+      assert_equal 'Jan', @foo.y
+    end
+    
+    should "save the entity" do
+      @foo.update(:x => 12, :y => 'Jan')
+      @foo.reload
+      assert_equal 12, @foo.x
+      assert_equal 'Jan', @foo.y
+    end
+  end
   
+  context "delete" do
+    setup do
+      redis.flushdb
+      @foo = Foo.create :x => 'Tim', :y => true
+    end
+    
+    should "delete the given entity" do
+      @foo.delete
+      assert_nil redis.get(@foo.key)
+    end
+
+    should "ensure that the entity is persistent" do
+      assert_raise(Remodel::EntityNotSaved) { Foo.new.delete }
+    end
+  end
+  
+  context "#set_key_prefix" do
+    should "use the given key prefix" do
+      class Custom < Remodel::Entity; set_key_prefix 'my'; end
+      assert_match /^my:\d+$/, Custom.create.key
+    end
+ 
+    should "ensure that the prefix is letters only" do
+      assert_raise(Remodel::InvalidKeyPrefix) do
+        class InvalidPrefix < Remodel::Entity; set_key_prefix '666'; end
+      end
+    end
+  end
+    
   context "find" do
     setup do
       redis.flushdb
       @foo = Foo.create :x => 'hello', :y => 123
+      @bar = Foo.create :x => 'hallo', :y => 124
     end
     
-    should "load an entity from redis" do
+    should "find and load an entity by key" do
       foo = Foo.find(@foo.key)
       assert_equal foo.x, @foo.x
       assert_equal foo.y, @foo.y
     end
     
-    should "raise EntityNotFound if the key does not exist" do
-      assert_raise(Remodel::EntityNotFound) { Foo.find(23) }
+    should "find and load an entity by id" do
+      foo = Foo.find(@foo.id)
+      assert_equal foo.x, @foo.x
+      assert_equal foo.y, @foo.y
+    end
+    
+    should "reject a key which does not exist" do
+      assert_raise(Remodel::EntityNotFound) { Foo.find('x:66') }
+    end
+
+    should "reject an id which does not exist" do
+      assert_raise(Remodel::EntityNotFound) { Foo.find(66) }
+    end
+  end
+  
+  context "all" do
+    setup do
+      redis.flushdb
+      17.times { |i| Foo.create :x => 'hello', :y => i }
+      5.times { |i| Bar.create }
+    end
+    
+    should "find all entities of the given class" do
+      assert_equal 17, Foo.all.size
+      assert_equal 5, Bar.all.size
     end
   end
   

data/test/test_mappers.rb

@@ -1,6 +1,7 @@
 require 'helper'
 
 class Item < Remodel::Entity
+  property :boolean, :class => Boolean
   property :string, :class => String
   property :integer, :class => Integer
   property :float, :class => Float
@@ -41,6 +42,7 @@ class TestMappers < Test::Unit::TestCase
     
     should "handle nil values" do
       item = Item.create
+      assert_nil item.boolean
       assert_nil item.string
       assert_nil item.integer
       assert_nil item.float
@@ -51,6 +53,7 @@ class TestMappers < Test::Unit::TestCase
     end
     
     should "reject invalid types" do
+      assert_raise(Remodel::InvalidType) { Item.create :boolean => 'hello' }
       assert_raise(Remodel::InvalidType) { Item.create :string => true }
       assert_raise(Remodel::InvalidType) { Item.create :integer => 33.5 }
       assert_raise(Remodel::InvalidType) { Item.create :float => 5 }

data/test/test_monkeypatches.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+class TestMonkeypatches < Test::Unit::TestCase
+
+  context "Boolean" do
+    should "be the superclass of both true and false" do
+      assert true.is_a?(Boolean)
+      assert false.is_a?(Boolean)
+    end
+  end
+
+  context "Class[]" do
+    should "return given Class objects" do
+      assert_equal String, Class[String]
+    end
+    
+    should "return the Class object for a given String" do
+      assert_equal String, Class['String']
+    end
+
+    should "return the Class object for a given Symbol" do
+      assert_equal String, Class[:String]
+    end
+    
+    should "work for nested classes" do
+      assert_equal Remodel::Entity, Class['Remodel::Entity']
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: remodel
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Tim Lossen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 +01:00
+date: 2010-04-28 00:00:00 +02:00
 default_executable: redis-monitor.rb
 dependencies: []
 
@@ -29,6 +29,8 @@ files:
 - Rakefile
 - VERSION
 - bin/redis-monitor.rb
+- docs/docco.css
+- docs/remodel.html
 - example/book.rb
 - lib/remodel.rb
 - remodel.gemspec
@@ -37,6 +39,7 @@ files:
 - test/test_many_to_many.rb
 - test/test_many_to_one.rb
 - test/test_mappers.rb
+- test/test_monkeypatches.rb
 - test/test_one_to_many.rb
 - test/test_one_to_one.rb
 has_rdoc: true
@@ -73,5 +76,6 @@ test_files:
 - test/test_many_to_many.rb
 - test/test_many_to_one.rb
 - test/test_mappers.rb
+- test/test_monkeypatches.rb
 - test/test_one_to_many.rb
 - test/test_one_to_one.rb