Jekyll2023-02-24T17:31:39+00:00http://codebeerstartups.com/feed.xmlMohit JainMohit Jainjain.mohit27@gmail.comLazy Loading of Images in Rails2016-02-14T00:00:00+00:002016-02-14T00:00:00+00:00http://codebeerstartups.com/lazy-loading-of-images-in-rails<p>I recently came across a lot of lazy loading javascript plugins, but finally came to know about <a href="https://github.com/callmecavs/layzr.js">Layzr plugin</a> simple, lightweight and works like charm.</p>
<p>But the problem is the usage. So what we use in rails:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="o"><</span><span class="sx">%= image_tag "my_image.jpg" %></span></code></pre></figure>
<p>which generates an HTML code like this:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="o"><</span><span class="n">img</span> <span class="n">src</span><span class="o">=</span><span class="s2">"my_image.jpg"</span><span class="o">/></span></code></pre></figure>
<p>Now layzr javascript plugin is expecting something like this:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="o"><</span><span class="n">img</span> <span class="n">data</span><span class="o">-</span><span class="n">normal</span><span class="o">=</span><span class="s2">"my_image.jpg"</span><span class="o">/></span></code></pre></figure>
<p>and later on, it gets converted into using javascript:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="o"><</span><span class="n">img</span> <span class="n">scr</span><span class="o">=</span><span class="s2">"my_image.jpg"</span><span class="o">/></span></code></pre></figure>
<p>So what I want is a default image which will be loaded when page load happens and while scrolling default image should be replaced by a real image. So I can do it something like:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="o"><</span><span class="sx">%= image_tag "default_image.jpg", "data-normal" =</span><span class="o">></span> <span class="s2">"my_real_image.jpg"</span> <span class="o">%></span></code></pre></figure>
<p>or while using the paperclip as a gem makes it like:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="o"><</span><span class="sx">%= image_tag "default_image.jpg", "data-normal" =</span><span class="o">></span> <span class="n">image</span><span class="p">.</span><span class="nf">photo</span><span class="p">.</span><span class="nf">url</span><span class="p">(</span><span class="ss">:medium</span><span class="p">)</span> <span class="o">%></span></code></pre></figure>
<p>The above code is ugly. I don’t want to screw up my whole image_tag, so wrote a simple ruby gem to write a clean code, which takes a default image from configuration files and do the magic behind the screen. ie:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="o"><</span><span class="sx">%= image_tag "my_real_image.jpg", lazy: true %></span></code></pre></figure>
<p>This gets converted into:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="o"><</span><span class="n">img</span> <span class="n">src</span><span class="o">=</span><span class="s2">"default_image.jpg"</span> <span class="n">data</span><span class="o">-</span><span class="n">normal</span><span class="o">=</span><span class="s2">"my_image.jpg"</span><span class="o">/></span></code></pre></figure>
<h2 id="how-to-use-it">How to use it:</h2>
<p>All you need to do is:</p>
<h3 id="step-1">Step 1:</h3>
<p>Add it in your Gemfile</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">gem</span> <span class="s1">'layzr-rails'</span></code></pre></figure>
<h3 id="step-2">Step 2:</h3>
<p>Create a configuration file and put it in your initializers config/initializers/layzr.rb</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="no">Layzr</span><span class="o">::</span><span class="no">Rails</span><span class="p">.</span><span class="nf">configure</span> <span class="k">do</span> <span class="o">|</span><span class="n">config</span><span class="o">|</span>
<span class="n">config</span><span class="p">.</span><span class="nf">placeholder</span> <span class="o">=</span> <span class="s2">"/assets/some-default-image.png"</span>
<span class="k">end</span></code></pre></figure>
<h3 id="step-3">Step 3:</h3>
<p>Download layzr.js and include in application js and place this code:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="err">$</span><span class="p">(</span><span class="n">document</span><span class="p">).</span><span class="nf">ready</span><span class="p">(</span><span class="n">function</span><span class="p">()</span> <span class="p">{</span>
<span class="n">const</span> <span class="n">instance</span> <span class="o">=</span> <span class="no">Layzr</span><span class="p">()</span>
<span class="p">});</span></code></pre></figure>
<h3 id="step-4">Step 4:</h3>
<p>Images you want to make lazy load:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="o"><</span><span class="sx">%= image_tag "kittenz.png", alt: "OMG a cat!", lazy: true %></span></code></pre></figure>
<h3 id="thats-all-">That’s all :)</h3>
<p>that makes my code clean and efficient. You can use see the source code <a href="https://github.com/mohitjain/layzr-rails">here</a> having guidelines how to use it and some more options from the gem.</p>Mohit JainI recently came across a lot of lazy loading javascript plugins, but finally came to know about Layzr plugin simple, lightweight and works like charm.Scaling Ruby on Rails by Caching your database queries2014-11-22T19:02:46+00:002014-11-22T19:02:46+00:00http://codebeerstartups.com/scaling-ruby-on-rails-by-caching-your-database-queries<p>It’s pretty good to use active record in ruby on rails, relationships, find_by methods, where queries everything makes your
life much simpler as a developer but sooner or later your application becomes slow. At that time you need to work on optimizations.
There are a lot of work around for optimizations and one of them in caching the queries. The company I work for is StudyPad and we have a product
ie <a href="http://splashmath.com/?utm_campaign=codebeerstartups">splashmath</a> and that has over 9 millions users using it across multiple platforms. The amount of traffic that
we get is pretty huge and caching one of the things that helped us to solve out scaling problems. Here is a quick idea to cache your queries in Memcache.</p>
<h2 id="basic-requirements">Basic requirements</h2>
<p>There are few requirements for this. First is the <a href="https://github.com/mperham/dalli">dalli</a> gem and Memcache installed on your machine.</p>
<h2 id="basic-structure">Basic structure</h2>
<p>We have a lot of static/seed data which change very less and the queries on those things are pretty high. So first thing to handle that static data.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">Grade</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">has_many</span> <span class="ss">:skills</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Skills</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:grade</span>
<span class="k">end</span></code></pre></figure>
<p>So in order to get skills for a grade, its pretty simple</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">grade</span> <span class="o">=</span> <span class="no">Grade</span><span class="p">.</span><span class="nf">first</span>
<span class="n">skills</span> <span class="o">=</span> <span class="n">grade</span><span class="p">.</span><span class="nf">skills</span></code></pre></figure>
<p>Now for that matter every time we are fetching skills for a grade its gonna hit the database and get the results. So its
time to get this query and its results cached.</p>
<p>Assuming you have configured dalli gem easily and you have Memcached up and running. Here is a simple method to cache the results</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">def</span> <span class="nf">cached_skills</span>
<span class="no">Rails</span><span class="p">.</span><span class="nf">cache</span><span class="p">.</span><span class="nf">fetch</span><span class="p">([</span><span class="nb">self</span><span class="p">.</span><span class="nf">class</span><span class="p">.</span><span class="nf">name</span><span class="p">,</span> <span class="nb">id</span><span class="p">,</span> <span class="ss">:skills</span><span class="p">],</span> <span class="ss">expires_in: </span><span class="mi">240</span><span class="p">.</span><span class="nf">hours</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">skills</span><span class="p">.</span><span class="nf">to_a</span>
<span class="p">}</span>
<span class="k">end</span></code></pre></figure>
<p>So instead of fetching skills like</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">grade</span><span class="p">.</span><span class="nf">skills</span></code></pre></figure>
<p>we are gonna get it like</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">grade</span><span class="p">.</span><span class="nf">cached_skills</span></code></pre></figure>
<p>So whats its gonna do. It’s gonna fetch the results first time from the database and store it in a cache.
Next time its gonna return the results from the cache. Note few things here.</p>
<ul>
<li>Understand the pattern of the key. [self.class.name, id, :skills] is your key here.</li>
<li>Cache will expire in 240.hours. You can customize it as per your needs.
Better keep a constant for this somewhere in your application.</li>
<li>In cached_skills methods we keep records not the active record relations that why we have to convert
into array by using to_a else active-record-relation will be cached and database query will be executed.</li>
</ul>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">skills</span><span class="p">.</span><span class="nf">to_a</span></code></pre></figure>
<h2 id="expiring-the-cache">Expiring the cache.</h2>
<p>We are caching the query results but we are not expiring the results. What if some skill has changed. Grade object is
not getting any notification for that, so the cache is stale, we need to expire it. So we can write an after_commit hook for
skill to expire its grade object’s cache</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="c1"># in skill model</span>
<span class="n">after_commit</span> <span class="ss">:flush_cache</span>
<span class="k">def</span> <span class="nf">flush_cache</span>
<span class="no">Rails</span><span class="p">.</span><span class="nf">cache</span><span class="p">.</span><span class="nf">delete</span><span class="p">([</span><span class="nb">self</span><span class="p">.</span><span class="nf">grade</span><span class="p">.</span><span class="nf">class</span><span class="p">.</span><span class="nf">name</span><span class="p">,</span> <span class="nb">self</span><span class="p">.</span><span class="nf">grade_id</span><span class="p">,</span> <span class="ss">:skills</span><span class="p">])</span>
<span class="k">end</span></code></pre></figure>
<p>This is enough to make sure you cache is never stale. There is another way to handle the expiring cache. Let’s see that.</p>
<h2 id="another-way">Another way</h2>
<p>We redefine the models like this</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">Grade</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">has_many</span> <span class="ss">:skills</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Skills</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:grade</span><span class="p">,</span> <span class="ss">touch: </span><span class="kp">true</span>
<span class="k">end</span></code></pre></figure>
<p>Note we have added touch: true in skills, and now we redefine our cached_skills method again:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">def</span> <span class="nf">cached_skills</span>
<span class="no">Rails</span><span class="p">.</span><span class="nf">cache</span><span class="p">.</span><span class="nf">fetch</span><span class="p">([</span><span class="nb">self</span><span class="p">.</span><span class="nf">class</span><span class="p">.</span><span class="nf">name</span><span class="p">,</span> <span class="n">updated_at</span><span class="p">.</span><span class="nf">to_i</span><span class="p">,</span> <span class="ss">:skills</span><span class="p">],</span> <span class="ss">expires_in: </span><span class="mi">240</span><span class="p">.</span><span class="nf">hours</span><span class="p">)</span> <span class="p">{</span>
<span class="n">skills</span><span class="p">.</span><span class="nf">to_a</span>
<span class="p">}</span>
<span class="k">end</span></code></pre></figure>
<p>Now just caching this we don’t need to expire the cache manually, whenever skills get updated it will touch its parent
object grade, that will update its updated_at value and that specific cache will be never used, as key attribute updated_at has been changed.</p>
<h2 id="the-problem-with-the-second-approach">The problem with the second approach</h2>
<p>But there is a problem. Assume you have 10 different has_many relationships for grade and you are caching it all, now every time a
skill has been changed all the other cache keys for grade relationships will be useless too. For example Grade has_many topics</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">Grade</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">has_many</span> <span class="ss">:skills</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Skill</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:grade</span><span class="p">,</span> <span class="ss">touch: </span><span class="kp">true</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Topic</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:grade</span><span class="p">,</span> <span class="ss">touch: </span><span class="kp">true</span>
<span class="k">end</span></code></pre></figure>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="c1"># In Grade model</span>
<span class="k">def</span> <span class="nf">cached_skills</span>
<span class="no">Rails</span><span class="p">.</span><span class="nf">cache</span><span class="p">.</span><span class="nf">fetch</span><span class="p">([</span><span class="nb">self</span><span class="p">.</span><span class="nf">class</span><span class="p">.</span><span class="nf">name</span><span class="p">,</span> <span class="n">updated_at</span><span class="p">.</span><span class="nf">to_i</span><span class="p">,</span> <span class="ss">:skills</span><span class="p">],</span> <span class="ss">expires_in: </span><span class="mi">240</span><span class="p">.</span><span class="nf">hours</span><span class="p">)</span> <span class="p">{</span>
<span class="n">skills</span><span class="p">.</span><span class="nf">to_a</span>
<span class="p">}</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">cached_topics</span>
<span class="no">Rails</span><span class="p">.</span><span class="nf">cache</span><span class="p">.</span><span class="nf">fetch</span><span class="p">([</span><span class="nb">self</span><span class="p">.</span><span class="nf">class</span><span class="p">.</span><span class="nf">name</span><span class="p">,</span> <span class="n">updated_at</span><span class="p">.</span><span class="nf">to_i</span><span class="p">,</span> <span class="ss">:topics</span><span class="p">],</span> <span class="ss">expires_in: </span><span class="mi">240</span><span class="p">.</span><span class="nf">hours</span><span class="p">)</span> <span class="p">{</span>
<span class="n">topics</span><span class="p">.</span><span class="nf">to_a</span>
<span class="p">}</span>
<span class="k">end</span></code></pre></figure>
<p>Now in this case changing any skill will make topics cache useless, but that’s not the case when you are trying to expire it manually.
So both approaches has pros and cons, first will ask you write more code and second expire cache more frequently. You have to make that choice as per your needs.</p>
<h2 id="what-else">What else?</h2>
<p>Using the same base principle you can cache lot of queries like</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="no">Grade</span><span class="p">.</span><span class="nf">cached_find_by_id</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="no">Skill</span><span class="p">.</span><span class="nf">first</span><span class="p">.</span><span class="nf">cached_grade</span></code></pre></figure>
<p>This approach helped us to reduce the load on RDS and make things pretty fast. I hope this will help you too.
Let me know your feedback or some tips that made you system faster</p>Mohit Jainjain.mohit27@gmail.comIt’s pretty good to use active record in ruby on rails, relationships, find_by methods, where queries everything makes your life much simpler as a developer but sooner or later your application becomes slow. At that time you need to work on optimizations. There are a lot of work around for optimizations and one of them in caching the queries. The company I work for is StudyPad and we have a product ie splashmath and that has over 9 millions users using it across multiple platforms. The amount of traffic that we get is pretty huge and caching one of the things that helped us to solve out scaling problems. Here is a quick idea to cache your queries in Memcache.Spliting Seed files into multiple file in Ruby on Rails2014-01-18T18:25:53+00:002014-01-18T18:25:53+00:00http://codebeerstartups.com/2014/01/spliting-seed-file-into-multiple-files-in-ruby-on-rails<p>Last month I joined a new job after a break of almost 4 months. You can check out the <a href="http://www.splashmath.com?utm_source=codebeerstartups">product</a> and there we had a small problem that our seed file was growing very fast. So we did a small thing to maintain our seed file. Here is a small tip if you are having a massive seed file and it’s pretty easy to implement.</p>
<p>We can store all our seeds inside the folder db/seeds and inside the db/seeds.rb we write the following:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="no">Dir</span><span class="p">[</span><span class="no">File</span><span class="p">.</span><span class="nf">join</span><span class="p">(</span><span class="no">Rails</span><span class="p">.</span><span class="nf">root</span><span class="p">,</span> <span class="s1">'db'</span><span class="p">,</span> <span class="s1">'seeds'</span><span class="p">,</span> <span class="s1">'*.rb'</span><span class="p">)].</span><span class="nf">sort</span><span class="p">.</span><span class="nf">each</span> <span class="p">{</span> <span class="o">|</span><span class="n">seed</span><span class="o">|</span> <span class="nb">load</span> <span class="n">seed</span> <span class="p">}</span></code></pre></figure>
<p>We can sort the files alphabetically before loading them.</p>
<h2 id="what-if-seed-file-ordering-is-important">What if seed file ordering is important?</h2>
<p>In that case, we can use the trick migrations are using. Timestamp in front of file names to make sure there ordering is same. So instead of using a timestamp, you can add a serial number in front of file name like 01_grades.rb, 02_topics.rb, 03_skills.rb.</p>
<p>I hope this will help someone in case you are facing same issues.</p>Mohit Jainjain.mohit27@gmail.comLast month I joined a new job after a break of almost 4 months. You can check out the product and there we had a small problem that our seed file was growing very fast. So we did a small thing to maintain our seed file. Here is a small tip if you are having a massive seed file and it’s pretty easy to implement.Use belongs_to with presence validator2013-07-13T22:35:00+00:002013-07-13T22:35:00+00:00http://codebeerstartups.com/use-belongs-to-with-presence-validator<p>Assume we have two models: User and Image. User has one image and image belongs to a user. The code below:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">User</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">has_one</span> <span class="ss">:image</span>
<span class="k">end</span>
<span class="k">class</span> <span class="nc">Image</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:user</span>
<span class="k">end</span></code></pre></figure>
<p>Now we want to add validation for the image to check if the user is there or not.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">Image</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:user</span>
<span class="n">validates</span> <span class="ss">:user</span><span class="p">,</span> <span class="ss">:presence</span> <span class="o">=></span> <span class="kp">true</span>
<span class="k">end</span></code></pre></figure>
<p>So by adding just one line whenever you are trying to save image object, it will fire a query with respect to the user_id to check whether that user exists or not. In case the user doesn’t exit “image.save” with return an error.</p>
<p>Happy Hacking :)</p>Mohit Jainjain.mohit27@gmail.comAssume we have two models: User and Image. User has one image and image belongs to a user. The code below:Better way to parse user info from omniauth hash2013-07-10T04:06:00+00:002013-07-10T04:06:00+00:00http://codebeerstartups.com/better-way-to-parse-user-info-from-omniauth-hash<p>Let’s assume we have to parse this hash. There can be the case we are not getting the keys as a response. So this post is about handling those cases.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">auth</span> <span class="o">=</span> <span class="p">{</span>
<span class="ss">:provider</span> <span class="o">=></span> <span class="s1">'facebook'</span><span class="p">,</span>
<span class="ss">:uid</span> <span class="o">=></span> <span class="s1">'1234567'</span><span class="p">,</span>
<span class="ss">:info</span> <span class="o">=></span> <span class="p">{</span>
<span class="ss">:nickname</span> <span class="o">=></span> <span class="s1">'jbloggs'</span><span class="p">,</span>
<span class="ss">:email</span> <span class="o">=></span> <span class="s1">'joe@bloggs.com'</span><span class="p">,</span>
<span class="ss">:name</span> <span class="o">=></span> <span class="s1">'Joe Bloggs'</span><span class="p">,</span>
<span class="ss">:first_name</span> <span class="o">=></span> <span class="s1">'Joe'</span><span class="p">,</span>
<span class="ss">:last_name</span> <span class="o">=></span> <span class="s1">'Bloggs'</span><span class="p">,</span>
<span class="ss">:image</span> <span class="o">=></span> <span class="s1">'http://graph.facebook.com/1234567/picture?type=square'</span><span class="p">,</span>
<span class="ss">:urls</span> <span class="o">=></span> <span class="p">{</span> <span class="ss">:Facebook</span> <span class="o">=></span> <span class="s1">'http://www.facebook.com/jbloggs'</span> <span class="p">},</span>
<span class="ss">:location</span> <span class="o">=></span> <span class="s1">'Palo Alto, California'</span><span class="p">,</span>
<span class="ss">:verified</span> <span class="o">=></span> <span class="kp">true</span>
<span class="p">},</span>
<span class="ss">:credentials</span> <span class="o">=></span> <span class="p">{</span>
<span class="ss">:token</span> <span class="o">=></span> <span class="s1">'ABCDEF...'</span><span class="p">,</span> <span class="c1"># OAuth 2.0 access_token, which you may wish to store</span>
<span class="ss">:expires_at</span> <span class="o">=></span> <span class="mi">1321747205</span><span class="p">,</span> <span class="c1"># when the access token expires (it always will)</span>
<span class="ss">:expires</span> <span class="o">=></span> <span class="kp">true</span> <span class="c1"># this will always be true</span>
<span class="p">}</span>
<span class="p">}</span></code></pre></figure>
<h2 id="general-scenario">General Scenario</h2>
<p>So in the best case scenario, we will be having all the keys. So the code like this will work.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">user_email</span> <span class="o">=</span> <span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">][</span><span class="ss">:email</span><span class="p">]</span>
<span class="n">user_nickname</span> <span class="o">=</span> <span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">][</span><span class="ss">:nickname</span><span class="p">]</span>
<span class="n">user_location</span> <span class="o">=</span> <span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">][</span><span class="ss">:location</span><span class="p">]</span></code></pre></figure>
<h2 id="exceptional-scenario">Exceptional Scenario</h2>
<p>Now think about this case when we don’t have location key in the response. So we got a hash like this:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">auth</span> <span class="o">=</span> <span class="p">{</span>
<span class="ss">:provider</span> <span class="o">=></span> <span class="s1">'facebook'</span><span class="p">,</span>
<span class="ss">:uid</span> <span class="o">=></span> <span class="s1">'1234567'</span><span class="p">,</span>
<span class="ss">:info</span> <span class="o">=></span> <span class="p">{</span>
<span class="ss">:nickname</span> <span class="o">=></span> <span class="s1">'jbloggs'</span><span class="p">,</span>
<span class="ss">:email</span> <span class="o">=></span> <span class="s1">'joe@bloggs.com'</span><span class="p">,</span>
<span class="ss">:name</span> <span class="o">=></span> <span class="s1">'Joe Bloggs'</span><span class="p">,</span>
<span class="ss">:first_name</span> <span class="o">=></span> <span class="s1">'Joe'</span><span class="p">,</span>
<span class="ss">:last_name</span> <span class="o">=></span> <span class="s1">'Bloggs'</span><span class="p">,</span>
<span class="ss">:image</span> <span class="o">=></span> <span class="s1">'http://graph.facebook.com/1234567/picture?type=square'</span><span class="p">,</span>
<span class="ss">:urls</span> <span class="o">=></span> <span class="p">{</span> <span class="ss">:Facebook</span> <span class="o">=></span> <span class="s1">'http://www.facebook.com/jbloggs'</span> <span class="p">},</span>
<span class="ss">:verified</span> <span class="o">=></span> <span class="kp">true</span>
<span class="p">},</span>
<span class="ss">:credentials</span> <span class="o">=></span> <span class="p">{</span>
<span class="ss">:token</span> <span class="o">=></span> <span class="s1">'ABCDEF...'</span><span class="p">,</span> <span class="c1"># OAuth 2.0 access_token, which you may wish to store</span>
<span class="ss">:expires_at</span> <span class="o">=></span> <span class="mi">1321747205</span><span class="p">,</span> <span class="c1"># when the access token expires (it always will)</span>
<span class="ss">:expires</span> <span class="o">=></span> <span class="kp">true</span> <span class="c1"># this will always be true</span>
<span class="p">}</span>
<span class="p">}</span></code></pre></figure>
<p>Now in this case</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">user_email</span> <span class="o">=</span> <span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">][</span><span class="ss">:email</span><span class="p">]</span> <span class="c1"># will work</span>
<span class="n">user_nickname</span> <span class="o">=</span> <span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">][</span><span class="ss">:nickname</span><span class="p">]</span> <span class="c1"># will work</span>
<span class="n">user_location</span> <span class="o">=</span> <span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">][</span><span class="ss">:location</span><span class="p">]</span> <span class="c1"># will return nil here...</span></code></pre></figure>
<p>As we all know there is no surety of the hash from the provider so we cant trust it and this ‘nil’ value can, later on, create issues as we start using it assuming everything is coming perfectly fine from the provider.</p>
<p>So if you want to generate an error in this case when key is not found a simple way can be using statement modifiers ie</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">][</span><span class="ss">:location</span><span class="p">]</span> <span class="n">or</span> <span class="k">raise</span> <span class="no">ArgumentError</span>
<span class="c1"># => example.rb:23:in `<main>': ArgumentError (ArgumentError)</span></code></pre></figure>
<p>but there is a better way ie <strong> using ‘fetch’ </strong></p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">].</span><span class="nf">fetch</span><span class="p">(</span><span class="ss">:location</span><span class="p">)</span> <span class="o">/</span><span class="sr">/ this will throw an error
# => example.rb:23:in `fetch': key not found: :location (KeyError) from example.rb:23:in `<main>'</span></code></pre></figure>
<p>If you are not sure even for info part (which actually you can’t be) then you can chain ie like this:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">auth</span><span class="p">.</span><span class="nf">fetch</span><span class="p">(</span><span class="ss">:info</span><span class="p">).</span><span class="nf">fetch</span><span class="p">(</span><span class="ss">:location</span><span class="p">)</span></code></pre></figure>
<h2 id="use-case-1---providing-a-default-value">Use case 1 - Providing a default value</h2>
<p>Now if you want to pass a block for a default value which will be executed if and only if that key is not valuated.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">].</span><span class="nf">fetch</span><span class="p">(</span><span class="ss">:location</span><span class="p">)</span> <span class="p">{</span> <span class="s2">"India"</span> <span class="p">}</span>
<span class="c1"># => "India"</span></code></pre></figure>
<h2 id="use-case-2---passing-a-block">Use case 2 - Passing a block</h2>
<p>Another use case of fetch is it yields the missing key which can be used as</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">default</span> <span class="o">=</span> <span class="o">-></span><span class="p">(</span><span class="n">key</span><span class="p">)</span> <span class="k">do</span>
<span class="nb">puts</span> <span class="s2">"</span><span class="si">#{</span><span class="n">key</span><span class="si">}</span><span class="s2"> is missing "</span>
<span class="k">end</span>
<span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">].</span><span class="nf">fetch</span><span class="p">(</span><span class="ss">:location</span><span class="p">,</span> <span class="o">&</span><span class="n">default</span><span class="p">)</span></code></pre></figure>
<h2 id="caution">Caution</h2>
<p>Another thing to note with fetch is, there is another way to pass the second parameter is method ie:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">def</span> <span class="nf">default</span>
<span class="s2">"This is my default value"</span>
<span class="k">end</span>
<span class="n">auth</span><span class="p">[</span><span class="ss">:info</span><span class="p">].</span><span class="nf">fetch</span><span class="p">(</span><span class="ss">:location</span><span class="p">,</span> <span class="n">default</span><span class="p">)</span></code></pre></figure>
<p>But the problem with the second one is default method. This method will be computed every time whether your key exists or not, which can be a problem in case you are doing some heavy computation. Using block will execute if and only if the key doesn’t exist.</p>
<h2 id="fetch-also-works-on-arrays">Fetch also works on arrays</h2>
<p>Another thing to note down is fetch also works on array as it works on hash</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'a'</span><span class="p">,</span><span class="s1">'b'</span><span class="p">,</span><span class="s1">'c'</span><span class="p">,</span><span class="s1">'d'</span><span class="p">]</span>
<span class="n">a</span><span class="p">[</span><span class="mi">10</span><span class="p">]</span> <span class="c1"># => nil</span>
<span class="n">a</span><span class="p">.</span><span class="nf">fetch</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span> <span class="c1"># => example.rb:39:in `fetch': index 10 outside of array bounds: -4...4 (IndexError) from example.rb:39:in `<main>'</span></code></pre></figure>
<p>That’s all :)</p>Mohit Jainjain.mohit27@gmail.comLet’s assume we have to parse this hash. There can be the case we are not getting the keys as a response. So this post is about handling those cases.The Law of Demeter for ruby on rails2013-05-19T00:00:00+00:002013-05-19T00:00:00+00:00http://codebeerstartups.com/the-law-of-demeter-for-ruby-on-rails<p>According to the law of Demeter, a model should only talk to its immediate association, don’t talk to the association’s association and association’s property, it is a case of loose coupling.</p>
<h2 id="bad-smell">Bad Smell</h2>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">Invoice</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:user</span>
<span class="k">end</span>
<span class="o"><</span><span class="sx">%= @invoice.user.name %>
<%=</span> <span class="vi">@invoice</span><span class="p">.</span><span class="nf">user</span><span class="p">.</span><span class="nf">address</span> <span class="sx">%>
<%= @invoice.user.cellphone %></span></code></pre></figure>
<p>In this example, invoice model calls the association(user)’s property(name, address, and cellphone), which violates the law of Demeter. We should add some wrapper methods.</p>
<h2 id="refactor">Refactor</h2>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">Invoice</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:user</span>
<span class="n">delegate</span> <span class="ss">:name</span><span class="p">,</span> <span class="ss">:address</span><span class="p">,</span> <span class="ss">:cellphone</span><span class="p">,</span> <span class="ss">:to</span> <span class="o">=></span> <span class="ss">:user</span><span class="p">,</span> <span class="ss">:prefix</span> <span class="o">=></span> <span class="kp">true</span>
<span class="k">end</span>
<span class="o"><</span><span class="sx">%= @invoice.user_name %>
<%=</span> <span class="vi">@invoice</span><span class="p">.</span><span class="nf">user_address</span> <span class="sx">%>
<%= @invoice.user_cellphone %></span></code></pre></figure>
<p>Luckily, Rails provides a helper method delegate which utilizes the DSL way to generates the wrapper methods. Besides the loose coupling, delegate also prevents the error call method on nil object if you add option :allow_nil => true.</p>
<p><a href="http://rails-bestpractices.com/posts/15-the-law-of-demeter">Source</a></p>Mohit Jainjain.mohit27@gmail.comAccording to the law of Demeter, a model should only talk to its immediate association, don’t talk to the association’s association and association’s property, it is a case of loose coupling.Keeping ruby on rails model DRY - MetaProgramming2013-04-28T17:41:00+00:002013-04-28T17:41:00+00:00http://codebeerstartups.com/keeping-ruby-on-rails-model-dry-metaprogramming<p>If you find some methods whose definitions are more or less similar, only different by the method name, it may use meta programming to simplify the things to make your model more clean and DRY.</p>
<p>Consider this simple example where we have an article with three states.</p>
<h2 id="before">Before</h2>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">Article</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="k">def</span> <span class="nc">self</span><span class="o">.</span><span class="nf">all_published</span>
<span class="n">where</span><span class="p">(</span><span class="s2">"state = ?"</span><span class="p">,</span> <span class="s2">"published"</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">all_draft</span>
<span class="n">where</span><span class="p">(</span><span class="s2">"state = ?"</span><span class="p">,</span> <span class="s2">"draft"</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">all_spam</span>
<span class="n">where</span><span class="p">(</span><span class="s2">"state = ?"</span><span class="p">,</span> <span class="s2">"spam"</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">published?</span>
<span class="nb">self</span><span class="p">.</span><span class="nf">state</span> <span class="o">==</span> <span class="s1">'published'</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">draft?</span>
<span class="nb">self</span><span class="p">.</span><span class="nf">state</span> <span class="o">==</span> <span class="s1">'draft'</span>
<span class="k">end</span>
<span class="k">def</span> <span class="nf">spam?</span>
<span class="nb">self</span><span class="p">.</span><span class="nf">state</span> <span class="o">==</span> <span class="s1">'spam'</span>
<span class="k">end</span>
<span class="k">end</span></code></pre></figure>
<p>Now this code can be written as:</p>
<h2 id="after">After</h2>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">Article</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="no">STATES</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'draft'</span><span class="p">,</span> <span class="s1">'published'</span><span class="p">,</span> <span class="s1">'spam'</span><span class="p">]</span>
<span class="k">class</span> <span class="o"><<</span><span class="nb">self</span>
<span class="no">STATES</span><span class="p">.</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">state_name</span><span class="o">|</span>
<span class="n">define_method</span> <span class="s2">"all_</span><span class="si">#{</span><span class="n">state_name</span><span class="si">}</span><span class="s2">"</span> <span class="k">do</span>
<span class="n">where</span><span class="p">(</span><span class="s2">"state = ?"</span><span class="p">,</span> <span class="n">state_name</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="no">STATES</span><span class="p">.</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">state_name</span><span class="o">|</span>
<span class="n">define_method</span> <span class="s2">"</span><span class="si">#{</span><span class="n">state_name</span><span class="si">}</span><span class="s2">?"</span> <span class="k">do</span>
<span class="nb">self</span><span class="p">.</span><span class="nf">state</span> <span class="o">==</span> <span class="n">state_name</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span></code></pre></figure>
<p>This makes your code drier and cleaner. And adding more states makes it easier to modify.</p>Mohit Jainjain.mohit27@gmail.comIf you find some methods whose definitions are more or less similar, only different by the method name, it may use meta programming to simplify the things to make your model more clean and DRY.How to optimize image uploaded via paperclip2013-04-26T22:28:00+00:002013-04-26T22:28:00+00:00http://codebeerstartups.com/how-to-optimize-image-uploaded-via-paperclip<p>Previously I wrote a post for <a href="http://www.codebeerstartups.com/2012/10/save-image-as-progressive-image-using-paperclip-and-imagemagick/">saving image as progressive image</a>, continuing the same, here is and another gem to reduce the size of the progressive image.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">gem</span> <span class="s2">"paperclip-compression"</span><span class="p">,</span><span class="s2">"~> 0.1.1"</span></code></pre></figure>
<h2 id="usage">Usage</h2>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="k">class</span> <span class="nc">User</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">has_attached_file</span> <span class="ss">:avatar</span><span class="p">,</span>
<span class="ss">:styles</span> <span class="o">=></span> <span class="p">{</span> <span class="ss">:medium</span> <span class="o">=></span> <span class="s2">"300x300>"</span><span class="p">,</span> <span class="ss">:thumb</span> <span class="o">=></span> <span class="s2">"100x100>"</span> <span class="p">},</span>
<span class="ss">:processors</span> <span class="o">=></span> <span class="p">[</span><span class="ss">:thumbnail</span><span class="p">,</span> <span class="ss">:compression</span><span class="p">]</span>
<span class="k">end</span></code></pre></figure>
<p>From <a href="http://www.codebeerstartups.com/2012/10/save-image-as-progressive-image-using-paperclip-and-imagemagick/">previous learnings</a> we can optimize this code as:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">has_attached_file</span> <span class="ss">:attachment</span><span class="p">,</span> <span class="p">{</span>
<span class="ss">:styles</span> <span class="o">=></span> <span class="p">{</span>
<span class="ss">:medium</span> <span class="o">=></span> <span class="p">[</span><span class="s2">"654x500>"</span><span class="p">,</span> <span class="ss">:jpg</span><span class="p">],</span>
<span class="ss">:thumb</span> <span class="o">=></span><span class="p">[</span><span class="s2">"200x200#"</span><span class="p">,</span> <span class="ss">:jpg</span><span class="p">]</span>
<span class="p">},</span>
<span class="ss">:convert_options</span> <span class="o">=></span> <span class="p">{</span>
<span class="ss">:medium</span> <span class="o">=></span> <span class="s2">"-quality 80 -interlace Plane"</span><span class="p">,</span>
<span class="ss">:thumb</span> <span class="o">=></span> <span class="s2">"-quality 80 -interlace Plane"</span>
<span class="p">}</span>
<span class="p">},</span>
<span class="ss">:processors</span> <span class="o">=></span> <span class="p">[</span><span class="ss">:thumbnail</span><span class="p">,</span> <span class="ss">:compression</span><span class="p">]</span></code></pre></figure>
<p>After using this optimization trick I am able to save approx 20% of image size in my projects. Pretty nice and clean.</p>Mohit Jainjain.mohit27@gmail.comPreviously I wrote a post for saving image as progressive image, continuing the same, here is and another gem to reduce the size of the progressive image.Must have gems for development machine in ruby on rails2013-04-25T23:29:00+00:002013-04-25T23:29:00+00:00http://codebeerstartups.com/must-have-gems-for-development-machine-in-ruby-on-rails<p>Rubygems are the best thing that happened in ruby on rails. So today here is my list of gems in development group that helps to make things faster or sometimes bring simplicity to the development process</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">gem</span> <span class="s2">"better_errors"</span>
<span class="n">gem</span> <span class="s2">"binding_of_caller"</span>
<span class="n">gem</span> <span class="s1">'annotate'</span>
<span class="n">gem</span> <span class="s1">'bullet'</span>
<span class="n">gem</span> <span class="s1">'debugger'</span>
<span class="n">gem</span> <span class="s1">'flay'</span>
<span class="n">gem</span> <span class="s1">'hirb'</span>
<span class="n">gem</span> <span class="s1">'localtunnel'</span>
<span class="n">gem</span> <span class="s1">'lol_dba'</span>
<span class="n">gem</span> <span class="s1">'mailcatcher'</span>
<span class="n">gem</span> <span class="s1">'meta_request'</span><span class="p">,</span><span class="s1">'0.2.1'</span>
<span class="n">gem</span> <span class="s1">'pry'</span>
<span class="n">gem</span> <span class="s1">'pry-doc'</span>
<span class="n">gem</span> <span class="s1">'quiet_assets'</span>
<span class="n">gem</span> <span class="s1">'rack-mini-profiler'</span>
<span class="n">gem</span> <span class="s1">'railroady'</span>
<span class="n">gem</span> <span class="s1">'rails-footnotes'</span><span class="p">,</span> <span class="s1">'>= 3.7.5.rc4'</span>
<span class="n">gem</span> <span class="s1">'rails_best_practices'</span>
<span class="n">gem</span> <span class="s1">'reek'</span>
<span class="n">gem</span> <span class="s1">'request-log-analyzer'</span>
<span class="n">gem</span> <span class="s1">'smusher'</span>
<span class="n">gem</span> <span class="s1">'zeus'</span> <span class="c1"># don't add this in your gemfile.</span></code></pre></figure>
<h2 id="what-they-do">What they do:</h2>
<h4 id="better_errors"><a href="https://github.com/charliesome/better_errors">better_errors</a>:</h4>
<p>Better Errors replaces the standard Rails error page with a much better and more useful error page. It is also usable outside of Rails in any Rack app as Rack middleware. If you would like to use Better Errors’ advanced features (REPL, local/instance variable inspection, pretty stack frame names), you need to add the binding_of_caller</p>
<p><img src="/wp-content/images/better_errors.png?fit=750,274" alt="Better errors Screenshot" /></p>
<h4 id="annotate"><a href="https://github.com/ctran/annotate_models">annotate</a></h4>
<p>Will generate a schema of the model on the top of the model. Something like this.</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="c1"># == Schema Info</span>
<span class="c1">#</span>
<span class="c1"># Table name: line_items</span>
<span class="c1">#</span>
<span class="c1"># id :integer(11) not null, primary key</span>
<span class="c1"># quantity :integer(11) not null</span>
<span class="c1"># product_id :integer(11) not null</span>
<span class="c1"># unit_price :float</span>
<span class="c1"># order_id :integer(11)</span>
<span class="c1">#</span>
<span class="k">class</span> <span class="nc">LineItem</span> <span class="o"><</span> <span class="no">ActiveRecord</span><span class="o">::</span><span class="no">Base</span>
<span class="n">belongs_to</span> <span class="ss">:product</span></code></pre></figure>
<h4 id="bullet"><a href="https://github.com/flyerhzm/bullet">bullet</a>:</h4>
<p>The Bullet gem is designed to help you increase your application’s performance by reducing the number of queries it makes. It will watch your queries while you develop your application and notify you when you should add eager loading (N+1 queries), when you’re using eager loading that isn’t necessary and when you should use the counter cache. Best practice is to use Bullet in development mode or custom mode (staging, profile, etc.). The last thing you want is your clients getting alerts about how lazy you are.</p>
<h4 id="debugger"><a href="https://github.com/cldwalker/debugger">debugger</a></h4>
<p>Best debugger for your rails application.</p>
<h4 id="flay"><a href="https://github.com/seattlerb/flay">flay</a></h4>
<p>Flay analyzes code for structural similarities. Differences in literal
values, variable, class, method names, whitespace, programming style, braces vs do/end etc are all ignored. Making this totally rad.</p>
<h4 id="hirb"><a href="https://github.com/cldwalker/hirb">hirb</a>:</h4>
<p>A mini view framework for console/irb that’s easy to use, even while under its influence. Console goodies include a no-wrap table, auto-pager, tree, and menu. A console gem that will display your results something like this:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="o">>></span> <span class="no">Tag</span><span class="p">.</span><span class="nf">last</span>
<span class="o">+-----+-------------------------+-------------+---------------+-----------+-----------+-------+</span>
<span class="o">|</span> <span class="nb">id</span> <span class="o">|</span> <span class="n">created_at</span> <span class="o">|</span> <span class="n">description</span> <span class="o">|</span> <span class="nb">name</span> <span class="o">|</span> <span class="n">namespace</span> <span class="o">|</span> <span class="n">predicate</span> <span class="o">|</span> <span class="n">value</span> <span class="o">|</span>
<span class="o">+-----+-------------------------+-------------+---------------+-----------+-----------+-------+</span>
<span class="o">|</span> <span class="mi">907</span> <span class="o">|</span> <span class="mi">2009</span><span class="o">-</span><span class="mo">03</span><span class="o">-</span><span class="mo">06</span> <span class="mi">21</span><span class="p">:</span><span class="mi">10</span><span class="p">:</span><span class="mi">41</span> <span class="no">UTC</span> <span class="o">|</span> <span class="o">|</span> <span class="n">gem</span><span class="ss">:tags</span><span class="o">=</span><span class="n">yaml</span> <span class="o">|</span> <span class="n">gem</span> <span class="o">|</span> <span class="n">tags</span> <span class="o">|</span> <span class="n">yaml</span> <span class="o">|</span>
<span class="o">+-----+-------------------------+-------------+---------------+-----------+-----------+-------+</span>
<span class="mi">1</span> <span class="n">row</span> <span class="k">in</span> <span class="n">set</span></code></pre></figure>
<h4 id="localtunnel"><a href="https://github.com/progrium/localtunnel">localtunnel</a></h4>
<p>Localtunnel lets you expose a local web server to the public Internet. For example, running a web server on port 8000 on your laptop can be made public with::</p>
<figure class="highlight"><pre><code class="language-bash" data-lang="bash"> <span class="nv">$ </span>localtunnel-beta 8000
Port 8000 is now accessible from http://8fde2c.v2.localtunnel.com ...</code></pre></figure>
<h4 id="lol_dba"><a href="https://github.com/plentz/lol_dba">lol_dba</a>:</h4>
<p>lol_dba is a small package of rake tasks that scan your application models and displays a list of columns that probably should be indexed. Also, it can generate .sql migration scripts.</p>
<h4 id="mailcatcher"><a href="https://github.com/sj26/mailcatcher">mailcatcher</a>:</h4>
<p>MailCatcher runs a super simple SMTP server which catches any message sent to it to display in a web interface. Run mail catcher, set your favorite app to deliver to smtp://127.0.0.1:1025 instead of your default SMTP server, then check out http://127.0.0.1:1080 to see the mail that’s arrived so far.</p>
<p><img src="/wp-content/images/mailcatcher.png?fit=750,274" alt="mailcatcher" /></p>
<h4 id="meta_request">meta_request</h4>
<p>RailsPanel is a Chrome extension for Rails development that will end your tailing of development.log. Have all information about your Rails app requests in the browser - in the Developer Tools panel. Provides insight to db/rendering/total times, parameter list, rendered views and more.</p>
<p><img src="/wp-content/images/railspanel.png?fit=750,274" alt="RailsPanel" /></p>
<h4 id="pry"><a href="https://github.com/pry/pry">pry</a></h4>
<p>:An IRB alternative and runtime developer console</p>
<h4 id="quiet_assets"><a href="https://github.com/evrone/quiet_assets">quiet_assets</a>:</h4>
<p>Mutes assets pipeline log messages.</p>
<h4 id="rack-mini-profiler"><a href="https://github.com/harleyttd/miniprofiler">rack-mini-profiler</a>:</h4>
<p>Middleware that displays speed badge for every HTML page. Designed to work both in production and in development.</p>
<p><img src="/wp-content/images/miniprofiler.png?fit=750,274" alt="miniprofiler" /></p>
<h4 id="railroady"><a href="https://github.com/preston/railroady">railroady</a>:</h4>
<p>RailRoady generates Rails 3 model (AcitveRecord, Mongoid, Datamapper) and controller UML diagrams as cross-platform .svg files, as well as in the DOT language.</p>
<h4 id="rails-footnotes"><a href="https://github.com/josevalim/rails-footnotes">rails-footnotes</a>:</h4>
<p>Every Rails page has footnotes that give information about your application and links back to your editor</p>
<p><img src="/wp-content/images/footernotes.png?fit=750,274" alt="footernotes" /></p>
<h4 id="rails_best_practices"><a href="https://github.com/railsbp/rails_best_practices">rails_best_practices</a>:</h4>
<p>A code metric tool for rails projects</p>
<h4 id="reek"><a href="https://github.com/troessner/reek">reek</a>:</h4>
<p>Code smell detector for Ruby</p>
<h4 id="request-log-analyzer"><a href="https://github.com/wvanbergen/request-log-analyzer">request-log-analyzer</a></h4>
<p>A command line tool that analyzes request logfiles (e.g. Rails, Apache, MySQL, Delayed::Job) to produce a performance report</p>
<p><img src="/wp-content/images/log_analyser.png?fit=750,274" alt="footernotes" /></p>
<h4 id="smusher"><a href="https://github.com/grosser/smusher">smusher</a>:</h4>
<p>Ruby/CLI: Automatic lossless reduction of all your images. Must run for image assets.</p>
<h4 id="zeus"><a href="https://github.com/burke/zeus">zeus</a></h4>
<p>Boot any rails app in under a second.</p>
<p>Please let me know if you have some other cool gems. It will great to know about some cool gems.</p>Mohit Jainjain.mohit27@gmail.comRubygems are the best thing that happened in ruby on rails. So today here is my list of gems in development group that helps to make things faster or sometimes bring simplicity to the development processHow to encyrpt and decrypt data in ruby on rails2013-04-18T22:44:00+00:002013-04-18T22:44:00+00:00http://codebeerstartups.com/how-to-encrypt-and-decrypt-data-in-ruby-on-rails<p><a href="https://github.com/Gurpartap/aescrypt">AESCrypt</a> is a simple gem to encryption and decryption in ruby on rails. From the readme file.</p>
<h2 id="installation">Installation</h2>
<p>Add this line to your application’s Gemfile:</p>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">gem</span> <span class="s1">'aescrypt'</span></code></pre></figure>
<p>and run bundler</p>
<h2 id="usage">Usage</h2>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">message</span> <span class="o">=</span> <span class="s2">"top secret message"</span>
<span class="n">password</span> <span class="o">=</span> <span class="s2">"this_is_a_secret_key_that_you_and_only_you_should_know"</span></code></pre></figure>
<h2 id="encrypting">Encrypting</h2>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">encrypted_data</span> <span class="o">=</span> <span class="no">AESCrypt</span><span class="p">.</span><span class="nf">encrypt</span><span class="p">(</span><span class="n">message</span><span class="p">,</span> <span class="n">password</span><span class="p">)</span></code></pre></figure>
<h2 id="decrypting">Decrypting</h2>
<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"> <span class="n">message</span> <span class="o">=</span> <span class="no">AESCrypt</span><span class="p">.</span><span class="nf">decrypt</span><span class="p">(</span><span class="n">encrypted_data</span><span class="p">,</span> <span class="n">password</span><span class="p">)</span></code></pre></figure>Mohit Jainjain.mohit27@gmail.comAESCrypt is a simple gem to encryption and decryption in ruby on rails. From the readme file.