Ruby Italian Style

Rails Phone Country Codes

Sat, 16 Feb 2013 00:00:25 +0100

Today I needed to add a select box for the internationals phone country codes.
This is also known as E.164

I wasn’t able to find a library for that, except for: https://github.com/hexorx/countries that I used as a base and extended this way:


c = ISO3166::Country::Data.map{ |_,v| v["country_code"].to_i }
codes = c.uniq.sort.map{ |v| "+#{v}" }

Now you can use the array in an options_for_select helper

Developer Love

Fri, 15 Feb 2013 23:13:03 +0100

Developer Love

Paypal Recurring Payments

Wed, 05 Dec 2012 00:14:00 +0100

There is a time when every SaaS need to get his money, and maybe you choose to get them month by month.

This is a post about the steps that I took to integrate Paypal recurring payments, and the problems that I run into.

Part 1. Find the right library

The most common and known library for payment, and the one I was using for instant payment with Paypal is the ActiveMerchant gem, an huge container of all the payment gateway of the galaxy.

The gem is great, until you realize that you need recurring payments….
Some users provided forks with their own implementatios, but there wans’t a clean solution, and some messy code inside a huge library for me was not the way to go.

My Choice:


gem "paypal-recurring", "~> 1.1.0"

Part 2. Understanding Paypal

Before the integration of the gem is important to understand what we are going to do and why.
I attach an image from the Paypal developer website, that explain all the steps needed for a recurring payment:

Image credit of Paypal, source: Paypal Developer Network

We ask Paypal for an address where we can send our customer, with a return and an error url
Paypal give us the address, and we redirect the customer there
Customer signup and/or login to Paypal, and confirm the amout that we want to bill montly.
If the customer agree is redirected to the return url we provided. Paypal return us a token and an id to identify the customer and the transaction
We show the customer a review of the subscription
If the customer agree we instantly bill the amount and we create a recurring profile for the future payments.

Part 3. Integration

WARN: The files in this section are only examples, the code miss some basic security, that can be easly added when integrated in your project.

Using the examples provided by the gem, and a little help from a recent Railscasts I ended up with this integration.

Subscription model: here you can manage the relations with the customers. One customer has many subscriptions, and a subscription belongs to a plan.


class Subscription

Through the paypal method we can access the PaypalPayment model, that manage the code between the gem “paypal-recurring” and our code.

The PaypalPayment module is as follow:


class PaypalPayment
  def initialize(subscription)
    @subscription = subscription
  end
  
  def checkout_details
    process :checkout_details
  end
  
  def checkout_url(options)
    process(:checkout, options).checkout_url
  end
  
  def make_recurring
    payment = process(:request_payment)
    if payment.approved? && payment.completed?
      # Set the subscription as paid
    end
    recurring = process(:create_recurring_profile, {period: :monthly, frequency: 1, start_at: Time.zone.now + 30.days})
    @subscription.update_attribute(:paypal_profile_id, recurring.profile_id)
  end
  
  def cancel_recurring
    ppr = PayPal::Recurring.new(:profile_id => @subscription.paypal_profile_id)
    ppr.cancel
  end

private

  def process(action, options = {})
    options = options.reverse_merge(
      token: @subscription.paypal_token,
      payer_id: @subscription.paypal_payer_id,
      description: @subscription.name,
      amount: @subscription.amount,
      currency: "USD",
      ipn_url: "http://www.example.com" + "/paypal/notifications/#{@subscription.id}"
    )
    response = PayPal::Recurring.new(options).send(action)
    raise response.errors.inspect if response.errors.present?
    response
  end
end

Checkout details: return some details about the customer that is subscribing to our website, like name and email address.
Checkout url: return the url of paypal where we need to redirect the customer to give us the permission to create a recurring payment.
Make recurring: Create an instant payment, and a recurring profile. Note: The first month is paid with the instant payment, so the recurring start from the next month.
Cancel recurring: Cancel the recurring profile

Everything is glued in the controller


class PaymentsController  :notification

  before_filter :load_subscription

  def checkout
    redirect_to @subscription.paypal.checkout_url(
      return_url: "http://www.example.com" + "/paypal/review/#{@subscription.id}",
      cancel_url: "http://www.example.com" + "/paypal/cancel/#{@subscription.id}"
    )
  end

  def review
    @subscription.update_attributes(paypal_token: params["token"], paypal_payer_id: params["PayerID"])
  end

  def complete
    @subscription.paypal.make_recurring
  end

  def cancel
  end

  # Manage the paypal IPN
  #
  def notification
    notify = PaypalNotification.new(request.raw_post)
    if notify.acknowledge
      begin
        if notify.complete? && @subscription.amount == notify.amount
          # Mark as paid
        else
          # Mark as error and investigate
        end
      rescue => e
        # Mark as error and investigate
        raise
      end
    end

    render :nothing => true
  end

  private

    def load_subscription
      @subscription = Subscription.find(params[:id])
    end

end

Part 4. Final note

This steps should be enough to integrate paypal into your app. Paypal also provide a sandbox in wich you can create fake account and test that everything is working as expected.

Payment is mostly done in Paypal and model code, the views can be styled to reflect your website aspect and don’t require specific code.

On another post I will show how to manage the IPN with a custom library.

The code in this post can be found in this Gist: https://gist.github.com/4197985

Carrierwave resize based on orientation

Tue, 03 Jul 2012 02:03:13 +0200

Today I had the need to create a thumbnail, from an image uploaded with Carrierwave, based on the image orientation, landscape or portrait. It was very simple, and I’m going to share with you how I’ve done it. My application is a Rails 3.1, with Carrierwave and MiniMagick. Place inside the initializers folder a file, containing a custom Carrierwave processor config/initializers/carierwave.rb


module CarrierWave
  module MiniMagick
    def from_orientation(portrait, landscape)
      manipulate! do |img|
        if img[:width] > img[:height] # Landscape
          width, height = landscape
        else # Portrait
          width, height = portrait
        end
        img.resize "#{width}x#{height}>"
        img
      end
    end
  end
end

you may need to restart your Rails application after adding this file.

After that you can use the processor in one of your uploader:


 version :thumb do
    process :from_orientation => [[184, 130], [140, 197]]
  end

Simple as that.

Chef Cookbook Redis

Fri, 13 Apr 2012 00:19:50 +0200

In this days I’m implementing an analytics system for social media with Redis, so I’ve updated my Chef cookbook repo.

In the “readme” you can find detailed instruction to test the cookbook with Vagrant.

The repo can be found on Github: https://github.com/McRipper/Chef-Cookbooks.

Ruby namespaced methods

Fri, 23 Mar 2012 15:54:00 +0100

Today I was writing a library to access some API, in the design process I started wondering if in Ruby is possible to use some sort of namespacing on class.

All that I wanted was concatenating methods, like you do on active record objects. I show you the solution that I found:


module Test
  module Foo

    def bar
      @namespace = "bar"
      self
    end

    def bar_quack
      puts "Quack!"
    end
  end
end

module Test
  class Base

    def initialize
      puts "Init!"
    end

    def method_missing(method, *args)
      if @namespace
        self.send("#{@namespace}_#{method}", *args)
      else
        super
      end
    end

    include Test::Foo

  end
end

In this way you can do this:


test = Test::Base.new
#=> Init!
test.bar
#=>
test.bar_quack
#=> Quack!
test.bar.quack
#=> Quack!

The code works by implementing a method missing in the Base class, and a namespace method in the module that you want namespaced. All the method in the module must have the format: namespace_method.
Now when you call the namespace method an instance variable is set with the namespace, and self is returned. Because the method cannot be found method missing is triggered, and is the instance variable is set we send the method with the namestace.

This is a quick way that I foud to achive a prettier way to access mehods. Bye!

Ruby 1.9.3 + Evernote + Thrift

Thu, 22 Mar 2012 13:08:00 +0100

Today I started studing the Evernote Api for a new project.

The first thing after reading the website was searching for the gem that provide a wrapper over the Thrift interface of Evernote.

Simple and easy, just add the gem to the Gemfile, bundle install and write a small piece of code inside the project to test api key

Nobody ever said life was easy… The program exit with and error


1.9.3-p0/lib/ruby/gems/1.9.1/gems/thrift-0.8.0/lib/thrift/transport/http_client_transport.rb:47:in `initialize': can't convert nil into String (TypeError)

WTF? The error seems to be in the Thrift gem… Let’s start searching on Google. Nobody seems to have the same problem, it must be my fault! Then the idea… Try with another ruby version, I use rbenv to change my ruby version… 1.8.7… No error!

Some Google digging later I find that the problem is with enconding in the new Ruby. A fork of Thrift with the fix is on Github. Good!

Another test and another error: cannot change encoding on frozen String! This seems simple, let’s add a dup on the string… and Done!

Now the example work again with ruby 1.9.3-p0 and 1.9.3-p125

How I make the change? I fork the github project, make the fix and do a pull request… No way! Thrift Github repo contains code for a lot of languages, and I can’t understand how to specify in bundle how to use it!

The idea… “RECREATE ALL THE PRJECTS”. Long story short I’ve recreated the repo for the project. To get yourself up and running without hassle add this to your Gemfile:


gem "evernote", "~> 1.2.0", :git => "git://github.com/McRipper/evernote.git"
gem "thrift", :git => "git://github.com/McRipper/thrift-1.9.3.git"
gem "thrift_client", "~> 0.8.1", :git => "git://github.com/McRipper/thrift_client.git"

I wrote this post to share with the community the hours I’ve spent figuring out this mess. The solution is very ugly and quick, but I think that in the future the various gems will be fixed and this hack can be removed!

Ruby Inject for sum

Sun, 11 Mar 2012 12:21:00 +0100

Ruby is a great language because some tasks can be achieved in different ways.

The way you choose can be the most readable and beautiful.

Today I want to show you different ways to do a sum on values returned from different methods.


def negative
  25
end

def positive
  25
end

def neutral
 50
end

The result that we want is this:


  (negative + positive + neutral)
  # => 100

First way: collect all the values in an array and then inject + on it. (http://apidock.com/ruby/Enumerable/inject)


  %w(negative positive neutral).collect{ |m| send(m) }.inject(:+)
  # => 100

Or: pass to the inject method the values that we want sum to be initialized, in this case 0, and a second variable m as the method name.


  %w(negative positive neutral).inject(0) {|sum, m| sum + send(m) }
  # => 100

That’s all!

Rails 3 Javascript asset

Mon, 20 Feb 2012 21:18:00 +0100

To keep my Js code clean with the Rails 3 asset pipeline I remove the require tree from the main application js file, then to load only the file that correspond to the correct controller I created this helper:

Helper


def js_controller

  js = []

  path = controller.controller_path.split("/")

  path.shift

  while path.size > 0

    js << (["frontend"] << path).join("/")

    path.pop

  end

  return js.reverse

end

Layout


-js_controller.each do |js|

    =javascript_include_tag js