Записки про Ruby

Привіт, DataMapper!

2009-11-09T13:23:00.001+02:00

DataMapper - це ORM бібліотека (англ. Object-relational mapping, Обє'ктно-реляційна проекція - технологія, яка зв'язую бази даних з концепцією об'єктно-орієнтовного програмування, створюючи "віртуальну об'єктну базу даних"). DataMapper написана на Ruby, і широко використовується у таких фреймворках як Merb та Sinatra. Вона була розроблена, щоб усунути недоліки бібліотеки ActiveRecord, яка використовується в Ruby on Rails по замовчуванню. DataMapper слідує стандартам ORM-моделі: таблиці відображаються у вигляді класів, записи - у вигляді об'єктів, а стовпці - у вигляді властивостей цих об'єктів. Методи класу використовуються для здійснення операцій на рівні таблиці, а методи екземпляра здійснюють операції над окремими рядками.
Якщо в базі даних є таблиця з назвою posts (записи), то наш застосунок матиме клас Post. Рядки цієї таблиці відповідають об'єктам класу - конкретний запис представляється як об'єкт класу Post. У межах цього об'єкту для отримання доступу до окремих стовпців і встановлення їм значення, використовуються властивості.

Інсталяція DataMapper

DataMapper доступний через менеджер пакетів Ruby Gem:

gem install dm-core

Якщо ви плануєте використовувати DataMapper з базою даних, встановіть адаптер бази даних з проекту DataObjects. В залежності від ваших уподобань, це може бути do_mysql, do_postgres або do_sqlite3.

gem install do_sqlite3

Давайте уявимо, що ми створюємо деякі моделі для застосунку блогу. Ми отримаємо їх просто і красиво. Перше рішення, яке потрібно ухвалити - які моделі нам потрібні. Очевидно нам потрібна модель для записів (Post) і коментарів (Comment). Також нам можуть знадобитися категорії (Category).

Для роботи з DataMapper необхідно додати наступні рядки до нашого застосунку:

require 'rubygems'
require 'dm-core'

Перед тим, як зайнятися визначенням моделей, потрібно з'єднатися з базою даних:

# An in-memory SQLite3 connection:
DataMapper.setup(:default, 'sqlite3::memory:')

# A file SQLite3 connection:
DataMapper.setup(:default, "sqlite3://#{Dir.pwd}/the_database_name.sqlite3")

# A MySQL connection:
DataMapper.setup(:default, 'mysql://localhost/the_database_name')

# A Postgres connection:
DataMapper.setup(:default, 'postgres://localhost/the_database_name')

В нашому застосунку буде використовуватися база даних SQLite3 (яку потрібно встановити, якщо ви збираєтесь відтворювати приведений тут код). Якщо ви користуєтесь іншим сервером баз даних (наприклад, MySQL чи PostgreSQL), вам потрібно заздалегідь подбати про створення бази даних і надання повноважень користувачу.

Визначення моделей

Таблиця для моделі Post повинна існувати в чистому вигляді, тому включаємо DataMapper::Resource. Це вказує на те, що клас Post є ресурсом DataMapper(тобто описує записи в БД). У базі буде створена таблиця posts і ми отримаємо методи для роботи з нею. Угода з іменуванням моделей - використовувати однину, а не множину. Але це лише угода, ви можете робити як бажаєте. Це означає, що в базі буде створена таблиця posts і ми отримаємо методи для роботи з нею.

class Post
  include DataMapper::Resource

  property :id,         Serial
  property :title,      String
  property :body,       Text
  property :created_at, DateTime
  property :published,  Boolean, :default => false

  default_scope(:default).update(:order => [created_at.desc])
end

class Comment
  include DataMapper::Resource

  property :id,         Serial
  property :posted_by,  String
  property :email,      String
  property :url,        String
  property :body,       Text
end

class Category
  include DataMapper::Resource

  property :id,         Serial
  property :name,       String
end

Всередині класу моделі викликається метод property для кожної властивості. Він має два необхідних аргументи - ім'я і тип, а все інше не є обов'язковим.
Тип Serial вказує на те, що властивість буде первинним ключем, тобто AUTOINCREMENT(автоматично отримувати значення).

property :id,  Serial

Властивість created_at буде автоматично заповнюватися часом створення запису TIMESTAMP(для цього необхідно підключити 'dm-timestamps').
DM-Timestamps забезпечує автоматичне оновлення властивостей created_at або created_on і updated_at або updated_on.

property :created_at, DateTime

Аргумент :default, встановлює значення по замовчуванню для властивості.

property :published,  Boolean, :default => false

І нарешті

default_scope(:default).update(:order => [created_at.desc])

говорить нам про те, що записи по замовчуванню треба діставати впорядкованими за спаданням часу створення.

Доступні типи

DM-Core підтримує наступні типи даних:

Boolean
String
Text
Float
Integer
BigDecimal
DateTime, Date, Time
Object
Discriminator

Якщо включити DM-Types, стають доступні наступні типи даних:

Csv
Enum
EpochTime
FilePath
Flag
IPAddress
URI
Yaml
Json
BCryptHash
Regex

Асоціації

Асоціації - це спосіб оголошення відносин між моделями. Вони надають ряд методів, які дозволяють створювати відносини та отримувати пов'язані моделі. У DataMapper є декілька видів асоціацій.

Один до багатьох(One-To-Many)

Запис(Post) потенціально може мати безліч коментарів(Comment). Така прив'язка до запису обумовлюється тим, що кожен коментар містить посилання на ідентифікатор запису, якому він належить. Тому ми повинні налаштувати one-to-many асоціацію між ними.

class Post
  has n, :comments
end

class Comment
  belongs_to :post
end

Має і належить до багатьох(Has and belongs to many або One-To-Many-Through)

Запис може належати багатьом категоріям, і кожна категорія може містити безліч записів. Це і є прикладом зв'язку "багато до багатьох", який також носить дивовижну назву "має і належить до багатьох". Схоже на те, що кожна із взаємодіючих сторін містить колекцію елементів іншої сторони. Всередині БД зв'язки "багато до багатьох" здійснюються з використанням проміжної об'єднавчої таблиці. У ній містяться пари зовнішніх ключів, які зв'язують дві задані таблиці.

class Categorization
  include DataMapper::Resource

  property :id,         Serial
  property :created_at, DateTime

  belongs_to :category
  belongs_to :post
end

class Post
  has n, :categorizations
  has n, :categories, :through => :categorizations
end

class Category
  has n, :categorizations
  has n, :posts,      :through => :categorizations
end

Перевірка даних

gem install dm-validations

DataMapper дозволяє перевіряти дані до того, як вони будуть збережені до бази даних за допомогою так званих валідаторів. Щоб зробити перевірку доступною для нашого затосунку, просто додамо рядок:

require 'dm-validations'

У DataMapper є два способи для перевірки властивостей у класі - ручна і автоматична.

Ручна перевірка

Подібно до інших Ruby ORM, ми можемо викликати метод перевірки безпосередньо передавши йому ім'я властивості(або масив імен) для перевірки:

validates_length :title
validates_length [:title, :body]

На даний момент доступні наступні перевірки:

validates_present
validates_absent
validates_is_accepted
validates_is_confirmed
validates_format
validates_length
validates_with_method
validates_with_block
validates_is_number
validates_is_unique
validates_within

Автоматична перевірка

Перевірку можна створити разом із оголошенням властивості у класі моделі:

# неявно створює validates_present
:nullable => false
:length => (1..n)

# неявно створює validates_length
:length => 20
:length => (1..20) # не може бути нульовим
:lenth => (0..20)  # може бути нульовим

# неявно створює validates_format
:format => :email_address
:format => /\w+_\w+/
:format => lambda {|str| str}
:format => Proc.new {|str| str}

Тепер давайте створимо клас як з ручною перевіркою, так і з автоматичною:

require 'dm-validations'

class Post
  include DataMapper::Resource

  property :title, String
  validates_length :name, :max => 30

  property :body, Text, :length => (1..5000)
end

Робота з помилками перевірки

Якщо валідатор знаходить помилку в моделі, він генерує об'єкт Validate::ValidationErrors, який доступний моделі через виклик методу #errors :

my_post = Post.new(:title => "Is It Alright?")
if my_post.save
  # my_post є дійсним і буде збережений
else
  my_post.errors.each do |e|
    puts e
  end
end

Повідомлення про помилки, які надаються DataMapper як правило чіткі і точно пояснюють, що пішло не так. Але у вас є можливість змінити їх, шляхом передання опції :message :

validates_is_unique :body, :scope => :post_id,
  :message => "There's already a comment of that body in this post"

Цей приклад демонструє використання опції :scope для перевірки унікальності властивості в обмеженій області. Об'єкт не буде дійсним, якщо інший об'єкт з таким самим post_id матиме ідентичне body.

Щось подібне також можна зробити і для автоматичної перевірки через встановлення :messages у параметрах властивості:

property :email, String, :nullable => false, :unique => true, :format => :email_address,
                         :messages => {
                           :presence => "We need your email address.",
                           :is_unique => "We already have that email."
                           :format => "Doesn't look like an email address."
                        }

Робота з даними

CRUD - (англ. create read update delete) 4 базові функції управління даними "створення, зчитування, зміна і видалення".
Стосовно СУБД:

Створити - INSERT 
Вибірка   - SELECT
Оновити  - UPDATE
Знищити  - DELETE

Для прикладу створимо новий екземпляр моделі Post, оновимо його властивості і збережемо. Якщо збереження пройде успішно функція поверне true, або false, якщо щось пішло не так.

post = Post.new
post.attributes = {:title => "Hello world!", :body => "DataMapper is awesome!"}
post.save

Є декілька способів встановлення властивостей моделі:

post = Post.new(:title => 'Pass in a hash to the new method'
post.title = 'Set individual property')
post.attributes = {:title => "Hello world!", :body => "DataMapper is flexible!"}

Також можна оновити властивості моделі і зберегти за допомогою одного методу:

post.update_attributes = {:title => "Hello world!", :body => "DataMapper is simple!"}

Щоб знищити запис, ви просто викликаєте на ньому метод #destroy!. Він поверне true або false, в залежності від того чи запис був видалений. Ось приклад знаходження існуючого запису, та його знищення:

post = Post.get(3)
post.destroy! #=> true

Методи пошуку для об'єктів DataMapper визначені в DataMapper::Repository. Вони включають get(), all(), first().
DataMapper має методи, які дозволяють отримати:

один запис по ключу;
перший запис, що збігається з набором умов;
множину записів, які відповідають умовам.

post = Post.get(1)                          # отримати запис із первинним ключем 1
post = Post.get!(1)                         # аналогічно get(), але у випадку невдачі поверне ObjectNotFoundError
post = Post.first(:title => 'Hello world!') # перший запис із заголовком 'Hello world!'
posts = Post.all                            # всі записи
posts = Post.all(:published => true)        # всі опубліковані записи

Методи all() і first() можуть бути з'єднані в ланцюжок для подальшої побудови запиту до бази даних:

all_posts = Post.all
published_posts = all_posts.all(:published => true)

Як прямий наслідок цього:

class Post
  def self.published
    all(:published => true)
  end
end

published_posts = Post.published

Замість визначення умов, використовуючи SQL, можна вказувати умови, використовуючи хеш значень.
Наведені нище приклади є досить простими, ви буде здивовані, як ви можете визначити умови рівності не вдаючись до SQL.

posts = Post.all(:created_at.gt => 2, :created_at.lt => 10)
# SQL: 'created_at > 2 AND created_at < 10'

Доступні символи операцій для умов:

gt    # більше
lt    # менше
gte   # більше або рівне
lte   # менше або рівне
not   # не рівне
eql   # рівне
like  # схоже
in    # міститься - використовується автоматично, якщо в якості аргументу переданий масив

Щоб визначити порядок, в якому повинні бути відсортовані результати, використовується:

posts = Post.all(:all => [:created_at.desc]
# SQL: select * from posts ORDER BY created_at DESC)

Сортувати можна за зростанням(asc) і за спаданням(desc).

Крім того DataMapper підтримує й інший синтаксис для умов:

posts = Post.all(:conditions => {:id => 1})
posts = Post.all(:conditions => ["id = ?", 1])
posts = Post.all(:conditions => {:id => 1}, :title.like => '%foo%')

Іноді потрібно зробити запит до БД вручну:

posts = repository(:default).adapter.query('SELECT title, body FROM posts WHERE published = 1')

Зауважте, така форма запиту поверне об'єкт Struct, а не Post.

Ну і на сам кінець варто згадати конструкцію before, яка може стати у нагоді тоді, коли потрібно виконати якусь дію з даними до того як вони будуть збережені у базу. Для прикладу:

class Post
  include DataMapper:Resource

  before :save, :format_body

  def format_body
    # ... деякий код
  end
end

class Comment
  include DataMapper:Resource

  before :save do
    # ... деякий код
  end
end

Спочатку я планував вкластися в одну статтю, але практика показала, що навіть двох мало. Тому чекайте продовження, в якому ми спробуємо написати свій затишний блог на Sinatra по мотивах бестселера "Creating a weblog in 15 minutes with Rails".

Що почитати на дозвіллі?

DataMapper Documentation

Користуючись нагодою, вітаю співвітчизників з Днем української писемності та мови.

Привіт, Sinatra!

2009-10-28T12:51:00.007+02:00

Sinatra — об'єктно-орієнтований програмний каркас(framework) для створення веб-застосунків, написана на мові програмування Ruby. На офійному сайті написано, що Sinatra це навіть не фреймворк, а DSL для створення веб-додатків. Залежить від інтерфейсу веб-сервера Rack. Вона є альтернативою іншим Ruby фреймворкам, таким як Ruby on Rails, Merb, Nitro та Camping.
Sinatra є відкритим програмним забезпеченням і розповсюджується під ліцензією MIT.
Розроблена та створена Blake Mizerany, Sinatra є крихітною(близько 1500 рядків коду, що майже 1/100-а розміру Rails) та надзвичайно гнучкою. Вона не слідує типовій архітектурі Модель-Вид-Контролер(Model-View-Controller, MVC), яка використовується в інших фреймвоках, таких як Ruby On Rails. Натомість, Sinatra зосереджена на "швидкому створенню веб-додатків на Ruby із мінімальними зусиллями". Sinatra використовує всі можливості Ruby і є його оригінальним розширенням.

Sinatra дає незвичайне відчуття присутності. Це як музика. Ви диригент оркестру. І перша скрипка звучить так, як ви їх наказали, хоча ви не обов'язково повинні знати, як на ній грати. Але в той же час у вас є можливість посмикати струни, побити в барабани, засурмити фанфари. Sinatra крихітна, гнучка і модульна. Ви вільні у виборі, що використовувати у якості бібліотеки моделі, двигуна шаблонів, двигуна JavaScript. Незважаючи на свій юний вік Sinatra є потужним і багатообіцяючим інструментом, про що свідчить підтримка з боку таких таких маститих проектів, як Engine Yard, Heroku, GitHub і Songbird.

Інсталяція Sinatra
Розпочнемо знайомство із встановлення Sinatra.
У вас уже повинен бути встановлений Ruby. Для тих хто вже користується новою гілкою 1.9 можу вас втішити - починаючи з версії 0.9.2, Sinatra повністю сумісна з Ruby 1.9 і Rack 1.0. Найпростіший шлях - встановити Sinatra через Rubygems:

$ gem install sinatra

Привіт, Sinatra
Тепер давайте створимо наш перший веб-додаток.

# myapp.rb
require 'rubygems'
require 'sinatra'

get '/' do
 "Привіт, Sinatra!"
end

Звичайно це не дуже корисна програма, це традиційний "Hello World!". Незважаючи на свою простоту, цей приклад корисний тим, що дозволяє виконати всі дії, необхідні для написання і запуску будь-якого Sinatra додатку.
Інша річ, яку ви могли помітити, вам не потрібно запускати нічого подібного Rails генераторам, для створення додатку. Для запуску програми код Ruby потрібно зберегти в файлі під якоюсь назвою (в нашому випадку це myapp.rb). Потім програму потрібно запустити. В залежності від операційної системи, це робиться по різному. Наприклад, під управлінням Linux, потрібно набрати на терміналі:

$ ruby myapp.rb

У результаті запуститься веб-сервер WEBrick, який можна переглянути з вашого улюбленого навігатора тенет за адресою http://localhost:4567.

Маршрути
В Sinatra-додатках вхідні запити спочатку відсилаються маршрутизатору, який і вирішує, куди запит повинен бути відісланий і як, власне, цей запит повинен бути оброблений. У Sinatra, маршрут пов'язаний із HTTP-методом, і записується у парі з відповідним зразком URL.

POST

DELETE

Кожен маршрут пов'язаний з блоком:

get '/' do
 # показати щось
end

post '/' do
 # створити щось
end

put '/' do
 # оновити щось
end

delete '/' do
 # знищити шось
end

Маршрути збігаються у тому порядку, в якому вони визначені. Тобто, викликається перший маршрут, який відповідає запиту. З цієї причини ви повинні розміщувати найбільш специфічні обробники зверху, а найбільш нечіткі - знизу.

Маршрут може включати в себе імена параметрів, які доступні через параметри хешу:

get '/hello/:name' do
 # збігається з "/hello/foo" і "/hello/bar"
 # params[:name] буде 'foo' або 'bar'
 "Hello #{params[:name]}!"
end

Також маршрут може включати підстановлювальний знак (wildcard), який доступний через масив params[:splat] :

get '/say/*/to/*'
 # збігається з "/say/hello/to/world"
 params[:splat] # => ["hello", "world"]
end

get '/download/*.*' do
 # збігається з "/download/path/to/file.xml"
 params[:splat] # => ["path/to/file", "xml"]
end

Маршрут, відповідний з регулярними виразами:

get %r{/hello/id([\d]+)} do
 # збігається з "/hello/id1234"
 # params[:captures] => ["1234"]
 "Hello, #{params[:captures].first}!"
end

Або те саме з параметром блоку:

get %r{/hello/id([\d]+)} do |c|
 "Hello, #{c}!"
end

User Agent.
Наступний маршрут відповідає будь-якому броузеру:

get '/agent', :agent => /(.+)/ do
 "You are using #{params[:agent].first}"
end

Тільки Opera:

get '/agent', :agent => /Opera\/(\d+\.\d+).*?/ do
 "You are using Opera version #{params[:agent].first}"
end

Інші методи викликаються так само як "get" маршрути. Ви просто використовуєте функції "post", "put" чи "delete" для визначення маршруту. Щоб отримати доступ до параметрів POST, використовується params[:xxx], де xxx - це ім'я елементу форми, яке було надіслано.

post '/foo' do
 "You just asked for foo, with post param bar equal to #{params[:bar]}"
end

Статичні файли
Статичні файли віддаються з директорії ./public. Ви можете визначити інше місце, встановивши опцію :public

set :public, File.dirname(__FILE__) + '/static'

Зверніть увагу, що ім'я публічного каталогу не включається в шлях URL. Файл ./public/css/style.css буде доступний як http://localhost/css/style.css.

Шаблони
Шаблони безпосередньо розміщуються у директорії ./views. Щоб використовувати іншу директорію, необхідно встановити опцію :views

set :views, File.dirname(__FILE__) + '/templates'

Важливо пам'ятати, що вам завжди доведеться посилатися на шаблон використовуючи об'єкт типу Symbol, навіть якщо він знаходяться у підкаталозі (в такому випадку використовувати :'subdir/template'). Методи будуть виконувати будь-які рядки, передані їм безпосередньо.

Шаблони HAML
Haml (XHTML Abstraction Markup Language) — мова розмітки для спрощеного генерування XHTML

get '/' do
 haml :index
end

Обробляє ./view/index.haml

Параметри HAML можуть бути встановлені глобально через конфігурацію Sinatra, або перевизначені індивідуально.

set :haml, {:format => :html5 } # формат Haml по замовчуванню :xhtml

get '/' do
 haml :index, :haml_options => {:format => :html4 } # перевизначення
end

Шаблони Erb

require 'erb'

get '/' do
 erb :index
end

Обробляє ./view/index.erb

Шаблони Builder

require 'builder'

get '/' do
 content_type 'application/xml', :charset => 'utf-8'
 builder :index
end

Обробляє ./view/index.builder

Шаблони Sass
Sass (Syntactically Awesome Stylesheets) - еквівалент HAML для CSS

require 'sass'

get '/stylesheet.css' do
 content_type 'text/css', :charset => 'utf-8'
 sass :stylesheet
end

Обробляє ./view/stylesheet.sass

Параметри Sass можуть бути встановлені глобально через конфігурацію Sinatra, або перевизначені індивідуально.

set :sass, {:style => :compact } # стиль Sass по замовчуванню :nested

get '/stylesheet.css' do
 content_type 'text/css', :charset => 'utf-8'
 sass :stylesheet, :sass_options => {:style => :expanded } # перевизначення
end

Вбудовані шаблони

get '/' do
 haml '%div.title Hello World'
end

Обробляє вказаний рядок.

Доступ до змінних у шаблоні
Шаблони оцінюються в тому контексті, як і обробники маршруту. Змінні, встановленні в обробнику маршруту безпосередньо доступні шаблону.

get '/:id' do
 @foo = Foo.find(params[:id])
 haml '%h1= @foo.name'
end

Або вказати явний хеш(Hash) локальних змінних:

get '/:id' do
 foo = Foo.find(params[:id])
 haml '%h1= foo.name', :locals => { :foo => foo }
end

Зазвичай це використовується для обробки шаблонів, як фрагментів(partials) з інших шаблонів.

In-file шаблони
Шаблони можуть бути визначеними у кінці вихідного файлу:

require 'rubygems'
require 'sinatra'

get '/' do
 haml :index
end

__END__

@@ layout
%html
 = yield

@@ index
%div.title Hello world!!!!!

Іменовані шаблони
Шаблони також можуть бути визначені з використання шаблону верхнього рівня:

template :layout do
 "%html\n  =yield\n"
end

template :index do
 '%div.title Hello World!'
end

get '/' do
 haml :index
end

Якщо шаблон під назвою "layout" існує, він буде використовуватися щоразу при обробці шаблону. Ви можете відключити макети(layouts), передавши

:layout => false

Що почитати на дозвіллі?

Try Ruby! Now With 1.9

2009-10-22T12:36:00.000+03:00

Веб-версія IRB(interactive ruby prompt) та 15 хвилинний навчальний посібник для людей, які хочуть познайомитися з Ruby. Тепер версія 1.9.

http://tryruby.sophrinix.com/

vk.com. Частина 7

2009-10-14T14:45:00.007+03:00

У цьому дописі мова знову піде про ВКонтакте і WWW::Mechanize. Хоч він і йде під номером сім, він не є продовженням попередніх частинами, хоча для повного розуміння про далі буде йти мова, бажано ознайомитися з ними. З них ви можете дізнатися, як робити наступні речі ВКонтакте:

Отримання новин профілю (кількості нових повідомлень, фотографій, відео, друзів, груп).

Отримання списку друзів

Отримання приватних повідомлень

Написання приватних повідомлень

Я вже писав про те, що домен VK.COM перейшов під контроль соціальної мережі ВКонтакте. Майже з тих самих пір авторизація користувачів на сайті vkontakte.ru відбувається через редірект login.vk.com. Це викликає незручність при авторизації за допомогою WWW::Mechanize.

require 'mechanize'
require 'json'

class Vkontakte
  def initialize
    @ua = WWW::Mechanize.new{|agent|
      agent.user_agent_alias = 'Linux Mozilla'
      agent.follow_meta_refresh = true
    }
  end

  # Authorisation by submitting email and password (Login)
  #                                                       
  def login_force(uid, email, pass)                       
    url = "http://login.vk.com/?act=login"                
    page = @ua.post(url, {'email' => email, 'pass' => pass, 'expire' => '1', 'vk' => 1})
    s = page.body.match(/'s' value='(.+?)'/)[1]                                         
    @ua.post('http://vkontakte.ru/login.php?op=slogin&redirect=1', {'s' => s})          
    user_page = @ua.get('http://vkontakte.ru/profile.php')                              
  end
  
end

if __FILE__ == $0
  id = "xxxxxxxx"
  email = "user@example.com"
  pass = "your_password"

  vkontakte_agent = Vkontakte.new
  vkontakte_agent.login_force(id, email, pass)
  
end

Далі можна продовжувати роботу з ВКонтакте як звичайно.

Давайте напишемо скрипт, який буде авторизуватись і працювати з vk.com:

require 'mechanize'
require 'json'     

class Vkontakte
  def initialize
    @ua = WWW::Mechanize.new{|agent|
      agent.user_agent_alias = 'Linux Mozilla'
      agent.follow_meta_refresh = true
    }
  end

  # Authorisation by submitting email and password (Login)
  #                                                       
  def login_force(uid, email, pass)                       
    url = "http://vk.com"
    login_page = @ua.get(url)
    login_form = login_page.form_with(:name => 'login')
    login_form.email = email
    login_form.pass = pass
    user_page = login_form.submit # У разі успішної авторизації відбувається перехід на http://login.vk.com.
    if user_page.uri.to_s == 'http://login.vk.com/?act=login'
      user_page =user_page.forms.first.submit
      return true
    else
      return false
    end
  end

end

if __FILE__ == $0
  id = "xxxxxxxx"
  email = "user@example.com"
  pass = "your_password"

  vkontakte_agent = Vkontakte.new
  vkontakte_agent.login_force(id, email, pass)
  
end

Як ви бачите, авторизація на сайті vk.com відбувається більш прозоро і зрозуміло.
Якщо порівняти сайти vkontakte.ru і vk.com, можна помітити, що крім відмінностей у назві домену вони практично ідентичні.
Для прикладу продемонструю метод для зміни статусу ВКонтакте:

class Vkontakte
  # Set status message for current user
  #
  def set_status(message)
    url = 'http://vk.com/profile.php'
    page = @ua.get(url)
    hash = page.body.match(/id='activityhash' value='(.+?)'/)[1]
    query = {"activityhash" => hash, "setactivity" => message}
    sleep(1) # http://vk.com/blank.php - Ви намагались завантажити бiльше однiєї однотипної сторiнки за секунду. Повернiться назад i спробуйте ще раз.
    page = @ua.post(url, query)
  end
end

Ддя того щою цей метод працював з сайтом vkontakte.ru достатньо у змінній url змінити vk.com на vkontakte.ru.

Proxy list fetcher using Ruby & Nokogiri

2009-09-29T00:15:00.005+03:00

А чому б нам не зробити накручувалку, яка голосує за що-небудь ? "Чорні"(брудні) технології залишимо нашим політиком. А самі займемося чимось корисним.

Цей скрипт складає список проксі-серверів з сайту proxy4free.com, і записує його до файлу proxy_list.txt.

# -*- encoding: utf-8 -*-

require 'nokogiri'
require 'open-uri'

file = File.new('proxy_list.txt', 'w')
url = 'http://www.proxy4free.com/page1.html'
# Get a Nokogiri::HTML:Document for the page
doc = Nokogiri::HTML(open(url))

# Search for nodes by css
doc.css('table tr.text').each do |tr|
  ip = (tr/"td:nth(1)").first.inner_html
  if ip.match(/^(\d{1,3}\.){3}\d{1,3}$/)
    port = (tr/"td:nth(2)").first.inner_html
    file.puts "#{ip}:#{port}"
  end
end
file.close

Керівництва до дії:

Do something

Do something else

Do something once more

<Do something so much you need>

?????

PROFIT!

RubyInstaller for Windows

2009-09-22T14:05:00.005+03:00

RubyInstaller (раніше відомий як One-Click Installer) - це автономний Windows-інсталятор, який включає в себе саму мову Ruby, середовище виконання, важливу документацію (містить документацію Ruby Core і стандартних бібліотеках, а також книжку "The Book of Ruby" написану Huw Collingbourne), та багато іншого.
Для інсталяції Ruby в один клік необхідно спочатку завантажити версію, яку ви хочете (на даний момент доступні 1.8.6 та 1.9.1) і запустити .exe файл.
Після цього в меню "Пуск" з'явиться відповідний пункт:

Хочу замітити цей проект знаходиться на першому місці по кількості скачувань з сайту RubyForge. На даний момент це - 3,572,852 раз.

wxRuby → Сайзери (3 частина)

2009-09-21T10:00:00.001+03:00

У попередній частині ми розглянули Wx::BoxSizer. Продовжимо знайомитися з сайзерами wxRuby.

Wx::StaticBoxSizer
Клас Wx::StaticBoxSizer є похідним від Wx::BoxSizer і відрізняється від нього тільки тим, що цей сайзер поміщає свої дочірні елементи в рамку з надписом, яка являє собою екземпляр класу Wx::StaticBox.
Використання Wx::StaticBoxSizer практично нічим не відрізняється від використання класу Wx::BoxSizer за виключенням того, що конструктор цього класу вимагає ще один параметр - екземпляр класу Wx::StaticBox, який і буде обводити дочірні елементи сайзера.

Wx::StaticBoxSizer.new(Wx::StaticBox box,  Integer orient)

Wx::StaticBoxSizer.new(Integer orient,  Wx::Window parent,
                      String label = '')

Перший приклад конструктора використовує вже існуючий екземпляр класу Wx::StaticBox. Він бере пов'язаний Wx::StaticBox та орієнтацію(параметр orient), яка може бути горизонтальною або вертикальною. Другий конструктор створює новий Wx::StaticBox із вказаними надписом і батьківським вікном.

Розглянемо простий приклад Wx::StaticBoxSizer разом з двома кнопками.

  def do_sizer
   static_box = Wx::StaticBox.new(self, :label => "StaticBox")
   sizer  = Wx::StaticBoxSizer.new(static_box, Wx::VERTICAL)

   button1 = Wx::Button.new(self, :label => 'Button 1')
   button2 = Wx::Button.new(self, :label => 'Button 2')

   sizer.add_item(button1)
   sizer.add_item(button2)

   set_sizer(sizer)
 end

У цьому прикладі ми спочатку створили екземпляр класу Wx::StaticBox, а потім сайзер Wx::StaticBoxSizer, в конструктор якого і передали щойно створений Wx::StaticBox, а також дві кнопки.

В результаті такого розміщення елементів ми отримали вікно, яке виглядає наступним чином:

Зверніть увагу, що Wx::StaticBox займає все вікно, так як він є основним сайзером для вікна. Якщо в перший Wx::StaticBoxSizer вставити дочірні такі ж сайзери, то вони будуть обводити тільки елементи керування. Давайте додамо ще пару кнопок:

  def do_sizer
   static_box0 = Wx::StaticBox.new(self, :label => "StaticBox 0")
   vert_sizer  = Wx::StaticBoxSizer.new(static_box0, Wx::VERTICAL)

   static_box1 = Wx::StaticBox.new(self, :label => "StaticBox 1")
   static_box2 = Wx::StaticBox.new(self, :label => "StaticBox 2")

   sizer_1 = Wx::StaticBoxSizer.new(static_box1, Wx::HORIZONTAL)
   sizer_2 = Wx::StaticBoxSizer.new(static_box2, Wx::HORIZONTAL)

   vert_sizer.add(sizer_1)
   vert_sizer.add_item(sizer_2, :flag => Wx::ALIGN_RIGHT|Wx::ALIGN_BOTTOM)
  
   button1 = Wx::Button.new(self, :label => 'Button 1')
   button2 = Wx::Button.new(self, :label => 'Button 2')
   button3 = Wx::Button.new(self, :label => 'Button 3')
   button4 = Wx::Button.new(self, :label => 'Button 4')

   sizer_1.add_item(button1)
   sizer_1.add_item(button2)
  
   sizer_2.add_item(button3)
   sizer_2.add_item(button4)

   set_sizer(vert_sizer)
 end

Тут ми створили три екземпляри класу Wx::StaticBoxSizer і передали кожному по своєму екземпляру класу Wx::StaticBox. В перший вертикальний сайзер ми додали ще два горизонтальні сайзери(sizer_1 та sizer_2). Перший буде прив'язаний по замовчуванню до лівого краю, а другий ми перенесли в правий нижній кут, вказавши прапорці Wx::ALIGN_RIGHT і Wx::ALIGN_BOTTOM. Насправді прапорець Wx::ALIGN_BOTTOM не буде відігравати тут ніякої ролі, оскільки друга "полиця" vert_sizer по висоті буде обмежена саме цим другим сайзером sizer_2. Але цей прапорець дасть нам зрозуміти істинні розміри головного сайзера vert_sizer, тому що розмір його рамки може ввести в оману.
В результаті виконання цього прикладу ми побачимо:

Для більшої наочності приведу знімок вікна з ОС Windows:

І щоб було більш зрозуміло, те ж вікно з намальованими сайзерами:

Як бачите, вкладені сайзери зайняли не всю доступну область, на відміну від головного сайзера vert_sizer.
На цьому огляд Wx::StaticBoxSizer закінчимо і перейдемо до огляду інших сайзерів.

Wx::GridSizer
Wx::GridSizer розміщує елементи керування (або дочірні сайзери) в комірках віртуальної таблиці. Віртуальної, тому що насправді ніякої таблиці не створюється. Розміри всіх комірок у цій таблиці однакові як по ширині, так і по висоті. При цьому розміри комірок залежать від того чи використовується прапорець Wx::EXPAND для розтягнення сайзера до максимально можливих розмірів. У випадку якщо Wx::EXPAND не використовується, ширина кожної комірки рівна ширині найбільш широкого елементу керування, а висота, відповідно, рівна висоті найбільш високого. Якщо при додаванні сайзера був встановлений прапорець Wx::EXPAND (або сайзер є головним для вікна), то вся займана сайзером площа ділиться порівну на кількість рядків і стовпців, необхідних для розміщення елементів.
Для початку розглянемо конструктор Wx::GridSizer:

GridSizer.new(Integer rows,  Integer cols,  Integer vgap,
             Integer hgap)

GridSizer.new(Integer cols,  Integer vgap = 0,
             Integer hgap = 0)

Він приймає 4 параметри. rows і cols визначає кількість рядків і стовпців у сайзері. Якщо який-небудь з цих параметрів рівний нулю, то він буде розрахований виходячи із загальної кількості дочірніх елементів у сайзері, роблячи сайзер динамічно зростаючим. vgap і hgap - величина зазору між рядками і стовпцями у пікселях, відповідно.

Розглянемо приклади. Нехай спочатку Wx::GridSizer буде основним для вікна. Розмістимо 6 кнопок у два рядки і три стовпці:

  def do_sizer
   grid_sizer = Wx::GridSizer.new(cols = 3, rows = 2)
   6.times do |i|
     button = Wx::Button.new(self, :label => "Button #{i}")
     grid_sizer.add(button)
   end
   set_sizer(grid_sizer)
 end
end

Так як основний сайзер намагається зайняти якомога більшу область вікна, то у нашому випадку grid_sizer займе все вікно, а висота рядків буде рівна висоті клієнтської області вікна, поділеної на кількість рядків. Аналогічно з шириною комірок, вона буде рівна ширині клієнтської області вікна, поділеної на кількість стовпців, необхідних для розміщення дочірніх елементів.

У цьому прикладі ми явно задали кількість рядків і стовпців за допомогою конструктора Wx::GridSizer, але ми би добилися того ж результату, якщо б вказали тільки кількість стовпців, які ми хочемо отримати. У цьому випадку сайзер сам розрахує необхідну кількість рядків. Пізніше ми розглянемо і такий приклад.
А щоб переконатися в тому, що комірки сайзера дійсно займають той розмір, який ми тільки що бачили на малюнку, розтягнемо кожну кнопку на всю комірку за допомогою прапорця Wx::EXPAND.

  def do_sizer
   grid_sizer = Wx::GridSizer.new(cols = 3, rows = 2)
   6.times do |i|
     button = Wx::Button.new(self, :label => "Button #{i}")
     grid_sizer.add_item(button, :flag => Wx::EXPAND)
   end
   set_sizer(grid_sizer)
 end

І побачимо очікуваний результат:

Наступні експерименти з цим сайзером ми будемо проводити, коли комірки сайзера залежать від розміру елементів керування, які вона містить. Тому підготуємо наступний приклад, у якому Wx::GridSizer не буде розтягуватися на все вікно, а буде знаходитися всередині сайзера Wx::BoxSizer.

  def do_sizer
   box_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
   grid_sizer = Wx::GridSizer.new(cols = 3, rows = 2)

   button_list = Array.new(6) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   button_list.each do |button|
     grid_sizer.add_item(button)
   end

   box_sizer.add(grid_sizer)
   set_sizer(box_sizer)
 end

У цьому прикладі для зручності кнопки створюються заздалегідь і поміщаються у масив, щоб в майбутньому ми могли незалежно одна від одної змінювати їх властивості. Основним тут є box_sizer, а grid_sizer "приклеєний" до верхнього лівого кута. Якщо ми запустимо цей скрипт, то побачимо таке розташування кнопок:

Як і варто було очікувати, розміри комірок однакові і співпадають із розмірами кнопок.

А тепер змінимо мінімально можливий розмір однієї кнопки і подивимося як зміняться розміри комірок таблиці:

  def do_sizer
   box_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
   grid_sizer = Wx::GridSizer.new(cols = 3, rows = 2)

   button_list = Array.new(6) {|i| Wx::Button.new(self, :label => "Button #{i}")}
   button_list[0].set_min_size([100, 35])

   button_list.each do |button|
     grid_sizer.add_item(button)
   end

   box_sizer.add(grid_sizer)
   set_sizer(box_sizer)
 end

Всі розміри комірок знову рівні, але на цей раз співпадають з розміром найбільшої кнопки "Button 0". Таблицю комірок сайзера у цьому випадку можна намалювати наступним чином:

В наступному прикладі розтягнемо всі кнопки за допомогою прапорця Wx::EXPAND, щоб переконатися, що розміри комірок саме такі, як ми їх представляли:

  def do_sizer
   box_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
   grid_sizer = Wx::GridSizer.new(cols = 3, rows = 2)

   button_list = Array.new(6) {|i| Wx::Button.new(self, :label => "Button #{i}")}
   button_list[0].set_min_size([100, 35])

   button_list.each do |button|
     grid_sizer.add_item(button, :flag => Wx::EXPAND)
   end

   box_sizer.add(grid_sizer)
   set_sizer(box_sizer)
 end

Тепер розглянемо параметри vgap і hgap, які задають відстань між елементами керування. Найпростіше ці параметри уявити у вигляді товщини стінок, які розділяють елементи, але при цьому зовнішні стінки сайзера-таблиці залишаються нульової товщини.

У наступному прикладі ми додамо 10 пікселів відстані між рядками і 20 пікселів між стовпцями:

  def do_sizer
   box_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
   grid_sizer = Wx::GridSizer.new(rows = 2, cols = 3, vgap = 10, hgap = 20)

   button_list = Array.new(6) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   button_list.each do |button|
     grid_sizer.add_item(button)
   end

   box_sizer.add(grid_sizer)
   set_sizer(box_sizer)
 end

В результаті отримаємо:

Схожого ефекту можна було б досягнути, використовуючи прапорці, які додають рамку(border) навкруги елементу: Wx::TOP, Wx::BOTTOM, Wx::LEFT, Wx::RIGHT і Wx::ALL, але в даному випадку використовувати параметри vgap і hgap зручніше, інакше довелось би для кожної кнопки індивідуально вказувати з якої сторони повинна бути рамка. Крім того, рамка змінила б розміри комірок.

У попередніх приклад ми явно задавали кількість рядків і стовпців таблиці, але ж, знаючи кількість елементів і кількість бажаних стовпців, Wx::GridSizer може сам розраховувати кількість необхідних рядків. Давайте розглянемо як він це буде робити:

  def do_sizer
   box_sizer = Wx::BoxSizer.new(Wx::VERTICAL)
   grid_sizer = Wx::GridSizer.new(cols = 2)

   count = 1

   button_list = Array.new(count) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   button_list.each do |button|
     grid_sizer.add_item(button)
   end

   box_sizer.add(grid_sizer)
   set_sizer(box_sizer)
 end

У цьому прикладі ми будемо змінювати кількість кнопок від 1 до 5, і за допомогою зміни значення змінної count.
count = 1

Нічого цікавого, одна кнопка вона і є одна кнопка.

count = 2

Тепер вже сайзер може зайняти два стовпці, що він і робить. У нас виходить один рядок.

count = 3

У нас з'являється другий рядок, але зверніть увагу на те, що спочатку заповнюється перший стовпчик, а потім другий.

count = 4

Ну і на кінець ми заповнили два стовпчика, і в нас з'явилося два рядки.

сount = 5

Можна і далі збільшувати значення змінної count - кількість рядків буде збільшуватися, але завжди в першу чергу буде повністю заповнюватися спочатку перший стовпчик, а потім другий.

Мабуть, це всі основні особливості класу Wx::GridSizer, давайте перейдемо до розгляду наступного сайзера.

Wx::FlexGridSizer
Wx::FlexGridSizer по поведінці схожий на Wx::GridSizer, він також розміщує елементи керування в комірках таблиці, але, на відміну від Wx::GridSizer у Wx::FlexGridSizer рядки і стовпці можуть розтягуватися, щоб займати весь вільний простір по вертикалі чи горизонталі.

Конструктор класу Wx::FlexGridSizer нічим не відрізняється від конструктора Wx::GridSizer:

Wx::FlexGridSizer.new(Integer rows,  Integer cols,  Integer vgap,
                     Integer hgap)

Wx::FlexGridSizer.new(Integer cols,  Integer vgap = 0,
                     Integer hgap = 0)

Для того щоб скористатися особливостями цього сайзера і встановити, які рядки і стовпці повинні розтягуватись передбачено, відповідно, два методи:

Wx::FlexGridSizer#add_growable_row(Integer idx,  Integer proportion = $0$)

Wx::FlexGridSizer#add_growable_col(Integer idx,  Integer proportion = $0$)

Ці методи приймають 2 параметри:
idx - номер рядка або стовпчика, починаючи з 0-ого, який повинен розтягуватись
proportion - пропорції, які визначають як потрібно розподілити вільне місце між розтяжними рядками і стовпцями. Цей параметр грає ту ж роль, що і однойменний параметр методу add().

Розглянемо цю поведінку на прикладах.
Для початку створимо Wx::FlexGridSizer, який не має розтяжних рядків і стовпців. У цьому випадку всі комірки мають мінімально можливий розмір, навіть не дивлячись на те, що сайзер встановлений як основний для вікна.

  def do_sizer
   grid_sizer = Wx::FlexGridSizer.new(cols = 2)

   count = 4

   button_list = Array.new(count) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   grid_sizer.add_item(button_list[0])
   grid_sizer.add_item(button_list[1])
   grid_sizer.add_item(button_list[2])
   grid_sizer.add_item(button_list[3])

   set_sizer(grid_sizer)
 end

А тепер змінимо приклад так, щоб другий стовпчик був "тягучим".

  def do_sizer
   grid_sizer = Wx::FlexGridSizer.new(cols = 2)
   grid_sizer.add_growable_col(1)

   count = 4

   button_list = Array.new(count) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   grid_sizer.add_item(button_list[0])
   grid_sizer.add_item(button_list[1], :flag => Wx::EXPAND)
   grid_sizer.add_item(button_list[2])
   grid_sizer.add_item(button_list[3], :flag => Wx::ALIGN_RIGHT|Wx::ALIGN_BOTTOM)

   set_sizer(grid_sizer)
 end

У цьому прикладі ми за допомогою виклику методу grid_sizer.add_growable_col(1) вказуємо, що другий стовпчик (перший рахується нульовим) повинен розтягнутися так, щоб зайняти вільне місце. Щоб переконатися у цьому, ми другу кнопку(button_list[1]) розтягуємо на всю комірку за допомогою прапорця Wx::EXPAND, а останню кнопку вирівнюємо по правому краю (Wx::ALIGN_RIGHT) і нижньому краю (Wx::ALIGN_BOTTOM). У даному випадку вирівнювання по нижньому краю нічого не дасть, так як розтягується тільки другий стовпчик, а не рядок, але завдяки цьому ми ще раз переконалися, що вертикальний розмір рядка не змінився.

Тепер розглянемо розтягування рядків.

  def do_sizer
   grid_sizer = Wx::FlexGridSizer.new(cols = 2)
   grid_sizer.add_growable_row(1)

   count = 4

   button_list = Array.new(count) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   grid_sizer.add_item(button_list[0])
   grid_sizer.add_item(button_list[1])
   grid_sizer.add_item(button_list[2], :flag => Wx::EXPAND)
   grid_sizer.add_item(button_list[3], :flag => Wx::ALIGN_RIGHT|Wx::ALIGN_BOTTOM)

   set_sizer(grid_sizer)
 end

У цьому прикладі за допомогою виклику метода grid_sizer.add_growable_row(1) ми вказуємо, що другий рядок повинен розтягуватись. На цей раз розтягуватись на всю комірку буде кнопка button_list[2], а прапорці для button_list[3] залишаться ті самі. І у результаті отримаємо:

Крім того для одного сайзера можна вказати, декілька розтяжних рядків і(або) стовпців. У наступному прикладі ми створимо 6 кнопок, розміщених у два рядки і три стовпці, і вкажемо, що останні два стовпці повинні розтягуватися. Для кнопок, які повинні потрапити у ці два стовпці ми встановимо прапорець Wx::EXPAND, щоб розтягнути їх на всю комірку.

  def do_sizer
   grid_sizer = Wx::FlexGridSizer.new(cols = 3)
   grid_sizer.add_growable_col(1)
   grid_sizer.add_growable_col(2)

   count = 6

   button_list = Array.new(count) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   grid_sizer.add_item(button_list[0])
   grid_sizer.add_item(button_list[1], :flag => Wx::EXPAND)
   grid_sizer.add_item(button_list[2], :flag => Wx::EXPAND)
   grid_sizer.add_item(button_list[3])
   grid_sizer.add_item(button_list[4], :flag => Wx::EXPAND)
   grid_sizer.add_item(button_list[5], :flag => Wx::EXPAND)

   set_sizer(grid_sizer)
 end

В даному випадку розтяжні стовпці поділити порівну доступне їм вільне місце. Щоб змінити співвідношення вільного місця між стовпчиками змінимо значення параметрів proportion. В наступному прикладі співвідношення останніх двох стовпців буде рівне 1:3.

  def do_sizer
   grid_sizer = Wx::FlexGridSizer.new(cols = 3)
   grid_sizer.add_growable_col(1, proportion = 1)
   grid_sizer.add_growable_col(2, proportion = 3)

   count = 6

   button_list = Array.new(count) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   grid_sizer.add_item(button_list[0])
   grid_sizer.add_item(button_list[1], :flag => Wx::EXPAND)
   grid_sizer.add_item(button_list[2], :flag => Wx::EXPAND)
   grid_sizer.add_item(button_list[3])
   grid_sizer.add_item(button_list[4], :flag => Wx::EXPAND)
   grid_sizer.add_item(button_list[5], :flag => Wx::EXPAND)

   set_sizer(grid_sizer)
 end

І останній для цього розділу приклад показує, що на деякі комірки може припадати пересічення розтяжних рядків і стовпців.

  def do_sizer
   grid_sizer = Wx::FlexGridSizer.new(cols = 2)
   grid_sizer.add_growable_col(1)
   grid_sizer.add_growable_row(1)

   count = 4

   button_list = Array.new(count) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   grid_sizer.add_item(button_list[0])
   grid_sizer.add_item(button_list[1])
   grid_sizer.add_item(button_list[2], :flag => Wx::ALIGN_BOTTOM)
   grid_sizer.add_item(button_list[3], :flag => Wx::EXPAND)

   set_sizer(grid_sizer)
 end

В результаті бачимо, остання кнопка, яка опинилася на пересічені розтяжних стовпчика і рядка значно додала у розмірах:

Wx::GridBagSizer
Wx::GridBagSizer, як і два попередніх сайзера розставляє елементи керування в комірках таблиці. Відмінність полягає у тому, що, на відміну від попередніх сайзерів, цей сайзер не розраховує кількість стовпчиків виходячи з кількості рядків, а при додаванні елементу програміст повинен явно вказати у яку комірку він хоче помістити елемент. Крім того один елемент керування може займати відразу декілька комірок. Всі комірки при цьому мають однаковий розмір, а сам сайзер не розтягується на все вікно, його комірки завжди мають мінімально можливий розмір.
Конструктор Wx::GridBagSizer має наступний вигляд:

Wx::GridBagSizer.new(Integer vgap = 0,  Integer hgap = 0)

У ньому ми не можемо задати кількість рядків і стовпців, ми можемо вказати тільки зазори між рядками і стовпцями сайзера.Метод add() цього сайзера теж змінився:

Wx::SizerItem add(Wx::Window window,  GBPosition pos,
             Wx::GBSpan span = DefaultSpan,
             Integer flag = 0,
             Integer border = 0,
             Object userData = nil)

Wx::SizerItem add(Wx::Sizer sizer,  Wx::GBPosition pos,
             Wx::GBSpan span = DefaultSpan,
             Integer flag = 0,
             Integer border = 0,
             Object userData = nil)

Wx::SizerItem add(Integer width,  Integer height,
             Wx::GBPosition pos,
             Wx::GBSpan span = DefaultSpan,
             Integer flag = 0,
             Integer border = 0,
             Object userData = nil)

Wx::SizerItem add(GBSizerItem item)

В ньому додалося два параметри:
pos визначає в яку комірку повинен додаватися елемент. Цей параметр повинен бути екземпляром класу Wx::GBPosition.

Wx::GBPosition.new(Integer row,  Integer col)

span визначає скільки комірок по горизонталі і вертикалі повинен займати елемент, що додається. Цей параметр повинен бути екземпляром класу Wx::GBSpan.

GBSpan.new(Integer rowspan,  Integer colspan)

(1, 1) - значення по замовчуванню, яке означає, що елемент буде займати одну комірку у будь-якому напрямку.

Зауважте, що ми ніде не вказуємо ні загальної кількості рядків, ні загальної кількості стовпчиків. Вони обчислюються виходячи із розташування доданих елементів.
В якості прикладу для початку отримаємо таке розміщення кнопок у вікні:

Ми могли б отримати таке розміщення використовуючи сайзер Wx::GridSizer, якщо б деякі комірки заповнили порожніми місцями (додали б екземпляри класу Wx::Size), але в Wx::GridBagSizer це реалізувати простіше:

  def do_sizer
   grid_sizer = Wx::GridBagSizer.new()

   count = 4

   button_list = Array.new(count) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   grid_sizer.add(button_list[0], pos = Wx::GBPosition.new(0, 1))
   grid_sizer.add(button_list[1], pos = Wx::GBPosition.new(1, 0))
   grid_sizer.add(button_list[2], pos = Wx::GBPosition.new(1, 2))
   grid_sizer.add(button_list[3], pos = Wx::GBPosition.new(2, 1))

   set_sizer(grid_sizer)
 end

При додаванні кнопки в сайзер ми просто вказуємо куди саме її необхідно помістити. На наступному малюнку показане те саме вікно з намальованою таблицею сайзера:

Тепер скористаємося особливостями цього сайзера і зробимо так, щоб кнопки зайняли би не одну, а дві комірки віртуальної таблиці:

Для цього під час додавання нульової і другої кнопки вкажемо скільки комірок вони повинні займати в обох напрямках за допомогою параметра span:

  def do_sizer
   grid_sizer = Wx::GridBagSizer.new()

   count = 4

   button_list = Array.new(count) {|i| Wx::Button.new(self, :label => "Button #{i}")}

   grid_sizer.add(button_list[0], pos = Wx::GBPosition.new(0, 1),
                  span = Wx::GBSpan.new(1, 2),
                  flag = Wx::EXPAND)
   grid_sizer.add(button_list[1], pos = Wx::GBPosition.new(1, 0),
                  span = Wx::GBSpan.new(1, 1),
                  flag = Wx::EXPAND)
   grid_sizer.add(button_list[2], pos = Wx::GBPosition.new(1, 2),
                  span = Wx::GBSpan.new(2, 1),
                  flag = Wx::EXPAND)
   grid_sizer.add(button_list[3], pos = Wx::GBPosition.new(2, 1),
                  span = Wx::GBSpan.new(1, 1),
                  flag = Wx::EXPAND)

   set_sizer(grid_sizer)
 end

Як бачите все доволі просто. У цьому прикладі ми розтягнули всі кнопки (навіть ті, на які цей прапорець не подіє), щоб показати, що кнопки дійсно можуть зайняти не тільки свою, а й сусіді комірки. У цьому прикладі для наочності використовуються параметри span, навіть для тих, що для них залишене значення по замовчуванню.

Для наочності на наступному малюнку те ж саме вікно, але з намальованим сайзером:

Ось ми і розглянули всі існуючі в wxRuby сайзери, а заодно і навчилися ними користуватися.

Основою для написання цієї і попередніх частин(1, 2) стала стаття Сайзеры в wxWidgets / wxPython

На все добре і успіхів.

З Днем програміста!

2009-09-13T00:00:00.002+03:00

irb(main):001:0> require 'date'
=> true
irb(main):002:0> (Date.new(2009) + 255).to_s
=> "2009-09-13"

День програмі́ста — офіційне професійне свято програмістів, яке відзначають у 256-й день року (255-й з нуля). У високосний рік це 12 вересня, а у невисокосний — 13 вересня.
Таку нетрадиційну дату було вибрано через те, що число 256 відповідає кількості чисел, яку можна виразити за допомогою вісімкового байта, це — від 0 до 255 (двійкова система: 11111111), які можна представити за допомогою одного байта, який складається з 8 бітів, котрі в свою чергу можуть мати значення 0 або 1, тобто — 2⁸ випадків. Також 256 у шістнадцятковій системі числення це 100 (0x100). А також це максимальна степінь числа 2, яка менша 356 (днів у році).

Вітаю всіх, хто має відношення!

Keyword: login.vk.com/?act=login

2009-09-12T02:17:00.004+03:00

Судячи з активності, або народ переживає, або щось не так...
Доменне ім’я vk.com віднедавна належить мережі "В контакте". VK на пути к мировому господству. А API нормальне не можуть надати, так то.

wxRuby → Сайзери (2 частина)

2009-09-07T19:43:00.044+03:00

У попередній статті ми познайомилися з позиціонуванням віджетів. А тепер перейдемо до найцікавішого, до огляду сайзерів, які є у бібліотеці wxRuby. І на прикладах побачимо, як впливають на розміщення елементів прапорці з методу Wx::Sizer#add().
У якості прикладу розглянемо код, на основі якого ми будемо експериментувати з сайзерами надалі.

# -*- encoding: utf-8 -*-

require 'wx'

class MainWindow < Wx::Frame
  def initialize
    super(nil, :id => -1, :title => 'Розмір має значення')
    self.size = [300, 200]
    self.do_sizer
    show
  end

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::VERTICAL)
    set_sizer(sizer)
  end
end

class SimpleApp < Wx::App
  def on_init
    MainWindow.new
  end
end

app = SimpleApp.new
app.main_loop()

У цьому прикладі оголошується клас вікна MainWindow, у конструкторі якого викликається метод do_sizer(). Всередині цього методу у майбутніх прикладах відбуватиметься все найцікавіше, в тому сенсі, що у ньому ми і будемо розміщувати елементи керування. Інший код змінюватись не буде, тому в усіх наступних прикладах буде наводитись тільки цей метод.

У даному прикладі цей метод містить створення порожнього сайзера Wx::BoxSizer (без заповнення його елементами керування), і цей сайзер додається у вікно. Запустивши цей приклад, ви побачите порожнє вікно розміром 300x200 пікселів:

Wx::BoxSizer

Wx::BoxSizer є найпростішим сайзером, який дозволяє розміщувати елементи вздовж однієї лінії - по вертикалі або по горизонталі. Конструктор класу Wx::BoxSizer приймає один параметр, який вказує як потрібно розміщувати елементи: по вертикалі чи по горизонталі. Відповідно параметр orient може приймати два значення: Wx::HORIZONTAL або Wx::VERTICAL. Підкласи Wx::HBoxSizer і Wx::VBoxSizer є посиланнями для створення горизонтального і вертикального Wx::BoxSizer, відповідно. Наступні рядки еквівалентні:

Wx::BoxSizer.new(Wx::HORIZONTAL)

Wx::HBoxSizer.new

Якщо orient = Wx::HORIZONTAL, то сайзер можна уявити у вигляді книжної полиці, розділеної по горизонталі на комірки, всередині яких розміщені елементи керування. При чому розмір кожної комірки рівний ширині елемента, який міститься всередині з урахуванням рамки(border). Якщо при цьому сайзер використовується як основний для вікна(встановлений за допомогою методу set_sizer()), то по вертикалі "полиця" буде займати все батьківське вікно. Якщо сайзер буде знаходитись всередині іншого сайзера (і не буде розтягуватись за допомогою прапорця Wx::EXPAND), то в цьому випадку його розмір по вертикалі буде обмежений елементом з найбільшою висотою.

Якщо orient = Wx::VERTICAL, то сайзер можна уявити у вигляді книжкової шафки, розділеної на горизонтальні полиці. Тепер вже висота кожної "полиці" рівна розміру, розміщеного у ній елемента (разом із рамкою). Якщо сайзер використовується як основний для вікна, то по горизонталі "шафка" займатиме всю ширину вікна. Інакше її ширина дорівнюватиме ширині найширшого елемента керування.
Розглянемо приклади:

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    sizer.add(button1)
    sizer.add(button2)

    set_sizer(sizer)
  end

У цьому прикладі ми створюємо вертикальний Wx::BoxSizer і додаємо у нього дві кнопки(button1 і button2). Для всіх параметрів використовуємо значення до замовчуванню. Результат розміщення кнопок:

Як ми і очікували, кнопки розмістилися по вертикалі одна під одною. Для кращого розуміння роботи сайзера на наступному малюнку червоним прямокутником намальовані комірки сайзера. Підкреслю, що "фізично", ніяких поличок і комірок у вигляді будь-яких панелей не існує, але така абстракція допоможе легше зрозуміти роботу сайзерів.

Як бачите, полиці сайзера зайняли все вікно по горизонталі, і справа є ще вільне місце, яке утворилося завдяки тому, що сайзер є основним для вікна і він намагається зайняти по можливості якомога більше місця. Щоб переконатися у цьому, вирівняємо першу кнопку по правому краю. Для цього будемо використовувати прапорець Wx::ALIGN_RIGHT при додаванні button1.
Зараз ми познайомимося з методом Wx::Sizer#add_item(), який є практично ідентичним до Wx::Sizer#add(), але, на відміну від свого брата, додаткові параметри можуть бути визначеними за допомогою ключових слів у будь-якому порядку, наприклад:

sizer.add_item(an_item, :index => 1, :proportion => 1, :flag => Wx::EXPAND)

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    sizer.add_item(button1, :flag => Wx::ALIGN_RIGHT)
    sizer.add_item(button2)

    set_sizer(sizer)
  end

В результаті виконання скрипта ми побачимо наступне вікно:

Або те саме з намальованим сайзером:

Тепер подивимось, як поводить себе горизонтальний сайзер. Запустимо скрипт з наступним методом, що встановлює розташування елементів керування:

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::HORIZONTAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    sizer.add_item(button1)
    sizer.add_item(button2)

    set_sizer(sizer)
  end

У результаті отримаємо таке розміщення кнопок:

І те саме з намальованим сайзером:

Щоб знову ж таки переконатися, що сайзер займає по вертикалі весь розмір вікна, вирівняємо першу кнопку по нижньому краю за допомогою прапорця Wx::ALIGN_BOTTOM:

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::HORIZONTAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    sizer.add_item(button1)
    sizer.add_item(button2, :flag => Wx::ALIGN_BOTTOM)

    set_sizer(sizer)
  end

Результат виконання скрипта (відразу з намальованим сайзером):

Розглянемо відступи навколо елементу. Оточимо другу кнопку межею розміром у 8 пікселів з усіх сторін, а параметр border буде рівний 8:

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::HORIZONTAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    sizer.add_item(button1)
    sizer.add_item(button2, :border => 8, :flag => Wx::ALL)

    set_sizer(sizer)
  end

Результат виконання скрипта:

І те ж вікно з намальованим сайзером:

А тепер розглянемо приклади, коли всередину одного сайзера додається інший. Для початку розглянемо, як зміниться поведінка сайзера, якщо він буде вкладеним у інший сайзер. Змінимо вищезгаданий приклад з вертикальним сайзером, таким чином, щоб кнопки додавалися не у головний сайзер, а у дочірній, який теж буде вертикальним:

  def do_sizer
    parent_sizer  = Wx::BoxSizer.new(Wx::VERTICAL)
    child_sizer = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    child_sizer.add_item(button1, :flag => Wx::ALIGN_RIGHT)
    child_sizer.add_item(button2)

    parent_sizer.add(child_sizer)

    set_sizer(parent_sizer)
  end

У цьому прикладі для змінної parent_sizer ми використовуємо метод add(), який приймає не елемент керування, а інший сайзер. В результаті виконання скрипта ми побачимо, що не дивлячись на те, що першу кнопку ми вирівнюємо по правому краю. Вона залишається зліва, так як, на відміну від головного сайзера, дочірній не розтягується на всю ширину вікна.

На наступному малюнку батьківський сайзер намальований червоним кольором, а дочірній - синім:

Щоб дочірній сайзер по розмірах співпадав з головним, достатньо його розтягнути, вказавши прапорець Wx::EXPAND:

  def do_sizer
    parent_sizer  = Wx::BoxSizer.new(Wx::VERTICAL)
    child_sizer = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    child_sizer.add_item(button1, :flag => Wx::ALIGN_RIGHT)
    child_sizer.add_item(button2)

    parent_sizer.add(child_sizer)

    set_sizer(parent_sizer)
  end

В результаті ми побачимо вже знайоме нам розміщення кнопок у вікні:

Цікавим може виявитися приклад, який показує, що вкладений сайзер по поведінці нічим не відрізняється від вкладеного елементу керування. У наступному прикладі вкладений сайзер вирівнюється по правому краю разом з усіма кнопками, які він містить:

  def do_sizer
    parent_sizer  = Wx::BoxSizer.new(Wx::VERTICAL)
    child_sizer = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    child_sizer.add_item(button1)
    child_sizer.add_item(button2)

    parent_sizer.add_item(child_sizer, :flag => Wx::ALIGN_RIGHT)

    set_sizer(parent_sizer)
  end

Результат виконання скрипта:

І те ж вікно з намальованими сайзерами:

У наступному прикладі чотири кнопки розташовуються в два рядки і в два стовпці:

  def do_sizer
    vert_sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    hor1_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
    hor2_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)

    vert_sizer.add(hor1_sizer)
    vert_sizer.add(hor2_sizer)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')
    button3 = Wx::Button.new(self, :label => 'Button 3')
    button4 = Wx::Button.new(self, :label => 'Button 4')

    hor1_sizer.add(button1)
    hor1_sizer.add(button2)
    
    hor2_sizer.add(button3)
    hor2_sizer.add(button4)

    set_sizer(vert_sizer)
  end

Тут структура трохи складніша. По-перше, ми створюємо головний вертикальний сайзер, який буде прив'язаний до вікна і, відповідно, розтягнутий на всю ширину вікна (тому що сайзер вертикальний). В коді він називається vert_sizer. Він у нас буде відігравати роль горизонтальних полиць, на кожній з яких може розташовуватись тільки один елемент. Цим елементом у нас буде інший сайзер, вже горизонтальний. На першу полицю ми покладемо сайзер hor1_sizer, а на другу - hor2_sizer. Ці горизонтальні сайзери будуть містити в собі кнопки, кожен сайзер по дві кнопки. hor1_sizer містить кнопки button1 і button2, а hor2_sizer - button3 і button4.
Результат виконання скрипта:

Те ж вікно із намальованими сайзерами:

Тут червоним кольором намальований вертикальний сайзер vert_sizer, а синім і зеленим - горизонтальні сайзери, відповідно, hor1_sizer і hor2_sizer.
Як видно з малюнка, вертикальний червоний сайзер займає всю ширину вікна, але кожна його комірка прагне зайняти якомога менше місця по вертикалі (при умові, що параметр proportion методу add() рівний 0). Саме цим розміром і обмежується вертикальний розмір вкладених сайзерів, які, навпаки, намагаються по можливості зменшити свої горизонтальні розміри (при тій же умові), але зайняти якомога більше місця по вертикалі.

А тепер розглянемо простий приклад, який показує як одні комірки впливають на розміри інших комірок того ж сайзера.
Змінимо попередній приклад і додамо навколо другої кнопки відступи:

  def do_sizer
    vert_sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    hor1_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
    hor2_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)

    vert_sizer.add(hor1_sizer)
    vert_sizer.add(hor2_sizer)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')
    button3 = Wx::Button.new(self, :label => 'Button 3')
    button4 = Wx::Button.new(self, :label => 'Button 4')

    hor1_sizer.add(button1)
    hor1_sizer.add_item(button2, :flag => Wx::ALL, :border => 8)
    
    hor2_sizer.add(button3)
    hor2_sizer.add(button4)

    set_sizer(vert_sizer)
  end

Результат виконання скрипта виглядає наступним чином:

І те ж саме з намальованими сайзерами:

Як видно з малюнку, кнопка "Button 2" збільшила висоту і першої комірки сайзера hor1_sizer. Тобто, в горизонтального сайзера Wx::BoxSizer всі комірки мають однакову висоту. Аналогічний експеримент можна провести з вертикальним сайзером, у нього всі комірки будуть мати однакову ширину.

Наступний приклад буде показувати використання прапорця Wx::EXPAND, який, нагадаю, вказує, що елемент керування повинен займати все вдоступне місце у комірці. Заодно цей приклад допоможе нам переконатися, що розмір першої комірки hor1_sizer дійсно займає все вільне місце. Отже, виправимо трохи попередній приклад:

  def do_sizer
    vert_sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    hor1_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
    hor2_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)

    vert_sizer.add(hor1_sizer)
    vert_sizer.add(hor2_sizer)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')
    button3 = Wx::Button.new(self, :label => 'Button 3')
    button4 = Wx::Button.new(self, :label => 'Button 4')

    hor1_sizer.add_item(button1, :flag => Wx::EXPAND)
    hor1_sizer.add_item(button2, :flag => Wx::ALL, :border => 8)
    
    hor2_sizer.add(button3)
    hor2_sizer.add(button4)

    set_sizer(vert_sizer)
  end

Після запуску скрипта ми побачимо наступне розміщення кнопок у вікні:

І те ж вікно з намальованими сайзерами:

Як ми і очікували кнопка "Button 1" розтягнулася на всю комірку.

Повернемося до методу add() класу Wx::Sizer. Як ви пам'ятаєте, він має один необов'язковий параметр proportion, який визначає у яких співвідношеннях елементи керування одного сайзеру повинні займати вільне місце.
До цього усюди ми неявно використовували значення, прийняте по замовчуванню, тобто proportion = 0. У цьому випадку вертикальний сайзер намагається якомога більше зменшити висоту своїх комірок. Якщо значення параметру proportion відмінне від 0, то поведінка сайзера різко змінюється. В цьому випадку вертикальний сайзер буде займати все вільне місце по вертикалі, а висота кожної комірки буде розраховуватись виходячи з відповідних значень параметра proportion.

Розглянемо приклад з однією кнопкою:

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')

    sizer.add_item(button1, :proportion => 1)

    set_sizer(sizer)
  end

Розміщення елементів у вікні виглядає наступним чином:

Тепер єдина комірка сайзера у цьому випадку займає все вікно:

По горизонталі вона займає все вікно, тому що вертикальний сайзер намагається зайняти якомога більше місця по ширині, а по вертикалі - тому що значення параметра proportion відмінне від нуля.

А тепер додамо у той же вертикальний сайзер другу кнопку також із значенням параметра proportion = 1 :

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    sizer.add_item(button1, :proportion => 1)
    sizer.add_item(button2, :proportion => 1)

    set_sizer(sizer)
  end

Вікно з таким розміщенням кнопок буде виглядати наступним чином:

Якщо змінити розміри вікна, то висота кнопок збільшиться на однакову кількість пікселів:

Тобто співвідношення між висотами кнопок завжди рівне 1:1, у відповідності з значеннями параметрів proportion.
Змінимо попередній приклад таким чином, щоб висота верхньої кнопки завжди була вдвічі більша нижньої. Для цього встановимо значення proportion першої кнопки рівне 2:

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    sizer.add_item(button1, :proportion => 2)
    sizer.add_item(button2, :proportion => 1)

    set_sizer(sizer)
  end

У результаті отримаємо:

Нам залишилося розглянути ще два прапорці, які ми не використовували до цього. Один з них це Wx::SHAPED, який вказує, що при зміні розмірів елемент повинен зберігати вихідні співвідношення сторін. Напишемо код для вікна з двома кнопками, одна з яких буде додана в сайзер із використанням прапорця Wx::SHAPED. Крім цього ми будемо використовувати значення параметру proportion = 1, щоб розмір кнопок змінювався при зміні розмірів вікна.

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')

    sizer.add_item(button1, :proportion => 1)
    sizer.add_item(button2, :proportion => 1, :flag => Wx::SHAPED)

    set_sizer(sizer)
  end

Результат виконання скрипта:

Якщо змінити розмір вікна, то друга кнопка зменшить не тільки свою висоту, але й ширину, щоб відношення сторін залишилось попереднім:

І коротко розглянемо прапорець Wx::FIXER_MINSIZE. Цей прапорець має специфічне призначення. При використанні цього прапорця сайзер не буде враховувати мінімальний розмір елементу, який задається за допомогою методу set_min_size(), а буде використовувати мінімальний розмір, встановлений для деяких елементів.
Нехай у нас є кнопка, для якої встановлений мінімальний розмір 200х35:

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button1.set_min_size([200, 35])

    sizer.add_item(button1)

    set_sizer(sizer)
  end

Тоді ми побачимо наступне розміщення елементів:

Встановивши прапорець Wx::FIXED_MINSIZE, кнопка змінить розмір до звичних значень:

  def do_sizer
    sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button1.set_min_size([200, 35])

    sizer.add_item(button1, :flag => Wx::FIXED_MINSIZE)

    set_sizer(sizer)
  end

Ми розглянули як в комірки сайзера можна додавати елементи керування та інші сайзери. Залишилось розглянути, як додавати порожні комірки. Достатньо у якості перших двох параметрів методу add() передати ширину і висоту, тобто розміри невидимого елементу керування, розмір якого і буде визначати розміри комірки. Розглянемо приклад:

  def do_sizer
    vert_sizer  = Wx::BoxSizer.new(Wx::VERTICAL)

    hor1_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)
    hor2_sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)

    vert_sizer.add(hor1_sizer)
    vert_sizer.add(10, 100)
    vert_sizer.add(hor2_sizer)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')
    button3 = Wx::Button.new(self, :label => 'Button 3')
    button4 = Wx::Button.new(self, :label => 'Button 4')

    hor1_sizer.add(button1)
    hor1_sizer.add(100, 10)
    hor1_sizer.add(button2)
    
    hor2_sizer.add(button3)
    hor2_sizer.add(100, 10)
    hor2_sizer.add(button4)

    set_sizer(vert_sizer)
  end

Тут між рядками вертикального сайзера, який містить кнопки, ми додаємо порожній рядок, розмір якого задається шириною і висотою у пікселях. В нашому випадку горизонтальний розмір не впливає, так як він менший ширини вікна. А ось вертикальний розмір розсуне полиці з кнопками на 100 пікселів. Аналогічно між комірками горизонтального сайзера додане порожнє місце 100х10, яке розсуне по горизонталі кнопки, але в нашому випадку не буде впливати на вертикальний розмір, так як розмір 10 пікселів буде меншим, ніж вертикальний розмір кнопок. Вікна з таким розміщенням елементів керування виглядає наступним чином:

І той же малюнок з намальованими сайзерами:

Крім того в класі Wx::Sizer є допоміжний метод add_spacer(), який дозволяє спростити додавання порожніх комірок, у яких ширина рівна висоті.

add_spacer(Integer size)

В якості параметра задається сторона квадрата. Наступні два рядки рівносильні:

sizer.add(20, 20)

sizer.add_spacer(20)

Також ви можете вставити порожній простір між елементами (наприклад між двома кнопками) за допомогою методу add_stretch_spacer(), і змусити цей простір розтягуватись за допомогою параметру proportion. У результаті ліва кнопка буде притиснена до лівої стінки сайзера, а права - до правої, а простір між ними буде тягучим під час зміни розмірів вікна.

  def do_sizer
    sizer = Wx::BoxSizer.new(Wx::HORIZONTAL)

    button1 = Wx::Button.new(self, :label => 'Button 1')
    button2 = Wx::Button.new(self, :label => 'Button 2')
    button3 = Wx::Button.new(self, :label => 'Button 3')

    sizer.add(button1)
    sizer.add_stretch_spacer
    sizer.add(button2)
    sizer.add(button3)
    
    set_sizer(sizer)
  end

Результат виконання скрипта:

І той же малюнок із намальованим сайзером:

Якщо змінити розмір вікна, то перша кнопка залишиться притисненою до лівого краю, а друга і третя - до правого:

Ось ми і розглянули всі можливі прапорці і параметри, які використовуються для додавання елементів у сайзер. Заодно і познайомилися з сайзером Wx::BoxSizer. У наступній статті ми оглянемо інші сайзерами, які є у wxRuby.

На все добре і успіхів.

wxRuby → Сайзери (1 частина)

2009-09-05T14:29:00.015+03:00

Під час створення графічного інтерфейсу, вам потрібно займатися розміщенням елементів на формі. Наприклад, вам може знадобитись текстове поле і кнопка справа під ним. Ви можете розмістити ці елементи керування(Wx::TextCrt і Wx::Button), чітко вказавши позицію і розміри у пікселях. Ймовірно це не найкраща ідея, але ви можете зробити це у будь-якому випадку:

# -*- encoding: utf-8 -*-

require 'wx'

class HelloFrame < Wx::Frame
  def initialize
    super(nil, :id => -1, :title => 'Hello World!', :size => [200, 200])
    text = Wx::TextCtrl.new(self, :id => -1,
                                  :text => 'Type in here',
                                  :pos => [0, 0],
                                  :size => [200, 175],
                                  :style => Wx::TE_MULTILINE)
    button = Wx::Button.new(self, :id => -1,
                                  :label => 'Press me',
                                  :pos => [100, 175],
                                  :size => [100, 25])

    show
  end

end

class HelloApp < Wx::App
  def on_init
    HelloFrame.new
  end
end

app = HelloApp.new
app.main_loop()

Результат виконання скрипта:

Чому це погана ідея? Спробуйте збільшити і зменшити розміри вікна. Елементи залишаються на своїх місцях.

wxWidgets використовує інший підхід до розміщення елементів на формі. Елементи розміщуються не лише по відношенню до верхнього лівого кута. Їхній розмір також задається по відношенню до висоти і ширини.
Тобто, повертаючись до прикладу із статті Welcome to wxRuby!, ми помістили у вікно лише одну кнопку, по замовчуванню вона має висоту і ширину рівну, відповідно, висоті і ширині вікна.

Замість організації віджетів, використовуючи точні розміри і позиції, можна використовувати так звані сайзери, тобто класи похідні від Wx::Sizer. Саме сайзери визначають поведінку дочірніх елементів при зміні розмірів головного вікна. На мою думку, сайзери є найбільш складною для освоєння частиною бібліотеки wxRuby. І саме сайзерам буде присвячена ця стаття.

Загальні відомості про сайзери.

Для того щоб краще зрозуміти, як користуватися сайзерами, їх найкраще уявити собі у вигляді книжкових полиць або шафок, розділених на секції. Всередині кожної секції може розміщуватися тільки один елемент. Ці елементи ви можете пересунути до лівої стінки полиці, так щоб справа залишилось вільне місце, або навпаки до правої. На відміну від книжок, елемент керування ви можете приклеїти до стелі, або примусити висіти по центру. На відміну від справжніх меблів, ці полички та шафки можуть розтягувати книжки, щоб вони займали все вільне місце.
Для початку розглянемо клас Wx::Sizer, який є базовим для всіх сайзерів. При створені інтерфейсу будуть використовуватись похідні від Wx::Sizer класи. Ви не можете безпосередньо використовувати Wx::Sizer. Замість цього використовуєте один із похідних від нього класів. На даний час це:

Wx::BoxSizer

Wx::StaticBoxSizer

Wx::GridSizer

Wx::FlexGridSizer

Wx::GridBagSizer

Варто пам'ятати, сайзери не є вікнами, тобто елементами керування, а тільки вміють змінювати розміщення і розміри своїх "підопічних" елементів.
Клас Wx::Sizer містить доволі багато методів, але нас в першу чергу цікавить тільки один - метод add(), за допомогою якого можна додати один елемент в "шафку". Слід зазначити, що всередині сайзеру замість елементу керування можна помістити інший сайзер. Завдяки цьому ми можемо розбити кожну "полицю" на декілька комірок.

Розглянемо параметри методу add()

Wx::SizerItem#add(Wx::Window window,
                Integer proportion = 0,
                Integer flag = 0,
                Integer border = 0
                Object user_data = nil)

item. У якості першого параметру можуть виступати 3 види об'єктів:

Елементи керування, а точніше вікна, похідні від класу Wx::Window

Інші сайзери, тобто класи, похідні від Wx::Sizer

Екземпляр класу Wx::Size(не плутати з Wx::Sizer), який представляє собою клас обгортку над двома числовими значеннями - шириною і висотою. Якщо в метод add() передати екземпляр класу Wx::Size, то замість елементу керування в комірку сайзера буде додане порожнє місце заданого розміру.

proportion. Цей параметр може використовуватись класом Wx::BoxSizer, про який ми поговоримо пізніше. При використанні цього параметру можна визначити як будуть змінюватись розміри елементів при зміні їх батьківського вікна. Якщо він рівний 0(значення по замовчуванню), то елемент буде займати мінімальний розмір. Якщо сайзер містить декілька елементів з однаковими значеннями proportion, то при зміні розмірів батьківського вікна, елементи будуть змінювати свої розміри таким чином, щоб мати однакові розміри відносно однієї із осей(яка це вісь, горизонтальна чи вертикальна, залежатиме від орієнтації сайзера). Якщо елементи будуть мати різні значення proportion, то їх розміри вздовж вісі будуть пропорційні значенням proportion.
flag. Це, мабуть, самий важливий параметр, який більше всіх визначає розміщення і розміри елементів керування. Є цілочисловим значенням, яке складається із набору констант. Всі ці константи умовно можна розділили на 3 групи:

Прапорці, які задають невидиму рамку навколо елементів керування.

Прапорці, які задають вирівнювання елементів керування.

Прапорці, які задають поведінку при зміні розмірів батьківського вікна.

До першої групи належать:

Wx::TOP

Wx::BOTTOM

Wx::LEFT

Wx::RIGHT

Wx::ALL

Вони задають з якої сторони від елементу керування буде невидима рамка: зверху, знизу, зліва, справа чи з усіх сторін відповідно. Рамка представляє собою порожнє місце, розмір якого задається у наступному параметрі методу add(). Якщо ми, наприклад, хочемо щоб зліва і справа від елементу було залишене порожнє місце, то прапорець повинен мати наступний вигляд:
Wx::LEFT | Wx::RIGHT

До прапорців, що задають вирівнювання елементів керування належать:

Wx::ALIGN_CENTER

Wx::ALIGN_LEFT

Wx::ALIGN_RIGHT

Wx::ALIGN_TOP

Wx::ALIGN_BOTTOM

Wx::ALIGN_CENTER_VERTICAL

Wx::ALIGN_CENTER_HORIZONTAL

Ці прапорці позначають відповідно, що елемент керування буде "приклеєний" до центру, до лівої або правої стінки, до верху або низу комірки. Останні два прапорці дають можливість зазначити, що вирівнювання по центру потрібно робити тільки по вертикалі або тільки по горизонталі, у той час як Wx::ALIGN_CENTER означає, що вирівнювання по центру буде проводитися по обох осях.

Крім того є ще три прапорці, які впливають не на розміщення, а на розмір елементів.

Wx::EXPAND позначає, що елемент повинен займати всю комірку сайзера на скільки він зможе розтягнутися.

Wx::SHAPED позначає, що елемент знову ж таки повинен зайняти по можливості всю комірку, але при цьому він повинен зберігати вихідні пропорції між його довжиною і шириною.

Wx::FIXED_MINSIZE означає, що при зміні розмірів елементу, не буде враховуватися мінімально можливий розмір, тобто елемент може бути меншим заданого мінімального розміру.

А тепер перейдемо до огляду інших параметрів методу add()
border. Цей параметр визначає розміри рамки у пікселях. Таким чином цей параметр необхідний у тому випадку, якщо використовуються прапорці з першої групи.
user_data. Представляє собою дані користувача, які можуть прикріплятися до елемента, щоб більш точно визначати розташування елементу. Наразі wxRuby не підтримує цей параметр.

Встановлення сайзера для вікна.
Припустимо, ми створили сайзер, заповнили його елементами керування або іншими сайзерами. Тепер головному вікну потрібно вказати, що створений сайзер потрібно використовувати для розміщення елементів.
Для цього у класу Wx::Window є метод set_sizer():

Wx::Window#set_sizer(Wx::Sizer sizer, Boolean delete_old = true)

Перший параметр представляє собою екземпляр сайзера.
Другий параметр delete_old позначає, що попередній сайзер, встановлений для вікна повинен бути знищеним. Значення по замовчуванню true.

Варто пам'ятати, що вікно буде розтягувати сайзер на всю доступну область, що нагадує використання прапорця Wx::EXPAND.

Отже, загальний алгоритм роботи з сайзерами складається з наступних етапів:

Створити екземпляр вікна - батька для елементів керування

Після створення вікна створити екземпляр одного із класів похідних від Wx::Sizer. Це буде головний для вікна сайзер.

Заповнити головний сайзер елементами керування або іншими сайзерами.

Приєднати головний сайзер до вікна за допомогою методу Wx::Window#set_sizer()

У якості прикладу створимо вікно з текстовим полем і однією кнопкою справа під ним. Але на відміну від прикладу, який наводився на початку статті, для позиціонування будемо використовувати сайзер Wx::BoxSizer.

# -*- encoding: utf-8 -*-

require 'wx'

class HelloFrame < Wx::Frame
 def initialize
   super(nil, :id => -1,:title => 'Hello World!', :size => [200, 200])
   sizer = Wx::BoxSizer.new(Wx::VERTICAL)
   text = Wx::TextCtrl.new(self, :id => -1,
                                 :text => 'Type in here',
                                 :pos => Wx::DEFAULT_POSITION,
                                 :size => Wx::DEFAULT_SIZE,
                                 :style => Wx::TE_MULTILINE)
   button = Wx::Button.new(self, :id => -1,
                                 :label => 'Press me')

   sizer.add(text, 1, Wx::GROW|Wx::ALL, 2)
   sizer.add(button, 0, Wx::ALIGN_RIGHT, 2)
   set_sizer(sizer)
  
   show
 end
end

class HelloApp < Wx::App
 def on_init
   HelloFrame.new
 end
end

app = HelloApp.new
app.main_loop()

Запустіть цей приклад і спробуйте змінити розміри вікна.

У наступній статті ми детальніше розглянемо сайзери, які існують в бібліотеці wxRuby і на прикладах побачимо як впливають на розміщення елементів всі прапорці з методу Wx::Sizer#add().

На все добре і успіхів.

wxRuby → Вікно

2009-09-03T21:21:00.009+03:00

У статті Welcome to wxRuby! ми познайомилися з бібліотекою віджетів wxWidgets та обгорткою для роботи з Ruby. Також ми створили простий додаток на wxRuby, який показує вікно з однією кнопкою.

Розглянемо докладніше цей код.
У класі HelloApp є метод on_init(), який викликається під час запуску додатку.
Займемося головним вікном. За створення вікна відповідає конструктор класу Wx::Frame. Фрейм - це вікно, розмір і позиція якого можуть бути змінені користувачем. Зазвичай воно має рамку і заголовок, а також опціонально може містити рядок меню, панель інструментів і рядок стану(про які ми поговоримо в одній із майбутніх статей).

Конструктор класу Wx::Frame приймає 7 параметрів:
:parent => (Wx::Window) - це посилання на батьківський об'єкт(обов'язковий параметр)
:id => (Fixnum) - ідентифікатор вікна. -1 - значення по замовчуванню
:title => (String) - заголовок вікна
:pos => (Wxruby2::Point) - позиція вікна на екрані
:size => (Wxruby2::Size) - розмір вікна
:style => (Fixnum) - стиль вікна
:name => (String) - назва вікна

Змінимо код додатку з першої частини так, щоб наше вікно з'явилося у верхньому лівому куті і мало розмір 320х240 пікселів. Зміни вносимо у метод initialize() класу HelloFrame:

super(nil, :id => -1, :title => 'Hello World!', :pos => [0, 0], :size => [320, 240], :style => Wx::DEFAULT_FRAME_STYLE, :name => 'frame')

Щоб вікно з'явилося у центрі екрану можна скористатися методом centre():

self.centre

Для зміни позиції вікна після ініціалізації можна скористатись методам move(Wx::Point point):

self.move([100, 100])

Для зміни розміру вікна є метод set_size(Wx::Size size):

self.set_size([640, 480])

Для вікна можна задати один із стилів:
Wx::DEFAULT_FRAME_SLYLE - стиль по замовчуванню. Включає в себе Wx::MINIMIZE_BOX|Wx::MAXIMIZE_BOX|Wx::RESIZE_BORDER|Wx::SYSTEM_MENU|Wx::CAPTION|Wx::CLOSE_BOX|Wx::CLIP_CHILDREN
Wx::ICONIZE - показувати мінімізоване вікно. Тільки Windows
Wx::CAPTION - показувати заголовок вікна
Wx::MINIMIZE - аналогічно Wx::ICONIZE
Wx::MINIMIZE_BOX - показувати кнопку згортання вікна
Wx::MAXIMIZE - показувати максимізоване вікно. Тільки Windows
Wx::MAXIMIZE_BOX - показувати кнопку розгортання вікна на весь екран
Wx::CLOSE_BOX - показувати кнопку закриття вікна
Wx::STAY_ON_TOP - показувати поверх всіх вікон
Wx::SYSTEM_MENU - вікно буде мати системне меню
Wx::RESIZE_BORDER - показувати рамку для зміни розміру вікна.
Wx::FRAME_TOOL_WINDOW - вікно з рамкою невеликого розміру, і також вікно не буде показуватися на панелі задач. Тільки Windows і GTK+
Wx::FRAME_NO_TASKBAR - нормальне вікно, але воно не буде показуватися на панелі задач. Тільки Windows і GTK+
Wx::FRAME_FLOAT_ON_PARENT - вікно буде показуватися тільки поверх батьківського вікна (на відміну від Wx::STAY_ON_TOP)

Для того щоб створити вікно, розмір якого не може змінювати користувач, можна використати таку комбінацію стилів:
Wx::DEFAULT_FRAME_STYLE & ~ (Wx::RESIZE_BORDER|Wx::RESIZE_BOX|Wx::MAXIMIZE_BOX)

Тепер ви можете поекспериментувати із розміром, позицією і стилями вікна.
Стаття вийшла доволі коротка, і ми тут не розглянули всі нюанси роботи з вікнами. Виправлю цей недолік у майбутніх статтях.
На домашнє завдання така задачка: у випадку натиснення на кнопку пересунути вікно у позицію [10, 10].

На все добре і успіхів.

wxRuby → Welcome to wxRuby!

2009-09-01T13:07:00.009+03:00

Цим записом я розпочну серію статей присвячену основам створення графічних додатків за допомогою бібліотеки wxWidgets на мові Ruby.

wxWidgets(раніше відома як wxWindows) — це крос-платформена бібліотека інструментів з відкритим вихідним кодом для побудови графічного інтерфейсу користувача(GUI).
wxWidgets розповсюджується під ліцензією LGPL. Проект був запущений в 1992 Юіаном Смартом (Julian Smart), який до сих пір залишається головним розробником. У 2004 році проект wxWidgets на прохання Microsoft Corporation змінив оригінальну назву "wxWindows" на "wxWidgets", за що отримав фінансову допомогу.
wxWidgets дозволяє створювати додатки для багатьох комп'ютерних платформ із мінімальними змінами у вихідному коді, або взагалі без них. Вона підтримує системи Microsoft Windows, Apple Macintosh, UNIX-подібні(для X11, Motif і GTK+), OpenVMS і OS/2. WxWidgets не імітує вигляд компонентів, використовуючи графічні примітиви різних підтримуваних платформ. Натомість wxWidgets надає тонку абстракцію до існуючих компонентів системи.
Бібліотека розроблена на C++, але може бути підключеною до багатьох інших розповсюджених мов, таких як Ruby, Python, Perl, Java, C#/.NET та інших.

wxRuby - це обгортка бібліотеки wxWidgets для роботи з Ruby. Вона однаково добре працює на Windows, Linux, Mac OS X, і з Ruby версіями 1.8 та 1.9.

Інсталяція wxRuby2
Є два методи інсталяції wxRuby2:

Використовуючи Rubygems для встановлення бінарного gem-у(без залежностей)

Із вихідних кодів

Для більшості людей на більшості операційних систем перший метод є зручнішим і швидшим. Для цього достатньо у командному рядку виконати:

gem install wxruby

Слід зазначити, що при написанні власних додатків використовуючи wxRuby, встановлену із gem-ів, ви повинні попередньо завантажити(не обов'язково для ruby >= 1.9 ) бібліотеку rubygems. Це можна зробити кількома способами:

Запустити ruby з аргументом -rubygems. Наприклад: ruby -rubygems my_wxruby_script.rb

Встановити RUBYOPT змінну оточення як -rubygems

Додати на початку програми рядок require 'rubygems'

Розпочнемо з просто прикладу. Покажемо вікно з кнопкою "Press me", при натисканні на яку відобразиться діалогове повідомлення.

# -*- encoding: utf-8 -*-

# Підключаємо бібліотеку wxruby2 
require 'wx'

# Створюємо свій клас спадкоємець Wx::Frame з усіма потрібними нам елементами, а потім використовуємо його.
class HelloFrame < Wx::Frame
  def initialize
    super(nil, :title => 'Hello World!')
    button = Wx::Button.new(self, :label => 'Press me') # Створюємо кнопку. За допомогою посилання self вона сама себе додасть у фрейм
    
    evt_button(button.get_id, :bt_evt) # У випадку натиснення викликаємо bt_evt()
    show # показуємо вікно
  end

  def bt_evt
    Wx::MessageDialog.new(self, "Hello world!", "Test", Wx::OK).show_modal # створюємо діалог з однією кнопкою OK і відображаємо його за допомогою show_modal()
  end
end

class HelloApp < Wx::App
  def on_init
    HelloFrame.new # створюємо екземпляр нашого класу
  end
end

app = HelloApp.new
app.main_loop() # Запускаємо головний цикл Wx. З цього моменту програма очікує на різні події.

У результаті будемо мати таке віконечко:

В даний час API представляє собою прямий порт wxWidgets C++ інтерфейсу. Місцями цей інтерфейс є трохи аляповий, завдяки своїй довгій історії. В майбутньому розробники планують додати Ruby-специфічний шар поверх базового Wx API, аналогічно тому як це зроблено у FXRuby для Fox. Це розширене API буде простіше у використанні і орієнтуватиметься на Ruby-стиль. Крім того розробники створили підпроект wxSugar(який може використовуватись поверх wxRuby) у якості випробувального полігону для покращень синтаксису.

У гем пакеті wxRuby є досить багато прикладів роботи з різноманітними віджетами, тому цього цілком вистачить, для демонстрації можливостей Ruby + wxWidgets.
У мене це /opt/lib/ruby/gems/1.9.1/gems/wxruby-ruby19-2.0.0-x86-linux/samples

Посилання:
http://wxruby.rubyforge.org
http://www.wxwidgets.org/
http://ru.wikipedia.org/wiki/WxWidgets

Quake Live for Linux

2009-08-19T02:53:00.002+03:00

Те, що так довго очікувалося, нарешті збулося! Хай гримлять литаври і б’ють в барабани, хай нічні феєрверки не згасають цілу ніч, а вдень падають на землю важким дощем.Збулось!

Twitter доставив приємну звісточку:

QUAKE LIVE is back online, now with Mac & Linux support! Read more at www.quakelive.com/forum/showthread.php?t=31851

Протестовано на Ubuntu 9.04 з Firefox 3.0.13.
Плагін для Firefox оформлений у вигляді xpi-файла.

I18N. Підтримка української мови в Ruby і Ruby On Rails

2009-08-19T00:47:00.003+03:00

Ukrainian language support for Ruby & Ruby and Rails | Підтримка української мови для Ruby та Ruby on Rails

Що це і кому це може знадобиться?

Ukrainian – бібліотека повноцінної підтримки української мови(форматування дати та часу, плюралізації та інтернаціоналізації вцілому)

Ruby on Rails

Пакет мість в собі переклади стандартних бібліотек: ActionView, ActiveRecord, ActiveSupport, а також підтримку плюралізацій для таких методів як distance_of_time_in_words та distance_of_time_in_words_to_now

Плани на Ruby 1.9.2

2009-08-09T15:03:00.003+03:00

Фінальна версія Ruby 1.9.2 запланована на кінець 2009 року (25 грудня).
Вже зараз ви можете спробувати перший попередній реліз, який був представлений 17 липня, під час японської конференції Ruby Kaigi 2009.

Наступні цікаві особливості будуть включені до 1.9.2, якщо вони будуть реалізовані вчасно до заморожування (25 вересня 2009 року, 1.9.2 preview release 3):

підтримка зневаджувача(debugger)

підтримка профайлера(profiler)

підтримка DTrace на FreeBSD, OpenSolaris та OSX.

SQLite як стандартна бібліотека

Крім того розробники обіцяють оптимізувати інтепритатор YARV а також внести зміни до стандартної бібліотеки. Докладніше тут.

Ruby for System Administration → Ruby-inotify

2009-08-08T23:15:00.010+03:00

Inotify - це підсистема ядра Linux, яка дозволяє отримувати повідомлення про зміни у файловій системі. У основне ядро була включена починаючи з 2.6.13. Основна сфера використання - в системах пошуку (наприклад Beagle), таким чином програмі-індексатору не потрібно сканувати всю файлову систему кожні кілька хвилин.

ruby-inotify - це Ruby інтерфейс для доступу до системних викликів Linux Inotify.
Дозволяє виявляти, якщо файл був відкритий, закритий, переміщений, видалений, модифікований і багато чого іншого.


Доступні події:
ACCESS - звернення до файлу(читання).
MODIFY - файл був змінений(запис).
CREATE - файл був створений.
ATTRIB - змінені метадані (права, дата створення/редагування, розширені атрибути, і т.д.).
CLOSE_WRITE - файл, відкритий для запису, був закритий.
CLOSE_NOWRITE - файл, не відкритий для запису, був закритий.
OPEN - файл був відкритий.
MOVED_FROM - файл був переміщений від слідкування.
MOVED_TO - файл був переміщений до слідкування.
DELETE - файл був видалений.
DELETE_SELF - відслідковуваний файл/каталог був видалений.
CLOSE - IN_CLOSE_WRITE | IN_CLOSE_NOWRITE
MOVE - IN_MOVED_FROM | IN_MOVED_TO
ALL_EVENTS - будь-яка з подій.
UNMOUNT - файлова система була відмонтована.
Q_OVERFLOW - черава inotify переповнена.
IGNORED - відслідковуваний файл був автоматично видалений, тому що файл був видалений або файлова система розмонтована.
ISDIR - подій відбулася відносто каталогу.

Процес інсталяції з вихідних кодів є дуже простим:

$ wget http://dinhe.net/~aredridel/projects/ruby/ruby-inotify-0.0.2.tar.gz
$ tar xzvf ruby-inotify-0.0.2.tar.gz
$ cd ruby-inotify-0.0.2/
$ rake1.9.1
$ sudo make install

Як воно працює?
У каталозі examples міститься скрипт watcher.rb, який є простим прикладом роботи з ruby-inotify.

#!usr/bin/ruby

require 'inotify'
require 'find'

i = Inotify.new

t = Thread.new do
i.each_event do |ev|
p ev.name
p ev.mask
end
end

raise("Specify a directory") if !ARGV[0]

Find.find(ARGV[0]) do |e|
if ['.svn', 'CVS', 'RCS'].include? File.basename(e) or !File.directory? e
Find.prune
else
begin
  puts "Adding #{e}"
  i.add_watch(e, Inotify::CREATE | Inotify::DELETE | Inotify::MOVE)
rescue
  puts "Skipping #{e}: #{$!}"
end
end
end

t.join

При створенні/видаленні/переміщені будь-якого файлу чи каталогу на екран буде виведене його ім’я і маска.
Як бачите все доволі просто.

Запустимо скрипт:

$ ruby1.9.1 watcher.rb .

Створимо файл з іменем test.txt і подивимось на результат роботи скрипта
результат:

"test.txt"
256

Створимо каталог з іменем test
результат:

"test"
1073742080

Видалимо файл test.txt
результат:

"test.txt"
512

Видалимо каталог test
результат:

"test"
1073742336

Де застосовувати?

Та де завгодно! Наприклад на мому домашньому сервері крутиться скрипт, який слідкує за каталогом /mnt/smb/downloads (у який користувачі через ssh скачують файли з інтернету) і виводить час створення або видалення файлів на web-сторінку.

Посилання:

Kernel Korner - Intro to inotify

Ruby 1.9.1 on Ubuntu Jaunty

2009-08-08T14:00:00.003+03:00

В репозиторії Ubuntu Jaunty немає Ruby 1.9.1, а лише пакети версії 1.9.0.
Тому ви повинні збирати його з вихідного коду або використовувати сторонні репозиторії.

Починаючи з версії 1.9.1. у комплект Ruby також входить Rubygems, так сказати Just Work™.

Встановлення із вихідних кодів

Спочатку встановдюємо необхідні залежності:

sudo apt-get install build-essential libssl-dev libreadline5 libreadline5-dev zlib1g zlib1g-dev

Далі скачуємо найсвіжішу версію Ruby 1.9.1 з офіційного сайту.
Компілюємо і встановлюємо:

./configure --prefix=/opt/ruby191
make
make test
sudo make install

І на сам кінець для зручності створимо відповідні посилання:

sudo ln -s /opt/ruby191/bin/ruby /usr/local/bin/ruby1.9.1
sudo ln -s /opt/ruby191/bin/testrb /usr/local/bin/testrb1.9.1
sudo ln -s /opt/ruby191/bin/rake /usr/local/bin/rake1.9.1
sudo ln -s /opt/ruby191/bin/ri /usr/local/bin/ri1.9.1
sudo ln -s /opt/ruby191/bin/rdoc /usr/local/bin/rdoc1.9.1
sudo ln -s /opt/ruby191/bin/irb /usr/local/bin/irb1.9.1
sudo ln -s /opt/ruby191/bin/gem /usr/local/bin/gem1.9.1
sudo ln -s /opt/ruby191/bin/erb /usr/local/bin/erb1.9.1

Готово!

$ ruby1.9.1 -e 'puts RUBY_DESCRIPTION'
ruby 1.9.1p243 (2009-07-16 revision 24175) [i686-linux]

Встановлення з репозиторію Ubuntu on Rails PPA

Тим, хто вже тестує Ubuntu on Rails PPA спеціальний бонус від Antono Vasiljev
Додаємо новий репозиторій:

deb http://ppa.launchpad.net/ubuntu-on-rails/ppa/ubuntu karmic main
deb-src http://ppa.launchpad.net/ubuntu-on-rails/ppa/ubuntu karmic main

$ sudo apt-get update
[...]
W: GPG error: http://ppa.launchpad.net jaunty Release: Слідуючі підписи не можуть бути перевірені, тому що, публічний ключ відсутній: NO_PUBKEY B6C6326781C0BE11
[...]

Додаємо публічний ключ:

gpg --keyserver keyserver.ubuntu.com --recv B6C6326781C0BE11
gpg --export --armor B6C6326781C0BE11 | sudo apt-key add -

Встановлюємо Ruby 1.9.1:

sudo apt-get install ruby1.9.1 ri1.9.1 rdoc1.9.1

Також можете зібрати пакет самостійно як це описано тут.

Matz Has a Mac!

2009-07-23T18:54:00.003+03:00

Ця фотографія підняла мені настрій :)

Для тих хто не в курсі, це Юкіхіро Мацумото(Yukihiro Matsumoto) також відомий як Matz, творець мови програмування Ruby.

>>> Подробиці

Ubuntu on Rails

2009-07-23T18:20:00.005+03:00

Недавно на просторах Launchpad.net була створена команда Ubuntu on Rails.

Ціль команди полягає у підтриманні пакетів для розробки на Ruby/Rails. Першочергово це актуальні версії rubygems і passenger.
В команді беруть участь хлопці з Brightbox, які досі підтримують пакети passenger, nginx-passenger, ruby-ee для Ubuntu і Debian.

>>> Подробиці

Mechanize + Cookie + вКонтакте. Частина 6

2009-07-21T20:19:00.007+03:00

Куки(від англ. Cookie - печиво) - фрагмент даних, який створюється веб-сервером і зберігається на комп'ютері користувача у вигляді файлу, який веб-клієнт(зазвичай веб-браузер) кожен раз пересилає веб-серверу у HTTP-запиті при спробі відкрити сторінку відповідного сайту. Застосовується для збереження даних на стороні користувача, на практиці зазвичай використовується для:

автентифікації користувача;

зберігання персональних даних і налаштувань користувача;

відслідковування стану сесії доступу користувача;

ведення статистики про користувачів.

Бібліотека WWW::Mechanize надає зручний інтерфей для роботи з куками - WWW::Mechanize::CookieJar. Цей клас використовується для керування куками, які були повернуті з якого-небудь конкретного сайту. Крім того дозволяє зберігати куки до файлу, з можливістю використовувати його пізніше(наприклад, для автентифікації користувача на сайті без необхідності вводу логіна і пароля). Доступні наступні формати для зберігання/завантаження куки: :yaml <- YAML структура і :cookiestxt <- Mozilla у форматі cookies.txt.

Повернемося до попередньої статті і додамо можливість авторизації за допомогою пересилання куки вебсерверу.
Авторизація здійснюється через надсилання куки 'remixpassword'. Значення 'remixpassword', встановлюється в результаті успішної авторизації, і може бути використане для продовження ідентифікатора сесії('sid').
Цей метод можна використати і у UserAPI при запиті до http://login.userapi.com/auth?login=auto&site=2.

Тут я не буду приводити повний лістинг. А лише доповню код з попередньої статті.
Для початку потрібно авторизуватися на сайті ВКонтакте і записати куки у файл на диску. Для цього створимо новий метод save_cookie().

def save_cookie(cookie_file)
 @a.cookie_jar.save_as(cookie_file, format = :cookiestxt) 
end

Якщо авторизація пройшла успішно, записуємо куки у файл cookie.txt

if login_force(id, email, pass)
  puts "Successfully Authentication"
  save_cookie('cookie.txt')
else
  puts "Authentication Error"
end

Далі ми будемо авторизовуватись за допомогою цією куки. Створимо метод login_auto()

def login_auto(uid, cookie_file)
  @a.cookie_jar.load(cookie_file, format = :cookiestxt)
  login_page = @a.get('http://vkontakte.ru/')
  return /http:\/\/vkontakte\.ru\/id(\d+)/ === login_page.uri.to_s ? ($1 == uid ? true : false) : false
end

Надалі у нас нема необхідності використовувати метод login_force(). Замість нього використовуємо login_auto()

if login_auto(id, 'cookie.txt')
  puts "Successfully Authentication"
else
  puts "Authentication Error"
end

Якщо комусь цікаво про плюси авторизації за допомогою куки(в т.ч. і на сайті ВКонтакте), залишайте коментарі.

розробка.com

2009-07-14T00:07:00.007+03:00

Розробка — молодий соціальний сайт для розробників, побудований по моделі Хабрахабри. Сайт орієнтований на українську аудиторію розробників. Наразі проет ще досить малоактивний, але маю надію в майбутньому до нього буде залучатися все більше і більше людей.

Це перша стаття на Розробці опублікована мною, проба пера так сказати. Прошу не судити строго. Можливо комусь вона буде цікавою. Ця стаття була написана мною у цьому блозі ще у вересні 2007 року. Хоча і досі не втратила своєї актуальності.

Mechanize + Nokogiri + вКонтакте. Частина 5

2009-07-10T18:40:00.010+03:00

Ніхто не помітив зовнішніх змін. Положення тіла пацієнта вКонтакте на операційному столі залишалось незмінним. Але мушу повідомити неприємну новину: ідентифіковано мутації. Тому всі попередні дослідження [1][2][3][4] вважаються недійсними. Нічого... не треба падати духом.
Їжачки плакали і кололись, але продовжували кохатися з кактусами! ©

Nokogiri - це парсер HTML, XML, SAX. Серед його численних можливостей можна виділити можливість використання XPath(XML Path Language) і CSS3 селекторів для пошуку.
Крім того Nokogiri має сумісний з Hpricot синтаксис XPath та CSS.
На даний час Nokogiri найшвидший парсер XML для Ruby.
Mechanize для синтаксичного розбору html використовує саме Nokogiri.

Приклад використання:

Підключення необхідних бібліотек

require 'nokogiri'
require 'open-uri'

Завантаження HTML сторінки, використовуючи open-uri, який йде з Ruby

doc = Nokogiri::HTML(open('http://www.google.com/search?q=ruby-ua'))

Пошук вузлів за допомогою CSS3 селекторів

doc.css('h3.r a.l').each{|link| puts link.content}

Пошук вузлів за допомогою XPath

doc.xpath('//h3/a[@class="l"]').each {|link| puts link.content}

Автор рекомендує використовувати XPath селектори для вищої швидкодії - пошук CSS швидкий ніж у Hpricot, але не такий швидкий.
Nokogiri::XML::Node#xpath(*paths) - функція пошук вузлів(nodes) для XPath шляхів(paths). Шлях повинен бути одним або декількома XPath запитами(queries).
Цікавоє можливістю є задання власних функцій XPath із використанням регекспів(regexp). Для цього потрібно створити класс і застосувати функцію # яку хочете визначити. Наприклад:

node.xpath('.//tr[mess(., "mess\d+")]', Class.new {
  def mess node_set, regex
    node_set.find_all { |node| node['id'] =~ /#{regex}/ }
  end
}.new)

Така функція знайде всі вузли виду:

<tr id="mess127">[...]</tr>
<tr id="mess128">[...]</tr>
<tr id="mess129">[...]</tr>

вКонтакте!?
У зв'язку зі змінами на сайті vkontakte.ru мої попередні дописи про вконтакте втратили свою актуальність. Не знаю скільки часу буде працездатним цей код. Але суть в іншому: показати принципи роботи з Mechanize і Nokogiri на реальному прикладі.
Що ж робить нищеприведений код?

Авторизація через надсилання email-адреси та пароля користувача; (login_force)

Отримання останніх приватних повідомлень; (get_messages)

# -*- encoding: utf-8 -*-
require 'mechanize' # recommended 0.9.2

@a = WWW::Mechanize.new{|agent|
  agent.user_agent_alias = 'Linux Konqueror'
  agent.follow_meta_refresh = true
}

# Authorisation by submitting email and password (Login)
#
def login_force(uid, email, pass)
  login_page = @a.get('http://vkontakte.ru/login.php')
  login_form = login_page.form_with(:name => "login")
  login_form.email = email
  login_form.pass = pass
  user_page = login_form.submit
  return /http:\/\/vkontakte\.ru\/id(\d+)/ === user_page.uri.to_s ? ($1 == uid ? true : false) : false
end

# Getting private messages list for current user
#
# Structure of each entry of resulting array
#   [0] - message from
#   [1] - message date
#   [2] - message title
#   [3] - message_body
#
def get_messages
  url = 'http://vkontakte.ru/mail.php'
  messages_page = @a.get(url)
  node = Nokogiri::HTML(messages_page.body)
  message = node.xpath('.//tr[mess(., "mess\d+")]', Class.new {
    def mess node_set, regex
      node_set.find_all { |node| node['id'] =~ /#{regex}/ }
    end
  }.new)
  message_from = message.xpath('//td[@class="messageFrom"]/div[@class="name"]/a').map {|link| /\/id(\d+)/.match(link['href'])[1]}
  message_date = message.xpath('//td[@class="messageFrom"]/div[@class="date"]').map {|link| link.content}
  message_title = message.xpath('//a[@class="new messageSubject"]/span').map {|link| link.content}
  message_body = message.xpath('//a[@class="new messageBody"]').map {|link| link.content}
  messages = Array.new
  messages = [message_from, message_date, message_title, message_body].transpose
  return messages
end

id = "12345678"
email = "username@example.com"
pass = "secret"

if login_force(id, email, pass)
  puts "Successfully Authentication"
  get_messages.each {|message|
    puts "[#{message[1]}]: #{message[0]}"
    puts message[2]
    puts message[3]
    puts "==="
}
else
  puts "Authentication Error"
end

Blogger: Створи власний безкоштовний блог?

2009-07-10T00:10:00.002+03:00

Весь час перебування в Blogger мені не вистачало однієї корисною фічі з ЖЖ. І нарешті цей прикрий пробіл закритий.
За посиланням можна прочитати як створювати розширювані короткі описи повідомлень, такий собі аналог <lj-cut> з ЖЖ.
Доведеться трохи повозитися з шаблоном. Але найважливіше воно працює :)
Не встиг я потішитись обновці, як на і-мейл прийшов лист від Blogger.
А-а-а-а-а!!!!!11 OMG! Хто б міг подумати? Я спамер!!! На жаль або на щастя в Україні немає безпосередньої відповідальності за поширення спаму.
І тепер замість блогу красується заглушка з багатозначним надписом:

Я пам'ятайте, якщо ви читаєте цей пост, значить цей блог не містить потенційного спаму :). Перевірено Великим Ґуґло'м.

Якщо комусь цікаво, під катом текст листа від Blogger.

Вітаємо!

Ваш блог на: http://ruby-ua.blogspot.com/ ідентифіковано як блог із потенційним спамом. Для вирішення цієї проблеми надішліть запит на перегляд, заповнивши форму на http://www.blogger.com/unlock-blog.g?lockedBlogID=4152168096498110483

Якщо ваш блог не буде переглянуто, його буде видалено через 20 днів, а впродовж цього періоду вашим читачам відображатиметься сторінка попередження. Після отримання запиту ми переглянемо ваш блог і розблокуємо його протягом двох робочих днів. Після того як ваш буде розглянуто та буде виявлено, що він не є спамом, блог буде розблоковано, а повідомлення на вашій панелі керування Blogger більше не відображатиметься. Якщо цей блог не належить вам, нічого робити не потрібно. Це не вплине на будь-які інші ваші блоги.

Ми шукаємо спам, використовуючи автоматичний класифікатор. Автоматичне виявлення спаму є неточним, і час від часу блоги, схожі на ваш, позначаються неправильно. Ми просимо вибачення за цю помилку. Однак за допомогою такої системи ми можемо забезпечити більше місця для зберігання, вищу пропускну здатність і більше технічних ресурсів для таких авторів блогів, як ви, а не для спамерів. Для отримання додаткової інформації див. довідку Blogger: http://help.blogger.com/bin/answer.py?answer=42577

Дякуємо за розуміння та допомогу в боротьбі зі спамом.

Із повагою,

команда Blogger

P.S. Ще одне нагадування: якщо ви не надішлете запит на перегляд вашого блогу, через 20 днів його буде видалено. Перейдіть за цим посиланням, щоб надіслати запит на перегляд: http://www.blogger.com/unlock-blog.g?lockedBlogID=4152168096498110483

Мені от дійсно цікаво: хто і як буде перевіряти ~~rub~~україномовний блог на ~~спам~~ відповідність умовам обслуговування Blogger?

Ruby for System Administration → Bash quoting

2009-07-05T16:22:00.006+03:00

Інколи використовую Ruby для задач системного адміністрування. Ruby з широким набором бібліотек чудово для цього підходить.
Однією з поширених задач є виклик зовнішніх команд Linux, передачі їм різноманітних параметрів, отримання і обробки результатів. І тут ви обов'язково стикнетеся з маскуванням символів в bash.

Маскування(quoting) в bash використовується для відміни спеціального значення для команд інтерпрeтатора визначених символів або слів.
Маскування можна використовувати для скасування специфічної обробки спеціальних символів, для запобігання розпізнавання зарезервованих слів, а також для запобігання підстановки параметрів.
Метасимвол - це символ, який розділяє слова, якщо він не замаскований. Є одним з наступних символів:
| & ; ( ) < > пробіл табуляція

Існує три механізми маскування:
символ маскування (escape character), одинарні лапки і подвійні лапки.

Незамаскована зворотна коса риска (\) є символом маскування(escape character). Вона вимагає використовувати наступний за нею символ(за винятком переведення рядка) буквально.

Усі символи в одиночних лапках (') використовуються буквально. Символ одиночної лапки(апостроф) не повинен вказуватися між лапках, навіть якщо його випереджає зворотна коса.

Символи в подвійних лапках(") використовуються буквально, за виключенням $, !, ` і \
Зворотна коса має спеціальне значення тільки якщо після неї йде один з спеціальних символів.

З точки зору програмування, маскування з допомогою одинарних лапок є найпростішим (але не дозволяє маскувати символ одинарних лапок). Тоді як з допомогою зворотної косої - найскладніший.
Ми не шукаємо простих шляхів :)

Напишемо просто функцію, яка отримуватиме cтроку і повертатиме масковану строку, придатну для використання в bash.
Зауважу, код буде працювати тільки в версіями Ruby вище 1.9, оскільки в Regexp використовується нова можливість Oniguruma - іменовані групи(named groups).

#!/usr/bin/env ruby1.9
# -*- encoding: utf8 -*-

def quote_for_bash(text)
text = text.dup
text.gsub!( /(?<backslash>\\)/,       '\\\\\k<backslash>'       )
text.gsub!( /(?<space>\s)/,           '\\\\\k<space>'           )
text.gsub!( /(?<double-quotes>")/,    '\\\\\k<double-quotes>'   )
text.gsub!( /(?<single-quotes>')/,    '\\\\\k<single-quotes>'   )
text.gsub!( /(?<apostrophe>`)/,       '\\\\\k<apostrophe>'      )
text.gsub!( /(?<brackets>[()<>])/,    '\\\\\k<brackets>'        )
text.gsub!( /(?<semicolon>;)/,        '\\\\\k<semicolon>'       )
text.gsub!( /(?<exclamation-mark>!)/, '\\\\\k<exclamation-mark>')
text.gsub!( /(?<ampersand>&)/,        '\\\\\k<ampersand>'       )
text.gsub!( /(?<dollar-sign>\$)/,     '\\\\\k<dollar-sign>'     )
text.gsub!( /(?<number-sign>#)/,      '\\\\\k<number-sign>'     )
text.gsub!( /(?<vertical>\|)/,        '\\\\\k<vertical>'        )
return text
end

Задамо текст, який, наприклад, в майбутньому будемо використовувати як параметр для якоїсь команди:

text = %{#<b>$a;say "hello" & |Profit!|  -  (`1$)</b>}

Початковий текст матиме такий вигляд:

puts text
#<b>$a;say "hello" & |Profit!|  -  (`1$)</b>

Маскований текст буде таким:

puts quote_for_bash(text)
\#\<b\>\$a\;say\ \"hello\"\ \&\ \|Profit\!\|\ \ -\ \ \(\`2\$\)\</b\>