Thoughts Heap

Default mutable values in Python functions are WACK!

Wed, 31 Mar 2010 16:31:46 -0700

If you use mutable default values on functions, this will keep it state in recurrent calls:


def myAppend(x, L=[]):
    L.append(x)
    return L

#=============

>>> myAppend(1)
=> [1]
>>> myAppend(2)
=> [1, 2]

That’s seriously messed up o.O

Use form_for from Rails' console

Mon, 29 Mar 2010 15:41:00 -0700

As a curious developer, I always like to inspect an objects guts on the console, that way I can now as much as I can from the class without reading the documentation. It was the time for the rails form_for view helper. I had no idea how to access that from the terminal whatsoever, so I googled a bit and I found nice tidbits that got me going pretty quickly.

However when you try to use a method like form_for, a NoMethodError is being thrown because you are trying to call url_for for on a nil instance. This is because the default console helper doesn’t have any controller assigned. This can be easily fixed:


helper.controller = ActionController::Integration::Session.new

However, when we try again the form_for method we get a new error.


NoMethodError: undefined method `protect_against_forgery?' for #

It seems that for some reason, the ActionController integration session doesn’t support the forgery protection, because this is not a biggie for what we need we are just going to stub the method, and go our own way.


s = ActionController::Integration::Session.new
class << s; def protect_against_forgery?; false; end; end
helper.controller = ActionController::Integration::Session.new

At this point we thought we were going get away with it… well no, it seems it never stops.


NoMethodError: You have a nil object when you didn't expect it!
You might have expected an instance of Array.
The error occurred while evaluating nil.<<
    from /Users/roman/Sites/git/work/noomii/vendor/rails/actionpack/lib/action_view/helpers/text_helper.rb:32:in `concat'
    from /Users/roman/Sites/git/work/noomii/vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb:281:in `form_for_without_haml'
    from /Library/Ruby/Gems/1.8/gems/haml-2.2.9/lib/haml/helpers/action_view_mods.rb:170:in `form_for'
    from (irb):16

The default helper object doesn’t have an initialized output buffer either!… luckily is easy to skip this one as well.


s = ActionController::Integration::Session.new
class << s; def protect_against_forgery?; false; end; end
helper.controller = ActionController::Integration::Session.new
helper.output_buffer = ''
f = nil
u = User.new
helper.form_for { |_f| f = _f }
f
>> #



Oh the nice smell of victory!



Now we are talking…
Fri, 20 Nov 2009 18:29:38 -0800


Now we are talking…


guillee:


I see your puny garbage plate and I raise you a...
Wed, 18 Nov 2009 16:48:32 -0800


guillee:


I see your puny garbage plate and I raise you a typical venezuelan street vendor’s burger. This will either kill you or make you immortal. Ingredients (in order):


Mayo, ketchup & mustard
Onions
Cabbage
Potato chips
More mayo, ketchup & mustard
Avocado
Tomato
Hamburger patty
Chorizo
Chicken
Bacon & eggs
Cheese

(Warning: DO NOT eat this.)




Now that IS a HAMBURGER :-D


Randoms and Haskell
Sun, 15 Nov 2009 13:12:00 -0800
Right now I’m on chapter 15 of my RWH book. This one talks about problems that get complicated without the use of a Monad, one of them is the System.Random API of Haskell. I’m going to start by introducing two typeclasses that this module exports for clarity’s sake:


RandomGen: a RandomGen represents an state that holds the random input, I like to think of it like a stream of some sort (stdin, stdout).
Random a: This typeclass  is the abstraction of a Random value, all the common types of Haskell implement this typeclass (String, Integer, Float, Int, etc.)

What confused me for sometime, and I actually had to analyze throughly was how the interactions between the Random API and the IO Monad worked.

The following code was the one that got me thinking:


import System.Random hiding (next)

randomsIO :: Random a => IO [a]
randomsIO =
    getStdRandom $ \g ->
        let (a, b) = split g
        in (randoms a, b)


Where the IO [a] comes from?, if this anonymous function is returning a type 
([a], RandomGen) instead of an IO [a]. This got me really confused, at some point I thought that a StdGen was an instance of an IO, but realized pretty quickly that IO is not a classtype, but an instance of Monad.

The best way to figure this out was checking the types of getStdRandom:

getStdRandom :: (StdGen -> (a, StdGen)) -> IO a

getStdRandom receives as it’s first parameter, a function that receives a StdGen and then return a tuple with the first position being some value of an anonymous type and second position being a (probably altered) StdGen, the return of the getStdRandom is whatever the parameter function returned on the first parameter of the tupple, wrapped in an IO Monad.

So the only way to work with a random function, is with the use of a getStdRandom like interface, why is that?. I’m assuming this is a way to provide “factory functions” for random generated data, a pretty clever choice (yet confusing, at least for me). Another important reason is that this way it will keep things pure, you don’t have to use the IO Monad on the random functions definitions.

Haskell is fun :-).


chiguire:


El último mes pasó bastante rápido, ¿no? Un mes no...
Fri, 13 Nov 2009 11:26:02 -0800


chiguire:


El último mes pasó bastante rápido, ¿no? Un mes no es mucho tiempo, pero es un hecho que la expectativa de vida (en los Estados Unidos) es de solamente 936 meses. Realmente la vida la veo distinta cuando puedo ver toda mi vida ante mi en la forma de 936 puntitos.
Si cada punto representa un mes de tu vida tomada secuencialmente de izquierda a derecha, de arriba a abajo, he aquí algunos hitos/estadísticas interesantes.
[…]
¡Ahora mueve ese culo y haz algo este mes!




Wow… this is kinda heavy, I’ve spent 8 of those blobs learning Haskell :-s


An implementation of a jQuery plugin using BDD
Wed, 30 Sep 2009 17:08:23 -0700
On Web apps, sometimes we want to avoid unnecessary requests, one of those situations happens when there is a form that represents a record, and the values of this record haven’t changed. On these cases you would like the user to send an update request only when the values of the record’s form actually changed, this technique is called “dirty form”, and is a very common practice.

I checked out some of the plugins out there to solve this problem, however, the functionality was sometimes sketchy. That’s why I started to implement my own solution, with a BDD approach using Screw.Unit.

In this post we will be covering some BDD practices, and at the same time I will be explaining what this plugins may offer to your plugin toolbox. Let’s start by pointing out the structure of a jQuery plugins project:

jquery-plugins/
|-- lib/
|-- spec/
`-- vendor/


In the lib/ folder we will have all the plugins we would like to develop, the spec/ folder will have all the test-related files and the   vendor/ folder we will store all the frameworks needed in order to run the specs. In this project we will be using the livequery plugin, the Screw.Unit test framework and the Smoke mocking framework.

The spec/ folder will be composed (at least) by this two core files:

spec/
  |-- suite.html
  `-- spec_helper.js


The suite.html file will contain all the HTML scenarios needed for the jQuery plugins to work. This will look something like this (read the HTML comments):



  
    
    

    
    

    
    
    
    
    
    
    

    
    
    
    
    

    
    

    
    
    

    
    

    
    
  
  
    
    

    
    
      
        
        some value
        
        
        
        
      
    

  




The spec_helper.js file will have all the common setup for the test environment.


// This function well put the HTML contents of the clean-state we are working on to the sandbox
function resetDOM(id) {
  $("#sandbox").html($("#" + id  + "-clean-state").html());
}

// If we want to put some global setup and teardown code, here is the place to put it
// for setup, inside the before block
// for teardown, inside the after block
Screw.Unit(function() {

  before(function() { 
  });

  after(function(){
  });

});



So, now that we have established our test environment, its time to do the implementation of the plugin, we start by defining the specs for it on the spec/jquery.when_changed_spec.js file, this file will represent the tests made to the lib/jquery.when_changed.js file.


Screw.Unit(function(){

  describe("$.fn.whenChanged", function(){
    
    // We establish a new clean state for each test case
    // with a resetDOM invocation before each spec.
    before(function(){
      resetDOM("when-changed");
    });

    describe("invoked on an input:text", function(){
      it("should invoke the given function when value has changed on keyup");
      it("should not invoke the given function when value has not changed on keyup");
      it("should not consider new blank text on the edges as a new text");
      it("should call the reverse callback when the value returns to the same");
    });

  });

});  



So, in the given spec file we specified (for now) the behavior of the plugin when we are interacting with an input text field. we expand this definitions by giving actual test code to each spec.


describe("invoked on an input:text", function(){
  
  // first we define the setup for each spec, assign the plugin behavior to an input
  before(function(){
    // When the value of the input:text change it's original value, an alert will be called.
    $("#sandbox input:text").whenChanged(function(){
      window.alert("The input text has changed it's value");
    });
  });
  
  it("should invoke the given function when value has changed on keyup", function(){
    mock(window).should_receive("alert").exactly(1).with_arguments("The input text has changed it's value");
    // the event checking will be raised by a keyup event
    $("#sandbox input:text").val("some random value different than the original").trigger("keyup");
  });
});



On the previous code, we are using the Smock’s method mock, this will do a temporary replacement of the window.alert function, and will check that this is being called exactly 1 time, and with the argument “The input text has changed it’s value”. This way we can check that the callback assigned on the whenChanged invocation was actually being called when necessary. Next step is to implement a whenChanged function that is simple enough to make the spec pass.


(function($){
  
  $.fn.whenChanged = function(callback) {
    // we store the old values on each element
    $(this).each(function(){
      $(this).data("jquery.whenChanged.oldValue", $(this).val());
    });
    
    // we assign a keyup event binding using livequery
    $(this).livequery("keyup", function(){
      var oldValue = $(this).data("jquery.whenChanged.oldValue");
      var newValue = $(this).val();
      if (oldValue !== newValue) {
        callback.apply(this);
      }
    });
    
    return this;
  };
  
})(jQuery);



So we implemented the most simple solution possible that makes our specs run (Just check the suite.html file on a browser and you should have the feedback right away), now we continue developing adding more specs and changing the code as we go.


it("should not invoke the given function when value has not changed on keyup", function(){
  mock(window).should_receive("alert").exactly(0);
  $(this).trigger("keyup");
});



We added other method that didn’t need any code to be changed, in this case we are checking that window.alert is not being called at all. Awesome let’s continue with the next spec.


it("should not consider new blank text on the edges as a new text", function(){
  mock(window).should_receive("alert").exactly(0);
  $(this).val("  some value   ").keyup();
});



At this point, this specs fails with our current implementation, we are not stripping the spaces on the border, this can be fixed easily.


$.fn.whenChanged = function(callback) {

  $(this).each(function(){
    // NOTICE: Invoking $.trim here!
    $(this).data("jquery.whenChanged.oldValue", $.trim($(this).val()));
  });
  
  $(this).livequery("keyup", function(){
    var oldValue = $(this).data("jquery.whenChanged.oldValue");
    // NOTICE: Invoking $.trim here!
    var newValue = $.trim($(this).val());
    if (oldValue !== newValue) {
      callback.apply(this);
    }
  });
  
  return this;
};



Now that we have stripped the spaces on the old value storage, when we check the stripped new value, it will still be the same as the old value and the callback won’t be called. Finally we have to add the reverse callback functionality.



before(function(){
  // When the value of the input:text change it's original value, an alert will be called.
  $("#sandbox input:text").whenChanged(
    function(){
      window.alert("The input text has changed it's value");
    },
    function(){
      window.alert("The input returned to the same value");
    }
  );
})

it("should call the reverse callback when the value returns to the same", function(){
  mock(window).should_receive("alert").exactly(1).with_arguments("The input text has changed it's value");
  $(this).val("Changing input value").keyup();
  mock(window).should_receive("alert").exactly(1).with_arguments("The input returned to the same value");
  $(this).val("some value").keyup();
});



So at this point, this spec will break previous specs, this is because the alert function is being called, even when the value is not changed, so mock(window).should_receive("alert").exactly(0) won’t work.


// NOTICE: we change this to alert with an specific argument.

it("should not invoke the given function when value has not changed on keyup", function(){
  mock(window).should_receive("alert").exactly(0).with_arguments("The input text has changed it's value");
  $(this).trigger("keyup");
});

it("should not consider new blank text on the edges as a new text", function(){
  mock(window).should_receive("alert").exactly(0).with_arguments("The input text has changed it's value");
  $(this).val("  some value   ").keyup();
});



At the same time we need to add a new callback parameter to the whenChanged method.


$.fn.whenChanged = function(callback, reverseCallback) {
  $(this).each(function(){
    $(this).data("jquery.whenChanged.oldValue", $.trim($(this).val()));
  });

  // we assign a keyup event binding using livequery
  $(this).livequery("keyup", function(){
    var oldValue = $(this).data("jquery.whenChanged.oldValue");
    var newValue = $.trim($(this).val());
    if (oldValue !== newValue) {
      callback.apply(this);
    }
    else {
      reverseCallback.apply(this);
    }
  });

  return this;
};  



Now this code should run successfully and we now have covered our bases with input:text selectors, I could talk about how added support to other form input types, but I rather not in order to keep this short. Some thoughts I can share though is that the whenChanged method changed A LOT, after realizing that each type of input has it’s own gotchas, I created an specific whenChange method for each kind of form element. All in all… I was always sure that nothing broke on this process because the specs always told me if anything I was doing added any bug. Uhmmm the smell of good test code on late nights is incredible.

I hope this post can help you get some guidelines on how to get started with development of Javascript code using BDD, one word of caution though: testing effects in Javascript is a nasty challenge, you may like to pass an option to your method specifying if you want effects or not. check your code doesn’t depend on setTimeout invocations, take my word, is a BIG PAIN to test that.

Good luck with your BDD sessions.


"Object is not missing !" + Amazon::S3
Wed, 09 Sep 2009 16:50:30 -0700
Today at the office, we had one of the weirdest Rails errors I have ever encountered
rails-project/vendor/rails/activesupport/lib/active_support/dependencies.rb:417:in `load_missing_constant’: Object is not missing constant Photo! (ArgumentError)
We looked up into the stack trace and we found the problem was being caused by this line:
vendor/rails/activerecord/lib/active_record/base.rb:2195:in `compute_type’
When we checked the code, we found a dead-end with a class_eval invocation (oh meta-programming damn you on debugging times)
# Returns the class type of the record using the current module as a prefix. So descendants of
# MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
def compute_type(type_name)
  modularized_name = type_name_with_module(type_name)
  silence_warnings do
    begin
      class_eval(modularized_name, __FILE__, __LINE__)
    rescue NameError
      class_eval(type_name, __FILE__, __LINE__)
    end
  end
end
This error was caused in the first place because we created a new environment for running the app, we checked the files on config/environments/ to see the differences between them; we didn’t find that many, commenting the few lines that were different didn’t make any change.
A (very long) while later, we noticed that the config/amazon_s3.yml file didn’t have a set of keys for the environment we were trying to run, after adding them everything went by pretty smoothly.
What pissed me off (and probably this guy as well) is that the error displayed didn’t make any sense at all, wtf is “Object is not missing constant Photo!”?, seriously? I investigated a bit further and it seems to be related with the autoload feature of the Rails framework, geez thanks for the cryptic error message ¬¬
I hope this info helps some unfortunate developer out there.


The jQuery DSL
Mon, 07 Sep 2009 11:27:30 -0700
For the last 4 months I’ve been using jQuery for Javascript development. To be honest, I didn’t got started before with jQuery because it didn’t seem too practical to me (no Class approach), but after looking carefully at the plugin model, it was truly a revelation of a good API for development.
So I started to accommodate to the jQuery’s way of things, and one of the API’s that got my interest in the past 2 months was the traversal one. I mean, what were those methods .find(), .end() and .endSelf(). Why I would go and use those methods when my standard code was always like:
$("#container .sub-container .items").click(..);
$("#container .sub-container .other-items").hover(..);
$("#container form.create-item").ajaxForm(..);

and never needed them. I guessed that the way I was doing things wasn’t the jQuery’s way; I mean, I could rewrite the previous code like this instead:
$("#container").
  find(".subcontainer").
    
    find(".items").
      click(..).
    end().
    
    find(".other-items").
      hover(..).
    end().
    
  end().
  
  find("form.create-item").
    ajaxForm().
  end().
end();
Of course at first sight it didn’t look that good, but I was not too sure that it didn’t look bad either, it was just different. So I just let time tell me if it was good enough. I left that implementation and came back a month later, the WTF/min were almost none, I did still understand the code right away, it actually looked like a CSS funky syntax to me.
After deciding that it was indeed a good way to do things, I just started to look at the pros & cons of this funky syntax vs the normal syntax I used before. This is what I got
Funky syntax Pro’s

The order of the code is in a hierarchical way, representing the DOM position. 
If the main container is not there (e.g #container) the child selectors will not be called, making the code “more efficient”.
When multiple elements have the same behavior, a new HTML class that represented the behavior is exposed. For example, if you require 2 out of 3 forms in a container to be an AJAX form, you wouldn’t replicate the same instructions to each selector, instead you will create a common selector for the 2 forms by adding a new HTML class.
The lookup for elements will be faster on every nesting, that is because the lookup will be done from the parent, not from the main document.

Funky syntax Con’s

.live() method wouldn’t work, this method only works on un-nested selectors. However, you may use the livequery plugin.
Initially it is a difficult syntax for other developers, 3 out of 4 developers in my team did say that it was confusing, but as I stated before, probably is more different than confusing.

Classic syntax Pro’s

Would be the approach used by most of developers.
.live() can be used without any problems.
Probably there are other benefits that I’m taking from granted ¬_¬.

Classic syntax Con’s

A lookup from the HTML document for every element.
Lookups are being made even when there is no parent element. (This could be easily avoided with an if statement, but still). 
It’s harder to spot the common behavior, different selectors factor.

As you can see, there are some benefits and some pros attached to the use of this jQuery DSL; I don’t know if this is the way to go but I’m certain that I’m not the first one who came up with this (I haven’t read any book of jQuery yet). If you could leave some thoughts about what is the one you prefer and why, it would give much value to this discussion.
Until next time.


(ActiveRecord::Callbacks + acts_as_taggable).gotcha?
Tue, 01 Sep 2009 00:06:00 -0700
Have you ever been in a situation where you have this strange bug, that takes you more time than expected to find out what (tha hell) is  going on? That happened to us (me and my team) last Rails Rumble when we were trying to have some stuff done after the creation of an element that had some tags associated to it.
The code looked something like the following:
## app/models/entry.rb
class Entry < ActiveRecord::Base
  
  ##################
  ### Extensions ###
  ##################
  acts_as_taggable
  
  #################
  ### Callbacks ###
  #################
  after_create :do_something_with_tags
  
  def do_something_with_tags
    self.tags.each do |tag|
      # do something with tag
    end
  end
  
  protected :do_something_with_tags
  
end

## app/controllers/entries_controller.rb
class EntriesController < ApplicationController
  # ...
  def create
    @entry = Entry.new(params[:entry])
    entry.tag_list = params[:tags]
    if entry.save
      # success
    else
      # failure
    end
  end
  # ...
end
The problem was that the do_something_with_tags callback was not doing what it supposed to. At first we thought it was a problem with our implementation, but after some debugger sessions, we found out what the real problem was. The tags array didn’t correspond with the value of the the tag_list that was being assigned on the controller level.
After having some thoughts I decided to go inside the acts_as_taggable_redux source code (the version of acts_as_taggable that we were using), and I found something pretty peculiar related to the tag creation; This tags were being created on an after_save callback. The extract of the acts_as_taggable looked something like this:
def acts_as_taggable(options = {})
  has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag
  has_many :tags, :through => :taggings, :order => 'LOWER(name) asc', :select => "DISTINCT tags.*"

  after_save :update_tags

  extend ActiveRecord::Acts::Taggable::SingletonMethods
  include ActiveRecord::Acts::Taggable::InstanceMethods
end
As you can tell, an after_save was invoking this callback update_tags; after looking more closely, this method was the one that created the tag list, (the one we needed for our custom callback do_something_with_tags to work). So I checked in the Rails documentation page the precedence of callbacks just to be sure which one was being invoked first. Our main problem was that our callback was an after_create, and those get executed after the after_save callbacks.
To solve this issue, we simply called the update_tags callback directly on the first line of our callback, making the final do_something_with_tags look something like this:
def do_something_with_tags
  update_tags # invoke callback by hand
  self.tags.each do |tag|
    # do something with tag
  end
end
Because the acts_as_taggable library is so well implemented (at least the redux version, I’m not sure about others), the second time the update_tags method was being invoked simply returned without repeating the process of tag creation again.
Small issues like this are the ones that keep you having debugging fun for hours. I hope this may help you if you are this kind of trouble.


Rails Rumble 2009: The competition
Tue, 25 Aug 2009 09:28:08 -0700
So… it happened, the last weekend was the Rails Rumble, a really kick ass event that made me squeeze all my skills and drop all my social life for 48 hours. I learned a lot of lessons (some the hard way).
The Event Organization.
The competition organization was OUTSTANDING, starting with the registration/team page, everything worked really well. At the competition, the little details stand out pretty quickly, and they made me laugh a lot. Big brags for you guys.
I’ve read the post from the intredia guys, it got me thinking that it will also be a good thing to share some “Good Idea, Bad Idea” thougths (of course, I’m not going to repeat what they have told you already).
1. Good Idea: Know your plugins
For the love of God, be sure that the plugins you are planning to use actually do what you are expecting them to do. It happened that I wanted to do (and at the end DID!)  a twitter authentication for the system, I didn’t wanted to use TwitterAuth because it is to invasive, it assumes things, makes a lot of stuff and I don’t feel comfortable with it.
I thought.. “Gee this oauth-plugin looks awesome, and it has support for Twitter too!”, what I found out after actually trying to use it (on the rumble) was that it is not intended to do authentication, it’s intended only to use the Twitter API via oauth.
Don’t get me wrong, the plugin is AWESOME in what it does, It was actually my fault because I didn’t pay attention to their README when they said:
It requires an authentication framework such as acts_as_authenticated, restful_authentication or restful_open_id_authentication
At some point, I didn’t assume that the purpose of the plugin didn’t include authentication. So remember, think it twice before using planning to use plugin you don’t know that well (a.k.a used before).
2. Bad Idea: Don’t use an editor that you are still learning how to use.
This recommendation has a little bit of it’s history, it turns out that since 3 weeks ago, I dished Textmate in favor of Vim (Don’t throw tomatoes at me please!, I don’t regret it, say whatever you want :-p), Textmate is awesome, but when I started to use Vim, I felt all the love right away (after customizing a little bit of course).
The problem was that, to use this editor you need to learn and use a lot of commands. At Sunday afternoon, when your brain is starting to throw SEGFAULTS because you haven’t slept that well, the Vim goodness didn’t flow (I guess this happens when you are still thinking on the commands before actually using them on normal basis).
3. Good Idea: Provision your workspace with all the fast food, energy drinks and snacks you can suffice.
You know it, body needs food to do it’s thing… FullThrotle drinks kept me up on night time.
4. Bad Idea (If you are actually planning to win): Go without a sys-admin and a designer
The perfect balance is 2 proficient Ruby coders, 1 sys-admin, and a Heck of a good designer, with that you should have all your needs covered (ah… and of course a good project to do).
Besides that I have a really good war story related to ActiveRecord callbacks caveats (I will have a blog post for this soon, promise), and the post-mortem evaluation of Paperback for judges, the app that we intended to create and partially did.
Thank you RailsRumble team for such a fun and great time, I had a blast… see you next year.


RailsRumble 2009. Paperback: A Post Mortem evaluation
Tue, 25 Aug 2009 09:25:00 -0700
So, to make life easier to the judges of my application, I will straight down the main features and the issues I’ve found along the way. We start now.
What it supposed to be.
Paperback in one sentence: “A day activity log manager with twitter-like interface”.
Paperback may look very similar to twitter when you log in, please be patient enough to pass through that. Paperback is intended to do something different.
1. You use Paperback when you are stating some activity you are doing in your day to day work
You will have the entries organized by date, so you can navigate to an specific day and see what you did for audit purposes.
2. You can categorize the entries
Some entries are related to projectX, some others to bug #123 of projectY. With categorization is easy for you to check entries  related to an specific activity.
3. You specify time factor to the entries:

You can state an entry representing an activity that took you H hours and M minutes to complete
You can state an entry representing an activity that you think will take you H hours and M minutes to complete

This way, you can do time estimates on your entries, and actually get some useful insight data out of it. Sadly , we didn’t have enough time to represent good charts about that data we are recollecting :-(.
4. Entries can be Todo items:
Entries that had an estimation date could happen to be todos, so you could go to a pending page when you see all this entry representing a todo list instead of an activity log entry date. The only way you could  check an entry as completed, was when you specify the actual time you took to finish it.
5. The social twitter factor
Normally you would use this as an activity log, but what would happen if people actually care of what you are doing, say your supervisor or team members?. I wanted to use twitter for this, but I considered that people that followed me for other reasons (social life, ruby community, etc) wouldn’t care about my progress on the bug #123 from the project XYZ. With Paperback we made explicit in which channels I want to follow a person.
6. Keep your identity
As I said before, We wanted to use twitter for this, and in some cases we still want to, that’s why we use the Twitter authentication in the first place, to keep the identity you have from twitter. We added OpenID just to support more ways to get you in the project for judging purposes, as soon as the competition ends, the OpenID authentication will go out.
What we have.
Sadly everything is not there, as its supposed to be on the final product, but we are proud to say that at least the core features are there, not polished nor well designed, but there.
The bad

Header titles… there is not a single one, it hurts so bad to see it
The update entry feedback is not well behaved, the entry will be updated, but you won’t be able to see it that well.

The Ugly

We didn’t specify user Timezones, we gather the info from OpenID and Twitter, but we didn’t actually assign the Timezone to the framework, you will find out pretty quickly if you are way off UTC (as in my case)
Public pages are not working, a last minute change added the current_user username on the rightbar, when there is no authenticated user it stills try to get the username, causing a NoMethodFoundError on the Nil class.
The update process won’t work if you don’t specify a valid command, as soon as you hit update, you will see the throbber rolling and rolling.
The OpenID process seems to fail, probably a last minute change added a bug

To finish the entry, I will post a short screencast showing some of the features, we hope you find this product helpful, we surely do, Thanks for syntoynizying.









gesteves:

Make Bono History print:

Bono, the lead singer for...
Fri, 14 Aug 2009 14:52:58 -0700


gesteves:

Make Bono History print:

Bono, the lead singer for U2, is performing a concert in Ireland. As part of his promotion for the anti-poverty campaign in which he plays such a prominent part, he stops singing and starts clicking his fingers, repeating the action every three seconds. The crowd falls silent, and after a while, Bono speaks:
Every time I click my fingers, a child dies unnecessarily from a preventable disease.
After he has been doing this for a few minutes to a largely silent and transfixed audience, someone helpfully shouts out:
Stop clicking your fucking fingers then.




My Crush On Vim <3
Tue, 11 Aug 2009 14:59:44 -0700
So it has been a while since I don’t talk about vi/vim… I sadly had at some point to leave behind my goal to use vi/vim to work in more important things in the office.

But last week I regained my will to learn vim; and a lot of people at the office asked me why I do this… well what I’ve tell to them (and to myself) is that I needed to learn it because I don’t know in which platform I will be working at some point and Vim is one of those editors that is reliable on most of them (and is not made in Java).

So, one of the reasons I didn’t use Vim (even if I learned many of the commands) is that I didn’t know how to manage multiple files at the same time, after making a serious commitment to learn how to manage multiple files on the Vim environment, I got almost all my bases covered.

What I’m going to do know is give you all the steps I did in order to get familiar with vim, and finally what got me to use it as a replacement of TextMate (sometimes I go back to use some special features of TextMate, not that often though).

First of all, find yourself a good reference to get started, whatever works best for you… most of the tutorials are free, some of them are not. I did buy the book from O’Reilly Learning the vi and Vim Editors, because I wanted a well structured set of contents to learn from, I can say that is a great book to get started on the Vi field, and to get to know how to use the niceties of Vim. However, this book is mainly for first-time users, most of the high advanced stuff is online, but in order to understand that, first you need to understand the basics that this books covers.

After spending like 3 months reading (and practicing) all the commands and exercises from the O’Reilly Book, I started to look out how I could integrate easily my work environment with the Vim editor. Thanks to the developers of the rails.vim, NERDTree and FuzzyFinder plugins, it was not hard enough to get the Vim editor to work along. Also there were some good references from Fabio Akita (akitaonrails), Jason Stirk and Jamis Buck from the Ruby/Rails Community that helped me a lot in the process of installing all the things I needed.
After learning a lot of the cool stuff about navigation between files using ctags and the rails.vim plugin (watching the Fabio Akita screencast), I felt like I was about to stop using TextMate, there was just a really small thing holding me back. I really didn’t like the themes of vim; that’s why I took the time and effort to learn how to do colorschemas in Vim, and created the sunburst theme for the vim (the one I normally use in TextMate); The result… pure awesomeness, if you would like to use it, don’t hesitate to download it from this gist I made. Here is an screenshot to get you convinced ;-).

To summarize, the steps to get started wih Vim (on the Mac) are:

1. Download and install MacVim.
2. Download the .vim configuration files from github, either from my account or the one from Fabio Akita (mine is a fork of his with a few other niceties).
3. Follow the directions on the README of the github project.
4. Start coding, you have everything you need there.


chiguire:

darkana:

Help the #freemediave campaign on twitter....
Tue, 04 Aug 2009 08:04:23 -0700


chiguire:

darkana:

Help the #freemediave campaign on twitter. Where in Venezuela the government is closing down radio stations, takes away 2 coffee plants and tries to approve the Law against media crimes (among other things). The translation of the law can be found here: http://artists4freedom.net/2009/08/chavez-kills-the-radio-star/
Join us in letting everyone know.
Thanks to Artists 4 freedom for the link.
Photo found in http://ihasahotdog.com




walruz: Creating Basic Authorization Policies
Wed, 15 Jul 2009 21:39:00 -0700
Last post we checked the architecture of the walruz authorization framework, now we will continue on the implementation of basic policies. Creation of Authorization Policies.
To create a policy you have to create a class that extends from the Walruz::Policy class, once that is done, you’ll need to define the authorized? method. This method will receive 2 parameters: the actor, and the subject.
class ActorIsAdmin < Walruz::Policy

  def authorized?(actor, _)
    actor.admin?
  end

end

class ActorIsSubject < Walruz::Policy

  def authorized?(actor, subject)
    actor == subject
  end

end

In the example above, we define the most common policies, the first one is the “current user is admin” policy, in this policy we ignore completely the subject because it won’t affect the nature of the policy.
The second one is the “actor is subject”, you may not see the utility of this one after we use it (and ooh boy… we are going to use it a lot!).
Using the Authorization Policies
So, suppose we have the “all well known” User class, and we want to check if a User can be read, modified, updated or destroyed by the current authenticated user. The User class would go as follow:
class User < ActiveRecord::Base
  include Walruz::Actor
  include Walruz::Subject  

  ######################
  ### Authorizations ###
  ######################
  
  UserReadPolicy = Walruz::Utils.any(ActorIsSubject, ActorIsAdmin)  

  check_authorizations :read => UserReadPolicy

end

So the code above states that a User is an Actor (an entity that wants to execute some action in other entity), and at the same time a Subject (an entity that wants to be accessed in some way). It also defines some authorization policies associated to a label (in this case the action name). In this example Walruz::Utils.any let’s us define a composition of policies, this method will join a collection of policies together by a logical or statement.
There are several ways to check if an Actor can perform some action on a Subject, but for now, we are going to use the most basic one: the can? method.
def show(user)
 if current_user.can?(:read, user)
    render user
  else
    render :template => 'public/unauthorized'
  end
end

In the declaration of the UserReadPolicy we define that a User “A” can be read by another User “B” if either “A” is “B”, or “A” is an admin user. We are checking that conditions are met when we execute the current_user.can?(:read, user) statement.
Let’s extend our example a little bit, and Add a friendship relationship between users:
class User < ActiveRecord::Base
  include Walruz::Actor
  include Walruz::Subject
  
  ####################
  ### Associations ###
  ####################
  
  has_many :friendships
  has_many :friends, :through => :friendships, :class => 'User', :foreign_key => 'friender_id'
  
  ######################
  ### Authorizations ###
  ######################
  
  UserReadPolicy = Walruz::Utils.any(ActorIsSubject, ActorIsAdmin)  

  check_authorizations :read => UserReadPolicy
  
  ########################
  ### Instance Methods ###
  ########################
  
  def become_friend_of(another_user)
    Friendship.create!(:friender => self, :friendee => another_user)
    Friendship.create!(:friender => another_user, :friendee => self)
  end
  
end

class Friendship < ActiveRecord::Base
  
  belongs_to :friender
  belongs_to :friendee
  
end

Let’s say we want to enable friends to see each other records, right now it’s not possible with the policies stated, but this can be easily achievable with a new walruz policy.
class UserIsFriend < Walruz::Policy
  
  def authorized?(current_user, another_user)
    another_user.friends.include?(current_user)
  end
  
end

Once we create the new policy, we add it to the UserReadPolicy composition.
class User < ActiveRecord::Base
  ...
  UserReadPolicy = Walruz::Utils.any(ActorIsSubject, UserIsFriend, ActorIsAdmin)
  ...
end

As you may already noticed, the name of this new policy is different from the previous ones (this new one starts with “User” instead of “Actor”), this is because, in this policy the class of the Subject is important for the use of it. As a rule of thumb, if the subject is an important deal on the policy class, you should always start the name of the policy with the class of the Subject; that way it will become more easier to merge different policies together; but more on that later.
That’s all for this episode now, next post we are going to do some more fancy stuff with the policies of this episode and going to extend the example a little bit more, until then.


walruz: Simple but powerful authorization framework in Ruby
Wed, 15 Jul 2009 16:56:00 -0700
You have been there already… your kick-ass app suddenly becomes an insatiable beast  when you have to add special conditions for authorized access, roles types, etc. And as soon as a new kind of user is added, or new more specific conditions are created for the existing authorizations, you just want to shoot your application just to put it out of its misery.
Well it doesn’t have to be that way anymore…
Introducing walruz.
walruz is an authorization framework that helps you on that creepy process of adding new authorization policies to your application, without having to change each piece of code that is related to it.
You see, the authorization process is divided in two sub-processes, the authorization checking and the action execution. walruz divides this 2 processes so that you can change without pain, the checking implementation from the execution implementation.

walruz Architecture.
In order to understand how walruz works, we need to clarify the architecture it has in order to achieve it’s goals. We have the three following components.


Subject. Object that is going to be managed (Posts, Profiles, Todos).

Actor. Entity that wants to perform an action on a subject (User, Admin).

Policy. A set of rules that tells if the Actor can perform the desired action on the Subject.

The framework represent this concepts with the following modules/classes:


Walruz::Subject. Module that when it is included makes the class a subject.

Walruz::Actor. Module that when it is included makes the class an actor.

Walruz::Policy. Class that will hold the authorization checking process.

This is all for now folks… I will be explaining the framework in short post, so that we don’t make this a very long hard read process.
A word of notice: The purpose of this series of posts is to serve as a tutorial to learn step by step all the goodies of the walruz framework. If you want something more technical, I suggest you read the README document that comes with the walruz gem. To install just do sudo gem install walruz, or download from github.
Next Post: How to create and use authorization policies.


Updates approaching
Wed, 15 Jul 2009 16:20:35 -0700
Hello guys… I’m adding this post just to apologize with the readers of this blog (If there’s any besides me). I started to work almost 2 months ago in this place called noomii and I have been really busy afterwards. Anyways! I have been doing some interesting stuff with Ruby and I will be posting new API soon-ish enough.
Peace out.


"Rule of thumb… whenever you query with datetime, date, or time attributes in Rails, transform..."
Mon, 13 Jul 2009 20:24:14 -0700
“Rule of thumb… whenever you query with datetime, date, or time attributes in Rails, transform them first to UTC.”

 - Me


Rails had improved A LOT since last visit
Fri, 29 May 2009 21:12:17 -0700
GameParticipation on schema.rb

  create_table "game_participations", :force => true do |t|
    t.integer  "giver_id"
    t.integer  "receiver_id"
    t.integer  "game_id"
    t.datetime "activated_at"
    t.date     "occurs_on"
    t.datetime "created_at"
    t.datetime "updated_at"
  end

The error:

ActiveRecord::HasManyThroughSourceAssociationNotFoundError in 'Game#is_participating? should return false when the user is not participating on the game'
Could not find the source association(s) :participant or :participants in model GameParticipation.  Try 'has_many :participants, :through => :participations, :source => '.  Is it one of :game, :giver, or :receiver?

What impress me about this error, is the las part of the last sentence “Is it one of :game, :giver, or :receiver?”…  If they wouldn’t add the last sentence, my first question would be “WTF is source?”, this meaningful error helped me save some time.
Good Job Rails Team \m/.

Thoughts Heap

Default mutable values in Python functions are WACK!

Use form_for from Rails' console

Now we are talking…

guillee: I see your puny garbage plate and I raise you a...

Randoms and Haskell

chiguire: El último mes pasó bastante rápido, ¿no? Un mes no...

An implementation of a jQuery plugin using BDD

"Object is not missing !" + Amazon::S3

The jQuery DSL

(ActiveRecord::Callbacks + acts_as_taggable).gotcha?

Rails Rumble 2009: The competition

The Event Organization.

1. Good Idea: Know your plugins

2. Bad Idea: Don’t use an editor that you are still learning how to use.

3. Good Idea: Provision your workspace with all the fast food, energy drinks and snacks you can suffice.

4. Bad Idea (If you are actually planning to win): Go without a sys-admin and a designer

RailsRumble 2009. Paperback: A Post Mortem evaluation

What it supposed to be.

1. You use Paperback when you are stating some activity you are doing in your day to day work

2. You can categorize the entries

3. You specify time factor to the entries:

4. Entries can be Todo items:

5. The social twitter factor

6. Keep your identity

What we have.

The bad

The Ugly

gesteves: Make Bono History print: Bono, the lead singer for...

My Crush On Vim <3

chiguire: darkana: Help the #freemediave campaign on twitter....

walruz: Creating Basic Authorization Policies

Using the Authorization Policies

walruz: Simple but powerful authorization framework in Ruby

Introducing walruz.

walruz Architecture.

Updates approaching

"Rule of thumb… whenever you query with datetime, date, or time attributes in Rails, transform..."

Rails had improved A LOT since last visit