(443) 451-3001
John Trupiano has a great post to get you started with sanitize_email for Ruby on Rails.
I wanted to preview my HTML emails without having to fill up my online email inboxes with tons of email (and then I’d have to make filters too). I also didn’t want to manage actually sending real email. So, I set up my machine for local delivery. Read on for instructions.
Read the rest of this entry »
Just a heads up that I’ve released environmentalist 0.2.3. You can update with:
sudo gem install environmentalist
The only substantial change in this release is that we moved the loading of postboot.rb to the bottom of the boot.rb file as opposed to the top of config/environment.rb. This was necessary because common db rake tasks like db:create and db:drop stopped loading the environment in 2.3.2.
As a recap, environmentalist provides an executable that converts a rails app’s config structure. The basic idea is that environments themselves are now first-class citizens, allowing you to create several environments (e.g. staging, prodtest, demo, etc.) in a clean, organized fashion. Each environment is given its own folder where it can store its own set of configuration files (think mongrel configs, apache configs, etc.) without polluting the top-level config/ directory.
MySQL’s slow query log is a very handy tool to detect which SQL queries are running slowly in a production app.
So what about rails applications? Often, test data only contains a small amount of data. Over time more users use the site and generate more data. A page that usually renders in 100ms could be taking 3-5 seconds, or more!
I present, SlowActions. The goal was to analyze a standard log file to detect actions that render slowly. It had to be easy to use and also not require modification of rails’ logging mechanism. Observe:
$> slow-actions --actions development.log
Cost Average Max
- UsersController : game_history (22 entries, 0% Error)
Total: 11275.447 3642.437 12728.0
Render: 7.20300 2.32700 17.2450
DB: 10.5020 3.39200 10.0000
- QuestionsController : refresh_index_table (89 entries, 0% Error)
Total: 908.494 202.348 307.000
Render: 0.00000 0.00000 0.00000
DB: 32.5880 7.25800 10.0000
More info after the break ….
Read the rest of this entry »
Do you program ruby on rails? Do you use geminstaller? Do you run Ubuntu?
If you want to pull it all together, read on!
This past weekend I released v0.1.0 of the Timecop gem. Timecop makes it dead simple to travel through or freeze time for the sake of creating a predictable and ultimately testable scenario.
The gem is derived from a plugin I wrote a while back to achieve more or less the same functionality for an extremely time-sensitive application. My goals for the gem included:
The gem is hosted on RubyForge and can be installed by simply running:
sudo gem install timecop
Have you ever opened 4 terminal windows, SSHed each one into a server, and ran tail on all of them to watch 4 log files?
Have you ever had a terminal window open whose sole purpose was to run “tail my_log” over and over again to look at the output of a file?
It’s a pain, isn’t it?
Introducing “Watch Me” a simple ruby script that allows you to watch multiple log files simultaneously.
go from this:
Using multiple terminals to watch logs
to this:
Using WatchMe to watch logs
We are currently working on a project that involves Flex and active resource + will_paginate and we needed to be able to paginate the xml transactions easily. Unfortunately, will_paginate and to_xml don’t play nicely when it comes to adding the current_page, total_pages, and page attributes to the xml. After many failed attempts I went looking around github and found in a few forks of will paginate that some people had solved this problem but, I didn’t want to install another version of the gem to risk breaking other apps on the server so I did it the rails way!
I started by creating a module that opens up the will_paginate collection class and includes ActiveResource and alias method chain the to_xml method to include these values. Example code below.
#enviroment.rb ... require 'to_xml_extensions'
#lib/to_xml_extensions.rb module WillPaginateHelpers include ActiveSupport::CoreExtensions::Array::Conversions def to_xml_with_collection_type(options = {}) serializeable_collection.to_xml_without_collection_type(options) do |xml| xml.tag!(:current_page, {:type => ActiveSupport::CoreExtensions::Hash::Conversions::XML_TYPE_NAMES[current_page.class.name]}, current_page) xml.tag!(:per_page, {:type => ActiveSupport::CoreExtensions::Hash::Conversions::XML_TYPE_NAMES[per_page.class.name]}, per_page) xml.tag!(:total_entries, {:type => ActiveSupport::CoreExtensions::Hash::Conversions::XML_TYPE_NAMES[total_entries.class.name]}, total_entries) end.sub(%{type="array"}, %{type="collection"}) end alias_method_chain :to_xml, :collection_type def serializeable_collection #:nodoc: # Ugly hack because to_xml will not yield the XML Builder object when empty? empty? ? returning(self.clone) { |c| c.instance_eval {|i| def empty?; false; end } } : self end end WillPaginate::Collection.send(:include, WillPaginateHelpers)
This now gives me the proper xml when I call to_xml
<?xml version="1.0" encoding="UTF-8"?> <time-cards type="collection"> <current_page type="integer">1</current_page> <per_page type="integer">25</per_page> <total_entries type="integer">108</total_entries> <time_card> <approved type="boolean">false</approved> <billable type="boolean">false</billable> <created_at type="datetime">2008-10-10T14:04:13-04:00</created_at> <date type="datetime">2008-10-10T14:04:13-04:00</date> <has_been_billed type="boolean">false</has_been_billed> <has_been_paid type="boolean">true</has_been_paid> <hours type="float">2.0</hours> <id type="integer">98</id> <is_overtime type="boolean">false</is_overtime> <task_id type="integer">6</task_id> <updated_at type="datetime">2008-10-10T14:04:13-04:00</updated_at> <user_id type="integer">1</user_id> </time_card> ... </timecards>
I’ve found myself on a benchmarking kick these last couple of weeks. Sometime last week, I dug up the better-benchmark library written by Pistos. Pistos’ library is basically just a wrapper for the rsruby gem, which is more or less an interface to R (similar to what rmagick is to ImageMagick).
Combining these tools together, we can do some pretty nifty code performance analysis in very few lines of code, e.g.
require 'rubygems' require 'better-benchmark' result = Benchmark.compare_realtime(:iterations => 10) { |iteration| save_the_world() }.with { |iteration| save_the_world_and_save_the_girl() } Benchmark.report_on result
I have forked better-benchmark and wrapped the library up into a RubyGem.
I love YAML. It’s portable. The majority of languages I work with already have libraries built to read/write it. It’s more lightweight, more expressive, and easier to read than XML. I really love YAML.
Unfortunately, it turns out that Ruby’s YAML library is a little incomplete for some edge cases. I just discovered that YAML.dump fails to generate valid YAML for certain multi-line strings. The specifics are very difficult to explain, and we’ll summarize them at the end after trying out some examples. Fire up irb and give the following a try.
require 'yaml' s = "\n Something embedded.\nAnd on a new line." YAML.load(YAML.dump(s))
You are currently browsing the archives for the Programming category.