Upgrading to the latest RubyGems in Ubuntu Gutsy is a bit non-straightforward. I’d like to share a quick fix this time. It’s trivial when you know it, but if not, a friend of mine has almost hosed his system just because of this annoying “bug”.

Installing Ruby in Ubuntu is pretty simple:

sudo aptitude install ruby ri irb rdoc rubygems libruby-extras libmysql-ruby ruby1.8-dev

(add other packages as you see fit)

The problem occurs right after you upgrade RubyGems to the latest version:

sudo gem update --system

Then you get something like this:

ceefour@caliva:/usr/bin$ gem
/usr/bin/gem:23: uninitialized constant Gem::GemRunner (NameError)

Logging in and out doesn’t work. The world is coming to an end!

Don’t worry, the world is still running. Check out your /usr/bin folder:

ceefour@caliva:/usr/bin$ ls -la gem*
-rwxr-xr-x 1 root root 701 2007-08-24 12:18 gem
-rwxr-xr-x 1 root root 698 2008-03-20 09:20 gem1.8
-rwxr-xr-x 1 root root  84 2008-03-20 09:20 gemlock
-rwxr-xr-x 1 root root  89 2008-03-20 09:20 gem_mirror
-rwxr-xr-x 1 root root  76 2008-03-20 09:20 gemri
-rwxr-xr-x 1 root root  89 2008-03-20 09:20 gem_server
-rwxr-xr-x 1 root root  86 2008-03-20 09:20 gemwhich

So, there is some mismatch between gem and gem1.8. The latter being the newer/correct version.

Simply remove the “gem” one and replace (or link) it to the “gem1.8″ one:

ceefour@caliva:/usr/bin$ sudo rm gem
ceefour@caliva:/usr/bin$ sudo ln -s gem1.8 gem

Now:

ceefour@caliva:/usr/bin$ gem -v
1.0.1

Presto! We’re back in business.

Interesting RubyGems articles:

• Compiling Ruby, RubyGems and Rails on Ubuntu
• Jag har litet bråttom: Ruby Gems on Ubuntu Linux
• :: nEvEr gIVeUp :: » Ruby, RubyGems Mirroring
• VMUNIX Blues » Blog Archive » Ruby GEMS still doesn’t work on 10.4?
• Stefano’s Blog(s) » The magic world of Ruby, Rails and RubyGems …
• Ruby/RubyGems/Rails/MySQL installation h e double-hockey sticks …

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

A common stumbling block for beginner Rails developers is learning the basics required to write plugins. This is made more complicated by the fact that Ruby is inherently dynamic and offers many techniques for code reuse.

Luckily, if you can write Rails applications you can write plugins by simply drawing on a handful of basic patterns.

Why write plugins?

Writing a plugin will:

• Help make sharing code more efficient, whether it’s between projects or within the same project
• Allow you to publish generic code to the community
• Save time and increase your confidence by testing once and reusing many times
• Share functionality in a robust manner, especially when using namespaces with ActiveRecord

Usage

Rails provides installation scripts through script/plugin install, and a generator for creating new plugins: script/generate plugin. These will work with URLs, saving time when trying out plugins. You can read more about installing and managing plugins at the Rails wiki.

Rubyisms

Any of the following tools and techniques provided by Ruby are used by plugins to extend functionality:

• Mixins: including or extending classes using modules
• Opening a class or module definition and adding or overriding methods
• Dynamic extension through callbacks and hooks: method_missing, Class#inherited, Module#const_missing, Module#included
• Dynamic extension through code generation: eval, class_eval, instance_eval

These techniques fall into two broad categories:

• Using modules and classes to extend existing classes, providing new features
• Using introspection to adapt generic code to specific cases

It’s important to consider exactly what should be extended when writing a plugin. If complex meta-programming to adapt your plugin to the host application is required, care should be taken to ensure concurrency will not produce unexpected results.

Hopefully this very short summary clears things a bit. Read more on Alex Young’s article.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

We’ve been doing a lot of scraping and mashups lately. So we’d love to share on how to do this. Fortunately Schadenfreude has written a good tutorial about using Mechanize and Hpricot to scrape Gmail.

The tutorial uses mechanize and hpricot to login to gmail and return a list of Unread emails.

Installation of required tools

gem install mechanize --include-dependencies


This will install both mechanize and hpricot.

Usage

Before we can scrape our gmail account, we will need to login. Mechanize is a lib for “automating interaction with websites”. It can store and send cookies as well so once we login our script will now have a session to putter around in as if it was a web browser.

require 'rubygems'
require 'mechanize'

agent = WWW::Mechanize.new
page = agent.get 'http://www.gmail.com'

form = page.forms.first
form.Email = '***your gmail account***'
form.Passwd = '***your password***'

page = agent.submit form

After logging in gmail will try to redirect us to http://mail.google.com/mail?ui&auth=DC8F…. we need to follow this link. Using hpricot we can search for the meta redirect and grab the href attribute then have mechanize follow the link.

page = agent.get page.search("//meta").first.attributes['href'].gsub(/'/,'')

Note we need to strip the single quotes from around the url, i used gsub for this.

The returned page will try to use javascript to load the interface but it will not work for use. Thankfully a noscript tag is included in the source and contains a helpful clue.

<noscript><font face="arial">JavaScript must be enabled in order for you to use Gmail in standard view.
However, it seems JavaScript is either disabled or not supported by your browser.
To use standard view, enable JavaScript by changing your browser options, then <a href="">try again</a>.

<p>To use Gmail's basic HTML view, which does not require JavaScript,
<a href="?ui=html&zy=n">click here</a>.</p></font>

<p><font face="arial">If you want to view Gmail on a mobile phone or similar device
<a href="?ui=mobile&zyp=n">click here</a>.</font></p></noscript>

Full source

require 'rubygems'
require 'mechanize'

agent = WWW::Mechanize.new

page = agent.get 'http://www.gmail.com'
form = page.forms.first
form.Email = '***your gmail account***'
form.Passwd = '***your password***'
page = agent.submit form

page = agent.get page.search("//meta").first.attributes['href'].gsub(/'/,'')
page = agent.get page.uri.to_s.sub(/\?.*$/, "?ui=html&zy=n")
page.search("//tr[@bgcolor='#ffffff']")  do |row|
from, subject = *row.search("//b/text()")
url = page.uri.to_s.sub(/ui.*$/, row.search("//a").first.attributes["href"])
puts "From: #{from}\nSubject: #{subject}\nLink: #{url}\n\n"

email = agent.get url
# ..
end

Enjoy the tutorial!

Read more on Schadenfreude.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

If you simply want to write simple GUI desktop applications, Ruby with Shoes is a quick way to do it.

Example session in my computer:

The code for that Timer GUI application is taken from the Shoes samples, which is concise enough for me to put it here:

Shoes.app :height => 150, :width => 250 do
  background rgb(240, 250, 208)
  stack :margin => 10 do
    button "Start" do
      @time = Time.now
      @label.replace "Stop watch started at #@time"
    end
    button "Stop" do
      @label.replace "Stopped, ", strong("#{Time.now - @time}"), " seconds elapsed."
    end
    @label = para "Press ", strong("start"), " to begin timing."
  end
end

To install Shoes on Ubuntu, it needs some dependencies which fortunately are very easy to install:

sudo aptitude install libungif4g libvlc0

More detailed download and installation instructions are available on whytheluckystiff’s site.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

microformats has been only two years old, yet it has brought significant changes in a relatively short time.

What is it, actually? According to microformats.org, “[microformats is] designed for humans first and machines second, [they] are a set of simple, open data formats built upon existing and widely adopted standards.”

Enough with the fluff, let’s see how it actually works, microformats in action:

Flickr picture source

The above picture is me browsing to the LinkedIn profile of one of Indonesia’s renowned Ruby on Rails experts, Arie Kusuma Atmaja. The overlay window that contains these semantic information is not a LinkedIn feature. Rather, it is the easily usable, cross-browser Microformats Bookmarklet by LeftLogic. Go on… try it if you haven’t!

As you can see, the mere act of clicking the bookmarklet shows you some important facts about Arie (or any microformats-enabled you’re currently at). In case of a microformats-enabled resume page like in LinkedIn, it shows you where he works, when, education information, and related stuff. For fun comparison purposes only, my LinkedIn profile has more detailed information than his, hehe

The best part is not only that the information is human-readable, but it can also be extracted and processed automatically by machines or software. The primary distinguishing trait of a microformats-enabled HTML page is that it has semantic meaning. A microformats processor can know the difference between a name, an e-mail address, a street address, a job, a university, and so on; while in plain HTML, all you can infer are things dealing with paragraphs, tables, lists, and so on.

Making microformats-enabled pages aren’t hard at all, actually it is very easy! It’s even much easier than CSS.

To see how simple it is, let’s see a snippet of a real-world microformats, still courtesy of Arie:

<div id="masthead" class="vcard contact">
  <div id="nameplate">
    <h1 id="name"><span class="fn n"> <span class="given-name">Arie</span> <span class="family-name">Kusuma Atmaja</span> </span></h1>
      <p class="headline title"><strong>Senior Ruby Developer at IMT</strong></p>
    <div class="adr">
      <p class="locality">Indonesia</p>
    </div>
  </div>
</div>

Most of the above snippet is just HTML. The microformats part is simply the class=”something“ convention. Simple, and it gets the job done.

Some more commonly used microformats specifications include:

• hCard for people and organizations
• hCalendar for calendars and Events
• hCalendar for calendars and Events
• VoteLinks and hReview for opinions, ratings, and reviews
• XFN for social networks
• rel-license for licenses
• rel-tag for tags, keywords, and categories
• XOXO for lists and outlines
• …and more…

Despite all these specifications, “who uses it?” is a good question. It turns out, there has been many, and more and more sites are adopting it. LinkedIn with hResume is one example, along with Google Maps, Yahoo, Flickr, and all these cool guys have been using them. Why shouldn’t you?

Interested? Here are some stuff to get you started:

1. Online Tools
   1. Microformats Bookmarklet by LeftLogic
      A handy microformats explorer bookmarklet. Useful also if you’re on the go and you want to check out some microformats. No need to install anything fancy on the computer.
   2. Operator Firefox Extension
      Microformats explorer extension for Firefox. Whether you’re a web developer or simply want to check out this latest technology, this is a very useful tool.
   3. Tails Firefox extension is another microformats Firefox extension
   4. Almost Universal Microformats Parser is a useful web-based tool to parse microformats.
2. Tutorials and Resources
   
   1. Microformats, what they are and how to use them, by Smashing Magazine
   2. Microformats Tutorial by XFront
      This is a very extensive tutorial. The complete tutorial package including the example files is a 13 MB download!
   3. How to Use Microformats by Vitamin Features
   4. Introduction to Microformats by WhyMicroformats.com
   5. The Big Picture on Microformats by Digital Web Magazine
   6. Another by Digital Web Magazine: Microformats Primer
   7. Back to the future: Mozilla Firefox 3.0 Does Microformats
      Read/WriteWeb’s articles also touched microformats-related stuff quite often.
3. Microformat Parsers
   1. Mofo Ruby Gem and Rails Plugin
      Of course, this is Ruby on Rails blog! Mofo is a microformats parser for Ruby and it also doubles as a Rails plugin. Check out Chris Wanstrath’s post for more information.
      There are also microformat parsers for other languages:
   2. Sumo is a microformats parser for JavaScript
   3. hKit is a microformats parser for PHP
   4. Microformats Parser is another parser for PHP
   5. Microformats Parser for Python
   6. Hpricot Ruby Gem
      Found a bizarre microformat or inventing your own? No problem, Hpricot comes to the rescue. Parse any HTML-ish document as you see fit… More info available from this RedHanded post.
   7. scrAPI is another Ruby library for parsing HTML that can be useful for processing microformats.
4. References
   1. Microformats.org
      “Official” web site of Microformats. You can read everything about microformats, current specifications and newly proposed specs.
   2. “Microformats: Empowering Your Markup for Web 2.0″ Book by John Allsopp
      <br />
      This is the first book dedicated to, and is a comprehensive guide to, microformats. It explores why, in Bill Gates’s words, “We need microformats”; how microformats work; and the kinds of problems microformats help solve. the book covers every current microformat, with complete details of the syntax, semantics, and uses of each, along with real-world examples and a comprehensive survey of the tools available for working with them. the book also features case studies detailing how major web content publishers such as yahoo put microformats to work in their web applications.
   3. Brian Suda’s microformats cheatsheet
      For people who likes it quick and done, this is perfect. It lists microformats properties by format and also lists each format and the hierarchy. This includes elemental microformats, compound microformats and some of the standard design patterns used.
   4. Dave Child’s microformats cheatsheet is another good reference
   5. And more cheatsheets on microformats.org wiki
   6. Gleaning Resource Descriptions from Dialects of Languages (GRDDL) is a recently approved W3C Recommendation that can be used, among others, for extracting semantic information (including microformats) from HTML pages.
   7. microformatique. A blog about all things microformats!

Feel free to add more resources as you see fit, in the comments!

Updates:

1. I originally thought I was gonna list 10 resources… But it seems there are much more
2. More links to John Allsopp’s resources

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

NetBeans 6 Beta 1 is here!!

Let’s rock the boat

It’s the first significant NetBeans event in probably a year

NetBeans isn’t only for Java geeks anymore, it has tons of Ruby and Ruby on Rails support now!

What surprises me (and delights me!) about this release is that, not like previous NetBeans 6 milestones where NetBeans-Java is bundled with Ruby, they actually make a special Ruby-only version.

The Ruby-only download is mere 19 MB in size!

That’s quite “cheap” (in terms of bandwidth usage). I’d expect the Ruby version to be less memory bloat and should have better performance as well, than the mammoth 172 MB one

I have been using NetBeans 6 for several months now, starting from the first NetBeans+Ruby version which is NetBeans 6 Milestone 7, and I can say I’m very impressed.

I’m still downloading Beta 1 and haven’t yet installed Beta 1 at the time of this writing, but I can be sure it’s gonna be event better than the last NetBeans 6 Milestone 10.

Don’t let the “Milestone” or “Beta” name put you off, it’s already usable in more ways than most software.

Check out why George Cook says Netbeans THE best ruby on rails IDE:

… I was gonna write a blow for blow comparison of netbeans against radrails, but I really see no point. I figured it’s best just to tell you why netbeans’ rails support is so creamingly good, but so you know I have evaluated both and textmate, firstly – here’s some points about the other 2. …

… I looked about and by chance came across an article that said that ruby on rails support was being added to netbeans 6. I hunted around like a crack addict and found the nightly builds to try out.

I was extremely impressed.

Netbeans is fucking fab, it proper rocks. I’ve been on netbeans 6 since milestone 8, which is about 1,000 builds now (they’re constantly working on it, and updating it). I’ve been with it through broken indentation, broken code completion, broken everything, null pointers, new features, more efficiency, the memory leak sorted out. I’ve watched it evolve before my eyes: I was installing new builds twice a day – Now it’s so stable and so good that I haven’t updated my build in a month (I might later on .
Code completion that works – really really works:
Code completion is activated with CTRL + SPACE – once activated you can type, or select from the list:

And here are what the diffs look like in the files themselves:

In line documentation when you need it, where you need it:
Just press CTRL+SPACE on a keyword and you get the docs.

Click on rescue, or move the caret over it with the cursor keys:

code folding:
You use the + and – buttons to fold code

(Read his article for more info. He has a very comprehensive review of many NetBeans-Ruby features!)

Michael Urban has his own opinion in Move Over Eclipse. NetBeans 6 Rocks!:

Ok, I admit the title is a bit inflammatory to Eclipse fans. But after working with NetBeans 6 over the last week, I have to say I am very impressed. This is not simply a minor upgrade, as is so common in IDEs these days even when they are given a new major version number. Quite the contrary, NetBeans 6 is a major new release, and a major improvement over NetBeans 5.5.

A roundup of NetBeans Ruby-specific features in this release:

Ruby/JRuby/Ruby on Rails Support

• Project Support. Quickly create Ruby projects with logical structure, run Ruby files, configure other Ruby interpreters (such as JRuby or native Ruby), locate and install Ruby Gems through a graphical wizard, create and execute unit tests, run RSpec specification files, jump between a Ruby file and its corresponding unit test or spec file, and so on. View Demo.
• Advanced Ruby Editing. Advanced code editing for Ruby, using semantic information about the program to offer code completion, showing available classes and methods for the current expression, along with the associated RDoc documentation. The syntax highlighting is enhanced with semantic information, such that unused local variables and parameters are shown in gray. There are many other editing features, including Goto Declaration for jumping to the declaration point of a class or method reference. View Demo.
• Ruby Debugger. Single-step or run through Ruby code, set breakpoints, look at local variables, navigate the call stack, switch threads, and evaluate expressions by just hovering the mouse over the variable in the Editor. There is also support for the “fast debug” extension.
• Ruby on Rails Support. Generate Rails projects, or generate code through the Rails code generator graphical wizard, which offers documentation on the plugins within the wizard itself. Third party generators are also supported. Furthermore, there are actions for jumping quickly between a Rails action and its corresponding View, or warping to the browser for the URL most relevant to the file you are editing. Database migrations and Rake targets are supported as well. Finally, RHTML files are highlighted (along with improved NetBeans 6.0 support for related files, such as JavaScript and CSS). View Demo.

And also:

• Quick Fixes
  • Automatic detection of block variables that might be accidentally modifying local variables

• • Rails deprecation warnings which identify usages of deprecated Rails idioms (enable this warning in the Ruby options panel)

• • Quick which finds same-line definitions of classes or methods and offer to explode these into multiline, formatted definitions

• • A number of experimental hints compatible with Beta 1 but not bundled; access these from the Plugin manager. These hints can convert between do and brace-style blocks, they warn about “wrong” name conventions for Ruby symbols, they offer to run the Rails generator to generate missing views for action methods, they identify possible incorrect usage of attributes
  • More information about the Ruby quick fixes
• RHTML formatting (and improvements to the Ruby formatting algorithm). A new formatting preferences panel allows configuration of the continuation indent as well as enabling reformatting of comments.
• Updated bundled JRuby to version 1.0.1
• Ability to deploy Rails projects to Java EE application servers
• YAML code folding and navigator, improved RHTML navigator
• Go To Declaration in RHTML files now work to warp to partials, redirect_to, link_to, etc.

• Large number of bug fixes and tweaks

Diff

• Export Diff Patch – CVS and Subversion integration
  • based on unified diff
  • automatically opens generated patch file into the editor with colored annotations

Don’t forget the general improvements as well:

Editor Improvements

• Smarter code completion. The NetBeans editor is quicker and smarter, providing completions for keywords, fields, and variables. It also lists the most logical options at the top, and lets you dig down into the full options at the bottom
• Highlights. You can think of the highlights feature as an easy-to-use and more correct substitution for the editors Search. The IDE tracks the position of the caret and, based on it, highlights some parts of the code. The highlights are marked with a background color in the editor they are also put into the error stripe, which permits for having overview of the whole file.
• Better Navigation and Inspection. In addition to Highlights, the source editor lets you quickly navigate through your code with improved Navigator window organization and the Members and Hierarchy Inspectors.
• More than just code completion. With live templates and Surround With functionality, you can quickly enter commonly used blocks of code and focus on the business logic.
• There is much more. See the Java Editor User’s Guide.

Update: And more from Peter Cooper of Ruby Inside:

NetBeans is a powerful and free. You can create Ruby and Rails projects, run Ruby files, configure interpreters (MRI and JRuby), install Gems graphically, run tests, run RSpecs, debug Ruby code, run Rails apps, and so on, all from the IDE. The Ruby edition is only a 19MB download and it’s available right now. There are several Ruby related NetBeans screencasts for the less convinced.

Already more than enough evangelizing, I guess…

Head on to NetBeans 6 Release page to find out more and download.

Related posts:

1. NetBeans IDE 6.8 Released — with Enhanced Ruby on Rails Support! NetBeans IDE version 6.8 has been released, Sun Microsystems’...

Related posts brought to you by Yet Another Related Posts Plugin.

Profligacy is a JRuby library that makes building Swing Graphical User Interface much easier than with Raw code. It’s not a builder as with many other projects, but instead a simple Ruby way to structure the UI for the 80% common cases you’ll encounter.

It’s actively used in the Utu iHate client. iHate started as a RubyCocoa project and then convert to JRuby and Swing.

The purpose of Profligacy is not to be a complete way of hiding Swing components from you. You’ll still be making JButtons and JLabels, you’ll just be putting them into a Ruby idiomatic code structure that doesn’t make your eyes hemorrhage diarrhea like when you try to code in Java.

The only real innovation in Profligacy is a simpler way to configure a GroupLayout using a simple regex/wiki style syntax. This is a work in progress, but it should make building GUIs much much easier.

Sample code:

require 'profligacy/swing'
require 'profligacy/lel'

module Test
  include_package 'javax.swing'
  include Profligacy

  layout = "
     [ label_1         | label3      ]
     [ (300,300)*text1 | (150)people ]
     [ <label2         | _           ]
     [ message         | buttons     ]
  "

  ui = Swing::LEL.new(JFrame,layout) do |c,i|
    # nothing here for now
  end

  ui.build(:args => "Simple LEL Example")
end

The result:

TADA!

No fluff required.

Profligacy is really easy to use, but you should still be referring to the Swing™ docs to learn how to actually use the components.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Some people asked me about SVK so here it is. Quickly written because I am a bit lazy and sleepy right now.

SVK is a distributed version control system. In other words, it allows you to mirror a Subversion repository, have local commits, pull changes from upstream, and synchronize/merge it back to the remote Subversion server if you want.

English version

UPDATE: This is an outdated version. The most up-to-date version with newer tips and tricks is in wiki Ruby Indonesia: SVK, which unfortunately is only available in Indonesian.

Method 1: Use Subversion repository, but SVK working copy

Assumptions:

• Subversion repository remote: http://svn.example.com/try/
• SVK depot: /try/

svk depot try ~/.svk/try
svk mirror /try/remote http://svn.example.com/try/
svk sync /try/remote
svk cp /try/remote /try/local

Checkout & working copy:

svk co /try/local/trunk

Commit:

svk ci

Push: (merge to remote)

svk push

Pull: (merge from remote to local)

svk pull

Method 2: Use remote Subversion repository, local Subversion repository, and SVK to merge between those repositories

The advantage of this approach is that you can use usual Subversion tools (TortoiseSVN, or native utility from Aptana IDE, NetBeans, etc.)

Assumptions:

• Subversion repository remote: http://svn.example.com/try/
• Subversion repository local: http://svn.mycomputer/try/
• SVK depot: /try/

svk depot try ~/.svk/try
svk mirror /try/remote http://svn.example.com/try/
svk sync /try/remote
svk mirror /try/localsvn http://svn.mycomputer/try/
svk sync /try/localsvn
svk smerge /try/remote /try/localsvn

Checkout & working copy:

svn co http://svn.mycomputer/try/trunk/

Commit:

svn ci

Push: (merge to remote)

svk sync /try/localsvn
svk sync /try/remote
svk smerge /try/localsvn /try/remote

Pull: (merge from remote to local)

svk sync /try/localsvn
svk sync /try/remote
svk smerge /try/remote /try/localsvn

Tip: Moving local Subversion repository history to remote Subversion server

Assumptions:

• Subversion repository remote (still empty): http://svn.example.com/try/
• Subversion repository local (has history): http://svn.mycomputer/try/
• SVK depot: /try/

In short:

svk depot try ~/.svk/try
svk mirror /try/remote http://svn.example.com/try/
svk sync /try/remote
svk mirror /try/localsvn http://svn.mycomputer/try/
svk sync /try/localsvn
svk smerge --incremental --log --baseless /try/localsvn /try/remote

Versi Indonesia

UPDATE: Versi ini sudah out-of-date. Versi paling up-to-date dengan tips-tips tambahan dan edisi revisi ada di wiki Ruby Indonesia: SVK.

SVK adalah sistem version control terdistribusi.

Cara 1: Pake Subversion repository, SVK working copy

Asumsi:

• Subversion repository remote: http://svn.example.com/coba/
• SVK depot: /coba/

svk depot coba ~/.svk/coba
svk mirror /coba/remote http://svn.example.com/coba/
svk sync /coba/remote
svk cp /coba/remote /coba/local

Checkout & working copy:

svk co /coba/local/trunk

Commit:

svk ci

Push: (merge ke remote)

svk push

Pull: (merge dari remote ke local)

svk pull

Cara 2: Pake Subversion repository remote, Subversion repository local, dan SVK untuk merge

Kelebihan dari cara ini adalah Anda bisa menggunakan tools Subversion seperti biasanya (TortoiseSVN, maupun native utility dari Aptana IDE, NetBeans, dsb.)

Asumsi:

• Subversion repository remote: http://svn.example.com/coba/
• Subversion repository local: http://svn.mycomputer/coba/
• SVK depot: /coba/

svk depot coba ~/.svk/coba
svk mirror /coba/remote http://svn.example.com/coba/
svk sync /coba/remote
svk mirror /coba/localsvn http://svn.mycomputer/coba/
svk sync /coba/localsvn
svk smerge /coba/remote /coba/localsvn

Checkout & working copy:

svn co http://svn.mycomputer/coba/trunk/

Commit:

svn ci

Push: (merge ke remote)

svk sync /coba/localsvn

svk sync /coba/remote

svk smerge /coba/localsvn /coba/remote

Pull: (merge dari remote ke local)

svk sync /coba/localsvn
svk sync /coba/remote
svk smerge /coba/remote /coba/localsvn

Tip: Mindahin history Subversion local ke remote

Ini pertanyaan dari Marcel.

Asumsi:

• Subversion repository remote (masih kosong): http://svn.example.com/coba/
• Subversion repository local (sudah berisi): http://svn.mycomputer/coba/
• SVK depot: /coba/

So singkatnya:

svk depot coba ~/.svk/coba
svk mirror /coba/remote http://svn.example.com/coba/
svk sync /coba/remote
svk mirror /coba/localsvn http://svn.mycomputer/coba/
svk sync /coba/localsvn
svk smerge --incremental --log --baseless /coba/localsvn /coba/remote

Credits

Thanks buat Marcel ([1]) yang sudah menyumbang pertanyaan yang akhirnya membuat saya menulis artikel ini. Trims. –Ceefour 11:23, 22 Agustus 2007 (CDT)

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Who said Capistrano is for Ruby on Rails only?

That’s probably the major tagline of the whole Capistrano 2.0 saga. You can use it to deploy PHP, Django, or not doing any deployment at all. Let me demonstrate, this time using Joomla:

Capistrano adalah library/tool yang digunakan untuk meng-online-kan aplikasi Ruby on Rails, tapi bisa juga digunakan untuk aplikasi PHP, misalnya Joomla:

ceefour@ojalanow:~/project/layout_mania/trunk$ cap deploy
  * executing `deploy'
  * executing `deploy:update'
 ** transaction: start
  * executing `deploy:update_code'
  * executing "svn checkout -q --username ceefour --no-auth-cache -r11 http://tools.assembla.com/svn/layout_mania/trunk /home/rainbow/apps/layout_mania/releases/20070814160555 && (echo 11 > /home/rainbow/apps/layout_mania/releases/20070814160555/REVISION)"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
  * executing `deploy:finalize_update'
  * executing "chmod -R g+w /home/rainbow/apps/layout_mania/releases/20070814160555"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
    triggering after callbacks for `deploy:finalize_update'
  * executing `deploy:symlink_secret'
  * executing "ln -s /home/rainbow/apps/layout_mania/secret /home/rainbow/apps/layout_mania/releases/20070814160555/secret"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
  * executing `deploy:use_live_configuration'
  * executing "cp -f /home/rainbow/apps/layout_mania/releases/20070814160555/joomla/configuration.php.live /home/rainbow/apps/layout_mania/releases/20070814160555/joomla/configuration.php"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
  * executing `deploy:symlink_cache'
  * executing "rm -rf /home/rainbow/apps/layout_mania/releases/20070814160555/joomla/cache && ln -s /home/rainbow/apps/layout_mania/shared/cache /home/rainbow/apps/layout_mania/releases/20070814160555/joomla/cache"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
  * executing `deploy:symlink'
  * executing "rm -f /home/rainbow/apps/layout_mania/current && ln -s /home/rainbow/apps/layout_mania/releases/20070814160555 /home/rainbow/apps/layout_mania/current"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
 ** transaction: commit
  * executing `deploy:restart'

The result? layout-mania.humblia.com. Below is the source code of deploy/config.rb used to deploy this Joomla app.

Hasilnya? layout-mania.humblia.com. Di bawah ini adalah source code dari file konfigurasi Capistrano deploy/config.rb yang digunakan untuk aplikasi ini.

set :application, "layout_mania"
set :repository,  "http://tools.assembla.com/svn/layout_mania/trunk"

# If you aren't deploying to /u/apps/#{application} on the target
# servers (which is the default), you can specify the actual location
# via the :deploy_to variable:
set :deploy_to, "/home/rainbow/apps/#{application}"
set :user, "rainbow"
set :scm_username, 'ceefour'
set :use_sudo, false
set :cache_path, "#{shared_path}/cache"
set :media_path, "#{shared_path}/media"

# If you aren't using Subversion to manage your source code, specify
# your SCM below:
# set :scm, :subversion

role :app, "rainbowpurple.com"
role :web, "rainbowpurple.com"
role :db,  "rainbowpurple.com", :primary => true

after 'deploy:finalize_update', 'deploy:symlink_secret'
after 'deploy:finalize_update', 'deploy:use_live_configuration'
after 'deploy:finalize_update', 'deploy:symlink_cache'

namespace :deploy do

  # Overwritten to provide flexibility for people who aren't using Rails.
  task :setup, :except => { :no_release => true } do
    dirs = [deploy_to, releases_path, shared_path, cache_path, media_path]
    dirs += %w(system).map { |d| File.join(shared_path, d) }
    run "umask 02 && mkdir -p #{dirs.join(' ')}"
  end

  # Also overwritten to remove Rails-specific code.
  task :finalize_update, :except => { :no_release => true } do
    run "chmod -R g+w #{release_path}" if fetch(:group_writable, true)
  end

  # Each of the following tasks are Rails specific. They're removed.
  task :migrate do
  end

  task :migrations do
  end

  task :cold do
  end

  task :start do
  end

  task :stop do
  end

  # Do nothing (To restart apache, run 'cap deploy:apache:restart')
  task :restart do
  end

  task :use_live_configuration, :roles => :app do
    run "cp -f #{release_path}/joomla/configuration.php.live #{release_path}/joomla/configuration.php"
  end

  task :symlink_cache, :roles => :app do
    run "rm -rf #{release_path}/joomla/cache && ln -s #{cache_path} #{release_path}/joomla/cache"
  end
  task :symlink_secret, :roles => :app do
    run "ln -s #{deploy_to}/secret #{release_path}/secret"
  end

end

namespace :db do

  desc "Overwrite the remote database with local database."
  task :push_force, :roles => :db do
    system "mysqldump --opt rainbow_layoutmania | bzip2 > /tmp/rainbow_layoutmania.sql.bz2"
    system "rsync -vPa /tmp/rainbow_layoutmania.sql.bz2 rainbowpurple.com:tmp/"
    run "bunzip2 -dc /home/rainbow/tmp/rainbow_layoutmania.sql.bz2 | mysql -u rainbow_layoutma -p`cat #{deploy_to}/secret/db_password` rainbow_layoutmania"
    run "rm -f /home/rainbow/tmp/rainbow_layoutmania.sql.bz2"
    system "rm -f /tmp/rainbow_layoutmania.sql.bz2"
  end

  desc "Optimize remote database."
  task  ptimize, :roles => :db do
    run "mysqlcheck --analyze --repair --optimize --user=rainbow_layoutma --password=`cat #{deploy_to}/secret/db_password` rainbow_layoutmania"
  end

end

Interested? Unfortunately this isn’t a tutorial. Look more on the resources below:

Tertarik? Sayang sekali ini bukan tutorial, coba cari informasi lebih lanjut di:

• Capistrano 2.0 official site
• Capistrano Wiki
• Deploy any project using Capistrano 2
• Automate the deployment of any PHP project using Capistrano 2.0
• Jamis Buck’s blog (creator, lead developer, and chief inventor of Capistrano )
• Capistrano and the Rails Application Lifecycle book from O’Reilly

Note: Sorry for dual-language posting, any better suggestion?

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Tau gak twitter tuh punya API

Ini contoh penggunaannya:

ceefour@ojalanow:~/bin$ salsabeela 'untuk sekarang enak gini'
Sending salsabeela 'untuk sekarang enak gini' '.... OK!
ceefour@ojalanow:~/bin$ salsabeela 'gak perlu mandi tiap hari '
Sending salsabeela 'gak perlu mandi tiap hari '.... OK!
ceefour@ojalanow:~/bin$ cat salsabeela
#!/usr/bin/ruby
require "#{File.dirname(__FILE__)}/twitter_pm"
send_pm 'salsabeela', ARGV.join(' ')

isi twitter_pm.rb :

ceefour@ojalanow:~/bin$ cat twitter_pm.rb
require 'rubygems'
gem 'twitter4r', '>=0.2.0'
require 'twitter'

def send_pm(recipient_id, message)
t = Twitter::Client.new(:login => 'gauldong@gmail.com', :password => ****************)
message = ARGV.join(' ')
sent = false
begin
recipient = t.user(recipient_id)
rescue
raise("Cannot find user #{recipient_username}")
end
print "Sending #{recipient.screen_name} '#{message}'"
$stdout.flush
sending = Thread.new { t.message(:post, message, recipient); sent= true; }
status = Thread.new { until sent; print '.'; sleep(0.5); $stdout.flush; end }
sending.join
status.join
puts ' OK!'
end

ato gini :

ceefour@ojalanow:~/bin$ irb -rubygems
irb(main):001:0> gem 'twitter4r'
=> true
irb(main):002:0> require 'twitter'
=> true
irb(main):003:0> t = Twitter::Client.new(:login => 'gauldong@gmail.com', :password => ****************)
=> #<Twitter::Client:0xb773d658 @login="gauldong@gmail.com", @password=****************>
irb(main):004:0> ollie = t.user('salsabeela')
=> #<Twitter::User:0xb7738090 @protected=false, @id=7296272, @profile_image_url="http://assets2.twitter.com/system/user/profile_image/7296272/normal/profileollie.jpg?1183741074", @client=#<Twitter::Client:0xb773d658 @login="gauldong@gmail.com", @password=****************>, @screen_name="salsabeela", @description="What I learn today...", @url="http://blog.salsabeela.com", @location="Jakarta", @name="Ollie">
irb(main):013:0* for f in ollie.friends; puts f.screen_name; end
popurls
al3x
davewiner
bbcnews
detikcom
ceefour
confession
21c
hotdogsladies
OpinionJournal
cnnbrk
avianto
thomasarie
jenniesbev
twittown
notstevenwright
farry
dhewlett
mbot
kukuhtw
BarackObama
jafrane
javajive
budip
istribawel
enda
timer
Indonesia
unwinged

lucu kan? =))

thanks to Susan Potter for making twitter4r gem

PS: Twitter tuh apaan sich?!?!? =))

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.