Безусловно, я сейчас говорил о методиках разделения информационной системы на реализацию и представление (пользовательский интерфейс, и, собственно, ядро (kernel) системы).

Если говорить об используемых мной технологиях эдак, скажем, год назад, то это, в лучшем случае, были системы шаблонирования Smarty и тому подобное, что в каком-то плане довольно удобно и полезно, однако всё равно представляет собой ряд ограничений, так низкий уровень возможной спецификации данных дизайнерами и в целом не имеющими квалификации в программировании людьми представляло собой большую ограниченность. Другими словами, за поставку данных в формате user-friendly чаще всего целиком и полностью отвечает программист, при этом дизайнер, либо разработчик интерфейсов, выступают лишь потребителями данных, без каких-либо дополнительных возможностей, конечно, если они не владеют специальными знаниями и технологиями, такими как средства server-side (python, php, ruby, т.д.) либо client-side (js, ммм... ) разработки. Всё это довольно замедляло работы над проектами, в ситуации, когда необходимо было разработать довольно простой модуль, функционал которого чаще всего ограничивался визуализацией некоторых данных БД либо результатов работы некоторого интегрированного в систему пакета, с чем мог бы справится и разбирающийся в базовых понятиях структуры системы (не кода, а скорее логики функционирования) обыватель, но что было невозможным из-за обязательного участия программиста в этом процессе.

И вот недавно (да, время - это конечно большая утрата) открытая мной для меня же ( ) технология XSL преобразований кардинально повлияло на форму и вектор направления моих мыслей, и на подход в реализации дружественности для не-программистов так же.

Я, в целом, давно знал о существовании данной технологии, и даже что-то писал на досуге, но всю несомненную полезность и flexibility оной, осознал лишь после того, как начал в корне пересматривать принцип работы разработанной в контексте одного проекта, а на сегодняшний день перешедшей в статус OpenSource, CMS платформы, которая на тот момент была довольно логично и правильно сделана в плане расширяемости, дружественности для сторонних разработчиков и, собственнно, конечных пользователей (users), поскольку в основе лежала идеология XML-обмена данными - как внутри системы, так и за её пределами - в контексте общения с внешними серверами, но это уже другая история.

Однако было в ней одно громадное "НО!", о котором мне громко в форме едкого сарказма (как умеют OpenSource разработчики, словно в поговорке: "в чужом глазу...") напомнили ребята с форума PHPClub. "НО" же это заключалось именно в том, что в системе почти не было явного разделения на "код" -> "представление", и это стало настоящей проблемой, степень важности которой не была оценена на начальных этапах проектирование, и которая в следствии стала значительным образом тормозить дальнейшее развитие системы как в плане реализации/безопасности/красивости, так и интереса к ней среди других решений в среде OpenSource-сообщества.

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

Поскольку основной задачей стало сделать так, чтобы дизайнеры не догадывались о существовании чего-то кроме XML/XSL (если конечно им этого не захочется), однако могли бы при этом спокойной получать данные в удобном для них формате, создавая пользовательские интерфейсы; при этом так же имея возможность более advanced'ного общения с системой, к примеру:

1. Возможность посредством XML-структур, входящих в файл конфигурации модуля, производить запрос данных из БД.
2. Возможность доступа к определённого рода функциям PHP, запрошенным в файле конфигурации модуля
3. Возможность быть в некоторых ситуациях полностью независимым от программииста

И вот с банкой кофе ("Nescafe Classic"), чайником и изрядным уровнем энтузиазма я закрылся на балконе-веранде, и пришёл к совершенно новому для меня подходу к разделению кода и данных.

Если возвращатся к системе CMS, упомянутой выше, то нужно (для большей степени понимания) ввести три понятия: "блок", "пакет", "модуль".

Эти базисный единины в её контексте представляли фундамент движка. Так "пакет" испключительно поставляет функционал, не принимая участия в формировании UI-представления данных, в свою очеред "модуль" наоборот является базовой единицей реализации функционала "пакета" и визуализации данных, разделяясь в свою очередь на подразделы, относительно их функций и семантики. И не относящаяся к "пакетам", но в то же время не совсем "модуль" сущность "блок" так же представляет собой элемент пользовательского интерфейса, при этом не имея всех возможностей модулей, как в структуре так и в функционале, что очевидно.

В окончательном варианте, файловая структура поставк модуля имеет следующий вид:

-- module
-- parts
-- main-part
-- actions
-- action.inc ; сервер-логика для обработки событий форм
-- xsl
-- main.xsl ; файл подключаемый в качестве XSL(T) по-умолчанию
-- ... ; список таблиц XSL, поставляемых с этим разделом
-- main.xml ; основной XML-файл реализации
-- others
-- client-logic
-- css
-- images
-- info.xml


Во время запроса пользователем некоторого модуля системы, происходит проверка текущего активного раздела, при условии отсутствия которого будет обработан `main-part`.

Процесс обработки заключается в следующих этапах:

1. Обработка XML-файла с данными для обработки на серверной стороне (запросы к БД, импорт методов, прочее).
2. Включение в результирующий массив данных результатов проводки по всем, привязанным к данному разделу некоторого модуля либо модуля в целом, обработчикам (wrappers) которые были назначены программистами.
3. Процессинг связанной с исходным XML файлом таблицей преобразований XSL.
4. Добавление данных в массив временных данных, с последующим возвратом их пользователю на последней стадии формирования контента.

Исходный информационный файл XML для настройки и определения запрашиваемых и поставляемых данных для каждого раздела модуля имеет следующую структуру:

<?xml version='1.0'?>
<input>
<transform>
<item src='${part_dir}/xsl/main-diff.xsl'/>
</transform>
<infoset>
<title></title>
<css></css>; Inline-объявление либо перечисление узлов <item>
<script></script>; Inline-объявление либо перечисление узлов <item>
<!--Некоторые дополнительные параметры страницы-->
<params>
<key>value1</key>
</params>
</infoset>

<!-- Exaple URL-parts exporting as XSL-variables -->
<var number='1' import-as='product_id' type='number'/>
<var number='2' import-as='product_title' type='string'/>
<var number='3' import-as='user_id' type='number'/>
</urlset:url>
<dbset:dataset>
<set id='1'>
<tables join='left'> ; "join" - опциональный атрибут
<item name='some_db_table1' variable='d'/> ; variable - опциональный атрибут
<item name='some_db_table2' variable='d1'/> ; опциональный атрибут
</tables>
<columns>
<item name='title' from='d' variable='product_title'/>
<item name='uid' from='d1' variable='user_id'/>
</columns>
<where>
<case type='default'>
<term object='SUMM(d1.count)*SUMM(d1.cost)'/>
<term object='SUMM(d2.salary)*SUMM(d2.salary)'/>
<action type='greater or equal'/>
</case>
<case type='or'>
<term object='(SUMM(d1.count)*SUMM(d1.cost))/SUMM(d2.salary)*SUMM(d2.salary)'/>
<term object='1.2'/>
<action type='less'/>
</case>
</where>
<order by='some_db_table1.title' way='ascend'/> ;Optional tag
<limit count='20'/> ; Optional tag
<group by='some_db_table1.uid'/> ; Optional tag
</set>
</dbset:dataset>
<!-- Разработчики могут задавать следующую структуру данных:
<dbset:dataset>
<query>INLINE DATABASE QUERY
<columns>
<item name='selected-column-name' import-as='NAME IN XSL VARIABLE ENVIRONMENT'/>
</columns>
</dbset:dataset>
-->
<functions-import>
<item name='{php_environment_function}' as='{xsl_environment_name}'/>
;...
</functions-import>
<vars-import>
<item name='{php_environment_variable}' as='{xsl_environment_variable}'/>
</vars-import>
<wrappers>
<item name='{php_valid_function_or_method_name}' step='0'/>
</wrappers>
</input>


Данная структура полностью описывает формат возможных данных для процессинга XSLT-процессором, применяя таблицы трансформации.

Стоит отдельно упомянуть такие элементы как <functions-import/>, <variables-import/> и <wrappers/>.

В теле элемента <functions-import/> перечисляются те функции среды PHP, которые должны быть импортированы в среду XSL, и соответственно <vars-import/> вложенными тегами <items/> описывает переменные среды PHP, которые будут доступны для обращения в среде XSL.

То есть это как-бы расширения стандарта XSL, подобно аналогичному - EXSLT, которое служит для увеличения уровня автономности и самобытности дизайнера (что, конечно, в любом случае не является желательным по ряду обстоятельств ).

Расширение стандарта поддерживается подключением в качестве пре-процессоров XSL внешних wrapper-методов, которые обспечивают предварительную подготовку и замену всех "самодельных" конструкций, на необходимые аналоги (обращение к импортированным функциям, переменным). Очевидно, что число wrapper'ов не ограничено ни чем, что, собственно, не ограничивает расширение стандарта.
При этом учтён тот факт, что некоторые такие методы следует применять в условиях последовательности, а посему введён такой параметр как `step`, которые говорит обработчику в какой последовательности применять wrapper-методы.

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

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

Однако прежде чем говорить о блоках, следует обсудить структуру страницы.

Я всегда был приверженцем проработки всех возможных ситуаций и вариантов, и конечно же все считал, что пользователю в определённый момент наскучит базовое оформление страницы, да и даже если не базовое - наскучит, посему всегда считал невозможным применение термина CMS к продуктам, в основе которых лежат идеи не только того, что пользователь потом "всё равно будут платить за дизайн", или "все должны будут выучить эту технологию", "..мы делаем систему для "нормальных людей", а они эту технологию почти все знаю...", не говоря уже об интернационализации и прочем.

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

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

1. Декларирование в настройках темы её структуры, в смысле активных областей для добавления блоков.
2. Специальные контейнеры для отображения стека системных сообщений некоторого типа, с применением (опционально) к ним стилевого оформления, характерного данной теме.
3. Абстрагирование от количества доступных модулей/пакетов в системе.
4. Абстрагирование от текущих интернациональных настроек системы.
5. Предоставление пользователю возможность собственноручно настраивать некоторые детали оформления, путём правки значений в файле настроек.

Так, в контексте не один раз упомянутой выше технологии XSL, системой в тему оформления портируются следующие структуры данных и методы:

Структуры:

1)

<handlers>
<set type='errors'> ; 'errors' | 'messages' | 'attempts'
<item code='error_code'>Short system error description</item>
</set>
</handlaers>

2)

<infoset>
<!--структура аналогична структуре вложенного в узел <input> элемента<infoset>, за исключением изъятия элементов <css>,<scripts>-->
</infoset>


Методы:

get_panel_content(< %идентификатор_панели%>) - получение блоков, которые относятся к данной панели, некоторой темы.
get_css_nodes() - отрисовка и возврат всех относящихся к данному документу таблиц стилей
get_scripts_nodes() - отрисовка и возврат всех относящихся документу скриптов
flush_error_handler(< %handler%>) ; handler='errors'|'messages'|'attempts'


Что ж, это было что-то вроде небольшого обзора, представления своих взглядов на решение проблемы, которые я использую в настощиее время. В целом многие идеологические моменты в реализации подсказаны Drupal, но исключительно идеологические, поскольку структура друпала совершенно обратна данной, и ориэнтирована скорее на разработчиков, нежели на нечто среднее с уклоном в сторону дизайнера и UI-интерфейс builder'а.

1. Более полная реализация ООП-подхода: явное присутствие сущности "класс", и "реализуемый интерфейс", инкапсуляция (установление уровня
доступности элементов класса посредством операторов "public" и "private"),
наследование, полиморфизм.
2. Присутствует понятие "динамичного класса", поля и методы которого, в момент инициализация не были объявлены
3. Реализация виртуальных instant no fax payday loanbank loan no payday statementno fax payday advance loan1 hour payday loancash advance payday loanfax payday loan,payday loan without fax,fax less payday loanadvance cash net payday usaloan online payday quickpayday loan in 1 hour,1 hour loan payday,1 hour payday loanameriloan loan paydayaafes payday loanonline payday loan servicepayday loan application,application loan paydaycash fast loan online paydayinstant approval payday loan,approval instant loan payday100 loan online paydayconsolidate debt loan payday,consolidate payday loan debtfast fax loan no paydayloan payday toronto,payday loan toronto,payday loan in torontocash fast loan paydaycash central loan paydaydefault loan paydayfree payday advance loan,free loan payday,interest free payday loaninternet payday loan law,internet loan payday,business internet loan payday startpayday loan in georgiafaxing loan no payday,faxing loan military no payday,500 faxing loan no paydayapproval guaranteed loan paydayemergency payday loanno faxing instant payday loancanadian loan online payday,canadian payday loanday loan payday same,day loan no payday same teletracklow fee payday loanfast loan payday,cash fast loan online payday search,approval fast loan paydaycash until payday loanamerica cash loan paydayadvance loan payday software? ?cashloan till paydaymilitary payday loanadvance america payday loanaafes loan paydayadvance cash loan payday softwareloan money payday treefaxless payday loanno fax payday cash advancecheap loan payday tillcompletely instant loan online payday,instant online payday loangeorgia in loan online payday,georgia loan paydayadvance cash loan? payday ?online payday cash loanday loan payday quick same,same day payday loan,day faxless loan payday same функций и "мета"-методов для чтения и записи значений полей класса (методы "get(value)" и "set(name,value)")
4. Возможность задания атрибута "final" относительно класса, для явного указания невозможности его
расширения и перезаписи методов после создания его экземпляра.
5. Понятие Meta-класса
6. Введение понятия прототип (Prototype)

Доброго времени суток уважаемые читатели !

В этой статье я бы хотел поговорить о многоязычных приложениях, а именно создание оных в контексте технологии JavaScript и XHTML, без использования при этом произвольных серверных технологий.
Каждый из нас, кто когда-то непосредственно сталкивался с разработкой многоязычных приложений, знает всю их многогранность и в некоторых случаях неоднозначность создания. Так например, иногда клиенту необходимо отправить, предположим, опросник, в котором бы клиент указал, что именно он хочет, как он этого хочет, и что может за это отдать.
Вот тут и появляется вопрос: «А если клиент иностранец ?», то есть уже из этого вопроса, появляется ещё один вопрос: «Как же рациональнее всего реализовать многоязычность ?». Конечно, можно изначально перевести документ на несколько языков, после же отправлять заказчику один из них. Да, это безусловно допустимо, и наиболее используемо в контексте современных веб-студий и прочих компаний так или иначе ведущих диалог с заказчиками.
Я же выбрал иной подход, который считаю немного более гибкий и практичный, при чём ничем не уступающий «ручному» разбиению на языки. Суть его заключается в введении системы шаблонирования, и преобразовании языковых единиц в переменные шаблона, которые в последствии будут заменены в теже языковые единицы, однако относящиеся к другому языку. Пример схожего механизма можно наблюдать повсеместно в системах, так или иначе использующих шаблонирование в интерфейсе или в целом во внутренней реализации системы. Так ярким примеров систем-шаблонизаторов могут служить такие системы как PatTemplaters, Smarty и прочее. В них результирующие данные формируются на основании некоторых входящих данных (переменных шаблона) которые «подставляются» в шаблон, после чего выполняются в контексте заданного набора алгоритмической логики шаблона, и возвращаются ввиде обработанного текста.
В нашем случае всё аналогично, однако парсер JSTemplater 0.5Afla создан в расчете на функционирование на стороне клиента, и в качестве входящих данных принимает не текст шаблона, а весь текущий HTML-документ, начиная тегом , и закачивая местом вызова метода для рендеринга служебных конструкций, которые были обнаружены в HTML-документе.
Но говорим мы сейчас не о предмете парсера JSTemplater 0.5 Alfa, а о том как его использовать на практике. Но ведь для этого вам необходимо как минимум скачать его, для этого перейдите по следующему адресу: http://e-code.tnt43.com/sources/jsTemplater.zip (ZIP-packed archive).
(more...)

Подробности здесь.

Предположим что на сайте есть форма, в которую пользователь должен ввести свои логин и пароль. Далее при нажатие на кнопку submit введенные им данные попадают в наш класс, скажем, class UserLogin { }. Казалось бы, чего сложного, проверить в базе и дальше авторизировать или нет. Для штучных, единичных и маленьких проектах, которые никогда и не будут развиватся, подобный подход самый быстрый и удобный, но когда надо написать нечно большое и развивающееся, здесь не обойтись без ООП.

Пароли могут хранится не только в базе SQL на хосте, но и скажем в базе другого хоста или в LDAP. Способов может быть множество и модули, под каждый из этих способов, не обязательно должен быть написан вами и не обязательно во время создание сайта. Это могут делать совершенно другие люди.

Вернемся к нашему классу и предположим что другая группа программистов пишет класс который будет проверять данные пользователя в своей базе. Вы конечно можете потратить время на то что бы договорится с ними что вам нужно получить от них, но можно сократит его, начав говорить на универсальном языке, язык кода, а именно абстрактный класс. И вот он
abstract class loginModule{

}

Абстрактный класс указывает своему наследнику какие методы там должны быть, вернее обязаны быть. Например метод ifMember который получит пароль и логин, и метод getInfo() который должен вернуть данные пользователя которого нашли или false.

Теперь, ваши партнеры могут написать нечто похожее на вот это.
class checkldap extends loginmodule{
function ifMember($login, $pass){
// некий код проверки
$this->info=true;
}
}

И таких модулей может быть много главное чтоб они был extends loginmodule. После этого в нашем классе мы делаем следующее
class UserLogin{
$checkldap=new checkldap();
$checkldap->ifMember("login","pass");
If ($checkldap->getInfo()){
// похоже это их пользователь
}else{
// а возможно нет так что проверим у других
}
}

Вот так с помощью абстрактного класс можно заложить основу расширяемости проекта.

И напоследок:

» Абстрактные классы также могут содержать обычные (не абстрактные) элементы.
» Нельзя объявлять абстрактными свойства класса.
» Нельзя напрямую создавать экземпляр абстрактного класса.

Недавно опять вернувшись к проблеме выбора между doxygen'ом и phpDocumentor'ом (Doxygen vs phpDocumentor) решил написать для доксигена свой INPUT_FILTER. В прошлый раз как-то не стал изучать детально этот вопрос, просто порывшись в инете и не найдя ни одного фильтра для PHP забил на это.

Написал... классно получилось:) По сути фильтр решает все проблемы использования доксигена для php, которые я описывал ранее.

Фильтр делает следующие преобразования:

Заменяет self и parent на имена классов, т.к. доксиген их не понимает.
По тэгу @var прописывает типы у свойств и констант классов.
< ?
/**
* foo
* @var array
*/
public $foo;
//----------------------------------------------------------->
/**
* foo
*/
public array $foo;
?>

По описанию функции прописывает возвращаемый тип (тэг @return)
и типы параметров (@param). Если не задан return, то прописывает void.
< ?
/**
* Foo.
* @param string[] $bar1 Desciption...
* @param array $bar2 Desciption...
* @return array Desciption...
*/
public function foo($bar1, $bar2)
//----------------------------------------------------------->
/**
* Foo.
* @param $bar1 Desciption...
* @param $bar2 Desciption...
* @return Desciption...
*/
public function array foo(string[] $bar1, array $bar2)
?>

Заменяет ZendStudio-описание класса объекта на строку кода: "Type Object;" - определение переменной в Си.
В результате чего доксиген начинает прослеживать обращение к методам объектов заданных не явно (как альтернатива рефлексии:)).
< ?
/* @var $oMyVar My_Class */
//----------------------------------------------------------->
My_Class $MyVar;
?>

Убивает у всех переменных бакс (если DoxyphpConfig::$baks true).
Доксиген начинает понимать ссылки на св-ва класса (а с баксом обламывается).
Плюс документация получается красивше, т.к. $ в заточенном под Си доксигене выделяется отдельно от переменной.
Заменяет определение глобальных констант в стиле PHP (define)
на стиль Си: "const CONST = VALUE;" Т.к. define доксиген не понимает и соответственно
не видит объявленные константы.
Проставляет у всех переменных при присваивание значения префикс ("LN::").
Чтоб доксиген не воспринимал их как глобальные и не делал перекрестные ссылки.
Заменяет тэг package на addtogroup. Чтоб при обработке кода заточенного
под phpDocumentor доксиген не делал namespace из пакета (эт я для тестов натравливал фильтр на пакеты пира:)).
Заменяет "abstract class" на "class", т.к. доксиген абстрактные классы
обзывает протоколом и не прослеживает наследование для них.

Пример:
Имеем код
док phpDocumentor 1.3.1
док doxygen 1.5.2+graphviz
док doxygen 1.5.2+graphviz+doxyphp

В конфиге доксигена следует указать:
INPUT_FILTER = "/usr/bin/php doxyphp.php"
FILTER_SOURCE_FILES = YES
Тестировалось всё на php5.

Источник: http://flash-ripper.com/

Local SharedObject (LSO) подойдет для хранения
данных клиента на его машине; сервер разгружается и освобождается от хранения
избыточной информации[1].
Сохранение информации происходит мгновенно. LSO поддерживается Flash Player c
версии 6.0.40.0; не описан в стандартной документации по Flash. Компания Macromedia
дала своим поклонникам действительно мощный инструмент, но не рассказала об этом
в документации.

(more...)

Аргументы
(arguments)
Функция при вызове может принимать параметры,
называемые аргументами. При этом говорят
"функции
были переданы аргументы", или "функция
получила аргументы". Аргументы часто
используются при создании новых объектов
из классов (в этом
случае функция в качестве аргументов получает
параметры создаваемого объекта).

(more...)

В этом учебнике рассматривается создание трехколоночной темы для вебсайта на Joomla. Такими является большинство Joomla сайтов и это уже считается в некотором роде стандартом. Кроме того, позже можно будет скрыть неиспользуемые колонки.

Вообще-то, создать тему для Joomla сайта с помощью таблиц проще, так поступает большинство. Использование CSS требует большего профессионализма - научиться этому сложнее, кроме того, есть проблемы с интерпретацией CSS некоторыми браузерами. Поэтому, этот учебник предназначен для людей, имеющих опыт работы с CSS.
(more...)