Neutron Flux

Bower, Rails, and Javascript Components with CSS and Images

2014-08-07T23:58:10-06:00

There are a number of good articles describing the setup of bower with rails applications, but I was having a hard time finding a good description for how to integrate Bower, Rails, and javascript components that contain CSS and images. Specifically, I was trying to use bower to manage my applications dependency on select2.

TL;DR;

Use the bower-rails gem.

It provides a number of nice rake tasks that help integrate the use of bower with a rails application and the asset pipeline. I prefer to stick with the bower.json configuration instead of the ruby-based DSL that bower-rails provides. I stick with the default bower location that stores assets in vendor/assets/bower_components. Make sure to add the following to your application.rb.

config.assets.paths <<  Rails.root.join("vendor","assets","bower_components")

Once you have packages added to your bower.json, then you run the following:

rake bower:install

to install your javascript packages. You then reference the javacript in your application.js and application.css files.

For javascript components that reference images within their CSS, you need some mechanism for updating the asset paths to be rails asset pipeline friendly. Bower-rails aids in fixing this issue with the provided rake task:

rake bower:resolve

It resolves relative asset paths in components by rewriting url references in component css files with the rails helper method to reference the asset in an asset pipeline friendly way. See BowerRails::Performer#resolve_asset_paths for more detail.

My preference is to check in all of the bower_components into our repository, so we run bower:install followed by bower:resolve. You then need to add the images referenced within the package to your config.assets.precompile list for your staging and production environments. For example here is the setup for adding the select2 javascript component to your rails project using bower and rails.

bower.json:

{
    "name": "Acme",
    "private": true,
    "dependencies": {
        "select2": "3.5.1"
    }
}

app/assets/javascripts/application.js.coffee:

#= require select2/select2

app/assets/stylesheets/application.css.sass

//= require select2/select2

config/environments/staging.rb and config/environments/production.rb:

config.assets.precompile += ["select2/*.png",
                            "select2/*.gif"]

It’s not perfect, but it gives you the dependency management of your javascript components, and it’s better then trying to figure out what gems you need to pull in to get the desired javascript component enabled for the asset pipeline.

Migrations Without a Restart on Heroku

2012-06-19T02:02:00-06:00

I ran into a situation today where I had 10 long running background processes that were getting bogged down because we were missing an index. The app is running on Heroku on a shared database, so I don’t have the luxury of using psql to add the needed index. However, I wanted to figure out a way to add the index without restarting the long-running processes.

My solution was to log in via the console, and create the migration by hand.

heroku run console --app irb(main):002:0* class AddIndexToSearches < ActiveRecord::Migration irb(main):003:1> def change irb(main):004:2> add_index :searches, :search_string, :quiet => true irb(main):005:2> end irb(main):006:1> end => nil irb(main):007:0> t = AddIndexToSearches.new => # irb(main):008:0> t.change -- add_index(:searches, :search_string) (91.8ms) SELECT distinct i.relname, d.indisunique, d.indkey, t.oid FROM pg_class t INNER JOIN pg_index d ON t.oid = d.indrelid INNER JOIN pg_class i ON d.indexrelid = i.oid WHERE i.relkind = 'i' AND d.indisprimary = 'f' AND t.relname = 'searches' AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) ) ORDER BY i.relname (207509.6ms) CREATE INDEX "index_searches_on_search_string" ON "searches" ("search_string") -> 207.6028s => # irb(main):009:0> irb(main):010:0*

Once complete, I added a new migration within the source code that has the option :quiet => true (_updated: see note below), so that all environments/developers get the manually created index that resides in production. Had I just done a git push to heroku, the background processes would have restarted. The results of adding the needed index can be seen in our New Relic stats below:

Note: I thought :quiet was a valid option for add_index, but it is actually a patch that you will need to add for your specific database. The following article describes a patch for MySQL. See mine for PostGreSQL.

module ActiveRecord::ConnectionAdapters::SchemaStatements def add_index_with_quiet(table_name, column_names, options = {}) quiet = options.delete(:quiet) add_index_without_quiet table_name, column_names, options rescue raise unless quiet and $!.message =~ /^Index name '.*' on table '#{table_name}' already exists/i puts "Failed to create index #{table_name} #{column_names.inspect} #{options.inspect}" end alias_method_chain :add_index, :quiet end

Accepts Nested Attributes with Polymorphic Associations and a Custom Autosave

2011-07-07T08:11:24-06:00

Edit: This was originally posted on my companies blog.

Wheew… what a title… kinda dry, very geeky, but if you landed here, hopefully this will help. This blog documents some of the code wrangling that we did for a recent app, VRCompliance. I needed to have the ability to create multiple phone numbers when inputting either addresses or people in our system. It seemed like a great time to use models with with the :accepts_nested_attributes_for :nested_model declaration. When doing this I found out that the default creation of a nested object was not what I wanted. Essentially, I wanted a find_or_create for the nested object. After some searching I came across this StackOverflow article that describes a solution. This post adds to the discussed solution by going into additional detail and fleshing out the answer described in the previous link.

For this post I’ve simplified our objects so our sample application has people, addresses, and phone numbers. Both a person and an address can have many phone numbers. Additionally, with our application’s data it is possible to have a many-to-many relationship between the phone numbers, people and addresses. Instead of using two separate join tables to describe these relationships, I went with a polymorphic association, calling our resulting common join table, phonings, and the polymorphic relations a phonable.

Our models look similar to the snippets below:

class Address < ActiveRecord::Base has_many :phonings, :as => :phonable has_many :phone_numbers, :through => :phonings accepts_nested_attributes_for :phonings, :allow_destroy => true end

class PhoneNumber < ActiveRecord::Base has_many :phonings, :dependent => :destroy has_many :addresses, :through => :phonings, :source => :phonable, :source_type => "Address" has_many :people, :through => :phonings, :source => :phonable, :source_type => "Person" end

And the initial phoning model was:

class Phoning < ActiveRecord::Base belongs_to :phone_number, :autosave => true belongs_to :phonable, :polymorphic => true accepts_nested_attributes_for :phone_number end

With the models and their relationships defined, I built the forms for creating an address, and wanted to nest the creation of the phone numbers within the forms for the creating of both a person and address. Initially, I think I had :accepts_nested_attributes_for :phone_numbers in the address object, but there were issues with that approach.

First, deletion of the phone number deleted the object, and second, if I added the phone number to two different objects then I would get validation errors due to uniqueness constraints that I have on our real phone number object. After digging around, I found some links that discussed making the nested attributes for the join table so that on deletion you are really deleting the join object and not the object it relates. This resulted in :accepts_nested_attributes_for :phonings in the address object (as seen above).

Deleting of an object no longer deleted my phone number object, just the phoning object. However, I still had the issue that if the same phone number was added to two addresses via nested attributes then two distinct phone number objects were created. The test below shows passing tests that document this issue. Two addresses are initialized and saved with the same nested phone number. After saving both, we find that we have two phone number objects with the same phone number.

test "By default adding the same phone number will create a new phone number row when adding a second phone number" do a = Address.new(default_address( "phonings_attributes"=> {"1289233155995"=> {"phone_number_attributes"=> {"phone_number"=>"17032221234"}, "_destroy"=>"false"} } )) a.save! assert_equal "Cville", Address.find(a.id).city assert_equal "17032221234", Address.find(a.id).phone_numbers.first.phone_number b = Address.new(default_address(:address1 => "234 Test", "phonings_attributes"=> {"1289233155995"=> {"phone_number_attributes"=> {"phone_number"=>"17032221234"}, "_destroy"=>"false"} } )) b.save! assert_equal "Cville", Address.find(b.id).city assert_equal "17032221234", Address.find(b.id).phone_numbers.first.phone_number assert_equal @original_phone_number_count + 2, PhoneNumber.count assert_equal 2, PhoneNumber.where(:phone_number => "17032221234").count end

Based on the StackOverflow thread from above, I realized that I needed to change the autosave creation of phone numbers. It should be noted that accepts_nested_attributes_for automatically sets :autosave for the model. Autosave means that associated records are automatically saved when the parent object is saved. In our examples this means that when an Address object is saved the Phoning object and the PhoneNumber object are saved. The default functionality is to create a new object. The gist below shows the necessary changes to our test to generate the desired functionality of the find or create for the nested phone numbers.

test "When you override the autosave associated for the join table then you can point multiple addresses at the same phone number object." do # overriding autosave_associated_records_for_phone_numbers Phoning.send :define_method, :autosave_associated_records_for_phone_number do if new_phone_number = PhoneNumber.where(:phone_number => phone_number.phone_number).first then self.phone_number = new_phone_number else self.phone_number.save! self.phone_number_id = self.phone_number.id end end a = Address.new(default_address( "phonings_attributes"=> {"1289233155995"=> {"phone_number_attributes"=> {"phone_number"=>"17032221234"}, "_destroy"=>"false"} } )) a.save! assert_equal "Cville", Address.find(a.id).city assert_equal "17032221234", Address.find(a.id).phone_numbers.first.phone_number b = Address.new(default_address(:address1 => "234 Test", "phonings_attributes"=> {"1289233155995"=> {"phone_number_attributes"=> {"phone_number"=>"17032221234"}, "_destroy"=>"false"} } )) b.save! assert_equal "Cville", Address.find(b.id).city assert_equal "17032221234", Address.find(b.id).phone_numbers.first.phone_number assert_equal 3, PhoneNumber.count assert_equal 1, PhoneNumber.where(:phone_number => "17032221234").count end

We can then move that functionality back in to our model:

class Phoning < ActiveRecord::Base belongs_to :phone_number, :autosave => true belongs_to :phonable, :polymorphic => true accepts_nested_attributes_for :phone_number def autosave_associated_records_for_phone_number if new_phone_number = PhoneNumber.where(:phone_number => phone_number.phone_number).first then self.phone_number = new_phone_number else self.phone_number.save! self.phone_number_id = self.phone_number.id end end end

In a future post, I will walk through the view and controllers used for these nested forms.

Emacs Configuration

2011-04-19T23:55:00-06:00

I’ve had my emacs configuration under version control for the better part of the last decade, cvs then svn, and for the last 3 years git. I finally bit the bullet, and purged it of private data. Since I doubt the history is that interesting to most people, I kept a local historical branch, and then truncated the master branch which is now available in my github repos.

I used to use a monolithic .emacs file. When I declared .emacs bankruptcy a few years ago, I followed @rmm5t’s and @defunkt’s conventions… albeit probably not as nicely.

Forcing :before_validations to run and save the updated data

2010-12-17T10:44:17-07:00

I meant to write this up awhile ago, but just want to get it out… Have you ever decided to massage incoming data in a :before_validation. I ran into an issue recently where I added a change to a before_validation to remove extraneous characters from phone numbers. I already had a ton of numbers in the system, so I thought I would then be able to just iteration through the list of phone numbers and resave them, and voila… my data would be updated and I could then enable additional validation checks.

Nothing happened. After a bit of digging I realized that Rails was assuming that nothing was changing because the new phone number value was the same as the old value so no save was occurring and validations (and before_validation hooks) were not being run. Turning off partial updates temporarily in the console allowed me to resave my data and have the new before_validation hook massage my data.

# added a new before_validation PhoneNumber.all { |p| p.save! } # doesn't resave the data... silly me ActiveRecord::Base.partial_updates = false PhoneNumber.all { |p| p.valid?; p.save! } # now we are talking

Shoulda Snippets For Emacs

2009-07-27T22:00:00-06:00

I have just updated my Shoulda snippets for the Emacs YASnippets templating package. Shoulda is a ruby-based testing framework that consists of test macros, assertions, and helpers added on to the Test::Unit ruby framework. The snippets are based, and in many cases copied from the TextMate Shoulda snippet bundle, and modified where needed to work with the YASnippets package. New features in the recently released 0.6beta of YASnippet allow support for more of the TextMate-based snippets. The new YASnippet functionality is discussed in more detail in a post I did on Emacs Blog.

In order to port many of the snippets over from the TextMate bundle I wrote a script that automates the process. There is a Python script that does something very similar. The writing of my script was more of just a code kata for me, so take a look at both. One may be more suitable for your needs.

Better Oracle Support For db:structure:dump

2009-02-22T22:00:00-07:00

If you have tried

$ rake db:structure:dump

in a rails app when using Oracle as your database, then you have probably been slightly disappointed. The same rake task for MySQL and Postgres dumps everything you need to recreate the database. The task for Oracle only dumps SQL for the table creation (no constraints), and for the sequences. The active_record_oracle_extensions plug now supports dumping sql for the following:

primary keys
indexes
foreign keys
synonyms

I have added enough functionality to scratch my itch. If you need something else or find a bug let me know.

Active Record Oracle Extensions Plugin

2009-01-01T22:00:00-07:00

NOTE: This post is OBE. Check out the active record oracle adapter. Most/all changes have been added to it.

The active_record_oracle_extensions plugin provides support for adding foreign keys to migrations, adding synonyms to migrations, and disabling foreign key constraints during fixture loading. These are features that I needed in my applications, but either did not exist in other plugins, or the plugins seem to have been abandoned.

Installing into a Rails app

$ script/plugin install git://github.com/eyestreet/active_record_oracle_extensions.git

Adding Foreign Keys In a Migration

The example below shows a snippet from a migration that adds a foreign key.

def self.up
    create_table :assets, :force => true do |t|
      t.integer :media_record_id
      t.string  :media_file_name
      t.string  :media_content_type
      t.integer :media_file_size
      t.datetime :media_updated_at
      t.timestamps
    end
    add_foreign_key_constraint :assets, :media_record_id,
                                        :media_records, :id
 end

Adding a Synonym in Migration

The example below shows the creation of a synonym named events for other_user.events. The force option adds “or replace” to the sql that generates the synonym. It is assumed that the user under which your are creating the synonym already has the needed grants to allow the creation of the synonym on other_user.

add_synonym :events, :other_user, :events, :force => true

Disabling Constraints During Fixture Loading

If you are using sys or system as your user for your rails application, then do not use this plugin, or use it at your own risk. During fixture loading, this plugin disables constraints for the user that has established the connection to oracle, and then re-enables the constraints after the load.