Jakub Kuźma

Quick and dirty scanner daemon

2011-10-20T00:00:00+02:00

I’m too lazy to connect my scanner every time I have some papers to scan. It’s more convenient if the scanner is always connected, and if I just press a button to perform the scan. I figured out that the states of those buttons can be obtained using SANE library. I didn’t find any simple way to read those states apart from writing some low level C code. Obviously it’s much more fun to do that in Ruby instead – that’s why I decided to write FFI bindings to SANE library. I didn’t manage to do everything in Ruby (scanner was hanging up at some point during the scan), but the scanimage CLI does the rest for me. I ended up with something like that:

#!/usr/bin/ruby1.9.1

require “sane”
require “logger”
require “fileutils”
require “tempfile”

logger = Logger.new(STDERR)

loop do
scan = nil

begin
Sane.open do |sane|
device = sane.devices.find { |device| device.vendor == “Canon” && device.model == “LiDE 100” }
if device
logger.info(“device found at #{device.name}”)
device.open do
logger.info(“device open, polling button states…”)
while scan.nil?
scan = [“—device”, device.name, “—mode”, “Lineart”, “—resolution”, “300”] if device[:file]
sleep(0.5)
end
logger.info(“closing device”)
end
else
logger.error(“device not found”)
end
end
rescue Sane::Error => exception
logger.error(“SANE exception caught: #{exception}”)
end

if scan
tempfile = Tempfile.new(“scan”)
tempfile.close

logger.info(“scanning with #{scan.join(” “)} to #{tempfile.path}”)
system(“scanimage”, *scan, :out => tempfile.path)

output_dir = “/nfs/media/Scans”
FileUtils.mkdir_p(output_dir, :mode => 0777)

output_file = “#{output_dir}/#{Time.now.strftime(”%Y%m%d%H%M%S")}.png"
logger.info(“converting file to #{output_file}”)
system(“convert”, tempfile.path, output_file)

tempfile.unlink
else
logger.info(“sleeping…”)
sleep(60)
end
end

The script saves everything on my local NAS device, but you can modify it to email the scans somewhere, or to send them to your Google Docs account. You can also make use of other buttons, providing different scan settings, format or destinations.

You just need an Ubuntu box with Upstart to run the script as a daemon:

Simply save the configuration file in /etc/init/scanner.conf. To run the daemon manually use start scanner command.

Mass assignment in Rails 3.1

2011-10-02T00:00:00+02:00

When I was browsing through the Ruby on Rails Security Guide yesterday, I stumbled upon an interesting configuration option:

This will create an empty whitelist of attributes available for mass assignment for all models in your app. As such, your models will need to explicitly whitelist or blacklist accessible parameters by using an attr_accessible or attr_protected declaration.

Shouldn’t this be enabled by default, just like escaping HTML output in ERb templates? The only drawback of this solution is that you’ll need to turn the protection off explicitly when assigning attributes by hand (i.e. rails console):

Serve local directory using Rack::Static

2010-09-10T00:00:00+02:00

Recently I needed to test compatibility of a static webpage on Internet Explorer running on VM. It’s not really handy to sync the files after every single change, so I decided to run a simple webserver to provide access to the directory via HTTP. After struggling with 5 liners using WEBrick, my friend came up with the idea to use Rack::Static to do so. You can simply save the following code in config.ru file in the directory that you want to publish, and run rackup command to start the server (don’t forget to gem install rack before).

Simple Rack application for JavaScript I18n

2010-06-22T00:00:00+02:00

I tried to improve my old javascript_i18n gem recently, and I stumbled upon Kelly Redding’s rack-sprockets gem. I really like the idea of putting such stuff into Rack middleware stack – it doesn’t mess up your application, and it becomes framework agnostic. Then I realized that it can be made even simpler using Rack::Builder and utilities from rack-contrib repository. The following Rack application works with default Rails’ I18n backend:

require “json”

class JavaScriptI18n
def self.call(env)
locale = env[“PATH_INFO”][1..-4]
if translations.key?(locale)
[200, {"Content-Type" => “text/javascript”}, new(translations[locale])]
else
[404, {}, “Not found”]
end
end

def self.translations
I18n.backend.send(:init_translations) if I18n.backend.send(:translations).empty?
I18n.backend.send(:translations).with_indifferent_access
end

def initialize(translations)
@translations = translations
end

def each
yield “var I18n=I18n||{};I18n.translations=”
yield @translations.to_json
yield “;”
end
end

The application serves JavaScripts, containing translations for the requested language, and stores them in the I18n.translations property. You can easily mount it using Rack::Builder in your config.ru file.

Now you can include the JavaScript in your application using ordinary script tag or javascript_include_tag helper:

If you need to cache JavaScript translations in the production environment, you can use Rack::ResponseCache to do that.

require “rack/contrib/response_cache”

map “/javascripts/i18n” do
use(Rack::ResponseCache, “public/javascripts/i18n”) { |env| env[“PATH_INFO”] }
run JavaScriptI18n
end
map “/” do
run MyShinyApp::Application
end

Rack::ResponseCache works very similar to Rails’ page caching – it stores responses in the given directory (public/javascripts/i18n).

The solution works great in Rails 3 applications, as well in the other frameworks with Rack::Builder available. If you need to use it in Rails 2, you should probably check out the Rack::SimpleEndpoint middleware. SimpleEndpoint can easily turn any Rack application into middleware, that you can mount in your Rails 2 app.

Using ActionMailer for internal messaging

2009-11-14T00:00:00+01:00

Rendering internal messages inline can be quite confusing, especially if you want to use some helpers inside (like path helpers). It’d be more convenient to render them in the same way as other messages – using ActionMailer and ERB templates. My solution uses email addresses to figure out the message recipients:

class UserNotifier < ActionMailer::Base
# sample message
def some_message(user)
from %Q{"Internal Messaging System"}
recipients user.email
subject “This is internal message”
body :user => user
end

# sample message notification
def message_notification(message)
from %Q{"MyAppName.com mailer"}
recipients message.recipient.email
subject “You’ve new message in your inbox”
body :user => user
end

private

# if the called method has “deliver_internal_”
# prefix, use notify method to deliver message
def self.method_missing(method_name, args)
if method_name.to_s =~ /^deliver_internal_([_a-z]\w)/
new($1, *args).send(:deliver_internal)
else
super
end
end

# deliver message to user using internal messaging
def deliver_internal
users = User.find_all_by_email(@mail.to)
from = @mail.from.first[1..-2] # remove quotes
users.each do |user|
Message.create!(:recipient => user,
:subject => @mail.subject,
:body => @mail.body,
:sender_name => from)
end
end
end

Additionally you can notify the user about a new message, by implementing a simple callback in the Message model.

class Message < ActiveRecord::Base
after_create :deliver_notification
belongs_to :recipient, :class_name => “User”

private

def deliver_notification
# deliver message notification email (external)
# if the user wants it
if recipient.wants_message_notifications?
UserNotifier.deliver_message_notification(self)
end
end
end

# send message and notify by email if user wants it
UserNotifier.deliver_internal_some_message(user)
# send email only
UserNotifier.deliver_some_message(user)

Ruby and Rails on Ubuntu 9.10 Karmic Koala

2009-11-10T00:00:00+01:00

Ruby Version Manager is a really powerful tool which provides an easy, non obtrusive way to install multiple versions of Ruby, Rails and other gems on your Ubuntu 9.10 box. You won’t have to compile anything manually (RVM does a great job) and everything will be kept in your home directory. All you need to do is:

Last step modifies your ~/.bashrc (or ~/.zshrc), so the changes will be visible in all new terminal instances. After restarting your terminal, pick a Ruby version to install:

After a couple of minutes you’ll have a fully functional Ruby 1.9.1 interpreter installed in your ~/.rvm directory. If you want to use it as a default Ruby, type:

Now you can install Rails and other stuff – remember to not use sudo to do that (since everything is kept locally in your home directory, RVM manages your PATH environment variable as well):

For more information about Ruby Version Manager, visit the RVM’s homepage.

Patching Rails and gems locally

2009-10-21T00:00:00+02:00

How many times did you have to wait ages until a patch that you’ve submitted gets merged into the Rails or a gem? Sometimes you can’t wait, it’s confusing to keep external libraries in your repository. Fortunatelly – Rails provides a simple way to unpack dependencies into vendor directory, where it’s possible to make local changes. Instead of tracking whole vendor, you can have small .patch files in a separate directory and apply them to frozen vendor stuff. You won’t need to remember which gems are locally modified, repository stays small, patches can be easily applied on your remote production server by invoking rake tasks (you can use Capistrano as well). All you need is a simple Rake task:

namespace :patch do
desc “Applies patches to Rails frozen in vendor”
task :rails do
rails_dir = Rails.root.join(“vendor”, “rails”)
Rails.root.join(“patch”, “rails”).children.each do |patch|
patch(patch, rails_dir)
end
end

desc “Applies patches to gems frozen in vendor”
task :gems do
Rails.root.join(“patch”, “gems”).children.each do |patch_dir|
patch_dir.children.each do |patch|
gem_dir = Rails.root.join(“vendor”, “gems”, patch_dir.basename)
patch(patch, gem_dir)
end
end
end

desc “Applies patches to Rails and gems in vendor”
task :all => [“gems”, “rails”]
end

def patch(patch, dir)
puts “Applying patch #{patch.basename} to #{dir.basename}”
sh “patch -N -p 1 -d #{dir} -i #{patch}”
end

Freeze your Rails and/or gems using rake rails:freeze:gems and rake gems:unpack. You have to store your patches as shown below. Notice that gem’s patches directories must include the version number (just like in vendor/gems).

To apply the patches run rake patch:gems or rake patch:rails task (rake patch:all). Don’t forget to add vendor/rails and vendor/gems to your .gitignore.