def method1(*args)
  puts "method1 got a block" if block_given?
end
 
def method2(*args)
  puts "method2 got a block" if block_given?
end
 
method1 method2 do
end
 
method1 method2 {
}

method1 got a block
method2 got a block

#[...]
class Foo
  def bar=(o)
    puts "Foo#bar= got a block" if block_given?
  end
end
foo = Foo.new
 
foo.bar = method1 method2 do
end 
#method1 got a block
 
foo.bar = method1 method2 {
} 
#method2 got a block

import dbus
 
bus = dbus.SystemBus()
 
proxy = bus.get_object("org.freedesktop.DeviceKit.Disks", 
                       "/org/freedesktop/DeviceKit/Disks")
iface = dbus.Interface(proxy, "org.freedesktop.DeviceKit.Disks")
#enumerates all devices
print iface.EnumerateDevices()
 
#gets the device kit path of a specific device
path = iface.FindDeviceByDeviceFile("/dev/sdc1") 
#= "/org/freedesktop/DeviceKit/Disks/devices/sdc"
 
#gets an object representing the device specified by the path
device = bus.get_object("org.freedesktop.DeviceKit.Disks", path) 
 
#prints some XML that shows you the available methods, signals and properties
print device.Introspect()
 
#gets a proxy for getting properties
device_prop = dbus.Interface(device, "org.freedesktop.DBus.Properties")
 
#you need to specify an interface (properties could be ambiguous)
print device_prop.Get("org.freedesktop.DeviceKit.Disks.Device", "device-mount-paths")
 
#gets a proxy you can call methods on
device_iface = dbus.Interface(device, "org.freedesktop.DeviceKit.Disks.Device")
 
#unmounts the partition
device_iface.FilesystemUnmount(dbus.Array([], 's'))

import dbus
import gobject
from dbus.mainloop.glib import DBusGMainLoop
 
def device_added_callback(device):
    print 'Device %s was added' % (device)
 
def device_changed_callback(device):
    print 'Device %s was changed' % (device)
 
#must be done before connecting to DBus
DBusGMainLoop(set_as_default=True)
 
bus = dbus.SystemBus()
 
proxy = bus.get_object("org.freedesktop.DeviceKit.Disks", 
                       "/org/freedesktop/DeviceKit/Disks")
iface = dbus.Interface(proxy, "org.freedesktop.DeviceKit.Disks")
 
#addes two signal listeners
iface.connect_to_signal('DeviceAdded', device_added_callback)
iface.connect_to_signal('DeviceChanged', device_changed_callback)
 
#start the main loop
mainloop = gobject.MainLoop()
mainloop.run()

Device /org/freedesktop/DeviceKit/Disks/devices/sdc was added
Device /org/freedesktop/DeviceKit/Disks/devices/sdc1 was added
Device /org/freedesktop/DeviceKit/Disks/devices/sdc1 was changed

class A < Sequel::Model
  plugin :single_table_inheritance, :object_type
end
 
class B < A
end

add_to_classpath '../lib/java/monkeybars-1.0.2.jar'
#to
add_to_classpath '../lib/java/monkeybars-1.0.4.jar'

./script/generate model Thing a:datetime b:datetime

class Thing < ActiveRecord::Base
  def b=(d)
    write_attribute(:b, d)
  end
end

require 'test_helper'
 
class ThingTest < ActiveSupport::TestCase
  test "a and b" do
    d = DateTime.now
    t = Thing.new
    t.a = d
    t.b = d
    t.save
    assert_equal t.a, t.b
    t.reload
    assert_equal t.a, t.b
  end
end

  def b=(d)
    d = d.utc
    write_attribute(:b, d)
  end

(function($)
{
  $().ajaxSend(
    function(a,xhr,s){
      xhr.setRequestHeader("Accept","text/javascript, text/html, application/xml, text/xml, */*")
    }
  )
}
)(jQuery); 
[...]

class Thing < ActiveRecord::Base
  def name=(str)
    str.upcase! unless str.nil?
    write_attribute(:name, str)
  end
end

=begin
...
=end

property :lock_version, Integer, :default => 0

begin
  if @obj.update_attributes({:dummy => 123})
    #successful
  else
    #validation errors?
  end
rescue DataMapper::StaleObjectError
  #tell the user that he was too slow
  #or even better: show him the conflicts and let him merge the changes
end

gem install dm-optlock

class Array
  def mergesort(&cmp)
    if cmp == nil
      cmp = lambda { |a, b| a <=> b }
    end
    if size <= 1
      self.dup
    else
       halves = split.map{ |half|
        half.mergesort(&cmp)
      }
      merge(*halves, &cmp)
    end
  end
 
 
  protected
  def split
    n = (length / 2).floor - 1
    [self[0..n], self[n+1..-1]]
  end
 
  def merge(first, second, &predicate)
    result = []
    until first.empty? || second.empty?
     if predicate.call(first.first, second.first) <= 0
        result << first.shift
      else
        result << second.shift
      end 
    end
    result.concat(first).concat(second)
  end
end

                user     system      total        real
Original Sort 0.630000   0.010000   0.640000 (  0.639860)
Stable Sort 12.780000   0.700000  13.480000 ( 13.477982)
Mergesort 109.170000  13.420000 122.590000 (122.617323)