I was refactoring the method, which accepted single argument. Initially it was integer, but the client wanted to add some string characters and leading zeros. After refactoring, I had to replace all the method calls in the app from:

someMethod(00123DHL)

to

someMethod("00123DHL")

In order to do it painlessly, you can facilitate RubyMine regex search&replace:

seach: someMethod\((\w.*)\)
replace: someMethod('$1')

In the regex above, \w stands for any word character repeated multiple times .*, the backets designate that the string matching this condition should be returned as $1 ($0 is the whole expression matching the search regex).

This is pretty straightforward, but I decided to keep it as a blog post for future reference.

Let’s consider the following situation. You’re building an app, where each user should be able to select what are one’s favourites colors. The gotcha is that (as more and more women register to our app …. :P) the available set of colours can be modified over time. How to tackle this task in Rails?

Well, as often when working with Ruby, there are several ways you can solve this task. If you happen to be using a NoSQL, document-oriented database (eg. MongoDB, Redis) then the task is actually not a problem at all. However, if you happen to be stuck to some relational DB, then you might consider to create a separate table to store colours and then some many-to-many relationship with users… nahh, awful, it is not definitely not worth it, as the only thing we need to store is colour. The other thing you might do is to store the colours array as a serialized attribute at users table. But this has some drawbacks, among the most painful is that you cannot efficiently search users basing on their serialized attributes (1, 2).

The efficient way to solve this task is to use the PostgreSQL hstore module. It is designed to store a key-value pairs of strings. As for PostgreSQL 9.3, it is not possible to natively store arrays of values in hstore. However not for long! As announced here, the version 9.4 will be shipped with a build-in support for nesting and array storage! But we have to wait for this another couple of months (~ October 2014). As for now, all we can do is to make a use of key-value store and a build-in support for hstore that came with Rails4 ActiveRecord (before it was a separate gem).

There a a couple of blog posts describing how to integrate hstore into your Rails app (eg. 1, 2), so there is no point to repeat it. Rails4 ships as a standard with a support for a handy store_accessor, which usage is described clearly here.  Please note however, that this method allows us to store only single value for every hash key. If you need to store an array of values for every hash key, keep on reading

Let’s assume we have a working PostgreSQL database@Rails, we have enabled hstore extension and have migrated the Users table, that contain the settings hstore field.

First thing, as a good habbit when using hstore (might save you time debugging!), we might want to do is to override a getter for settings in User model, as hstore save booleans as strings and we need to convert them back:

class User < ActiveRecord::Base
  #...
  def settings
    return (super == "true") if %w{true false}.include? super
    super
  end
  #...
end

Then we define the actual getter and setter for colors. It should be constructed so when we provide an array, let’s say: [‚purple’,’orange’], it should be properly serialized to the value of favourite_colors key of the settings field. Let’s try it in the Rails console:

user = User.new #<User id:nil, settings: nil>
user.settings = {favourite_colors: ['purple','orange']} #{:favourite_colors => ['purple','orange']}
user.settings #{"favourite_colors"=>"[\"purple\", \"orange\"]"}

Cool! The array is automaticaly converted to string. How can we retrieve the array back? Well, basically we can treat it as JSON, so type in console:

colors_array =
JSON.parse(user.settings['favourite_colors']) #['purple','orange']

Voila! Now we are ready to construct our getter and setter:

class User < ActiveRecord::Base
  #...
  def settings
    return (super == "true") if %w{true false}.include? super
    super
  end

  def favourite_colors
    if settings.present? && (colors=settings['favourite_colors']).present?
      JSON.parse(colors)
    end
  end

  def favourite_colors=(colors)
    self.settings = {:favourite_colors => colors}
  end
end

Let’s get further and construct a form and controller action to actually set this colors.

#app/views/users/_form.html.slim
== simple_form_for @user do |f|
  .form-inputs
    = f.input :favourite_colors, as: :check_boxes, collection: @available_colors
  .form-actions
    == f.button :submit

Then in the controller all we need to do is to set propertly the strong parameters to accept our custom data format:

#app/views/controllers/users_controller.rb
class UsersController < ActionController::Base

#...

private

  def user_params
    params.require(:user).permit(:favourite_colors => [])
  end

end

I hope it was helpful, good luck!

My team is currently working on an app, where different content need to be served depending on what device you use to access the page: desktop, tablet or a phone. Luckily, Rails 4.1 came out with an ActionPack Variants which just do this task. We might want the behaviour application-wide, so we need to share it accross all controllers. The first thought is to put the code in a base controller, that all the other controllers inherit from (eg. ApplicationController), like this:

class ApplicationController < ActionController::Base
  protect_from_forgery with: :exception
  before_filter :detect_device

  private
  def detect_device
    case request.user_agent
      when /iPad/i
        request.variant = :tablet
      when /ip(hone|od)/i
        request.variant = :phone
      when /Android/i && /mobile/i
        request.variant = :phone
      when /Android/i
        request.variant = :tablet
      when /Windows Phone/i
        request.variant = :tablet
    end
  end
end

Despite the fact it is not particularly DRY (this is a separate feature and it’s probable we’re gona reuse it), the app we’re builing is divided into several zones (client, emploee, admin), where each zone has a separate master controller, that inherits directly from ActionController::Base. The variants behaviour should be present only for client and emploee. How to do it then?

Extract the code to a concern!

When you created a Rails 4 app, you’ve probably noticed new directiories under controllers and models, which is called concerns. The idea of concerns was strongly promoted by DHH and now it is bundled in Rails together with a handy ActiveSupport::Concern wrapper. Let’s do it then, the separate concern will look like:

# coding: utf-8
#app/controllers/concerns/detect_format_variant.rb
module DetectFormatVariant
  extend ActiveSupport::Concern

  included do
    before_filter :detect_device
  end

  private
  def detect_device
    case request.user_agent
      when /iPad/i
        request.variant = :tablet
      when /ip(hone|od)/i
        request.variant = :phone
      when /Android/i && /mobile/i
        request.variant = :phone
      when /Android/i
        request.variant = :tablet
      when /Windows Phone/i
        request.variant = :tablet
    end
  end
end

Then in every controller we want this behaviour, we just need to include it:

class ClientController < ActionController::Base
  protect_from_forgery with: :exception

  include DetectFormatVariant
end

Not only it is DRYer, but it’s also self-descriptive. Concerns help you keep your controller clean and is a perfect tool to share code between controllers.

I have broken my Ubuntu Server VM, which is hosted on Xenserver, by improper entry in /etc/sudoers. Hence, I was stuck without the possiblity to run any command with sudo.

The solution in case of a desktop installation is to press ESC during boot and then simply select a recovery console in GRUB. However, no matter how fanatically you will press ESC when booting VM through Xenceter, AFAIK you would not be able to access the Recovery Console.

In some posts (eg. here or here) people recommend to start the VM in Recovery Mode that is provided by Xenserver (accessible by VM -> Start/Shutdown -> Start in Recovery Mode). The problem is that by default in this mode the system starts to boot from CD/DVD. This would be ok if Ubuntu Live CD would work in Xenserver, but it doesn’t! (vide this question on StackExchange).

Luckily, there is a simple solution! The Root Console can be called directly by change the VM boot options (eg. through Xencenter):

1. Backup! Make a snapshot of the problematic VM.
2. Right click on the problematic VM -> Properties, then go to the Boot Options tab.
3. Modify OS Boot Parameters from:

   -- quiet console=hvc0
   

   to:

   single
   

4. Boot/reboot the VM normally and select Drop to root shell prompt
5. Voila! Now you can perform as root the operations needed to recover the system.
6. Change back the OS Boot Parameters and reboot.

Somehow this is not described in Xenserver docs. I have fond it here.

Z dniem 22 marca 2013 weszła w życie nowelizacja Prawa Telekomunikacyjnego (http://www.dziennikustaw.gov.pl/DU/2012/1445), która jest bezpośrednim skutkiem konieczności dostosowania prawa polskiego do wytycznych Parlamentu Europejskiego – podobne zmiany zaszły, bądź zajdą wkrótce w pozostałych krajach UE.

Najbardziej istotną zmianą z punktu widzenia przedsiębiorców działających w branży WEBowej, jest konieczność pozyskiwania zgody na wykorzystywanie plików cookies na stronach internetowych (art. 173). Użytkownik może wyrazić zgodę przez zastosowanie odpowiednich ustawień w przeglądarce, jednak wtedy strona internetowa wykorzystująca ciasteczka ma obowiązek poinformować internautę o ich stosowaniu i przedstawić politykę ich przetwarzania.

W związku z opisanymi zmianami, warto dodać do wszystkich swoich Railsowych aplikacji stosowne procedury sprawdzające stosowanie plików cookie, zwłaszcza jeśli korzystamy w projektach z autoryzacji użytkowników poprzez np. Devise.

Tutaj http://clearcove.ca/2009/09/rails-cookie-detection/ znajduje się prosty moduł, który moża wykorzystać do wyświetlenia stosownego komunikatu, np.

Ta witryna używa plików cookie. Więcej informacji o używanych przez nas plikach cookie, ich zastosowaniu i sposobie modyfikacji akceptacji plików cookie, można znaleźć tutaj oraz w stopce na naszej stronie internetowej (Polityka plików cookie).

I have recently switched from Ubuntu to Win8 as my basic system. As RoR development under Win is a suicidal practice, I have decided to install Ubuntu on virtual machine (Oracle VM Box).

I want the guest Ubuntu network services (in particlar, LAMP&Rails server services) to be visible for host + guest OS should have access to the internet. Luckily, VirtualBox provides an easy method to accomplish this target in a few steps using secondary host-only network interface.

1. Install guest OS using default NAT network interface.
2. Keeping the VM turned off, configure according to your preferences the host-only network interface in VirtualBox (File->Preferences->Network in VirtualBox main window). Then add the host-only adapter as a secondary network interface for guest OS.
3. Configure guest OS to use static IP on secondary network interface.
4. Edit hosts file in host OS. In case of Windows 8, open notepad as administrator and edit %systemroot%\system32\drivers\etc\hosts appending the following line (GUEST_IP MOCK.DOMAIN) as in the example below:

   192.168.52.101 greg.or
   

Now you can easily access the guest network services (WWW, SSH, FTP etc.) from your host OS. You can find a comprehensive description of the host-only network layer provided by VirtualBox on slides published by Alex Hahn.

I am currently working on the eCommerce project motociclisti.pl based on Spree – „the world’s most flexible eCommerce platform”, as they advertise 😉

Motivation

I needed some tool to manage static pages – like contact, terms of use, some promo-pages etc. Eventually, I’ve decided to go for spree_essential_cms developed by  Spencer Steffen & Citrus. What I was missing there, was the tool to manage menus. So it was time to add some gem to spree community

I have developed spree_essential_menus gem, which smoothly integrates with spree > 1.0.0 and spree_essential_cms > 0.3.0.

Installation

Add the following line to your gemfile:

gem 'spree_essential_menus' 

Then run bundle.

Copy the migrations to your app (yeah, I know, I should add it to extension generator for the future):

bundle exec rake railties:install:migrations

and in the end run rake db:migrate. You are ready to play!

Usage

The SpreeEssentialMenus extension adds a subtab Menus to spree_essential tab (usually Static content, depending on you translation). You should first create Menu bars that you need for your shop (usually main menu and footer menu, but can be infinitely many).

Then in every menu bar, you can create as many menu elements as you want to.

You have two options:

• manually type the path (it can be both relative or absolute, but in case of aboulute path remember to start with „http://”)
• select a static page created in spree_essential_cms, that the menu element should point to. In this case, the path will be filled in automatically.

How to rearrange menu elements?

The menu elements can be easily reorganized by drag&drop functionality – just click on green arrows left to the element’s name in the index page of selected menu bar’s elements and drag it where you want to.

How to embedd it in my layout?

When you create Menu bars, you can easily embedd them in your layout by the partial, like below (written in HAML):

%header
  %nav
    - @menu_bar = Spree::MenuBar.find_by_name("main_menu")
    = render :partial => "spree/shared/render_menu", :locals => {:menu_bar => @menu_bar}

So far, 3 different menu presentations are available:

• render_menu – standard menu
• render_image_menu
  
  
• render_scroll_menu
  
  

Nested structure

Recently I’ve also added a nested_set structure for menu_elements. So for every menu element you can select a parent (within the same menu_bar), and thus create a nested menu with submenus.

Issues

So far I do not know any – if you find one, please report on GitHub – https://github.com/matfiz/spree_essential_menus

Feel free to pull and contribute I hope it will be usefull!

A client wanted to export some tabular data from the database to an editable format, so xls was an obvious choice. Before I mastered the export of the same piece of data into pdf format using Prawn gem, now I want to present you an easy way to achieve fairly the same effect, but in Excel output.

Let’s assume we have a list of clients in an array clients:

In order to export data to Excel, we will use the Ruby spreadsheet gem (project’s page: http://spreadsheet.ch/ and at Rubygem: http://rubygems.org/gems/spreadsheet). The gem provides a flexible way to manipulate, import and export xls data.

1. First, we need to register new mimetype – xls.
   Let’s create config/initializers/mime_types.rb and paste:

   Mime::Type.register 'application/vnd.ms-excel', :xls
   

2. Next, we have to extend the selected controller’s action to respond to xls

   def index
     @clients = Client.all
     require 'spreadsheet'
     respond_to do |format|
         format.pdf
         format.xls {
           clients = Spreadsheet::Workbook.new
           list = clients.create_worksheet :name => 'List of cliets'
           list.row(0).concat %w{Name Surname Age}
           @clients.each_with_index { |client, i|
              list.row(i+1).push client.name,client.surname,client.age
           }
           header_format = Spreadsheet::Format.new :color => :green, :weight => :bold
           list.row(0).default_format = header_format
           #output to blob object
           blob = StringIO.new("")
           clients.write blob
           #respond with blob object as a file
           send_data blob.string, :type => :xls, :filename => "client_list.xls"
         }
   end
   

3. In the end, we can create a link in the view: link_to clients_path(:format => :xls)
4. Click the link and enjoy the xls being downloaded. Remember you can style and/or add additional worksheets to your Excel workbook – refer to spreadsheet manual if needed.

I have just shown a Turnkey Linux Rails (VirtualBox edition) to my RoR developer friend. He really enjoyed using it, however after a few days he mentioned that he had a problem – every time he moved his laptop to a different network, he needed to restart Linux in orded to detect the proper IP through bridged network card connection. This is a distinct loss of time!

There is a simple command to renew (restart, or rather reflush) the ethernet connection, that will result in the renewing of DHPC IP. Assuming your network connection is eth0 (you can check it with ifconfig command), just type:

ifdown eth0
ifup eth0

And that’s all! The new IP would be printed in the output of the last command.

Recently I have worked on project that needed a pdf form to be filled with data gathered in Rails3 app db.

As I have decided to use PRAWN as a PDF generator (with prawn_rails gem – I can really recommend, works with Rails3), I had to choose between recreating the form or just filling in the form that was ready. As time=money, I decided to go for the second possibility.

1. I converted the pdf form to JPG (300 dpi resolution, no compression).

2. I needed A4 page size, so I also need to scale my image. In my example_document.pdf.prawn, I should put:

bg = "#{RAILS_ROOT}/public/pdf/pdf_bg.jpg"

prawn_document (
    :filename=>'foo.pdf',
    :page_size=> "A4",
    :margin => 0) do |pdf|
      pdf.image bg,
        :at  => [0, Prawn::Document::PageGeometry::SIZES["A4"][1]],
        :fit => Prawn::Document::PageGeometry::SIZES["A4"]
  pdf.text "This is pdf with background image ready to fill in"
end

The code above imports the image and positions it in the right left corner (remember! bounding box in pdf has its origin [0,0] in BOTTOM LEFT corner of the page). The size of A4 is set as constant by PRAWN (nice of them, isn’t it?). You can access it by Prawn::Document::PageGeometry::SIZES array. The full list of available page sizes you can find in PRAWN source code at https://github.com/sandal/prawn/blob/master/lib/prawn/document/page_geometry.rb.

3. Now one has to play around a little bit in order to position the data obtained from db in right positions.

Good luck!