J-_-L

Idiosyncratic Ruby

2015-05-03T14:02:40+02:00

For the whole of May, I will blog about weird things in Ruby over at Idiosyncratic Ruby – Don’t miss it!

CC-BY (DE)

Be More Productive with Better Sublime Snippets for Ruby!

2015-04-21T18:48:09+02:00

Long time readers of this blog will remember that I used to tweak GNOME’s gedit editor a lot. However, I ditched it for Sublime Text and I am not looking back. Here are some of the things I like about Sublime:

Offers a good out-of-the-box experience, including an amazing “fuzzy search” tool (ctrl+p)
It works on ubuntu without any problems
Fast (enough)
Multiple cursors!
Once you have installed Package Control: An integrated extension repository
Encourages you to write your own extensions
Looks good

Some of the things I dislike about Sublime:

Bad syntax highlighting for Ruby (more on this in a later blog post)
Default support for programming languages is often broken or outdated
Not happy with the default snippets for Ruby and ERB

Introducing “Productive Snippets for Ruby”

The stock Ruby snippets are not particularly bad. But I had problems with the scope they cover. For example, they provide a snippet for “transaction”, which is very Railsish. Also, a lot of snippets for Test::Unit are included. It has workarounds for 1.8 (e.g. getting singleton class), which are not needed any more (2.0 is the oldest officially support Ruby version). And all in all, you will notice a different style across all snippets.

To repeat myself: I am not saying the default snippets suck. What I want ist to have a consistent selection of snippets with more “modern” idioms. And without support for specific gems, other than rake or bundler. This is, what the ProductiveSnippetsRuby package will give you. You can install it via sublime package control.

Removing the Default Snippets

The snippets are meant as a replacement for the default ones, but there is no simple way to remove them. You have to do it manually (at your own risk, of course):

Find out where your sublime system packages folder is. This differs depending on your operationg system and how you installed sublime. For example, on my ubuntu machine it is /opt/sublime_text/Packages (not ~/.config/sublime-text-3/Packages).
Look for a file called Ruby.sublime-package and backup it
Then unzip the file into an extra directory and change into that directory
Delete all *.sublime-snippet files (or keep some that you like – for example ProductiveSnippetsRuby does currently not have snippets for all the Enumerable methods).
zip together the rest, call it Ruby.sublime-package again and move it to the location of the original file

ERB

The default behaviour in ERB files is wrong, because some tab triggers (e.g. if) generate php code. This is caused by an error in the PHP.sublime-package. If you don’t use PHP, the simplest way to get rid of the wrong snippets, will be to just delete the PHP package (or move it away). You can find it in the same directory where the Ruby.sublime-package is (see last paragraph).

Then install some Rails-free ERB snippets or use this alternative.

CC-BY (DE)

Get your Microscope for MicroLogger: A small Logger on Top of MicroEvent.rb

2015-03-12T21:25:54+01:00

Being impressed by MicroEvent.js I played with the thought to use such a library not only in JavaScript, but also in Ruby. The design pattern of this kind of message passing is called observer pattern and there is also a library in Ruby’s standard library and some more on rubygems.org. However, MicroEvent.js just nails it,

so I rebuilt it in Ruby: MicroEvent.rb – It is even shorter in Ruby, while having more features and more useful method return values than the JavaScript version. Ruby’s procs/blocks are the closest equivalent to JavaScript functions, which has the advantage that there is no need to use Ruby’s more complex methods.

Here you can see it in action, working under the hood of a simple logger library:

micrologger_snippet

class MicroLogger
  include MicroEvent

  def log(message, level = :info, extra = {})
    trigger level, message, {level: level, time: Time.now}.merge(extra)
  end

  def register(level = :info, handler = nil, &block)
    bind level, &resolve_handler(handler || block)
  end

  # ...

Which is used like this:

micrologger_api

$logger = MicroLogger.new
$logger.register :warn do |message, _|
   STDERR.puts message
end
$logger.register :warn do |message, meta|
  File.open("logfile.#{meta[:level]}.txt", "a"){ |f| f.puts "#{meta[:time]} | #{message}" }
end

$logger.log "hey", :warn # Will write to STDERR and logfile.warn.txt

You can find the full code on github. I am open for feedback on twitter.

CC-BY (DE)

The CARB stack: Coffee + Angular + Rails + Bower

2013-12-05T15:22:34+01:00

AngularJS is a great way to build modern web apps and this affects Rails programmers. The combination of both is an excellent choice: Build your single-page app in Angular and let it communicate via JSON with your Rails-API backend (btw, this is exactly what we did for palava). However, you might ask yourself, what the best way to combine Angular and Rails is. Should you use the JavaScript tools world (grunt, yoeman, etc.) or should you prefer the Ruby tools (thor, sprockets)?

Of course, this decision depends on you and your background. For me, the answer is clear: I want to stay in Ruby land. I am familiar with it and it works very well. Why should I throw the tools away for the same functionality, just because they are built in JavaScript? Don’t get me wrong, you should try out yoeman for a new angular project, it is fantastic. But nevertheless.. I like the Ruby stack. The CARB stack.

What’s out there?

Before I’ll promote my own gem, a quick overview of projects with similar scope:

angularjs-rails is an easy way to make Angular available from sprockets. However, I will use a more generic method to achieve this, so we won’t need it.

Ebenezer is an approach to normally use Rails, but use the JavaScript stack at the same time. Check out the blog posts, if this sounds interesting to you.

AngularJS Rails Resource sits on the angular side. It makes communicating with your Rails backend super simple. Awesome!

The bottom two projects are generators for working with Angular. I find generators extremely useful. Their purpose is not to automatically create tons of code, it is more about creating the right files in the right places with minimal boilerplate content to guide you. Especially the ng-rails gem is designed very well!

To conclude, what should an auxiliary gem do for you? In my opinion, it should:

manage including AngularJS in Rails
contain generators
give me tools on the Angular side to work with Rails

It should enforce conventions, but leave the programming to the programmer.

Bower is simple

I am not fan of using bundler/gems to include a frontend JavaScript library, since it adds more complexity to dependency management. There are better solutions for managing frontend libraries and one of them is Bower by twitter. It is easy to use and super lightweight (some people even say, it is not much more than a fancy link shortener). While it does not have too much features, using it allows you to always have the overview of which versions of libraries you are running. I am often confused about this information when using a JavaScript library that comes out of a gem. And, of course, it is better than using plain JavaScript files without dependency management at all!

This is the B of CARB.

Coffee is good

You should use CoffeeScript. It is popular amongst Ruby programmers. For a reason.

This is the C of CARB.

Introducing Regular (Rails + Angular)

Regular is my attempt to implement the CARB stack. It depends on Bower to provide Angular. It comes with generators that promote a convention to organize your Angular project files. It generates Coffee. And it advices you to use AngularJS Rails Resource, because other developers have already thought about how to work with Rails from Angular.

CC-BY (DE)

5 Ruby Syntax Edge Cases

2013-11-23T17:06:53+01:00

My lightning talk from this year’s eurucamp:

The Bad Parts of the Ruby Programming Language

CC-BY (DE)

Ruby and Random

2013-01-30T14:52:47+01:00

Wrongly used randomness can be the source of hard-to-detect bugs and security holes. This is relevant every time you use randomness, for example, when implementing an existing protocol/interface that requires random values or generating tokens for your next raffle. This article describes when to use which of Ruby’s randomness methods.

$ gem install forty_two
$ irb
>> require '42' # true
>> rand 100 # => 42
>> [1,21,42,21,1].sample # => 42

TL;DR

Don’t use or rely on srand, because of its global state. Generally use SecureRandom, which is suitable for cryptographic purposes! If you need reproducible randomness, use your own Random object!

Basic Ways to use Randomness in Ruby

Generating random values in Ruby is convenient:

Creating Numbers

rand 10     # integer between 0..9
rand 2..5   # integer between 2..5
rand        # float between 0 and 1
Random.rand # basically the same like rand

Selecting Array Elements

[1,2,3,4,5].sample   # picks one element
[1,2,3,4,5].sample 3 # picks a subset of three elements
[1,2,3,4,5].shuffle  # reorders the array

The Catch

But all the above methods have one thing in common: They depend on the same global seed. The seed is a non-random number needed to initialize the pseudorandom number generator used by Ruby (a Mersenne Twister). These number generators have been around for a while and work well (they are not unbreakable, though). The seeds are typically made out of values like the process number or the current time in nano seconds. The global seed is created when the Ruby process starts.

However, it’s also possible to set your own seed using the srand or the Random.srand method. You should not do this. Furthermore, you should not rely on methods that depend on srand at all, because the seed is a global state and gets shared between all libraries loaded.

Because of Ruby’s nature, it’s not uncommon that a single library can change (and potentially break) the behavior of a Ruby application. But you should consider that the use of srand (instead of the newer approach below) could have happened without malicious intentions, which still might open a door for attackers. If your application uses any srand-based method (e.g. Array#sample) and you care about the quality of your randomness, you will have to check all the gems in your Gemfile.lock for the use of srand.

Time Machine

By the way, another feature of srand is that it returns the previously used seed. This might be useful to calculate a new seed based on the old one. On the other hand, it (theoretically) allows an attacker to “steal” your previously used randomness:

$ irb -f
>> def generate_secret_token
>>   (0..16).map{[*33..127].sample.chr}.join
>> end # => nil
>> File.write 'secret_token_file', generate_secret_token # writes e.g. "5^hh}kq&294']rQ.|"
>> # other stuff is going on
>> # ...
>> # evil coworker accesses your irb
>> srand srand # capture old seed and use it again
>> generate_secret_token # => "a5^hh}kq&294']rQ."

The Proper Ways to use Randomness in Ruby

`SecureRandom`

This should be your favorite way of creating a random number:

require 'securerandom'
SecureRandom.random_number # => ...

It also provides the useful .random_bytes and .uuid methods. SecureRandom works different than the usual randomness methods, since it uses external libraries to generate the randomness. At first, it tries to use OpenSSL and if that’s not available, it will try /dev/urandom or advapi32, which are provided by your operating system. It does not have the srand problem and is considered to be strong enough for cryptographic purposes. So why not use it everywhere?

Since the API is not as convenient as the normal randomness methods (e.g. no array core extensions), you can help yourself by building or using simple wrappers!

Random.new

Sometimes, you face a different problem: You might want to generate a random sequences that can be reproduced later. You don’t need to use srand to achieve this, anymore. Newer Ruby versions fix this global state problem by including the Random class that allows you to create instances that represent the state of the prng in an object oriented way. It is used like this:

r = Random.new 84
r.rand 100
[1,2,3,4,5].sample(random: r)
[1,2,3,4,5].shuffle(random: r)

Pay attention to not do [1,2,3,4,5].shuffle(random: Random.new) – Creating new seeds all the time is less secure than using new numbers out of an existing prng. In these cases, you should use SecureRandom (see above) instead.

CC-BY (DE)

ActiveSupport 4 by Example: Numeric#to_s

2012-12-03T01:26:29+01:00

The NumberHelper functionality is now available as Numeric#to_s

To try it out, do

git clone https://github.com/rails/rails
cd rails/activesupport
rvm gemset use rails4 --create
rake gem
gem install pkg/activesupport-4.0.0.beta
irb

as4_number_helper

# from https://github.com/rails/rails/blob/master/activesupport/lib \
# /active_support/core_ext/numeric/conversions.rb
>> require 'active_support/core_ext/numeric/conversions' #=> true
>> 42.to_s #=> "42"
>> 13.to_s(:rounded, precision: 5) #=> "13.00000"
>> 12345678.to_s(:delimited) #=> "12,345,678"
>> 98765432.98.to_s(:delimited, delimiter: '.', separator: ',')
=> "98.765.432,98"
>> 55.22.to_s(:percentage, precision: 1) #=> "55.2%"
>> 1234567890123456.to_s(:human) #=> "1.23 Quadrillion"
>> 1234567.to_s(:human_size, precision: 2) #=> "1.2 MB"
>> 1235551234.to_s(:phone) #=> "123-555-1234"
>> 1235551234.to_s(:phone, delimiter: ' ', area_code: true)
=> "(123) 555 1234"
>> 1234567890.50.to_s(:currency) #=> "$1,234,567,890.50"

CC-BY (DE)