Aquarium is a framework that implements Aspect-Oriented Programming (AOP) for Ruby. The premise of AOP is that some concerns in an application will cut across the natural object boundaries of the problem domain. Rather than scatter duplicated code in each object to handle the cross-cutting concern, AOP modularizes the specification of which execution points are affected (called join points) and the actions that should be invoked at those points.

New in V0.4.0: Preliminary support for advising Java classes in JRuby! See the discussion here.

See also the RubyForge project page.

Usage

Aquarium provides a Domain Specific Language (DSL) with which you can express “aspectual” system behaviour in a modular way, i.e., using a succinct language and without repeating yourself all over your code base!

Imagine you want to trace all invocations of the public, instance methods in all classes whose names end with “Service”. Here’s how you can implement that behavior in Aquarium:

class ServiceTracer
    include Aquarium::Aspects::DSL::AspectDSL
    before :calls_to => :all_methods, :in_types => /Service$/ do |join_point, object, *args|
      log "Entering: #{join_point.target_type.name}##{join_point.method_name}: object = #{object}, args = #{args}"
    end
    after :calls_to => :all_methods, :in_types => /Service$/ do |join_point, object, *args|
      log "Leaving: #{join_point.target_type.name}##{join_point.method_name}: object = #{object}, args = #{args}"
    end
end
A more succinct implementation of this behavior uses #around advice:

class ServiceTracer
    include Aquarium::Aspects::DSL::AspectsDSL
    around :calls_to => :all_methods, :in_types => /Service$/ do |join_point, object, *args|
      log "Entering: #{join_point.target_type.name}##{join_point.method_name}: object = #{object}, args = #{args}"
      result = join_point.proceed
      log "Leaving: #{join_point.target_type.name}##{join_point.method_name}: object = #{object}, args = #{args}"
      result  # block needs to return the result of the "proceed"!
    end
end
See the Examples and the API section for more details.

Start Here

$ gem install -y aquarium

See the download page for different options or go directly to Rubyforge download page.

more resources: Aquarium.rubyforge home page.

No related posts.

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

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.

Recently I got a task which involves moving, or let’s say copying, an entire Subversion repository with history to another server. Problem is, I didn’t have access to the server itself, which means I couldn’t do a regular “svnadmin dump”.

SVK comes to the rescue!

To make it work, first of all you need to install SVK. In Ubuntu it goes like this:

sudo aptitude install svk

When you first run svk it’ll ask you to create a local depot, you can simply agree to its suggestion.

Now we mirror both of the Subversion repositories we’re trying to import and export from and to. Note that you need to create the destination repository first.

svk mirror //source http://svn.source.com/project1/
svk mirror //dest http://svn.dest.com/newproject/

A bit of niceness with this method instead of a regular svn dump/load procedure is that:

• you can import to a different folder/subfolder instead of the root folder
• you can do a partial export (subfolder of project repository)

Before doing the actual migration process, let’s sync these mirrors first:

svk sync //source
svk sync //dest

And then you’ll do the real thing. But we can simulate it first by using “–check-only”, kinda’ like when you simulate a DVD burning session before actually writing it.

svk smerge //source //dest --incremental --log --sync --verbatim --track-rename --baseless --check-only

There are several switches that I used above, feel free to use them only as needed:

• -I [--incremental]: apply each change individually
• -l [--log]: use logs of merged revisions as commit message
• -B [--baseless]: use the earliest revision as the merge point
• -s [--sync]: synchronize mirrored sources before update
• –verbatim: verbatim merge log without indents and header
• –track-rename: track changes made to renamed node
• -C [--check-only]: try operation but make no changes

After you’re ready, redo the above command without “–check-only”:

svk smerge //source //dest --incremental --log --sync --verbatim --track-rename --baseless

Simply wait several minutes–or possibly hours (or days!) if your project is sufficiently large–for SVK to do its job for you!

Are there disadvantages of using SVK to a “genuine” SVN dump/load? Sure, among them is that the original author names are lost.

Good luck!

Related articles and resources:

• HomePage – SVK Wiki
• An introduction to git-svn for Subversion/SVK users and deserters
• Distributed development with SVK
• An SVK primer | Tools | New Artisans LLC
• Make it happen: Using SVK for offline access to subversion
• jkraemer.net: Work offline with SVK and Subversion
• SVK – Mirror Subversion Repositories Locally and More at sablog.com

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.

The goal of Portable Ruby is to reduce those updates to a single place, your USB drive. About.com describes how to make this possible:

Installing Ruby

The easiest way to setup a Portable Ruby application is to start with an existing Ruby installation. I recommend the One-Click Installer. If you haven’t done so already, go ahead and install it.

The entire Ruby distribution is created in a single “ruby” directory structure. Additional changes include the creation of shortcuts for the start menu, which we will simulate in the PortableApp menu. The One-Click Installer also updates the Windows PATH environment variable to include the ruby\bin directory.

Layout the PortableApp Structure

Another helpful tip is to install PortableApps to the root of your hard drive so you can easily test the integration of your Portable Ruby development. Using the earlier articles as a reference, install PortableApps to “C:\PortableRoot”.

The next step is to create a standard PortableApp directory structure. To make this easy, you can download the Ruby Portable Template starter zip. In addition to the directory structure, the starter zip also contains files for creating the Ruby and SciTE Portable launchers.

Unzip the Ruby Portable Template inside of the directory “C:\PortableRoot\PortableApps\”. Your directory structure should look similar to the following.

• C:\PortableRoot
  • PortableApps
    • OtherApps
    • RubyPortable
      • App
        • AppInfo
        • ruby
      • Data
        • settings
      • Other
        • RubyPortableSource
        • RubySource

At this point, you can copy the contents of the “ruby” directory the One-Click Installer created into the RubyPortable -> App -> ruby directory.

Check your free space first. The directory is about 80MB, but I would plan on having additional free space for your projects. Once you have copied the Ruby directories over, you can uninstall the One-Click Installer. While this isn’t technically necessary, it is helpful to remove the changes to the Windows environment so they do not conflict with testing your setup of the Portable Ruby application.

More information and instructions are available on About.com: Ruby page.

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.

Sinatra is a new cool open-source DSL-driven web application framework!

This super-sexy DSL runs at lighting speed. It sits on top of Mongrel and was written to be thread-safe, sleek and tiny. And an entire web-application can be written and contained in one file (or a small collection of files)!

It’s super easy to use! Let’s create an app from scratch to demonstrate!

Install!

gem install sinatra -y

Use!

• Create a file called lyrics.rb (or any name you like)
• Add

    require 'rubygems'
  
    require 'sinatra'

• Run (yes, with just ruby)

    % ruby lyrics.rb
  
    == Sinata has taken the stage on port 4567!

• Take a moment and view the default page localhost:4567. Go ahead and bask in it‘s glory.
• Notice:
  • It didn‘t create any page to show you that default page (just a cool thing to see, that‘s all)
  • There was nothing generated other than a log file
  • Sinatra is a really cool name for a web-framework that‘s a DSL
• Modify lyrics.rb by adding:

    get '/' do
  
      'Hello World'
  
    end

• Refresh (no need to restart Sinatra):

    http://localhost:4567

• Modify again (then refresh):

•   get '/' do
  
      <<-HTML
  
        <form action='/' method="POST">
  
          <input type="text" name="name" />
  
          <input type="submit" value="Say my name!" />
  
        </form>
  
      HTML
  
    end  post '/' do
  
      "Hello #{params[:name] || 'World'}!"
  
    end

• Now you try: Use the Sinatra::Erb::EventContext or Sinatra::Haml::EventContext to do the same. Do them inline and as template files.
• Learn more cool stuff: see Sinatra::Dsl
• Create your own plugins!
  1. Create a ‘vendor’ directory in your app directory
  2. Lay it out like: myapp.rb : root

        |- vendor
     
                     | - plugin_name
     
                   | - init.rb  # load and hook here
     
                   | - lib
     
                         |- modules/classes here

  3. Use it in your app!

For further details visit:

• http://sinatra.rubyforge.org/doc/
• http://www.xnot.org/sinatra
• http://del.icio.us/tag/sinatra

Related posts:

1. Three Ways You Can Speed Up Your Fresh Rails Development A Ruby on Rails web application I’ve been developing...

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.

Just out from a pack of several of the world’s greatest Ruby and/on Rails programmers: Professional Ruby Collection: Mongrel, Rails Plugins, Rails Routing, Refactoring to REST, and Rubyisms.

GET STRAIGHT TO THE LEADING EDGE WITH RUBY AND RAILS

Information that’s so hot, new, and valuable, you can’t wait for a book. This package brings together 8 breakthrough primers on today’s most valuable Ruby and Rails technologies — including five new digital Short Cuts worth $69.95! From RailsSpace to ActiveRecord to Mongrel, here’s new content, techniques, and code from the Ruby community’s top innovators: insider’s information that’s never been available before in one place.

<br />On the CD-ROM: 5 brand-new digital Short Cuts…

• Mongrel: Serving, Deploying, and Extending Your Ruby Applications, by Matt Pelletier and Zed Shaw
• Rails Plugins: Extending Rails Beyond the Core, by James Adam
• Rails Routing, by David A. Black
• Rails Refactoring to Resources: Using CRUD and REST in Your Rails Application, by Trotter Cashion
• Rubyisms in Rails, by Jacob Harris

PLUS, PRINTED BONUS CONTENT INCLUDES

• Working with Active Record (from the forthcoming Addison-Wesley book The Rails Way by Obie Fernandez)
• RESTful Blogs (from RailsSpace by Michael Hartl and Aurelius Prochazka)
• OOP and Dynamic Features in Ruby (from The Ruby Way, Second Edition, by Hal Fulton)

About the Authors

• Matt Pelletier (WorkingWithRails profile) is a partner at EastMedia, a software, mobile, and business development firm. He is also cofounder of NYC.rb, the New York City Ruby group.
• Zed Shaw (WorkingWithRails profile) is the original and primary author of Mongrel.
• David A. Black (WorkingWithRails profile) is Director, Ruby Power and Light, LLC and also Co-Director, Ruby Central, Inc. He is the bestselling author of Ruby for Rails.
• Trotter Cashion (WorkingWithRails profile) is an application developer at motionbox.com, a Rails-based video sharing site.
• Dr. James Adam (WorkingWithRails profile) is the developer behind the Engines plugin.
• Jacob Harris (WorkingWithRails profile) is a web developer for New York Times Digital.

Enough said!

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.