dospuntocero

S3 Problems

Mon, 05 Mar 2012 20:06:26 -0500

After encountering this problem

Errno::EPIPE: Broken pipe

while trying to upload a file through the console using Paperclip or Carrierwave and also trying using Fog directly, I found out that the local request being sent to S3 was being rejected.
Then while trying different options I figured that ruby was calling openssl, so why not disable this and see what happened… and lo and behold it worked!
So for everyone out there just remember to add

:use_ssl => false

in this case if you’re using Paperclip in your model like so:

has_attached_file :doc,
  :path => "attachments/:id/:style/:basename.:extension",
  :storage => :s3,
  :s3_credentials => "#{Rails.root.to_s}/config/s3.yml",
  :use_ssl => false

Model default values

Tue, 15 Nov 2011 19:12:26 -0500

When looking for the best way to make default values, I’ve found that you shouldn’t rely on the DB for these. So in order to integrate these on your Model, I usually follow the next best practive:

 class User
    after_initialize :init

    def init
      self.number  ||= 0.0
    end
  end

This way it will initialize to 0.0 if the value is nil

Custom Validation (twitter bootstrap checkbox). Part 2

Thu, 27 Oct 2011 16:06:53 -0400

After creating the custom input on Part 1, we now needed to include a custom getter for each of these inputs. We could set up a method for each input inside our model but that wouldn’t be as cool, so we create a gem with the following behavior:

Object.instance_eval do 
   def check_for_check( *attrs )
       attrs.each do | attr |
           self.class_eval %Q{
                def #{attr}
                    #{attr}_check ? read_attribute(:#{attr}) : 0
                end
           }
       end
   end
end

This will make it so that we only have to add this to our model:

check_for_check :foo, :bar

Custom Input with Twitter Bootstrap

Mon, 17 Oct 2011 10:00:05 -0400

Using simple_form and Twitter’s bootstrap we can implement a custom input for the prepend left box used in bootstrap.

First you create an inputs folder under your app directory and then a file named left_box_input.rb with the following code:

class LeftBoxInput < SimpleForm::Inputs::Base
  def input
    "<div class='input-prepend'><span class='add-on'>#{options[:symbol]}</span>#{@builder.text_field(attribute_name, input_html_options)}</div>".html_safe
  end
end

Then in your views just call it the following way:

<%= f.input :foo, :as => :left_box, :symbol => "2 + 2 ?" %>

Then you will have in your views something like this:

Custom Validation (twitter bootstrap checkbox)

Fri, 14 Oct 2011 19:42:00 -0400

After jumping the wagon with Twitter Bootstrap for a new client app we are working on, I found myself in to some problem trying to implement this type of input:

We only have one input let’s say name and we wan’t to validate it’s presence when the check is true. The check is a virtual attribute named name_check. So using simple_form gem for this form.
We need to create the custom input element first, we do this by creating an inputs folder under the app folder. We name our file prepend_checkbox_input.rb

class PrependCheckboxInput < SimpleForm::Inputs::Base
  def input
    "<div class='input-prepend'>
      <label class='add-on active' title='#{options[:tooltip]}' rel='tooltip' >
        #{@builder.check_box(attribute_name.to_s + '_check')}
      </label>
      #{@builder.text_field(attribute_name,  input_html_options)}
      <span class='help-inline'>
        #{options[:help]}
      </span>
    </div>".html_safe
  end
end

The input will include an option for tooltip, it will automatically append ‘_check’ to the name of the input to create the check box element, the text field with all the regular HTML options and a help line under it.
This will be how we call it under our views:

  <%= f.input :name, :as => :prepend_checkbox, :tooltip => "Has name?", :help => "Please insert your name" %>

Now we include validations, for custom validators we need implement this one under our initializers:

ActiveRecord::Base.class_eval do
  def self.validates_checkbox(*attrs)
    attrs.each do |attr_name|
    validates attr_name, :presence => true, :if => "#{attr_name.to_s + '_check'} == '1'" 
    end
  end
end

We user *attrs as our input so that we can declare our validations on a single line like so:

 validates_checkbox :name, :phone, :number

Rails 3.1 custom serialize

Thu, 18 Aug 2011 13:16:47 -0400

A new feature that really makes our lives easier is the custom serialize option. Let’s say that your DB requires that when you save a serializable attribute to be in a CSV form instead of the YAML default.

If this is the case then you could use the following

  class CommaSeparatedList
    def load(text)
      return unless text
      text.split(",")
    end

    def dump(text)
      text.join(",")
    end
  end

So after creating this class you just call it as a parameter in your serialize call

  serialize :names, CommaSeparatedList.new

In this way the next time you save to your DB your data will be stored in CSV form.

Rails 3.1 asset pipeline

Thu, 11 Aug 2011 13:33:06 -0400

When you’re trying out the new asset pipeline it ~~might~~ will be hard to debug any CSS/JS since it will all be compressed in to one file.

When you use the link/include tag remember to add the next parameter

stylesheet_link_tag :admin, :debug => Rails.env.development?
javascript_include_tag :admin, :debug => Rails.env.development?

This way it will only server the files separately when in development mode.

Installing Rails 3.1 --pre on OSX Lion

Wed, 10 Aug 2011 20:02:50 -0400

After trying several ways of doing

gem install rails --pre

and still getting errors, I found the following to do the trick

rvm gemset rails --pre

It will save you a couple of hours.

Paperclip Scopes

Wed, 13 Apr 2011 23:29:00 -0400

A nifty pair of scopes for when you’re working with attachments on Paperclip that are images or other type of content.

# For finding images as in Article.attachments.images 
scope :images, where("file_content_type LIKE ?", "image%")
# For finding other files Article.attachments.docs
scope :docs, where("file_content_type NOT LIKE ?", "image%")

New Stickers

Wed, 19 Jan 2011 18:48:36 -0500

We are getting new stickers for our friends and clients who want to put them in the laptops/cars/bathroom stalls.

Here is a preview, get them while they’re hot.

My favorite Spec of the day

Tue, 23 Nov 2010 21:56:00 -0500

Here is the controller spec!

def notify

 	@user = User.find(params[:id])

 	if @user.is_expert?

		@topic.experts << @user

	end  @

	user.notify_about_topic!(@topic)

end

And the implementation

it 'should notify user and add to leader board if user is an expert' do

	user = mock_model(User, :is_expert? => true)

	topic = mock_model(Topic, :id => 1)

	collection = mock('col')

	collection.should_receive(:<<).with(user)

	topic.should_receive(:experts).and_return(collection)

	user.should_receive(:notify_about_topic!).with(topic)

	User.should_receive(:find).with(1).and_return(user)

	Topic.should_receive(:find).with(1).and_return(topic)

	post :notify, :topic_id => topic.id, :id => 1, :format => 'js'

	response.should be_succes

	assigns(:user).should == user

end

Isn’t this nice to have completely decoupled specs from other outside logic, isn’t Rspec and TDD great?

bullshit: jimray: The new 37 Signals office looks like it...

Mon, 25 Oct 2010 21:08:18 -0400

bullshit:

jimray:

The new 37 Signals office looks like it belongs on Unhappy Hipsters. Eating-lunch-all-by-himself-DHH is the new Sad Keanu.

Look at all the things he’s not eating. (reference)

Mass Payment - Paypal

Wed, 11 Aug 2010 20:33:00 -0400

When trying to figure out how to send multiple payments to different Paypal users, I stumbled into the Mass Payment feature.

This feature allows to send multiple payments in one call but more importantly is that the only charge %2 of the payment cap at $1 USD. Also you can send the payments in multiple currencies.

After digging around the web there wasn’t any post about how to make use of this feature using Ruby… that is after diving deep into ActiveMerchant’s documentation that I found the following:

gateway.transfer 1000, 'bob@example.com',    :subject => "The money I owe you", :note => "Sorry it's so late"
  gateway.transfer [1000, 'fred@example.com'],    [2450, 'wilma@example.com', :note => 'You will receive another payment on 3/24'],    [2000, 'barney@example.com'],    :subject => "Your Earnings", :note => "Thanks for your business."

You gotta love ruby! and thanks ActiveMerchant

Rails 3 + Metal

Tue, 29 Jun 2010 19:28:00 -0400

There has been a lot of talk about the new changes being introduced into rails 3, trying to upgrade current applications I found out a recipe for upgrading your Metal code:

The first thing is to change

require(File.dirname(__FILE__) + ”/../../config/environment”) unless defined?(Rails)

into

require File.expand_path(’../../../config/environment’, __FILE__) unless defined?(Rails)

This way using the new system for the absolute path to your app.

Next depending on the function of your app you should change

[404, {“Content-Type” => “text/html”}, [“Not Found”]]

in to

[404, {“Content-Type” => “text/html”, “X-Cascade” => “pass”}, [“Not Found”]]

This ”X-Cascade” => “pass” allows for the call to keep going through your routes and see if any other catches this call.

Last is to declare your action on the router, this wasn’t necessary on Rails 2 since Metal would go through Rack before Rails, but now that Rails is an actual Rack app, we need to express all of our routes.

match ‘/metal_path’, :to => MetalClass

La Vitrine

Fri, 02 Apr 2010 19:57:50 -0400

Moment Factory developed the interactive system and designed the interactive content.

The installation includes tracking devices and low-resolution LED displays and is capable of showing many different visualizations based on the presence and movement of people.

Visitors can interact with the installation every night from 7 PM to 11 PM.
La Vitrine
145, rue Sainte-Catherine Ouest, Montréal.

go: flag

Wed, 10 Mar 2010 17:44:59 -0500

go: flag:

Checking out the flag package, Go’s built in command line argument parser. Here’s a simple example:
// flag.go
package main import ( "flag" "fmt"
) var code *int = flag.Int("areacode", 716, "give me your codes") func main() { fmt.Printf("Testing out flags!\n"); flag.Parse();...