К моему удивлению не все Ruby программисты знают внутреннего устройства Ruby. Не в том, смысле, что Ruby’ст должен изучать исходники своего любимого языка программирования, но в том, что многие моменты не понятны. Например не понятно, чем класс отличается от объекта или что такое singleton’ы в Ruby. Эта статья призвана совершить некоторую демистификацию Ruby. В простой манере и без влезания в код самого Ruby я расскажу почему что-то работает именно так, как работает. Статья ориентирована не на новичков, а на программистов более-менее среднего уровня, то есть достаточно хорошо знакомых с Ruby.

Статья будет иметь формат повествования, она будет лишена структуры, читайте ее просто как программистскую сказку.

Классы — это объекты, но только на половину. Классы являются экземплярами одного из базовых классов Class, однако они не являются «классическими» объектами.

$ ruby -v
ruby 1.9.3p191 (2012-04-19 revision 35398) [i686-linux]
$ irb

class A
end

A.class #=> Class

В Ruby объекты не могут иметь собственных методов. Объект — это просто набор данных. Например объект класса Human содержит данные об имени, росте, весе, цвете глаз и прочих параметрах человека. В этом смысле объект в Ruby не сильно отличается от ассоциативного массива (а в JavaScript — это и вовсе одно и то же). Поскольку объект не может хранить собственные методы, то его методы хранятся в классе. То, что класс хранит методы своих экземпляров — это основное отличие класса от обыкновенного объекта. Даже не то, что класс может создавать экземпляры, а то, что он хранит методы экземпляров, ведь мы можем используя техники метапрограммирования расширить обыкновенный объект до того, что он будет подобным классу в своем поведении, но методы своих экземпляров он хранить не сможет.

class A
  def hello
    puts 'hello'
  end
end

a = A.new

a.hello
# hello

Когда мы для a вызываем метод hello, то, на самом деле a передает сообщение об его вызове по цепочке наследования, сначала к своему singleton классу, затем к классу A и т.д. пока метод не будет найден. У самого же a нет методов!

Вот он singleton класс:

a.singleton_class
#=> #<Class:#<A:0x82bf770>>

А вот еще один:

A.singleton_class
#=> #<Class:A>

Любой объект в том числе и класс (который объект только на половину) имеет закрепленный за собой singletion класс. Singleton класс встраивается в цепочку наследования. Здесь он наследуется от класса A:

a.singleton_class
#=> #<Class:#<A:0x82bf770>>

А здесь он наследуется от класса Class:

A.singleton_class
#=> #<Class:A>

Таким образом Singleton класс — это незаметная ссылка между экземпляром класса и классом. Когда мы определяем объектам специальные методы, например так:

def a.bye
  puts 'bye'
end

a.bye
# bye

… или так:

def A.how_are_you
  puts 'How are you?'
end

A.how_are_you
# How are you?

… или так:

class A
  def self.what_is_your_name
    puts "What is your name?"
  end
end

A.what_is_your_name
# What is your name?

… или даже так:

class A
  class << self
    def how_old_are_you
      puts 'How old are you?'
    end
  end
end

A.how_old_are_you
# How old are you?

… то мы не явно имеем дело с Singleton классами. Класс способен хранить методы своих экземпляров, но не свои собственные. Каждый класс имеет Singleton класс, который хранит уникальные методы класса. Стандартные методы класс, будучи экземпляром класса Class, хранит в классе Class и других базовых классах, например классе Object от которого он наследуется:

A.superclass #=> Object

Все уникальные методы объектов, которые вы определяете хранятся в Singleton классах, в универсальные методы хранятся в их классах.

a.singleton_methods #=> [:bye]
A.singleton_methods #=> [:how_are_you, :what_is_your_name, :how_old_are_you]
A.methods.count #=> 100
(A.methods - A.singleton_methods).count #=> 97

Почему название такое — Singleton класс? — Дело в том, что этот класс может иметь только один объект:

a.singleton_class.new
TypeError: can't create instance of singleton class

Потому и название такое, хотя ме больше нравится название Eigenclass, которое, однако встречается значительно реже. С названием eigenclass не возникает путаницы так как существует еще такой паттерн как Singleton («Одиночка»), который позволяет создавать классы, которые не могут иметь более одного экземпляра. Из-за того, что Eigenclass имеет только экземпляр — объект, за которым он закреплен, то и было решено использовать название Singleton, которое правда не описывает его предназначение и вносит путаницу с паттерном проектирования о котором говорилось выше. Название Eigenclass лучше отображает суть ведь в переводе с английского/немецкого оно означает «собственный класс».

Делаем выводы:

• Объект, если рассматривать его совсем примитивно является просто хэшем, который хранит определенные данные.
• Класс является объектом, который способен хранить методы своих экземпляров.
• Singleton класс — это класс, экземпляром которого на самом деле является объект, который может обладать только одним экземпляром, и которых хранит все уникальные методы объекта.
• Мы не говорим, что a наследуется от A и не смотря на наличие singleton класса — это правильно, так как singleton класс — это просто реализация, но не парадигма и его наличие ни на что не влияет.

Люди часто не понимают, что делает следующий код:

class A
  class << self
    def how_old_are_you
      puts 'How old are you?'
    end
  end
end

Этот код — это в некотором смысле синтаксический сахар. Выражение class нуждается в получении константы — имени класса. self — ссылка на текущий контекст, если мы не указываем приемник вызова метода явно, то предполагается, что им является self — объект в контексте которого осуществляется вызов. Когда мы используем class << self, то это просто специальный синтаксис, через стрелку «<<« в котором мы как бы открываем контекст предка — singleton класса. В class мы не можем передать что-то иное, кроме константы, в этом случае возникнет синтаксическая ошибка:

class A
  class singleton_class
    def rubydev
      puts "RubyDev.ru"
    end
  end
end

SyntaxError: (irb):90: class/module name must be CONSTANT
from /home/vladimir/.rvm/rubies/ruby-1.9.3-head/bin/irb:16:in `<main>’

Singleton классы являются безымянными (анонимными). Им не нужно имя хотя бы потому, что они сами по себе существовать не могу, с ними на прямую никто работать не должен, а если и возникает такая необходимость, то обратиться к ним можно через метод singleton_class объекта, за которым они закреплены.

Синтаксис class << self просто обрабатывается иначе. Интерпретатор понимает его не как необходимость вызова для объекта class метода << и передачи аргумента self, а как нечто иное — переключение в контекст singleton класса. Вот и все!

1. Введение в программирование на Си
2. Переменные и типы данных в Си
3. * Операторы, условия и циклы языка Си

Си включает в себя всего 3 цикла и 2 условных оператора. Набор арифметических операторов и операторов сравнения стандартен. В данной статье мы сначала бегло пробежимся по арифметическим операторам и операторам сравнения, а затем перейдем к изучению циклов и условий, в которых познакомимся с операторами еще более подробно. Операторы работы с бинарными данными мы рассмотрим в отдельной статье посвященной работе с битами и байтами.

Арифметические и логические операторы
= — присваивание (самый низкий приоритет),
+ — сложение,
- — вычитание,
* — умножение,
/ — деление,
% — остаток от деления на цело,
() — скобки имеют наивысший приоритет и используются для увеличения приоритета других действий, например сложения.

Пример:

#include <stdio.h>

int main(void) {
    int a = 5, b =10, c = 25, d = 100, result;

    printf("%d + %d = %d\n",  a, b, a + b);
    printf("%d - %d = %d\n",  a, b, a - b);
    printf("%d / %d = %d\n",  d, c, d / c);
    printf("%d * %d = %d\n",  c, a, c * a);
    printf("%d %% %d = %d\n", c, b, c % b);

    result = (c + d) / a * b;

    printf("result is: %d\n", result);
}

Результат:

5 + 10 = 15
5 — 10 = -5
100 / 25 = 4
25 * 5 = 125
25 % 10 = 5
result is: 250

К логическим операторам относятся следующие:
> — больше,
< — меньше,
>= — больше или равно,
<= — меньше или равно,
== — равно,
!= — не равно

Соединители логических условий:
&& — И,
|| — ИЛИ.
! — НЕ

Пример использования в условии IF:

#include <stdio.h>

int main(void) {
    int a = 5, b =10, c = 25, d = 100, result;

    if (b > a)
        printf("b > a\n");

    if (a >= b || b <= c)
        printf("a >= b OR b <= c\n");

    if (a == c / a && (c % a) == 0) {
        printf("c = a * a\n");
    }

    return 0;
}

Данная программа в результате выполнения напечатает следующее:

b > a
a >= b OR b <= c
c = a * a

Условные операторы
После знакомства с арифметическими и логическими операторами пора познакомиться и с операторами позволяющими создавать условия. С одним вы уже познакомились выше — это условие IF («ЕСЛИ») которое выполняет следующую после него единственную строку кода или блок кода, если условие в круглых скобках верно.

У условия с IF имеется еще альтернативная форма  IF-ELSE (ЕСЛИ-ИНАЧЕ) Пример:

#include <stdio.h>

int main(void) {
    int a = 5, b =10, c = 25, d = 100, result;

    if (b > a) {
        printf("b > a\n");
    } else {
        printf("b < a\n");
    }

    return 0;
}

А вот еще один пример, только на этой раз IF-ELSE IF-ELSE:

#include <stdio.h>

int main(void) {
    int a = 5, b = 10, c = 25, d = 100, result;

    if (b > a) {
        printf("b > a\n");
    } else if (b == a) {
        printf("b == a\n");
    } else {
        printf("b < a\n");
    }

    return 0;
}

Последний пример позволяет выполнить только дно из трех действий (один из блоков кода), а следующие после этого действия проверки игнорируются. Так, если b > a, то проверка на то, равно ли b == a производиться не будет.

Другой способ создать проверку условия — это использовать конструкцию SWITCH-CASE-DEFAULT. Ниже приведен пример:

#include <stdio.h>

int main(void) {
    int a = 5, b = 10, c = 25, d = 100, result;

    switch (d) {
        case 5:
            printf("d = 5\n");
            break;
        case 10: case 25:
            printf("d = 10 or 25\n");
            break;
        case 100:
            printf("d = 100\n");
            break;
        default:
            printf("d = d");
            /* здесь break не обязателен */
            break;
    }

    return 0;
}

Оператор switch принимает в качестве аргумента какое-либо значение, значение которой необходимо проверить. case 5:, case 10:, case 25: case 100: default: — являются метками, которые используются в операторе switch и goto для перемещения по коду. Конкретно метки case и default используются в switch, оператор ищет их и проверяет их соответствие значению переменного аргумента. В нашем случае значению 100 переменной d соответствует метка case 100:. Когда найдена соответствующая метка, программа выполняет ассоциируемый с нею код, то есть будет выполнена функция printf() и оператор break. Если ни одна метка не будет соответствовать значению аргумента, то будет выполнен код метки default:. Метка default: не обязательна, вы можете ее не использовать в тех случаях, когда она будет лишней.

Цикл WHILE

while является самым простым циклом, с его помощью можно заменить любой другой, правда их в Си всего 3 штуки. Пример while цикла:

#include <stdio.h>

int main(void) {
    int a = 5, b = 10, c = 25, d = 100, result;

    while (a <= d) {
        if (a % 10 == 0)
            printf("%d ", a);

        a += 5;
    }

    printf("\n");

    return 0;
}

Результат:

10 20 30 40 50 60 70 80 90 100

Цикл while принимает условие и выполняет блок кода до тех пор, пока условие верно. Мы обязаны каждый каждый раз увеличивать значение переменной a, которая фигурирует в условии, иначе мы получим бесконечный цикл.

Цикл DO…WHILE
Цикл do…while очень похож на цикл while, однако он является циклом с пост-условием. То есть условие выполнения блока кода проверяется после выполнения, а не до, что гарантирует то, что код выполнится минимум один раз. Ниже приведен пример:

#include <stdio.h>

int main(void) {
    int a = 5, b = 10, c = 25, d = 100, result;

    do {
        printf("%d ", a);
    } while (a >= d);

    printf("\n");

    return 0;
}

По условиям while блок кода не должен выполнится, однако он выполнится один раз потому, что мы используем цикл do…while. Реализовать цикл do…while через while очень просто — достаточно выполнить функцию или содержимое блок кода перед использованием цикла, а затем использовать их в цикле.

Цикл FOR

Цикл for является продвинутой версией циклов. for сразу заботится об инициализации и инкременте счетчика. Пример:

#include <stdio.h>

int main(void) {
    int a = 5, b = 10, c = 25, d = 100, result;

    for(int i = 0; i <= d; i += 10) {
        printf("%d ", i);
    }

    printf("\n");

    return 0;
}

Результат:

0 10 20 30 40 50 60 70 80 90 100

Как видите, мы сразу объявляем, что счетчик цикла должен увеличиваться после каждой итерации.

После знакомства с циклами и условными операторами давайте вернемся к упомянутому ранее break.

Оператор BREAK

Оператор break занимается прерыванием. В случае со switch мы используем его для кода каждой метки с той целью, чтобы следующие метки были проигнорированы, в противном случае switch проверит соответствие переданного ему значения всем меткам, точнее будет проверять пока не наткнется на break. Пример:

#include <stdio.h>

int main(void) {
    int a = 5, b = 10, c = 25, d = 100, result;

    switch (d) {
        case 5:
            printf("d = 5\n");
        case 10: case 25:
            printf("d = 10 or 25\n");
        case 100:
            printf("d = 100\n");
        default:
            printf("d = d\n");
    }

    return 0;
}

Результат:
d = 100
d = d

Еще break очень полезен в ситуациях, когда мы не знаем точно когда необходимо завершить работу цикла. В таком случае принято использовать концепцию «стоп слов» -значений, которые позволяют программе понять, что цикл необходимо завершить. Пример:

#include <stdio.h>
#include <string.h>

int main(void) {
    char str[100];

    while (1) {
        printf("Введите слово: ");
        scanf("%s", str);
        printf("\n");

        if (strcmp(str, "exit") != 0) {
            printf(">> %s\n", str);
        } else {
            printf("bye!\n");
            break;
        }
    }

    return 0;
}

Пример работы:

$ ./a.out
Введите слово: Hello!

>> Hello!
Введите слово: RubyDev

>> RubyDev
Введите слово: exit

bye!

Оператор CONTINUE
Оператор continue похож на оператор break. Отличием continue от break является то, что если break останавливает выполнение кода (например цикла), то continue позволяет остановить только текущую итерацию и перейти к следующей. Перепишем пример выше с использованием continue:

#include <stdio.h>
#include <string.h>

int main(void) {
    char str[100];

    while (1) {
        printf("Введите слово: ");
        scanf("%s", str);
        printf("\n");

        if (strcmp(str, "exit") != 0) {
            printf(">> %s\n", str);
        } else {
            continue;
            /* выполнено не будет */
            printf("bye!\n");
        }
    }

    return 0;
}

Пример работы:

$ ./a.out
Введите слово: exit

Введите слово: exit

Введите слово: RubyDev

>> RubyDev
Введите слово:

На этом знакомство с операторами в Си закончем. По goto, как и по работе с битами будет отдельная статья.

Что было сделано?

• Удалена сущность Document, а вместе с тем и понятие документов. В Quasar будут присутствовать ресурсы, например статья, продукт или топик форума — это ресурсы. Здесь понятие ресурс несколько отличается от ресурса REST архитектуры, точнее первое множество входит во второе. В общем, в Quasar вместо документов теперь ресурсы.
• Был добавлен первый ресурс — Article (статья). Он представляет собой какую-то совсем простую сущность, например пост в блоге или статью в новостном сайте. Для начала достаточно этой единственной сущности (ресурса), а затем мы добавим, например Product и Topic.
• Добавлена константа RESTYPES, которая хранит имена моделей — ресурсов Quasar CMS. Эти модели должны храниться в директории app/models/resources.
• Добавлена модель AttachmentLink, которая должна перелинковывать между собой ресурсы, точнее хранить связи между ресурсом и его вложениями (вложения — также ресурсы). Здесь и обнаружилась интересная проблема, о которой рассказано далее.
• Добавлены счетчики для attached/master ресурсов.

Проблема и ее рашение
Оказывается в ActiveRecord нельзя создавать полиморфные has_many :trough => … (HMT) ассоциации. Ниже приведенный упрощенный код возвращает ошибку:

 ActiveRecord::HasManyThroughAssociationPolymorphicSourceError:
       Cannot have a has_many :through association ‘Article#attachments’ on the polymorphic object ‘Attachment#attachment’.

#app/models/attachment_link.rb
class AttachmentLink < ActiveRecord::Base
  #...

  belongs_to :master,     polymorphic: true
  belongs_to :attachment, polymorphic: true
end

#app/models/resources/article.rb
class Article < ActiveRecord::Base
#...

  has_many :attachment_links, as: :master,     dependent: :destroy
  has_many :master_links,     as: :attachment, dependent: :destroy, class_name: "AttachmentLink"
  has_many :attachments, through: :attachment_links
  has_many :masters,     through: :master_links

  def attach(attachment)
    attlink = self.attachment_links.new
    attlink.attachment = attachment
    attlink.save
  end
end

К сожалению, такое решение не работает. Для реализации связывания типа master -> attachment было решено добавить новую сущность — Resource. Resource хранит список всех ресурсов (Article, Product, Topic и т.д.) и является промежуточным звеном связывания. Resource будет:

has_many   :attachment_links, as: :master, dependent: :destroy
has_many   :attachments, through: :attachment_links
belongs_to :real_resource, polymorphic: true

А ресурсы вроде Article будут:

has_many :master_links,     as: :attachment,    dependent: :destroy, class_name: "AttachmentLink"
has_many :masters,     through: :master_links

has_one  :resource,         as: :real_resource, dependent: :destroy
has_many :attachments, through: :resource

К сожалению, и этот способ не помог, была выброшена все так же ошибка — ActiveRecord::HasManyThroughAssociationPolymorphicSourceError. Немного  в исходниках Rails я нашел вот такой код:

if through_reflection.options[:polymorphic]
  raise HasManyThroughAssociationPolymorphicThroughError.new(active_record.name, self)
end

То есть, при любая HMT ассоциация с полиморфной сущностью невозможна. Странно конечно, что это не реализовано, ну да ладно. Данный код находится в методе ActiveRecord::Reflection::ThroughReflection.check_validity!. Я не стал сильно вникать в то, зачем необходима такая проверка ассоциации, но видимо она там не зря. Разумеется, можно переписать кусок Rails своим кодом, который, возможно, будет пораждать множество конфликтов.

Я решил пойти другим путем. Я решил реализовать ассоциацию с вложениями вручную, то есть без has_many. Например, списки ссылок на master/attached ресурсы получаются через такой код:

def attachment_links()
  @attachment_links ||= AttachmentLink.where("master_id = ? AND master_type = ?", id,  class_name).limit(attachments_count)
end

def master_links()
  @master_links ||= AttachmentLink.where("attachment_id = ? AND attachment_type = ?", id,  class_name).limit(masters_count)
end

Хеш присоединенных ресурсов получаем вот так:

def attachments()
  @attachments ||= {}

  if @attachments.empty?
    attachment_links.each do |attlink|
      attclass_name = attlink.attachment_type
      attclass = attclass_name.constantize
      attachment = attclass.where(id: attlink.attachment_id).limit(1)
      @attachments[attclass_name] ||= []

      unless @attachments[attclass_name].include? attachment
        @attachments[attclass_name] << attachment
      end
    end
  end

  return @attachments
end

Новый attachment добавляется вот так:

def attach(attachment)
  if new_attlink(attachment).save
    increment_attachments_count
    reload_attachments_with attachment
    attachment.increment_masters_count
  end
end

def new_attlink(attachment = nil)
  AttachmentLink.new do |attlink|
    attlink.master_id   = self.id
    attlink.master_type = class_name

    if attachment.present?
      attlink.attachment_id   = attachment.id
      attlink.attachment_type = attachment.class_name
    end
  end
end

Разумеется этот код не совершенен ии будет еще улучшаться, но на первое время он вполне годится.
Напомню, что у нас есть группа во Вконтакте: RubyDevClub, а еще за QuasarCMS можно следить на  странице в Google +.