Created noodall_poll.

So instead I used:

The result was lots of paths using noodall-poll, such as /app/helpers/noodall-poll/application_helper.rb. When I tried to run test, I got application_helper.rb not found errors. The system was looking for /app/helpers/noodall_poll/application_helper.rb.

Lesson learn: don’t play around with engine names. Use camelcase or underscored engine names.

It had been created in a somewhat pragmatic way, using the simplest way that I could find to implement it. That was to create the functionality in an ActiveRecord::Base abstract class, and then have all the models that needed this functionality, inherit this class. I’ve made the code available as SoftDeleteableBase.

This approach works fine and is very easy to implement. The problem is that it does not scale very well. That is, if you need to add additional functionality in the same way, the new abstact class has to inherit from the original.

A much better way to add functionality to a model is by mixing in via a module. Having recently read Elequent Ruby by Russ Olsen (my favourite Ruby author), and Metaprogramming Ruby by Paolo Perrotta (the two books complement each other very well), I felt I should rewrite SoftDeletableBase as an ‘Act as’ plugin.

The result was ActsAsSoftDeleteByField. A bit verbose, but as ActsAsSoftDeletable already existed I needed to differentiate my plugin from that. ActsAsSoftDeletable moves deleted items into another table, which was not been the functionality I wanted. My system uses a field in the model’s table to flag when a record is deleted. A simple solution, but ActsAsSoftDeletable maybe more suitable for many projects.

The two books gave me the knowledge I needed to understand how the methods used to create the mixin can be used. However, I found it very useful to look at other Acts As plugins such as acts_as_rateable, and acts_as_nested_set, to see how to arrange the code. The Ruby on Rails Guide was also useful.

Loading instance and class methods is actually fairly straight forward. Most of the work is done by this bit of code:

Getting the code to load properly was more difficult. It took me a little fiddling to get the init.rb file to work correctly. A lot of examples use class_eval here, but as I know the class names, I chose to use the simpler technique of monkey patching:

I used a set of assertions I’d used to test SoftDeleteableBase to test the new mixin, and included this code in the new plugin. That made it a lot easier to check the functionality. I created a new Rails app, and generated a Thing model. I then applied acts_as_soft_delete_by_field to thing, made sure it had a :deleted_at field, and ran the tests.

The next thing I did was to extend the functionality so that an alternative field could be used to store the deleted information. A few modifications and that was all working.

The last step was to create the gem. Russ Olsen’s book gave me the basics. The main thing that caused me problems was again initiating the script.

The main problem is that many of the examples on the web use the old system relying on /rails/init.rb, but I couldn’t get this to work. In the end, I realised that a file with the gem name was always loaded, and therefore that would be the place to put the hook script. So acts_as_soft_delete_by_field.rb was created and I put a hook script there. With that in place everything started working a treat.

The end result was the acts_as_soft_delete_by_field gem!

With all that in mind, here is my take on very stressful occurrences such as bereavement:

Bereavement: UDP and the unconcious mind

Your brain works very like a UDP stack, where the conscious mind sits at the application layer.

Most of the work is done within lower parts of the stack, and with everything working normally, stuff gets passed down into the unconscious brain and stuff pops back up without the top layer knowing or really caring about what happened lower down. You often think your conscious mind is doing all the work, but actually its all happening lower down.

Normally, the stack is able to handle problems and routes messages back and forth without any problem.

However, when something very stressful happens the stack gets disrupted. It gets information it doesn’t know how to handle. The result at the top layer is it doesn’t get any answers. Also as this is UDP, it doesn’t get any error messages either. So the net result is numb confusion.

With time the stack fixes itself. This can take hours or even days. Until then nothing computes properly. You can’t concentrate, you feel numb, and a little confused because you can’t figure out what is happening. These symptoms only go away once the stack fixes itself and normal conscious to sub-conscious communication returns.

This matches my experience:

Immediately after a very stressful situation I am left with a very numb, empty feeling where my brain just doesn’t work normally. The only thing that fixes this is time. I’ve learnt to recognise this feeling and the knowledge that time fixes it helps me deal with it. Trying to force my brain to fix the problem just makes the fix time longer.

Once the stack sorts itself out (for me, 2 to 12 hours is a common fix time), I can then start the rational process of sorting out the emotions and images that pop into my head.

My problem was how to connect a new Moderator class to the User class.

A starting point is that I want Moderator class to inherit from User. That’s simple:

The problem with this is if you do Moderator.find(:all) you get all users and not just those who are moderators.

In my last project, I overrode find, but that was a Rails 2 project and the same technique doesn’t work so well for this Rails 3 project. For example, Moderator.all still returns all users.

Another option would be to use ‘Single Table Inheritance’ (see ActiveRecord::Base api), but that would mean adding a new field and then limiting users to just one sub-class. For example, I think I will use the same technique with admins, and what if a moderator is both a moderator and an admin. Single Table Inheritance won’t let you do that.

In the end the solution was ridiculous simple. It is ‘default_scope’.

This works

And this is what I ended up with:

If I have special data entries that alter behaviour, I prefer to put them into constants and use the constants within the code. That way I can change the specific data entries at a later date without having to change every instance where it is used. Hence using MODERATION_SCOPES.

The final version also allows me to share the same code between User.find_moderators and Moderator.default_scope.

However, I needed to provide a production version of one of my applications for a colleague writing some documentation. In the past running a mongrel instance as a service on my PC has been great for this, but having recently upgraded to Rails 3, I’ve managed to kill my mongrel_service gem. Unfortunately reinstalling was not as easy as I thought. To get it to work I had to do the following:

Install win32-service separately and force it to install the binary version rather than build it from source. To do that:

Notice the double dash before platform. The blog where I first got this from had only one dash which caused me a little head scratching.

Then I had to install the ‘pre’ version of mongrel_service:

I found that step from this blog.

BTW, I run a command prompt as the administrator when running gem commands (right click cmd icon and select ‘run as administrator’)

Once that was done I could use the mongrel_service as usual:

I think the code speaks for itself. As you can see it is very easy to extend Time#to_s to provide straight forward formatting. It is also easy to overwrite the default

One: making session data available at the model and observer level. An article by Geoff Lane gave me the information I needed to be able to achieve that.

Two: use an observer to catch Model call backs and trigger an action in response. The Rails api documentation gave me the information I needed on creating an observer.

Here is a simple example as to how I was able to add an activity logger using these two techniques.

First I created a new module:

This was based on Geoff Lane’s UserInfo module. I made two changes: I used a more descriptive module name; and I changed the method name because current_user was already used in the controller by my authentication system (‘restful_authentication’). The later stopped me logging in successfully until I spotted the problem.

I then added these two lines to my ApplicationController:

Together with this private method:

So very similar to Geoff Lane’s code except with more descriptive method names.

I then needed to add the observer:

However, nothing happened until I added this line to config/environment.rb:

Note that config.active_record.observers only gets called at application start, so you may need to stop and start your application before the observer starts working.

I now have a system I can extend to log activity. As shown above, only changes to accounts and licenses are logged, and the log just outputs to the console at the moment. However, now I have the mechanism, it is easy to create a new ActivityLog model and save the log entries to that in whatever format I fancy.

The solution was to change over to storing the files within the database. This took a couple of small modifications:

model
I changed the has_attachment declaration to:

The default attachment_fu is to use the database to store files. So removing the :storage entry in this statement was enough to change over from file system storage to database storage.

database
I has to add a new table and an additional column to my main model. The new table was created with:

Note that adding a :limit entry can alter the blob field type created in the database. Without it the standard MySQL behaviour is to create an ordinary blob field. If the :limit statement indicated that a blob isn’t big enough, the data field will be set as a LONGBLOB.

The extra field added to my product_files table was ‘db_file_id’ which is an integer field.

public_filename
When working with database file storage, public_filename is no longer available. So I needed to come up with an alternative way to serve the file to the user.

controller download action
To do this I created a download action.

Note that send_data is a standard Rails method, so its use can be looked up in the Rails api. I wasted a little time trying to find this in the attachment_fu code.

helper
It was then just a case of creating a helper that pointed at this action.

view
This could then be used in a view, wherever I need a link to download a file I used it like this:

Job done (except writing the tests of course)

The class stores files related to a product. These are either code exerts or documentation. I’ve called the class ProductFile.

Params

If you are going to run tests that pass in data via a params hash, how do you get a file into the params in the right format. Here is the solution I worked out:

I couldn’t get this to work without having the test file in a sub-folder of the fixtures folder. So I added a file ‘test/fixtures/files/test.txt’. Then I used ActionController::TestCase.fixture_path to determine the path.

Tear down

The other problem I had was that the standard Rails unit test tear down process wasn’t removing files created during the test. I overcame this by keeping track of each ProductFile created during the tests, and then using a teardown method to remove them all at the end of the test. This is the code that achieved that:

Now, as long as I used the create_product_file_from_params to create new product_files with params, the test would clean up after itself.

Fixtures

By the way, Product Files created via fixtures didn’t create a matching file in the file system. Which make it easier to keep things tidy, but needs to be kept in mind if you need an actual file to test against.

References

attachment_fu wiki

Mike Clark’s example of using attachment_fu

David Jones’ very interesting article on using attachment_fu with acts_as_versioned