http://example.com/resource?param1=1&param2=2&offset=3

If one wants to remove the “offset” parameter, the following may help.

Having:
query = “param1=1&param2=2&offset=3″


unless query.empty?
  # build an Hash based on the query string
  # we want to build {"param1"=>"1", "param2"=>"2", "offset"=>"3"}
  temp_params = {}
  query.split(”&”).each {|v| temp_params.merge!(Hash[*v.split(”=”)]) unless (v.split(”=”).count < 2)}
  # remove the offset parameter
  temp_params.delete(”offset”)
  # convert the Hash back to a String
  new_query = temp_params.map{|k,v| “#{k}=#{v}”}.join(”&”)
end


EDIT: if a left side only param exists, it will be removed. Something like param2 in:
http://example.com/resource?param1=1&param2=&offset=3

As a Gist:

pg_dump

$ pg_dump -Fc -U username database_name > db_dump

Now, we have a “restore customizable” compressed dump of the database.
From the postgres documentation:

  -F format
  –format=format
    Selects the format of the output. format can be one of the following:

    c
    custom
      Output a custom-format archive suitable for input into pg_restore.
      Together with the directory output format, this is the most flexible
      output format in that it allows manual selection and reordering of
      archived items during restore. This format is also compressed by default.

pg_restore

To reorder database items, it is first necessary to dump the table of contents of the archive into a detailed file. This file will allow us to make a custom restore of the items (tables, etc) that we need.

$ pg_restore -l db_dump > db.list

Open the db.list file in your favorite editor (Vim) and proceed to comment or delete the lines of the item that you do not want to be restored.
From the postgres documentation there is a good example I changed here to comply with the previous dump:

;
; Archive created at Wed Dec 7 15:26:56 2011
; dbname: database_name
; TOC Entries: 306
; Compression: -1
; Dump Version: 1.12-0
; Format: CUSTOM
; Integer: 4 bytes
; Offset: 8 bytes
; Dumped from database version: 9.1.1
; Dumped by pg_dump version: 9.1.1
;
;
; Selected TOC Entries:
;
3; 2615 2200 SCHEMA - public pasha
1861; 0 0 COMMENT - SCHEMA public pasha
1862; 0 0 ACL - public pasha
317; 1247 17715 TYPE public composite pasha
319; 1247 25899 DOMAIN public domain0 pasha
…

One can carefully edit the file. Semicolons start a comment, and the numbers at the start of lines refer to the internal archive ID assigned to each item. Lines in the file can be commented out, deleted, and reordered. According to the example, one could edit this section of the file:

10; 145433 TABLE map_resolutions postgres
;2; 145344 TABLE species postgres
;4; 145359 TABLE nt_header postgres
6; 145402 TABLE species_records postgres
;8; 145416 TABLE ss_old postgres

This way, table species will no be restored, neither nt_header and ss_old.
If one try this, will see all the items like index information, relations, keys, etc.

After all set, one can restore the selected items from the dumped database:

$ pg_restore -L db.list db_dump

In Windows:

• open the SQL Server administration console for the databae and do a DIR > tables.txt to get a file with all the table names;
• remove all the tables you will not be needing from the file;
• now to export all the tables data to their files with a one-liner:

  FOR /F %A IN ('type tables.txt') DO bcp "dbo.%A" out "d:\export\path\%A.csv" -S SERVERNAME\SQLSERVEREXPRESS -d "databasename" -U SERVERNAME\username -C RAW -T -c -t "\t" -r "\n"

• Notice the column separator set to TAB \t, and row separator to newline \n;
• Codepage set to RAW (this is an ISO8859-1);
• This is done on a local machine so using a trusted connection;
• This line is executed in the Windows console (terminal);
• Mind that the tables.txt needs to have only the table names per line. I removed the “dbo.” prefix in the file, so had to include it in the parameter in “dbo.%A” parameter, because I want the CSV files not to have the dbo. prefix;
• So in short, the tables.txt file is iterated, each line containing a table name being passed in the %A variables, so that bcp command creates the CSV file.

In Linux:

• copy the previously exported data files folder to the linux machine;
• verify the file encoding $ file -bi filename.csv
• convert all the folder CSV files from ISO8859-1 charset to UTF-8 if needed: $ recode ISO8859-1..UTF-8 *.csv
• now because I need to have the data validated and reassociated, I have Ruby scripts to perform the import, using Datamapper ORM. One can use the CSV class to proceed and then do whatever needs with the data. In this example I get the data into an Hash:

fx_tip = "./../exported_data/some_table.csv"
h_tip = Hash.new
CSV.foreach(fx_tip, {:col_sep => "\t", :headers => false}) do |f|
  h_tip.merge!(f[0] => f[1])
end
puts h_tip.to_yaml


You can even specify a manual Query to export the SQL Server data, using:
FOR /F %A IN ('type tables.txt') DO sqlcmd -E -S SERVERNAME\SQLSERVEREXPRESS -d database -o %A -s ";" -W -Q "SELECT TOP 100 * FROM dbo.%A WHERE someting"

If your case is simpler and you need to make a straight port, you can export the SQL statements from SQL Server and then on Postgres something like:
COPY tablename FROM '/tmp/table.data' WITH DELIMITER ',';

Used Tools:
Microsoft SQL SERVER
Microsoft Windows 7
PostgreSQL
Ubuntu Linux
Ruby Language

Farewell Dennis Ritchie, your work changed my life.

C | Unix

.data( key,value )
“Store arbitrary data associated with the matched elements.”

Performance difference: on this jsPerf test the last is about 84% slower.

So instead of:
$('#element').data('type', 'critical')
prefer:
jQuery.data('#element', 'type', 'critical')

(tested on Google Chrome 12.0.742 browser)

def last_modified(time)
  return unless time
  time = time_for time
  response[’Last-Modified’] = time.httpdate
  # compare based on seconds since epoch
  halt 304 if Time.httpdate(env[’HTTP_IF_MODIFIED_SINCE’]).to_i >= time.to_i
rescue ArgumentError
end


Commited the code with a farewell git commit -am “Awesome handmade conditional GET to leverage client caching”, pushed it and refactored it to use the instance method last_modified(timestamp), just to commit it again.

Combine this with a before filter, like:

before do
  # set to rfc maximum because db_version will handle expiry date
  cache_control :public, :max_age => 31536000
  # get the database version time stamp
  db_version = Admin.first.created_at
  # now if db_version is more recent then last_modified will send a :halt 304 Not Modified as response.
  last_modified db_version
  # ... and if not, proceed here to the request route...
end


In short, the client (browser) issues a request for some content via a URI to the server. The server receives the request and checks the Request Headers to see if a If-Modified-Since directive is defined. If not, a response['Last-Modified'] header is set to the current time and the execution flow will proceed to the Sinatra app request route to deliver a response [no client local caching scenario]. Yet, this timestamp will be used by the client (browser) cache manager to store it locally, together with the response payload, building a client-side local cache for this resource. Now, if there is another client request, to the same URI, this time a If-Modified-Since Request Header will be sent along the request. The server will catch it and compare to an expiry date, in this case, the db_version. Since it is lower than, the server will stop the execution flow and send a 304 Not Modified status response. The “Conditional GET” technique name is because the GET request had an “interruption” based on conditions defined by HTTP Headers. Now, the client receiving this response will get the local storage cached content and deliver it as response. For the Sinatra app, the router was not even touched.

Acording to Google, using both Cache-Control: max-age and Last-Modified headers, or even Etag if necessary, instructs the browser to load previously downloaded resources from local disk rather than over the network. This is client (browser) caching.

Based on the documentation it is redundant to specify both Expires and Cache-Control: max-age, or to specify both Last-Modified and ETag. It makes note to use the Cache control: public directive to enable HTTPS caching for Firefox.

This allows the browser to efficiently update its cached resources by issuing conditional GET requests when the user explicitly reloads the page. Conditional GETs don’t return the full response unless the resource has changed at the server, and thus have lower latency than full GETs.

For this, I set the server to dispatch a 304 Not Modified response to the browser so that is gets the local cached content and presents it as the result of the request, with a:

Request Method: GET
Status Code: 304 Not Modified


This is quite important since I’m requesting readonly JSON content that takes about 3 seconds
to be fetched, and the result of this is 13 miliseconds response time. Local content. The payload is considerable, about 136KB of JSON response for one of the areas. Adding up that for one of the pages I’m loading 3 payloads of these via jQuery, the main server Merb app is now feeling quite lighter due to this recent decoupling. This means lower CPU utilization, database access, bandwith and time to respond.

Combining this with application server caching, response times get quite improved.

Before client (browser) local caching:

After client (browser) local caching:

Final Notes:
- Github SinatraRb documentation for (Object) last_modified(time);
- Google Code Optimize Caching page;
- HTTP Headers on Wikipedia;
- Google Chrome is an amazing browser to develop on, using the Developer Tools;
- still got to detect a “typo” on Google Code documentation.

So a Sinatra web app was built on another server/port, with a simple yet effective control panel for internal management and an API to generate JSON responses.

Some requests to that Sinatra app API are being made via jQuery originating on the Merb application. This represents a problem. Even if in the same server, but with a different port. The browser security model tells us that XMLHttpRequest, frames, etc. must have the same domain in order to communicate. Makes sense for security reasons, but at the same time distributed services feel the pain.

For production we use a server side proxy so that the request comes from the client to our (origin) domain and is dispatched to the Sinatra app on a port or server/port combination. But in development we use another technique to get around the same origin browser policy.

That’s where JSONP (JSON with Padding) makes its debut. jQuery > 1.5 brought some new features like the ability to control the callback configuration. If we specify an ajax call/request with dataType: "jsonp", jQuery adds a parameter to our request, with the standard name “callback”. That parameter name will be used as a function name to process data.

Callback function name can be overridden using the jsonp parameter, something like jsonp: 'onJSONLoad'. That will result in the callback parameter name change. So, we’d get http://new.server:port/service/parameter?onJSONLoad= followed by an unique stamp that jQuery creates for the request.

One of the advantages of controlling the callback parameter is related to better browser caching of GET requests, since it is set to false as default for ‘jsonp’ dataType ajax requests.

All the above in the client. What about the server ? Mind that the request is getting a new parameter. For the Sinatra app, we had to change the final response. So, based on the fact of the appearance of a callback parameter:

callback = params.delete('callback')
and in the end of the action:
final_response(callback, response)
with response being a well formed JSON object.

For the final_response method, we have:

def final_response( callback, res)
  if callback
    content_type :js
    response = "#{callback}(#{res})"
  else
    content_type :json
    response = res
  end
  response
end

This will make the necessary adjustment to the response for the case of cross domain requests or same (origin) domain requests.

So a simple jQuery function would be like:


$("#ep_search_medics").click(function() {
  $.ajax({
    type: 'get',
    dataType: 'jsonp',
    url: 'http://localhost:4567/dcipt/rosuvast',
    success: function(data) { $("#ep_search_results_nr").html(data.count); },
    error: function() { console.log("Error"); }
  });
  return false;
});


Final Notes:
- one can read more at the excellent jQuery page for ajax requests;
- be very confident on your JSON response. One can test for JSON validation in JSONLint;
- Google Chrome is an amazing browser to develop on, using the Developer Tools.

DataMapper has a defined method named first_or_create, very explicit name, that takes a condition and attributes as params. Its source code defined in dm-core-1.0.2/lib/dm-core/model.rb is:

def first_or_create(conditions = {}, attributes = {})
  first(conditions) || create(conditions.merge(attributes))
end

What is does is simply find the first resource by conditions, or create a new resource with the attributes if none found. This always returns an instance of the resource found or created.

It became handy to create an update_or_create method, so I created:
module DataMapper
  module Model
    def update_or_create(conditions = {}, attributes = {}, merger = true)
      (first(conditions) && first(conditions).update(attributes)) || create(merger ? (conditions.merge(attributes)) : attributes )
    end
  end # Module Model
end # Module DataMapper

There are differences to consider, like the merger param and the returned TrueClass bool upon update (and not an instance of the resource).

I found a merger param necessary because of the Serial type of properties. In the implementation of first_or_create method if we specify a Serial property as a search condition and the search has no success, then the conditions will be merged with the attributes and the Serial +1 will not be taken in account. Thus, in this implementation setting merger to false, search conditions will not be merged. Some examples:

Article.update_or_create({:id => 10}, {:name => "Spirou meet Franquin"})
If Article with ‘id’ 10 exists then it will receive a new name
=> true
If Article with ‘id’ 10 doesn’t exist, it will be created with {:id => 10, :name => “Spirou meet Franquin”}
=> #[Article @id=10 @name="Spirou meet Franquin" @date=#[Date: 4910965/2,0,2299161] @updated_on=#[Date: 4910965/2,0,2299161]]

Article.update_or_create({:id => 123}, {:name => "Fantasio meet Franquin}, false)
If Article with ‘id’ 123 doesn’t exist, it will be created with {:name => “Fantasio meet Franquin”} and a self sequential id:
=> #[Article @id=240 @name="Fantasio meet Franquin" @date=#[Date: 4910965/2,0,2299161] @updated_on=#[Date: 4910965/2,0,2299161]]

EDIT: new implementation to always get a DataMapper Object:

Apple OSX Snow Leopard
System Version: Mac OS X 10.6.2
Kernel Version: Darwin 10.2.0
(No Macports; No Homebrew)

PosgreSQL 8.4

I wanted to have PosgreSQL server working on the mac so that development is easier.
There is a .dmg package from the guys at EnterpriseDB that is a single click install. Check it at their downloads page. Get it. Install it. Everything goes into:

/Library/PostgreSQL/8.4

Now to install the do_postgres gem, I had to set the $PATH to:

$ export PATH=$PATH:/Library/PostgreSQL/8.4/bin

Now, installing the gem from rubygems.org should work:

$ gem install do_postgres
or
sudo env ARCHFLAGS='-arch i386' gem install do_postgres

Remember in OSX where your gems are installed, with or without root access using:

$ gem environment

Debian 5.0 Lenny

I have PosgreSQL 8.3 on my Debian servers, from the repositories. To install the do_postgres gem, you must get the header files for libpq5 (PostgreSQL library):

$ sudo apt-get install libpq_dev
$ sudo gem install do_postgres

Ubuntu 9.10 Karmic Koala

I have PosgreSQL 8.4 on my Ubuntu servers, from the repositories. To install the do_postgres gem, you must get the header files for libpq5 (PostgreSQL library):

$ sudo apt-get install libpq_dev
$ sudo gem install do_postgres

Hello -

You’re receiving this email because you’re a RubyForge project admin and a recent change robably affects you.
A few days ago we repointed gems.rubyforge.org to the gemcutter.org box. This means that Nick Quaranto’s excellent gemcutter app is now indexing and serving all the gems - so rather than having two gem indexes, we now have one. As a consequence of this, when you release files to RubyForge you will probably also want to do a “gem push” to get them onto gemcutter and into the main gem index.

Note that you can continue to release gems (and other files) at RubyForge; it’s just that gems won’t utomatically make it into the main gem index.

Yours,

The RubyForge support team
http://rubyforge.org/projects/support/

Just like last year a lot of hacks and experiments are expected.

Kudos to the SAPO team, the organisers, to build up such an impressive event.

Main systems covered, centralized vs distributed:
- Subversion
- Git

It was a good tech event, spent a good time there.
Some photos here.

BTW, the project site of Tokyo products have been moved onto my own server.
http://1978th.net/
Though it has not been completed yet, I’ll write more English information about Tokyo products.”

So, to get the latest, head there.

man sdef

From the site:

• graph-oriented model for flexible data representation;
• graph network consisting of nodes, relationships and properties;
• highly scalable to bilions of nodes/rels/props;
• can be sharded to scale out across multiple machines;
• hi-speed traversals in the node space;
• small footprint (500k jar)
• ACID transactions;
• robust persistence;
• concurrency control;
• API;
• Neo4j.rb, JRuby API;
• Lucene for quering and indexing.

Neo4j is released under a GNU Affero General Public License, so read carefully. There’s a price table for commercial products that includes severall support levels.

Not to miss this article too: Tokyo Cabinet: Beyond Key-Value Store

Tokyo Cabinet starts here with a nice presentation from its creator, another Japanese developer Mikio Hirabayashi.

Ruby, Perl, Python et_al bindings available.

I tell you, “it’s Big in Japan”

# select a folder where to build the aplication on your area:
cd to_your_workingspace_apps_folder
# get (clone) MacVim from its MacVim.git repository:
$ git clone git://repo.or.cz/MacVim.git
$ cd MacVim
$ cd src
# now let us configure it for macvim gui and for +Ruby (I’ll add +Python and +Perl) support:
$./configure --enable-gui=macvim --enable-rubyinterp --enable-perlinterp --enable-pythoninterp
$ make
# Success ? Let’s build the MacVim.app
$ cd MacVim
$ xcodebuild
# Sucess ? Let’s try it…
$ open build/Release/MacVim.app
# now lets copy vimblog to $HOME
$ cp $HOME/Downloads/vimblog.vim $HOME/.vim/plugin
# insert your credentials
# now test the existence of the script. Run MacVim and execute
:B + TAB
# you shoud get code completion for the Blog command.
# get the 10 most recent articles
:Blog rp

if you get problems, before another build, do a:
$ make distclean

Screenshots: macvim window building space

“Dear Sun Community Member,

Thank you for subscribing to the following Sun Microsystems eNewsletter(s)/notifications:
[…]
Sun respects your email privacy and security. In order to start receiving these publications, you must first confirm your subscriptions. Please click on the url below to activate your subscription(s): https://subscriptions.sun.com/sunmailapi/Optin?id=999999999
Thank you for subscribing. We hope you find the information to be valuable.”

The problem here is that the confirmation URL query is nothing but a (*not* garbled) sequential ID. Altering the ID from the link, all the other subscrivers e-mail starts poping-up, and more, they get activated if not done yet.
So, the above “Sun respects your email privacy and security” isn’t quite as should be.

With a simple script, one can get all the Sun.com subscrivers. I can see a spammer doing a:
“Dear Sun.com subscriver, we are partnering with Sun.com to sell you this lovely vacuum cleaner.”

Dear Sun, prevent us from buying lovely vacuum cleaners, fixing these vulnerabilities.
TY.

Update: Less than 24h later, Sun contacted me and fixed (the e-mail adress obfuscation, yet one can still approve other confirmations randomly) it. Well done.

one can read this here.
Bespin’s initial prototype includes support for very basic features, but one can easily notice its power. Its all drawn in the canvas, every character, cursor blinks, scroll bars, text selection, etc. As a Vim user, I immediatly thought of Vim commands/keybindings in Bespin. Even the simpler and most generally used ones. Not even asking for .vim power scripting ability. And that is a feature any one of us* can write as soon as Bespin coders release a good API. And it is already in the air. Neat.

By the way, look.at.this.mockup.…

The collaborative coding feature isn’t active yet, but if one can give instant editing access to a file for a “check this class”, that’s going to probably replace lots of gists, pasties, etc, on a coder2coder basis.
Code repository access via Dashboard ? Yes please.

I have no doubts, this is going to be a very usable product, for this little I’ve seen. The look’n'feel seems great (even if I had no repeat-key )

* floss

One of them will be  CouchDB and Merb (no DataMapper, no ActiveRecord). The db schema is modeled by each user and upon criteria decisions.
All of them Git managed, as been doing for the last year.
Served by a Debian based Linux distro, coded under Debian, UNR (my lovely little netbook), and OSX,  mainly in Ruby 1.8.7. Production server structure not defined yet but development phase will be Mongrel. May implement a very simple queuing system for a specific need.
Very likely use of AWS (not SimpleDB) for the sake of _simplicity_ .
Editor ? Vim.

None of this is of great interest for the project itself of course. I’ll be queuing 2 or 3 of them, in paralel with the main one. As in everything, time management is almost everything to GTD. Must. repeat. this. always.

For reference:
:[from],[to] Gist -p # post lines (from, to) to gist privatelly
:[from],[to] Gist # post lines (from, to) to public gist
:Gist [xxxxx] # edit gist xxxxx
:Gist -l # lists my gists
:Gist -k # lits gists from all

I used Paul Dixon’s Paste bin when needed, specially by its simple interface and good highlighting features. Very good. But Gist makes me able to store my gists on my own account. Quite nice.

:note for non-programmers: ‘!’ as an alias for ‘not’

[update]
This slideshare leaked from, as stated, a Sequoia Capital presentation is worth to look at.

“He was part of the generation of developers who switched from Perl to Ruby in the 90s. While his mastering of Perl was already great, his knowledge about Ruby was so deep and impressive that a lot of Rubyists would have been very happy to have the same one.”

Announcement at ruby-talk where we can see lots of appreciation and recognition for Guy’s work.

_why has a wonderfull post and drawing at Hackety.org.
The following paragraph from _why’s post:
“You’ll hear a lot of people say that we didn’t know who he was. That no one met him. But we all read alot of his code. And clearly that was how he wanted us to know him. Think of how that stands in such sharp contrast to the self-advertisement and vanity journalism of the Web today. We knew him, just not in the way we’re used to.”

Guy’s work in ruby-core libs lives inside the machines we daily operate.
Goodbye Guy Decoux.

riverside=# select * from foobar_schema_infos;
id | version
—+———
1 | 1.4
(1 row)

In a self note, forget not to set option :id => false on join tables for has_and_belongs_to_many relations.

The starting group talks Python (Nuno), Ruby (me and Mario), media and communication (Carlos), Php (and domain registering savoir-faire Karlus), and guess what: we’re all on Twitter, like godevel is.

The developers part of GOD isn’t restricted to code_monkeys. We speak business, startup’ing, venture capital, economy, talks (long or lightning), beer, unix, languages, hw, sw, media, web, web, web, servers, life, laptops, frameworks, gossip, gadgets, working environments, projects, code, code, scripts, threads, scaling, architectures. We’ll be focusing less on ideas, more on work. Implementations. On doing it.

I look forward a code_day in wich we’ll be coding for ourselves/others under a strong networking environment, during wich lightning-talks will hopefully rise.

More to come soon…
As for now, I’m fighting threads and forks in Ruby…

Now, under development, Mongrel(s), behind the same Lighttpd frontend, need to be restarted upon source code changes in the models, views, controllers or helpers (yet not CSS files, since they are taken care by lighty). Instead of moving to the xterm, kill the process and restart it i decided to automate it.
Since i was disconnected from the webz, I’ve done this script to detect file changes from a pre-specified array of files, monitored under a certain interval in seconds, with an action to start, kill, and restart an app (in my case, a Mongreled Camping web app).

Problem: Threads
Solution: Process::fork

The app load (in this case I load/execute ruby scripts) is done via Process::fork. A new process starts up each time this method is fired up upon a File.open(f, 'r').ctime change:

def load_app
  @pid = Process.fork { load(@app) }
end

Before loading up a new updated instance of the app, the previous one must be terminated. Threads behaviour was problematic because of the thread tree termination in time. This is well done, in a safe mode, with Process::kill(signal, pid) and Process::wait(pid) that waits the pid process termination, essential in the case of Mongrel server.

def kill_app
  Process.kill("KILL", @pid)
  Process.wait(@pid)
end

As one can see in this screenshot the main app process holds on while the child, in this case our Mongrel’ed Camping web app, is terminated and created a new one. Verbose mode to assert its behaviour. Suits this specific need.

This is very usefull to make tests (Test::Unit:TestCase) run automatically upon source changes (will get to an Autotest clone).

Changing from load(@app) to system(@app), one can get any command be executed. ftp, cp, etc…

The script is here do download under a Ruby License.

Usage: monstar [options]
-a, --app SCRIPT.RB,PARAMS,...
-i, --interval VAL
-f, --files FILE,FILE1,...
-h, --help

Look at the final results.
Now lets see 2007 standings.

Geo pattern ?

Andrei’s git (yep, they are git fans too, git rocks!) commit was calling another Vim from his machine. That was not a +ruby vim. So an error was fired upon git commits. Now we fixed it. This is now, vimblog 1.1. Thanks Andrei.

Open Source++

In short, Shoes.rb repository:
http://github.com/why/shoes
You can clone the repository with:
git clone git://github.com/why/shoes.git

Ditz, (“a simple, light-weight distributed issue tracker designed to work with distributed version control systems like darcs and git”) will be used as an issue tracker. The YAML database file is included in the commits, since it becomes a project source file. Its Ruby coded and produces quite nice HTML pages.

…nice move _why

“Structure and Interpretation of Computer Programs”

[update]: Twittershoes.rb is born: screenshot here

I’ll work there for this project.

Check ports:
$ sudo netstat -anput | grep postgres

Check wich configuration files and wich versions are running:
$ ps -Af | grep postgres

pg_upgradecluster when upgrading the existing PostgreSQL cluster, will check ports of the new and old version (check both 8.2 and /etc/postgresql/8.3/main$ grep 'port' postgresql.conf), and make the newer version use the older version’s port number. Then the older version will use an available port number. This keeps the original Port # in use.

Stop and drop the newly created 8.3 main cluster:
$ sudo pg_dropcluster --stop 8.3 main

Time to upgrade the 8.2 main cluster to 8.3
$ sudo pg_upgradecluster 8.2 main

After checking everything is ok we could remove the older cluster:
$ sudo pg_dropcluster --stop 8.2 main

and “apt-get remove” the 8.2 version.

docs:
$ man pg_dropcluster
$ man pg_upgradecluster

$ sudo gem install json_pure

Now, just need some attention on the use of the address / (slash) just after json and before the query, or you’ll get a HTTP 301 Status Code.
Code follows:

require 'rubygems'
require 'net/http'
require 'json/pure'

url = 'http://www.google.pt/search?q=json+ruby'
escaped_url = URI.escape(url, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
call = Net::HTTP.get_response(URI.parse("http://smallr.net/json/?url=#{escaped_url}"))
res = JSON.parse(call.body)

puts res['status'] # ok
puts res['url'] # http://smallr.net/925

(via snippets.dzone => Matt Zukowski)

“Bestselling author David Flanagan teams up with Ruby creator Yukihiro "Matz" Matsumoto and writer/cartoonist/programmer why the lucky stiff to bring you the authoritative guide to Ruby. Covering versions 1.9 and 1.8, this book helps you learn Ruby’s lexical structure, primary expressions, conditionals, syntax, classes, the data it manipulates, and more. For experienced programmers who want to look at this language in depth, this guide is invaluable.”

@state.error = ‘The unit is still operational, Dave. But it will fail within seventy-two hours’

The variable is cleared on the View layout method. Flash means just it. Show and clear. The layout code includes:

div(:class => 'error') { p @state.error.to_s; @state.error = ''; } unless @state.error.blank?

and the CSS .error class wraps the message inside a lightred box with a nice solid red border (say RoR?).

[#4] is the first row from postgres ‘beautifull’ database ‘blog_posts’ table. Fetched via ActiveRecord, via Blog::Models module, via Blog Camping app.

$ cat /var/lib/gems/1.8/gems/activerecord-1.15.3/lib/active_record.rb
[…]
unless defined?(RAILS_CONNECTION_ADAPTERS)
  RAILS_CONNECTION_ADAPTERS = %w( mysql postgresql sqlite firebird sqlserver db2 oracle sybase openbase frontbase )
end
[…]

Once you get used to git, you won’t be needing “anything else” to maintain your code. Git is gaining more and more traction, now that bigger (distributed) projects (or parts of them) are running away from other scm’s into this one (Gnome ?, Kde, …). CVS, SVN user base is still huge, though. From the questions at Google Tech Talks, seems that Google has a very centralized && protected development environment, wich is not that strange attending to their business core and innovative material under maintenance/production (they shut the camera/video down sometimes due to their non disclosure politics). That kind of environment, generally speaking, seems to fit for git usage, since it does ssh and its built-in cryptographic authentication of history ensures revisions purity.
He added a Randal Schwartz video also at Google, in addition to the Linus one i referred here a while ago (the last time i saw Randal, he was talking about the wonders of Smalltalk at #git in a very interesting debate)

[append]
pfig first-try screencast on git. well done.
[append]
to wrap up, this podcast, on Floss (not that) Weekly, a talk between the gitster (maintainer) Junio Hamano, Leo Laporte and Randal.

Solution: let’s code !! What response is the server sending… ?

Shugo Maeda’s Ruby net/imap.rb class (stdlib) is simple and trusty.
Not wasting lots of time in it, i made a new class with the following usage, to send specified mbox file mail messages to a gmail (google hosted) account:

$ ./2gmail.rb MBOXFILE GMAILFOLDER [STARTINGMESSAGE]

If GMAILFOLDER doesn’t exist, gets created (i prefered messages in temporary folders) upthere.
If it breaks, you can:

$ tail 2Gmail.log

to see the last message sent, and restart the process in that message. I could have threaded the whole thing, but this is done just once, so lets keep in focus…
Usual problems during the tests, msg headers/body separation, timestamps, etc…
Class Mail in mailread.rb does a great job creating an Hash for the Message Headers. Sweet…

Everything is logged, so that it’s easy to ‘grep’ for errors in the 2Gmail.log file.
I had one only problem on a message with a 25MB attachment (gmail didn’t accept it).
All the messages are now up there, nobody knows for certain where (EU ? US ? both ?…)

The code needs one or two more Exception Handling, but it works very well. I had 6 xterm’s uploading at the same time. And yes, I could have openned 6 tabs in Gnome Terminal since we have them for ages, Mr. Leopard ones! Hey, we can even detach Tabs to independent Terminal windows via drag-n-drop (like in Epiphany, way way long ago… way…)

There are some thousands more messages to be uploaded, from ancient backups… maybe next week.

Operation screenshot: at Flickr as usual
Wanna try ? Get it here (ready for Debian & Ubuntu. For other distros, check line 1 or just prepend ruby interpreter on call)

$ chmod u+x 2gmail.rb
$ ./2gmail.rb MBOXFILE GMAILFOLDER [STARTINGMESSAGE]

This is, RSpec is a state of mind in Ruby, represented in a DSL (Domain Specific Language for Behaviour Driven Development (BDD). It deals with expressing desired behaviours when building applications, creating the specifications and writing the code to match them.
Create examples for what the application should do, and build the code. Add another example, write more code, refactor it if necessary, and:

$/var/lib/gems/1.8/bin/spec app_spec.rb --format specdoc
RSpec rdoc
RSpec documentation

This is a work in progress but means a refactor on the way to think about developing…
Example: For us to be able to drive a car:
- it should have fuel;
- its battery should be charged;
- it should have at least 4 tyres (optimally a spare one), with the right pressure;
- …

require 'car'
describe Car do
   before(:each) do
     @car = Car.new
   end
 
   it "should not be out of fuel" do
     @car.should_not be_fuel(0)
   end
 
   it "should have a charged battery" do
     @car.batt(0.6).should be_close(1, 0.5)
   end
 
   it "should have at least 4 tyres" do
     @car.should have_at_least(4).tyres
   end
 
   after(:each) do
     @car = nil
   end
 
end


Now, in car.rb:

class Car
 
   def fuel?(qt)
     qt > 0
  end
 
   def batt(amp)
     @amp = amp
   end
 
   def tyres
     { 'fr' => 2.1, 'fl' => 2.1, 'rr' => 2.0, 'rl' => 2.0, 's' => 2.1 }
   end
 
end

Ok, running this small spec:

$ /var/lib/gems/1.8/bin/spec car_spec.rb --format specdoc
 
Car
- should not be out of fuel
- should have a charged battery
- should have at least 4 tyres
 
Finished in 0.014326 seconds
3 examples, 0 failures

Now, what about using BDD RSpec module with Camping… ?

I changed the DB connector, not to use the standard SQLite but PostgreSQL, done very rapidly in the dispatch.rb file:

Camping::Models::Base.establish_connection :adapter => 'postgresql', :host => 'localhost', :port => xxxx, :database => 'camping_db', :username => 'of_course', :password => 'you_wish'

Some more 100% free software, and open source, being used:

Gnu/Linux Debian server · Lighttpd web server · PostgreSQL database · ruby · rubygems · rubygorge · rubyforge’s Camping

Lib’s to pay closer attention:

lib/camping/fastcgi.rb · lib/camping/session.rb · ib/camping/db.rb

Classes:

Camping::Views · Camping::Session · Camping::Controllers · Camping::Controllers::ServerError · Camping::Controllers::NotFound · Camping::Helpers · Camping::Base · Camping::Models · Camping::Models::Session · Camping::FastCGI · Camping::Mab (for the Markaby(Markup as Ruby)) rdoc here · Camping::Reloader · Camping::H

I’ll add more stuff now on…

Of course the intention is making the effort for Camping to gain traction in the web scene. Model-View-Controller, is it to last ?
humm… i’m giving a look on Catalyst, but now its Ruby, not Perl time… for me.