larsgebhardt

ApplyHQ launched

Lars — Tue, 16 Jun 2009 07:13:29 +0000

After many hours of work i’m proud to say - it’s done. On June, 15th ApplyHQ.com launched successfully.

I am grateful for the support of my twitter friends. They have given me many helpful hints i’m going to implement next days and weeks.

ApplyHQ.com is a web application providing freelancers services to apply for jobs and projects in a easier, faster and professional way. Its purpose is to simplify project and job acquisition for hard working freelancers.

Use tweetmeme plugin with redtime theme

Lars — Fri, 05 Jun 2009 09:14:26 +0000

While i was setting up the new theme to this blog i found a small problem with the tweetmeme plugin. The featured post wasn’t displayed correctly because of the javascript code from tweetmeme.

It has costed me some efford but here comes the solution. This bug can be fixed easily by modifying the fn-general.php file inside the themes/redtime/includes folder.

You have to modify the function: the_content_limit around line 207.

Search following code in the function:

1 2	$content = str_replace(']]>', ']]>', $content); $content = strip_tags($content);

and replace it with

1
2
3

$content = str_replace(']]>', ']]>', $content);

$content = preg_replace("']*>.*'siU",'',$content);

$content = strip_tags($content);

What does this line? The regular expression removes all code between the script tags. So the javascript code from tweetmeme is removed and the featured post will be displayed properly.

17 Visual Effects for Ruby on Rails RJS functions

Lars — Mon, 01 Jun 2009 18:25:06 +0000

Ruby on Rails has a scriptaculous framework integration out of the box. The Rails helper functions are very powerful, but every time i need a visual_effect i have to search in API docs to get all Rails supported scriptaculous effects.

To shorten the search i’m going to list all 17 supported effects.

Effects for appearing

This effects make sence after AJAX create or show functions. They add the new content effectfully after your record is created or replace a list entry with a detail entry after show function.

Appear - Fades in the selected DIV.
BlindDown - Fades in the selected DIV from top to bottom.
SlidesDown - Slides in the selected DIV from top to bottom.
Grow - Fades and zoomes in the selected DIV.

Effects for disappearing

This effects you can use to remove a DIV after a destroy function was executed successfully.

Fade - Fades out the selected DIV
Puff - Fades out and zoomes out the selected DIV
Blind up - Fades out from bottom to top side of selected DIV
SwitchOff - Flash Up and fade out
SlideUp - Moves the DIV from bottom to top
DropOut - Fades and moves out to bottom.
Squish - Minimizes the DIV to left top corner.
Fold - Foldes the DIV first to top second to left.
Shrink - Minimize the DIV to center direction.
Hide - Hides the DIV (thx to Nick)

Effects for highlighting

After AJAX update functions this group of effects makes sence. It catches the attention after a record is updated.

Shake - Shakes the DIV horizontally.
Pulsate - Fades out and zoomes out the selected DIV
Highlight - Highlights the DIV with yellow flashing.

How to use in views

Use the effects in following way in your views:

1
2
3
4
5

<%= link_to_remote("Destroy", 

:url => item_path(item), 

:complete => visual_effect(:Fade,"item_box_#{item.id}"),

:method => :delete)

%>

Have fun.

Nokia Sportstracker GPS data on Google Maps with Ruby on Rails

Lars — Sun, 10 May 2009 18:19:05 +0000

In my last tutorial i have explained how to import GPX files from Nokia Sportstracker Software. We have created a small Ruby on Rails application - navtracker - which we will use again. We will display the imported data on Google Maps with Ruby on Rails.

Its a good idea to read my previous tutorial before. Information about the Google Maps API can you find here. We need a key for our http://localhost:3000 development environment too.

At first we have to update track.rb and routes.rb

1
2
3
4
5
6

class Track < ActiveRecord::Base

  has_many :tracksegments, :dependent => :destroy

  has_many :points, :through => :tracksegments

  has_attached_file :gpx

  ...

end

1
2
3

map.resources :tracksegments, :has_many => :points

  map.resources :tracks, :has_many => :tracksegments

  map.resources :tracks, :has_many => :points

At second, we modifiy views/tracks/show.html.erb to get a better overview.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<%=h @track.gpx_file_name %> 

<%@track.tracksegments.eachdo|segment|%>

    <% segment.points.eachdo|point|%>

    <%end%>
<%end%>
Point #LatitudeLongitudeElevationDescriptionTimestamp
<%= point.name%><%= point.latitude%> <%= point.longitude%><%= point.elevation%>m <%= point.description%>

            <%= point.point_created_at.strftime("%H:%M - %Y/%m/%d")%>

Next, we need the google maps api javascript code in layouts/tracks.html.erb

1	<script src="http://maps.google.com/maps?file=api&v=2&sensor=false&key=ABQIAAAA7oGKIGpyMHBf9frQDOIDqxTJQa0g3IQ9GZqIMmInSLzwtGDKaBTSyz-43dhS-cG7AWZa73AghbA31A" type="text/javascript">script>

Next we add the google maps div to views/tracks/show.html.erb:

1 2	<%=h @track.gpx_file_name %>

Programming the google maps api requires some javascript skills. At first we create a javascript file: googlemaps.js in /public/javascripts. We create following functions here:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

function load_segment_points(map){

    GDownloadUrl("/tracks/"+track_id+"/points.xml", function(data, responseCode) {

        var points = new Array();

    var xml = GXml.parse(data);

    var xml_points = xml.documentElement.getElementsByTagName('point');

        for (var i = 0; i < xml_points.length; i++) {

            points[i] = new Object();

            points[i]["latitude"] = xml_points[i].getElementsByTagName('latitude')[0].firstChild.data;

            points[i]["longitude"] = xml_points[i].getElementsByTagName('longitude')[0].firstChild.data;

        }

        set_start_point(points,map);

        set_end_point(points,map);

        add_route(points,map);

    });

}

We use the GDownloadUrl to get a xml file of all points of current track. We assign the track_id parameter in views/layouts/tracks.html.erb

1
2
3

And we add to views/layouts/tracks.html.erb the javascript_include_tag too:

1	<%= javascript_include_tag :all, :cache => true %>

In our googlemaps.js file we need following functions too:

1
2
3
4
5

function set_start_point(points,map){

    var point = new GLatLng(points[1]["latitude"], points[1]["longitude"]);

    map.setCenter(point, 13);

    map.addOverlay(new GMarker(point));

}

set_start_point marks the point the current segment of the route is starting.

1
2
3
4
5
6

function set_end_point(points,map){

    var max = points.length-1;

    var point = new GLatLng(points[max]["latitude"], points[max]["longitude"]);

    map.setCenter(point, 13);

    map.addOverlay(new GMarker(point)); 

}

set_end_point marks the latest point of current segment.

1
2
3
4
5

function init_map(){

    var map = new GMap2(document.getElementById("map_canvas"));

    map.setUIToDefault();   

    load_segment_points(map);

}

ini_map creates the Google Map and calls load_segment_points.

1
2
3
4
5
6
7
8

function add_route(points,map){

    var line = new Array();

    for (var i = 0; i < points.length; i++) {

        line[i] = new GLatLng(points[i]["latitude"],points[i]["longitude"]);

    }   

    var polyline = new GPolyline(line, "#aa0000", 5);

    map.addOverlay(polyline);

}

add_route creates the polyline and adds it on our Google Maps.

1
2
3
4
5

function initialize() {

  if (GBrowserIsCompatible()) {

    init_map();

  }

}

The function: initialize is called by body onload to add the map to our website. With all this javascript functions we can enter http://localhost:3000/tracks/3 (replace 3 with your test track number) and some screenshot like this:

With the both tutorials about GPX file import and display it in google maps you should be able to write your own applications working with Nokia Sportstracker GPS data.

Update. I uploaded project files and gpx data file. Both are compressed with ZIP:

navtracker.zip
ersland-rundtgpx.zip

If you like this tutorial tell it your friends and share it.

How to import Nokia Sportstracker GPS data with Ruby on Rails

Lars — Fri, 08 May 2009 09:32:52 +0000

In this tutorial i will explain how to import GPS data from Nokia mobile phones with Ruby on Rails and displaying them as route on a google map.

The first part will solve the data import of GPX formated data files. The second part will show you how to display the routes on google map.

As data source i use a sample *.GPX file. It is provided from Marton who asked me to write this tutorial. The full description of xml structure you can find at http://www.topografix.com/GPX/1/1/

I will write a sample Rails Application - navtracker - covering following points of Ruby on Rails programming:

Upload a *.GPX file
Parse a XML Data
Google Maps Api access to display the route

Alright, lets start writing the application. All code examples are based on Rails 2.3.2.

rails navtracker

rake db:create:all

For file upload we need the paperclip plugin.

script/plugin install git://github.com/thoughtbot/paperclip.git

Now we create the “Track”, “Tracksegment” and “Point” resources. One track has many tracksegments has many points.

Tragsegment is needed if you loss your GPS connection. The trackersoftware will create a new tracksegment if your GPS connections is etablished again.

script/generate scaffold track name:string gpx_file_name:string

gpx_content_type:string gpx_file_size:integer

script/generate scaffold tracksegment track:references

script/generate scaffold point name:string latitude:float 

longitude:float elevation:float description:string 

point_created_at:datetime tracksegment:references

Note: I broke the lines for better readabillity. Script/generate commands have to be written in single line.

After the command

rake db:migrate

we can write the associations into our models.

1
2
3
4

class Track < ActiveRecord::Base

  has_many :tracksegments, :dependent => :destroy

  has_attached_file :gpx

end

1
2
3
4

class Tracksegment < ActiveRecord::Base

  belongs_to :track

  has_many :points, :dependent => :destroy

end

1
2
3

class Point < ActiveRecord::Base

  belongs_to :tracksegment

end

Upload a GPX file

For uploading a GPX file we modify our view/tracks/new.html.erb following way:

1
2
3
4
5
6
7
8
9
10
11

<%form_for(@track, :html=>{:multipart=>true})do|f|%>
<%= f.error_messages%>

        <%= f.file_field :gpx %>

    <%= f.submit 'Upload GPX' %>

<%end%>

<%= link_to'Back', tracks_path %>

Upload a GPX file for testing before we start with with next section.

Parsing the GPX file

Let’s start with parsing.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Track < ActiveRecord::Base

  has_many :tracksegments

  has_attached_file :gpx

  def save_attached_files_with_parse_file 

    save_attached_files_without_parse_file

    parse_file

  end

  alias_method_chain :save_attached_files, :parse_file 

  def parse_file

    ...

  end

end

We like to parse the uploaded GPX file directly after upload. That tricky because the paperclip pluging uses the after_create callback. If we use after_create it will be executed before paperclip plugin upload. It will cause an error “File not found”. We workaround with alias chain method.

We need following steps to parse an xml file:

Open the uploaded GPX file
Parse the GPX file
Close GPX file

Open GPX file and prepare for parsing

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Track < ActiveRecord::Base

  has_many :tracksegments

  has_attached_file :gpx

  attr_accessor :file_handler, :gpx_document

  def save_attached_files_with_parse_file 

    save_attached_files_without_parse_file

    parse_file

  end

  alias_method_chain :save_attached_files, :parse_file

  def parse_file

    prepare_gpx_file

    parse_xml

    cleanup_gpx_file

  end

  ...

end

In the first step we prepare the file for parsing. We need a file handler to open the gpx xml file with REXML. For this reason i added two attributes to the model in line 5.

1
2
3

def parse_xml

    ...

end

Parse_xml executes the parsing. I will explain it later.

1
2
3
4
5

def prepare_gpx_file

  logger.info "Prepare GPX file ..."

  make_file_handler

  open_gpx_xml

end

Prepare_gpx_file calls functions to make a file_handler and
and gpx_xml handler.

1
2
3
4
5

def make_file_handler

  logger.info "Make file handler ..."

  file_handler = File.new(File.join(RAILS_ROOT,'public',

  gpx.url.split("?")[0]),"r")

end

make_file_handler assigns the file_handler. The file open is a little bit tricky. We have to remove the parameters after ? from gpx.url. So we use a simple “split” and take the first array element from it.

1
2
3
4

def open_gpx_xml

  logger.info "Open GPX XML file ..."

  gpx_document = REXML::Document.new file_handler

end

open_gpx_xml assigns the xml handler. We use REXML to parse the file.

1
2
3

def cleanup_gpx_file

  file_handler.close

end

cleanup_gpx_file closes the file afterwards.

Parse the GPX file

1	attr_accessor ..., :tmp_segment, :tmp_point

We need two more attributes: tmp_segment and tmp_point. This attributes contain the temporary data while parsing.

1
2
3
4
5

def parse_xml

  self.gpx_document.root.each_element do |node|

    parse_tracks(node)

  end

end

parse_xml loops the root level for each node it can find.
For each node we start the function parse_tracks with the current node as parameter.

1
2
3
4
5
6
7

def parse_tracks(node)

  if node.name.eql? "trk"

    node.each_element do |node|

      parse_track_segments(node)

    end  

  end    

end

parse_tracks function checks the node name. If the name is “trk” then we go a level deeper and loop all nodes from the current “trk” node. For each node we call
parse_track_segments(node).

1
2
3
4
5
6
7
8
9

def parse_track_segments(node)

  if node.name.eql? "trkseg"

    tmp_segment = Tracksegment.new

    self.tracksegments << tmp_segment

    node.each_element do |node|

      parse_points(node,tmp_segment)

    end

  end

end

In parse_track_segments we check for the name “trkseg”. If so then create a new segment. We go a level deeper now and loop all nodes of “trkseg” node. For each of this node we start parse_points.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

def parse_points(node,tmp_segment)

    if node.name.eql? "trkpt"

      tmp_point = Point.new

      node.attributes.each do |key,value|

        tmp_point.latitude = value if key.eql? 'lat'

        tmp_point.longitude = value if key.eql? 'lon'

      end

      node.each_element do |node|

        tmp_point.name = node.text.to_s if node.name.eql? 'name'

        tmp_point.elevation = node.text.to_s if node.name.eql? 'ele'

        tmp_point.description = node.text.to_s if node.name.eql? 'desc'

        tmp_point.point_created_at = node.text.to_s if node.name.eql? 'time'

      end

      tmp_segment.points << tmp_point

    end

  end

  ...

In parse_points the real action is starting. We check for node name “trkpt”. If so we create a new point object and read this node attributes lat and lon. We save it in the point object attributes latitude and longitude.

Next we start with looping all elements of current node “trkpt”. Inside loop we check for name, ele, desc and time. If one of this node names match we assign it to the corresponding attribute of point. At last we add the temporary point to the tmp_segment.

Comming next

In next tutorial we are going to care about display the route in google maps with Ruby on Rails.

Create Your Own Geodatabase using Ruby on Rails and Google Maps

Lars — Mon, 04 May 2009 07:26:39 +0000

Geocoding with Ruby on Rails isn’t a big deal. But sometimes you have do more than simple geocoding. For real estate webpages you need information about state, county or suburb for a given address.

This tutorial will show you how to build your own geodatabase without overusing google maps requests(limited on 15000 Requests per Ip/month).

Before you can start you must have a fresh rails application and a google maps api key. You can signup for one here: http://code.google.com/apis/maps/

This tutorial has following parts:

Geocode an address
Get extented information to this address
An Pratical example

We touch only the model layer(thin controllers fat models). I will use an address ressource like follows:

script/generate scaffold Address country:string state:string 

county:string city:string suburb:string zipcode:string street:string 

streetno:string longitude:float latitude:float error_code:string

and

rake db:migrate

You can use this address ressources for many purposes. But more on this later. You need some ruby-gems too.

1
2
3
4
5
6
7

class Address < ActiveRecord::Base

  require 'open-uri'

  require 'cgi'

  require 'hpricot'

  require 'iconv'

  ...

end

Geocode an address

For geocoding an address you can use a simple callback function.

1
2
3

def before_create

  geocode

end

And the gecode function itself:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def geocode

  url = ["http://maps.google.com/maps/geo?q="]

  url << address_for_geocoding

  url << "&output=xml&key="

  url << "your_google_maps_api_key"

    open(url.to_s) do |file|

      @body = file.read

      doc = Hpricot(@body)

      (doc/:status/:code).each do |code|

        self.error_code = code.inner_html

      end

      (doc/:point/:coordinates).each do |link|

        self.longitude, self.latitude = link.inner_html.split(',')

      end    

    end  

end

On line 3 i need an encoded address for proper geocoding. This function catches incomplete address information too.

1
2
3
4
5
6
7
8

def address_for_geocoding

  addressline = []      

  addressline << streetno.to_i unless (streetno || "").blank?

  addressline << street unless (street || "").blank?

  addressline << zipcode unless (zipcode || "").blank?

  addressline << city unless (city || "").blank?        

  CGI::escape(addressline.join(' '))

end

On line 8 we start the parsing of the returned xml-data from google maps. For more information about the xml structure you can read: Google Maps XML Structure

On line 15 we assign the longitude and latitude to our address attributes. So you get the coordinates into address model before rails creates it.

Get extented information

You can read at Google Maps XML Structure that far more information can delivered from google maps. So we update our geocode function:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

def geocode

  url = ["http://maps.google.com/maps/geo?q="]

  url << address_for_geocoding

  url << "&output=xml&key="

  url << "your_google_maps_api_key"

    open(url.to_s) do |file|

      @body = file.read

      doc = Hpricot(@body)

      (doc/:status/:code).each do |code|

        self.error_code = code.inner_html

      end

      (doc/:country/:countrynamecode).each do |country_code|

        self.country = country_code.inner_html

      end

      (doc/:country/:administrativearea/:administrativeareaname).each do |area|

        self.state = Iconv.conv('utf-8', 'ISO-8859-1', area.inner_html)

      end

      (doc/:country/:administrativearea/:subadministrativearea/:subadministrativeareaname).each do |sub_area|

        self.county = Iconv.conv('utf-8', 'ISO-8859-1', sub_area.inner_html)

      end

      (doc/:country/:administrativearea/:subadministrativearea/:locality/:dependentlocality/:dependentlocalityname).each do |t_area|

        self.suburb = Iconv.conv('utf-8', 'ISO-8859-1', t_area.inner_html)

      end 

      (doc/:point/:coordinates).each do |link|

        self.longitude, self.latitude = link.inner_html.split(',')

      end    

    end  

end

So we get extented information about country, state, county and suburb related to the address information you entered. You have now the complete set of address, administrative-level information and geo coordinates.

A practical example

It’s time for some practical stuff. I will use real estate example. In this example i will geocode a house location and add administrative information to it.

So let’s start with a property ressource scaffold:

script/generate scaffold Property title:string description:text 

street:string streetno:string zip:string city:string address_id:integer

and

rake db:migrate

I know there are some redundant address information, but it’s necessary to trace typing errors from users.

Lets go to the model layer an make some associations. One house can only have one address but one address can have many houses. So we write:

1
2
3
4

class Address < ActiveRecord::Base

  has_many :properties

  ...

end

and

1
2
3
4

class Property < ActiveRecord::Base

  belongs_to :address

  ...

end

Now lets start coding:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Property < ActiveRecord::Base

  belongs_to :address

  after_save :get_location

  protected  

  def get_location

    address = address_exist?

    address =Address.create(:streetno =>self.streetno, 

     :street => self.street,:zip => self.zip, 

     :city => self.city) unless address

    self.address = address

  end

  def address_exist?

    address = Address.find(:first,

    :conditions => "streetno = ? and street= ? 

    and zip = ? and city = ?",

    self.streetno,self.street,self.zip,self.city)

    address ? address : false

  end

end

Done. What happened? If you enter property data the property will saved. After save we call the get_location function to assign a address to our new property.

On line 7 we call the address_exist? function which try to find an address in our database. If this address doesn’t exist we create a new one on line 8.

Everytime a user adds unknown property your address database will grow. Once an address is saved it will resused every time a property with same address is entered.

Now you can get property listings like:

1
2
3
4
5
6
7
8
9
10

class Property < ActiveRecord::Base

  belongs_to :address

  ...

  def get_all_properties_with_same_streetname

    addresses = Address.find(:all,

    :conditions => ["street = ?",self.street])

    addresses.collect { |address| address.properties }

  end

  ...

end

I hope i could help you with this tutorial. Please write a comment if you have any questions or critics.

Extract zip files with Ruby on Rails

Lars — Mon, 13 Apr 2009 09:36:36 +0000

Some friends of mine found my first tutorial difficult to understand. So i’m going to start with smaller pieces of code and start with basic unzip functions in Ruby on Rails.

1
2
3
4
5
6
7
8
9

require 'fileutils'

require 'zip/zip'

require 'zip/zipfilesystem'

def unzip

  Zip::ZipFile.open("/path/to/file.zip").each do |single_file|

    single_file.extract(single_file.name)

  end

end

It extracts all files of file.zip into current folder. If you like to get some special file out of this zipfile you can use regular expressions to filter it out. The following example shows how to get
the xml file:

1
2
3
4
5

...

if single_file.name.downcase =~ /.xml/

  special_filename = single_file.name

end

...

How to process multiple zip-files with Ruby on Rails

Lars — Sun, 22 Mar 2009 16:52:31 +0000

Sometimes you have to integrate exported data from third party desktop software. One way to do is to pack all data into a zipped file and push it via FTP onto your server. This tutorial will explain how to process zip-files with your Ruby on Rails™ application.

I will take an example from a real estate managing software. It’s a common way for this kind of software to pack and push their data to online real estate listing services.

The zip-file contains:

A xml file with property data
Some picture files

The zip files are transfered by real estate managing software into a specific folder. There can be multiple zip files whose have to processed in correct time order.

The tutorial will cover following points:

Processing multiple zip-files
Parsing the included XML File to get the data
Processing binary data like pictures or documents
Error handling an cleaning up

Alright people, let’s start.

Processing multiple zip-files

All zip files will be uploaded into following directory. You have to create this directory with read/write access for your rails application. Furthermore you have to configure a FTP-User with write only access (”Postbox”-Setup). So you can use this ftp access for different clients.

1	RAILS_ROOT/external_uploads

The file

1	RAILS_ROOT/external_uploads/zipdata.zip

has following content:

1
2
3
4
5
6

data.xml

picture1.jpg

picture2.jpg

picture3.jpg

picture4.jpg

picture5.jpg

The complete import will be executed in model layer. So we need an Import class. Some ruby packages are required, too.

1
2
3
4
5
6
7
8
9
10
11

class Import < ActiveRecord::Base

require 'fileutils'

require 'zip/zip'

require 'zip/zipfilesystem'

require 'RMagick'

require 'find'

attr_accessor :current_source_file, :current_hash, :current_xml_file, :file_handler, :xml_document, :tmp_property, :expose, :tmp_attachment, :company, :current_is_topobjekt

....

end

Before we start we need some supporting class functions. This function returns a random string. We need it to create a temporary directory to extract the zip file:

1
2
3
4
5
6
7

# returns a random string

def self.make_random_string(len=10)

chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a

random_string = ""

1.upto(len) { |i| random_string << chars[rand(chars.size-1)] }

return random_string

end

The next function returns a list of all zipfiles of your directory sortet by date. It’s important because the zip files depent from each other.

1
2
3
4
5

# returns the sorted file list from oldest to latest timestamp

def self.sorted_filelist

unsortet_files = Dir.glob(RAILS_ROOT+'/external_uploads/*.zip')

unsortet_files.sort{|a,b| File.mtime(a) <=> File.mtime(b)}

end

This code loops throught our external_uploads directory and starts the process for each zipfile:

1
2
3
4
5
6
7
8

def self.go

self.sorted_filelist.each do |single_zip_file|

current_import = Import.new(

:current_source_file => single_zip_file,

:current_hash => make_random_string)

current_import.start

end

end

The object function start calls all sub processes once for each zipfile.

1
2
3
4
5
6
7
8
9

# processing the zipfile

def start

make_tmp_path

unzip

open_xml_file

parse_xml_file

close_xml_file

clean_up

end

The function make_tmp_path creates a temporary directory. Each zipfile must have an own temporary directory. With current_hash we can guarantee it.

1
2
3
4
5
6
7

def tmp_path

File.join('external_uploads','tmp',current_hash)

end

def make_tmp_path

FileUtils.mkdir_p tmp_path

end

The unzip function extracts the currently selected zip-file into temporary directory. The rescue block catches errors.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def add_path(filename)

File.join(tmp_path,filename)

end

def unzip

begin

Zip::ZipFile.open(current_source_file).each do |single_file|

if single_file.name.downcase =~ /.xml/

self.current_xml_file = add_path(single_file.name)

end

single_file.extract(add_path(single_file.name))

end

rescue

remove_tmp_path

end

end

I use a regular expression to get the included XML-File. The file and the corresponding path will saved into current_xml_file attribute.

Now we have the files

1
2
3
4
5
6

data.xml

picture1.jpg

picture2.jpg

picture3.jpg

picture4.jpg

picture5.jpg

unzipped into directory

1	RAILS_ROOT/external_uploads/tmp/adFvdSDed/

The current_xml_file attribute contains

1	RAILS_ROOT/external_uploads/tmp/adFvdSDed/data.xml

In the next part of this tutorial we will process the xml-file with REXML. We will do some image processing on the picture files with RMagick.

UPDATE: I canceled the second part of this tutorial because my latest tutorial will cover the XML parsing theme.