Installation

In your Gemfile:

gem 'acts_as_translatable'

Install the new gem:

bundle install

Example

Generate translations for a category model with name and description fields, with default locale set to ‘en’ (English):

$ rails generate acts_as_translatable en category name description

This will create the necessary migration. Then run:

$ rake db:migrate

Then add to app/models/category.rb:

class Category < ActiveRecord::Base
  acts_as_translatable_on :name, :description
  ...
end

And play around with I18n:

I18n.locale = "en"
Category.first.update_attribute :name, "English name"

I18n.locale = "de"
Category.first.update_attribute :name, "Deutsche Name"

Also try in combination with my translate_acts_as_translatable_models plugin to automatically translate your acts_as_translatable enabled models.

Have fun! Please send comments and suggestions to lassebunk@gmail.com, and issues at GitHub, please

Follow me on Twitter

In your Gemfile:

gem 'bing_translate_yaml'

Then run:

$ bundle install

Make sure you have your translation files in e.g.:

config/locales/en.yml (English)
config/locales/de.yml (German)
config/locales/es.yml (Spanish)

Then run:

$ rake translate from=en to=es

This will create (or update) the following file:

config/locales/es.yml

Simple as cake! Enjoy

Follow me on Twitter

Let’s assume that the database migration should take place when the plugin is activated. Assuming your plugin is named myplugin, put this code in the myplugin.php file:

register_activation_hook(__FILE__, 'myplugin_install');

This makes WordPress execute the myplugin_install() method when the user activates your plugin.

Next, add this method:

function myplugin_install() {
  myplugin_migrate();
}

And our migration method:

function myplugin_migrate() {
  global $wpdb;

  $migs = myplugin_migrations();

  $current_migration = get_option('myplugin_current_migration', 0);
  $needed_migration = count($migs);

  for ($i = $current_migration; $i < $needed_migration; $i++) {
    $mig = $migs[$i];
    $wpdb->query($mig);
  }

  if ($current_migration == 0) {
    add_option('myplugin_current_migration', $needed_migration);
  } else {
    update_option('myplugin_current_migration', $needed_migration);
  }
}

What this does is that it runs through database statements (queries) returned from the myplugin_migrations() method. Let’s implement the actual migrations – add this method:

function myplugin_migrations() {
  global $wpdb;

  $migs = array();

  // Create example table
  $migs[] = '
  CREATE TABLE '.$wpdb->prefix.'myplugin_examples (
    id int(11) NOT NULL AUTO_INCREMENT,
    name varchar(255) NOT NULL,
    PRIMARY KEY (id)
  )';

  // Add examples
  $migs[] = "INSERT INTO ".$wpdb->prefix."myplugin_examples SET name='First example'";
  $migs[] = "INSERT INTO ".$wpdb->prefix."myplugin_examples SET name='Second example'";

  // Return the migrations
  return $migs;
}

That would create an example table and insert some values.

Now imagine that two months later you need a description field in your examples table. What do you do? It’s as easy as adding one line of code to the migrations:

// Add description field to examples
$migs[] = "ALTER TABLE ".$wpdb->prefix."myplugin_examples ADD description VARCHAR( 255 ) NOT NULL";

Deactivate and activate the plugin, and you table now has an extra field. Easy as cake!

Share your thoughts, opinions, and suggestions below.

Follow me on Twitter

Visit the plugin page: A/B Test for WordPress

Follow me on Twitter

Visit the plugin page: A/B Test for WordPress

Follow me on Twitter

Let’s say you have a blog and you have been using the standard WordPress Twenty Eleven theme for a while but now you saw this great looking theme that’s just a must have. How do you find out if this new theme will make your site perform better or worse, and how will it affect outbound link clicks to your new book at Amazon? Let’s find out

WordPress comes with the Twenty Eleven theme, so we’ll split test between this and another theme. Let’s install the free Adventure Journal theme:

For information on how to install themes, visit Using Themes on the WordPress site.

Then intall the plugin and activate it in Plugins:

Click the A/B Testing link right below Settings:

Click Create new experiment:

Enter “Split testing my theme” as Name and select Theme as Experiment type:

Click Create experiment.

Click Edit below Experiment 1:

Select the Adventure Journal theme:

Click Update variation.

Do the same for Variation 2 where you select Twenty Eleven as the theme.

Click Back to experiments at the bottom of the page:

Now we’re going into Debug mode to test our variations. About the Debug mode:

“Normally, when a user first sees a variation to an experiment, this variation is locked for this user so that – in this session – she always sees the same variation.
If you want to test your experiments without this variation lock taking place for you (and only you), you can enable debug mode. Also, when entering debug mode, all tracking will be disabled for your session.”

Click Enter debug mode in the top right corner of the screen:

Debug mode is now on:

Now go to the front page of your site, and you’ll see one of the themes being displayed:

Now click Refresh a couple of times, and you’ll see that the theme changes:

Neat, eh?

Back into the admin interface, click Exit debug mode:

We’ll now set up a link and track when this link is clicked. We’ll use a link to a book on Amazon to simulate an author site with a “Buy my book” link.

Click Split testing my theme and scroll down to Goals:

Click Get tracking code right below Goal 1 and you’ll see this screen:

Select the javascript code below To track a link and copy it to the clipboard using CMD + C (on a Mac) or CTRL + C (on a PC):

We’ll now create a widget with our link to Amazon.

Click Appearance and then Widgets in the menu to the left:

Insert a widget by dragging a Text box from the Available Widgets box:

Onto the Main Sidebar on the right:

Enter “Buy my book” as Title and insert this code below:

<a href="http://www.amazon.com/WordPress-Power-Guide-Blogging-ebook/dp/B004UW29IK/ref=sr_1_1?ie=UTF8&qid=1326554345&sr=8-1" onclick="abtest.trackGoal(1, this);">Buy my book on Amazon</a>


Like this:

Notice how we’re using the onclick="abtest.trackGoal(1, this);" code? That’s what’s tracking our link when we click it.

Click Save.

Now go back onto the front page and you’ll see that the widget has been inserted into your site:

So far so good.

Try clicking the link.
You have now tracked a goal completion!

Back into the admin interface, click on the experiment and you’ll see that it has tracked a goal completion:

Nice! Now you just need to wait and see which theme performs better.

For more info, installation instructions, and tutorials, visit the A/B Test for WordPress plugin page.

Also, please feel free to contact me if you have any questions.

Follow me on Twitter

Visit the plugin page for more information, download, tutorials, and videos.

Here is a video introduction:

→ Download the plugin (or see more information)

Please feel free to contact me if you have any questions.

Follow me on Twitter

Start by creating a new project from File › New › New Project.

Select Master-Detail Application and click Next.

As Product Name enter ‘Twitter Test’. Make sure the Use Storyboard and Use Automatic Reference Counting check boxes are checked. Click Next.

Select where to save the project and click Create.

Your project is now created. It has automatically set up a storyboard a master view controller and a detail view controller. The storyboard is where we will design our app – the controllers are where the programming takes place.

Let’s open up our storyboard to see what it contains. Click on MainStoryboard.storyboard to the left and the storyboard comes up:

This basically tells us that we have:

1. A navigation view controller – that’s the type of controller that automatically gives a Back button when you navigate from a list view down to a detail view.
2. A master view controller – that’s where we’ll have our tweet list.
3. A the detail view controller – that’s where we’ll have details about each tweet.

The lines between each controller are called ‘segues’. We’ll talk more about these later on when we handle the action when the user selects a tweet.

Let’s set up our table view.

Select the table view in the tree view to the left:

And to the right select Dynamic Prototypes instead of Static Cells:

This tells the table view that we’re going to set up the cells dynamically from our controller.

Next, again in the tree view to the left, select the Table View Cell:

And, on the right, set style to Subtitle and Identifier to ‘TweetCell’ – that’s the name we’re going to use in our code to find the cell so we can fill out its details:

You’ll see that the view style changes – that’s the style we’ll use to display the tweet text as the title, and tweet author as the subtitle:

So, now we’re all set up in the storyboard part – at least as far as the master view goes. Don’t worry – we’ll get back to the detail view later on.

Go into MasterViewController.m by selecting it on the left:

This is where all the action will take place. But first we need to set up an instance variable to contain our tweets.

Click on MasterViewController.h to the left:

And replace the @interface to @end part with the following code:

@interface MasterViewController : UITableViewController {
    NSArray *tweets;
}

- (void)fetchTweets;

@end

This tells Objective-C that we have a tweets instance variable and a fetchTweets method.

Now to the actual tweet fetching. Go back into MasterViewController.m and insert the following method:

- (void)fetchTweets
{
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSData* data = [NSData dataWithContentsOfURL:
                        [NSURL URLWithString: @"https://api.twitter.com/1/statuses/public_timeline.json"]];

        NSError* error;

        tweets = [NSJSONSerialization JSONObjectWithData:data
                                                 options:kNilOptions
                                                   error:&error];

        dispatch_async(dispatch_get_main_queue(), ^{
            [self.tableView reloadData];
        });
    });
}

What this does is that it makes a separate thread to fetch the JSON data and then goes back to the main thread to update the table view when it’s done. The reason to do this is that if we were to get the data using the main thread, then the application would lock up until the data was loaded.

Call this method from inside the viewDidLoad method:

- (void)viewDidLoad
{
    [super viewDidLoad];
    [self fetchTweets];
}

This tells the application to load the JSON data as soon as the view loads.

So now our Twitter feed is loaded into to our instance variable named tweets. This now contains an array holding a number of NSDictionary objects where NSDictionary is a key/value collection.

Next, insert the following two methods:

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return tweets.count;
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *CellIdentifier = @"TweetCell";

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil) {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier];
    }

    NSDictionary *tweet = [tweets objectAtIndex:indexPath.row];
    NSString *text = [tweet objectForKey:@"text"];
    NSString *name = [[tweet objectForKey:@"user"] objectForKey:@"name"];

    cell.textLabel.text = text;
    cell.detailTextLabel.text = [NSString stringWithFormat:@"by %@", name];

    return cell;
}

And run your application. Click the Run icon:

And it works:

Pretty simple, huh?

Well, can’t dwell on our success, so let’s go on to something that needs to be done.

Try selecting a tweet. Our intention was to load the detail view, but this doesn’t happen. Why not?

Go back into the storyboard:

Notice how there’s no segue between the master view controller and the detail view controller. What happened was that when we went from static cells to prototype cells in the storyboard before, it erased it, so now it doesn’t know what to do. Let’s help it out.

To the left, CTRL + drag from the Table View Cell to Detail View Controller, and select Push:

Now it knows what to do, so try hitting Run again.

And it works.

In the storyboard, double click on the ‘Master’ and ‘Detail’ titles and change them to ‘Tweets’ and ‘Tweet’ accordingly:

Click on the segue between the table view and detail view:

And change its identifier to ‘showTweet’:

In MasterViewController.m, right below #import "MasterViewController.h", insert the following code:

#import "DetailViewController.h"

This is to give us access to the detail view controller from the master view controller.

Insert the following method:

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender
{
    if ([segue.identifier isEqualToString:@"showTweet"]) {

        NSInteger row = [[self tableView].indexPathForSelectedRow row];
        NSDictionary *tweet = [tweets objectAtIndex:row];

        DetailViewController *detailController = segue.destinationViewController;
        detailController.detailItem = tweet;
    }
}

Basically what this does is that it tells the app what to do when it hits the segue between the master view and the detail view. It identifies the selected row, finds the tweet, and then sets the detailItem property on the detail view controller. (The detailItem property was automatically created when we selected Master-Detail Application in the beginning. Thanks Xcode!)

Now we’re ready to do the detail view controller.

Open up the storyboard and delete the label saying ‘Detail view content goes here’. We’ll be creating our own.

Insert a label for the name, a label for the tweet, and an image view for the profile image, like this:

You can customize the text sizes like you want.

We’ll need a way to call these new controls from our code. This is done by creating three outlets which is a sort of wire, or connection, between the view and the controller. In DetailViewController.h, replace the @interface line with the following code:

@interface DetailViewController : UIViewController {
    IBOutlet UIImageView *profileImage;
    IBOutlet UILabel *nameLabel;
    IBOutlet UILabel *tweetLabel;
}

Now we have created the outlets. We now need to reference, or connect, these from our views. To the left, CTRL + drag from Detail View Controller to ‘Label – Name goes here’ and select nameLabel:

CTRL + drag also from Detail View Controller to ‘Label – Tweet goes here’ and select tweetLabel, and from Detail View Controller to ‘Image View’ and select profileImage.

Now we can call the labels and image view from our code.

In DetailViewController.rb, replace the configureView method with the following code:

- (void)configureView
{
    if (self.detailItem) {
        NSDictionary *tweet = self.detailItem;

        NSString *text = [[tweet objectForKey:@"user"] objectForKey:@"name"];
        NSString *name = [tweet objectForKey:@"text"];

        tweetLabel.lineBreakMode = UILineBreakModeWordWrap;
        tweetLabel.numberOfLines = 0;

        nameLabel.text = text;
        tweetLabel.text = name;

        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSString *imageUrl = [[tweet objectForKey:@"user"] objectForKey:@"profile_image_url"];
            NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:imageUrl]];

            dispatch_async(dispatch_get_main_queue(), ^{
                profileImage.image = [UIImage imageWithData:data];
            });
        });
    }
}

Try running the code, and there you have it – a list view and a detail view showing the tweet!

Hope you liked it

• Check out more of the Twitter API here and here
• More JSON here
• Thanks to the team at Ray Wendelich for inspiring me to begin iOS programming

Follow me on Twitter

Installation

In Rails 3:

$ rails plugin install git://github.com/lassebunk/sitemap_notifier.git

Example

Start by generating initializer and route:

$ rails generate sitemap_notifier sitemap_notifier

In config/initializers/sitemap_notifier.rb:

# wait 10 minutes between notifications
SitemapNotifier::Notifier.delay = 600

# replace this with your own url
SitemapNotifier::Notifier.sitemap_url = "http://example.com/sitemap.xml"

After installation

After you install and configure the plugin, it’ll automatically notify Google, Bing, and Yahoo every time you update a model. After each notification, it’ll wait 10 minutes (by default) before notifying again. This is to ensure that for example a batch update won’t trigger an equal amount of notifications.

Follow me on Twitter

Like this:

In app/views/api/users/index.apibuilder:

array :users do
  @users.each do |user|
    element :user do
      id @user.id
      name @user.name
    end
  end
end

Returns:

[
  {
    "id": 1234,
    "name": "Peter Jackson"
  },
  {
    "id": 1235,
    "name": "Marilyn Monroe"
  }
]

And the equivalent XML.

In app/views/api/users/show.apibuilder:

element :user do
  id @user.id
  name @user.name
  address do
    street @user.street
    city @user.city
  end
  array :interests do
    @user.interests.each do |interest|
      element :interest, interest.name
    end
  end
end

Returns:

{
  "id": 1234,
  "name": "Peter Jackson",
  "address": {
    "street": "123 High Way",
    "city": "Gotham City"
  },
  "interests": [
    "Movies",
    "Computers",
    "Internet"
  ]
}

And the equivalent XML.

You can then call your API like this:

http://example.com/api/users?format=json

or

http://example.com/api/users?format=xml

and so on.

Installation:

$ rails plugin install git://github.com/lassebunk/api_builder.git

Documentation and examples: Check out ApiBuilder at GitHub.
Looking forward to comments and suggestions

Follow me on Twitter