├── .bsl-language-server.json ├── .devcontainer ├── devcontainer.json └── postCreateCommand.sh ├── .gitattributes ├── .github └── workflows │ ├── deploy-docs.yml │ ├── perfomance.yml │ ├── qa.yml │ ├── re-run-workflows.yml │ ├── rebase.yml │ ├── release.yml │ └── testing.yml ├── .gitignore ├── .vscode └── launch.json ├── CONTRIBUTING.md ├── LICENSE.md ├── README.md ├── autumn-properties.json ├── docs ├── api │ ├── 010-Аннотации │ │ ├── 010-Желудь.md │ │ ├── 020-Пластилин.md │ │ ├── 030-Дуб.md │ │ ├── 040-Завязь.md │ │ ├── 050-Деталька.md │ │ ├── 060-Блестяшка.md │ │ ├── 070-Табакерка.md │ │ ├── 080-ФинальныйШтрих.md │ │ ├── 081-Напильник.md │ │ ├── 100-Заготовка.md │ │ ├── 110-Рогатка.md │ │ ├── 120-Приемка.md │ │ ├── 130-Прозвище.md │ │ ├── 140-Верховный.md │ │ ├── 150-Порядок.md │ │ ├── 160-Характер.md │ │ ├── 170-ОсобоеОбращение.md │ │ ├── 180-Спецификация.md │ │ ├── 190-ПрилепляемаяКоллекция.md │ │ ├── 200-Аннотация.md │ │ └── 210-Повторяемый.md │ ├── 020-Желуди │ │ ├── 010-Поделка.md │ │ ├── 020-РазворачивательАннотаций.md │ │ ├── 030-КонтейнерАннотаций.md │ │ └── 040-ПрилепляторЧастиц.md │ ├── 030-Детальки │ │ └── core │ │ │ └── ЗапускатьРогатки.md │ ├── 040-Прилепляемые-коллекции │ │ ├── 010-Массив.md │ │ ├── 020-ТаблицаЗначений.md │ │ ├── 030-Соответствие.md │ │ ├── 040-Карта.md │ │ ├── 050-Множество.md │ │ └── 060-Список.md │ ├── 050-Классы │ │ ├── 20-СоветДругогоМастера.md │ │ ├── 30-Табакерка.md │ │ ├── 40-ОпределениеЖелудя.md │ │ ├── 50-ОпределениеАннотации.md │ │ ├── 60-Завязь.md │ │ └── 70-ПрилепляемаяЧастица.md │ ├── 060-Модули │ │ └── РаботаСАннотациями.md │ ├── 070-Напильники │ │ ├── ОбработкаНапильникомПластилинаНаПолях.md │ │ └── ОбработкаНапильникомФинальныйШтрих.md │ ├── 080-Приемки │ │ ├── Заготовка.md │ │ ├── Приемка.md │ │ └── Рогатка.md │ ├── 090-Перечисления │ │ ├── 10-ТипыПрилепляемыхЧастиц.md │ │ └── 20-ХарактерыЖелудей.md │ └── index.md ├── img │ ├── Отладчик.png │ ├── ПримерТеста.png │ └── РезультатПрогонаТестов.png ├── product │ ├── framework-elements │ │ ├── 010-component-declaration.md │ │ ├── 020-component-instance.md │ │ ├── 030-components-binding.md │ │ ├── 040-components-factory.md │ │ ├── 050-dependency-injection.md │ │ ├── 060-app-settings-injection.md │ │ ├── 070-custom-arguments.md │ │ ├── 080-instance-generator.md │ │ ├── 090-aliases.md │ │ ├── 100-aliases-grouping.md │ │ ├── 110-components-sorting.md │ │ ├── 120-components-prioritization.md │ │ ├── 130-component-overriding.md │ │ ├── 140-component-post-initialization.md │ │ ├── 150-component-uniqueness.md │ │ ├── 160-additional-processing.md │ │ ├── 170-app-context.md │ │ ├── 180-conditional-registration.md │ │ ├── 190-launch-control-inversion.md │ │ ├── 200-custom-annotations.md │ │ ├── 210-annotation-inheritance.md │ │ ├── 220-annotations-processing.md │ │ ├── 980-changelog.md │ │ └── 990-end.md │ └── getting-started │ │ ├── 10-about-autumn.md │ │ └── 20-first-steps.md └── static │ └── cover.png ├── packagedef ├── performance_tests └── Производительность.os ├── sonar-project.properties ├── src ├── internal │ ├── Классы │ │ ├── _ПриемкаПриемка.os │ │ ├── АннотацияБлестяшка.os │ │ ├── АннотацияВерховный.os │ │ ├── АннотацияДеталька.os │ │ ├── АннотацияДуб.os │ │ ├── АннотацияЖелудь.os │ │ ├── АннотацияЗавязь.os │ │ ├── АннотацияЗаготовка.os │ │ ├── АннотацияНапильник.os │ │ ├── АннотацияОсобоеОбращение.os │ │ ├── АннотацияПластилин.os │ │ ├── АннотацияПорядок.os │ │ ├── АннотацияПриемка.os │ │ ├── АннотацияПрозвище.os │ │ ├── АннотацияРогатка.os │ │ ├── АннотацияСпецификация.os │ │ ├── АннотацияТабакерка.os │ │ ├── АннотацияФинальныйШтрих.os │ │ ├── АннотацияХарактер.os │ │ ├── ЗапускательПриложения.os │ │ ├── ОбработкаНапильникомПластилинаНаПолях.os │ │ ├── ОбработкаНапильникомФинальныйШтрих.os │ │ ├── Осенизатор.os │ │ ├── ПриемкаЗаготовка.os │ │ ├── ПриемкаРогатка.os │ │ ├── ПрилепляторЧастиц.os │ │ ├── СлужебныйДубОсени.os │ │ └── ФабрикаЖелудей.os │ └── Модули │ │ └── ФабричныеМетоды.os ├── Классы │ ├── Завязь.os │ ├── ОпределениеЖелудя.os │ ├── Поделка.os │ ├── ПрилепляемаяЧастица.os │ ├── СоветДругогоМастера.os │ └── Табакерка.os └── Модули │ ├── Осень.os │ ├── СостоянияПриложения.os │ ├── ТипыПрилепляемыхЖелудей.os │ ├── ТипыПрилепляемыхЧастиц.os │ └── ХарактерыЖелудей.os ├── tasks ├── coverage.os ├── oscript.cfg ├── performance.os ├── test.os └── testIsolated.os └── tests ├── oscript.cfg ├── ВнешнееПриложение.os ├── Заготовки └── Классы │ ├── ЗаготовкаСДеталькой.os │ └── ТестовыйИнициализатор.os ├── ИзолированныеТесты ├── oscript.cfg ├── ВЗаготовкуНельзяПрилепитьПластилин.os ├── ДваЖелудяСОднимИменемКонфликтуют.os ├── ДвухВерховныхЖелудейБытьНеМожет.os ├── ПадениеРогаткиДолжноБытьЗалогировано.os ├── ПовторениеНеповторяемыхПараметровКидаетИсключение.os └── ПроверкаНекорректногоХарактера.os ├── КаталогНастроекСОтключеннымиРогатками └── autumn-properties.json ├── ОдноименныеЖелуди ├── lib.config └── Классы │ ├── ВерховныйКругляш.os │ ├── ВерховныйТестовыйЖелудь.os │ ├── Желудь1.os │ ├── Желудь2.os │ ├── Желудь3.os │ ├── Желудь4.os │ └── Желудь5.os ├── ОшибочныеКлассы ├── АннотацияСПовторяемымиПараметрами │ └── Классы │ │ ├── АннотацияСПовторяемымиПараметрами.os │ │ └── ЖелудьСНекорректнымиНеПовторяемымиПараметрами.os ├── ДваВерховныхЖелудя │ └── Классы │ │ ├── ВерховныйТестовыйЖелудь.os │ │ └── ВторойВерховныйТестовыйЖелудь.os ├── ДваЖелудяСОднимИменем │ └── Классы │ │ ├── Желудь1.os │ │ └── Желудь2.os ├── ЖелудьСНекорректнымХарактером │ └── Классы │ │ └── ЖелудьСНекорректнымХарактером.os ├── ЗаготовкаСПластилином │ └── Классы │ │ └── ЗаготовкаСПластилином.os └── ПадающаяРогатка │ └── Классы │ └── ПадающаяРогатка.os ├── Поделка.os ├── СоветДругогоМастера.os └── ТестКлассы └── Классы ├── АннотацияКонструкторМассива.os ├── АннотацияКонтроллер.os ├── АннотацияМетаБлестяшка.os ├── АннотацияМетаЗавязь.os ├── АннотацияМетаПрозвище.os ├── ВерхнеУровневыйЖелудь.os ├── ГлавныйДуб.os ├── ДолгаяРогатка.os ├── ДубКонструктора.os ├── ДубСБлестяшкамиВПластилине.os ├── ЖелудьИзбирательноПрименяющийНапильники.os ├── ЖелудьНижнегоУровня.os ├── ЖелудьСБлестяшкой.os ├── ЖелудьСБлестяшкойВТабакерке.os ├── ЖелудьСБлестяшкойПластелиномДеталькой.os ├── ЖелудьСДеталькойИзСоответствия.os ├── ЖелудьСКомпанейскойТабакеркой.os ├── ЖелудьСКонструкторомМассива.os ├── ЖелудьСМетаБлестяшкой.os ├── ЖелудьСНастройками.os ├── ЖелудьСОтключеннымиНапильниками.os ├── ЖелудьСТабакеркой.os ├── КомпанейскийЖелудь.os ├── КомпанейскийЖелудьСПластилиномВКонструкторе.os ├── КомпанейскийЖелудьСПластилиномНаПолях.os ├── МногоимённыйЖелудь.os ├── МокАппендера.os ├── НапильникПрименяющийсяТолькоНаКонкретномЖелуде.os ├── НапильникПрименяющийсяТолькоНаКругляшах.os ├── НапильникСЖелудемВКонструкторе.os ├── ПользовательскийКонтроллер.os ├── ПользовательскийКонтроллерСМаршрутом.os ├── ПрилепляемаяКоллекцияСтрока.os ├── РогаткаМеняющаяМассив.os ├── РогаткаПриоритет1.os ├── РогаткаПриоритет2.os └── РогаткаПриоритет3.os /.bsl-language-server.json: -------------------------------------------------------------------------------- 1 | { 2 | "diagnostics": { 3 | "parameters": { 4 | "IncorrectLineBreak": { 5 | "listOfIncorrectFirstSymbol": ";" 6 | }, 7 | "Typo": { 8 | "userWordsToIgnore": "Разворачиватель,Блестяшка,Блестяшек,Блестяшки,Блестяшками,Блестяшку,Блестяшкой,Инит,Структурочка,Запускатель,Осенизатор,Прилеплятор,Просканированные,Аппендера" 9 | } 10 | } 11 | }, 12 | "codeLens": { 13 | "testRunner": { 14 | "testSources": [ 15 | "tests", 16 | "performance_tests" 17 | ] 18 | } 19 | } 20 | } -------------------------------------------------------------------------------- /.devcontainer/devcontainer.json: -------------------------------------------------------------------------------- 1 | // For format details, see https://aka.ms/devcontainer.json. For config options, see the 2 | // README at: https://github.com/devcontainers/templates/tree/main/src/ubuntu 3 | { 4 | "name": "Ubuntu", 5 | // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile 6 | "image": "mcr.microsoft.com/devcontainers/base:jammy", 7 | 8 | // Features to add to the dev container. More info: https://containers.dev/features. 9 | "features": { 10 | "ghcr.io/rocker-org/devcontainer-features/apt-packages:1": { 11 | "packages": [ 12 | "mono-complete" 13 | ] 14 | }, 15 | "ghcr.io/devcontainers-extra/features/gh-release:1": { 16 | "repo": "oscript-library/ovm", 17 | "version": "latest", 18 | "binaryNames": "ovm.exe", 19 | "additionalFlags": [ 20 | "--no-filter-assets-by-platform" 21 | ] 22 | } 23 | }, 24 | 25 | // Use 'forwardPorts' to make a list of ports inside the container available locally. 26 | // "forwardPorts": [], 27 | 28 | // Use 'postCreateCommand' to run commands after the container is created. 29 | "postCreateCommand": "bash .devcontainer/postCreateCommand.sh", 30 | 31 | "postAttachCommand": "source /home/vscode/.profile", 32 | 33 | // Configure tool-specific properties. 34 | "customizations": { 35 | "vscode": { 36 | "extensions":[ 37 | "1c-syntax.language-1c-bsl", 38 | "EvilBeaver.oscript-debug", 39 | "zhuangtongfa.material-theme", 40 | "yzhang.markdown-all-in-one", 41 | "GitHub.copilot", 42 | "GitHub.copilot-chat" 43 | ], 44 | 45 | "settings": { 46 | "language-1c-bsl.languageServerReleaseChannel": "prerelease" 47 | } 48 | } 49 | }, 50 | 51 | "containerEnv": { 52 | "LC_ALL": "en_US.UTF-8" 53 | } 54 | 55 | // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root. 56 | // "remoteUser": "root" 57 | } 58 | -------------------------------------------------------------------------------- /.devcontainer/postCreateCommand.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -eux 4 | 5 | mkdir -p /home/vscode/.local/bin 6 | echo "mono /usr/local/bin/ovm.exe \"\$@\"" > /home/vscode/.local/bin/ovm 7 | chmod +x /home/vscode/.local/bin/ovm 8 | 9 | ovm use --install dev 10 | 11 | source /home/vscode/.profile 12 | 13 | opm install opm 14 | opm install oscript-config 15 | opm install -l 16 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | * text=auto eol=lf 2 | -------------------------------------------------------------------------------- /.github/workflows/deploy-docs.yml: -------------------------------------------------------------------------------- 1 | name: Публикация документации 2 | 3 | on: 4 | push: 5 | paths: 6 | - 'docs/**' 7 | branches: 8 | - 'master' 9 | workflow_dispatch: 10 | 11 | jobs: 12 | deploy-docs: 13 | uses: autumn-library/workflows/.github/workflows/deploy-docs.yml@main 14 | with: 15 | github_repository: autumn-library/autumn 16 | secrets: inherit 17 | -------------------------------------------------------------------------------- /.github/workflows/perfomance.yml: -------------------------------------------------------------------------------- 1 | name: Производительность 2 | 3 | on: 4 | push: 5 | pull_request: 6 | workflow_dispatch: 7 | 8 | jobs: 9 | test: 10 | strategy: 11 | fail-fast: false 12 | matrix: 13 | oscript_version: ['dev', 'lts-dev', 'default'] 14 | uses: autumn-library/workflows/.github/workflows/test.yml@main 15 | with: 16 | oscript_version: ${{ matrix.oscript_version }} 17 | test_script_path: './tasks/performance.os' 18 | -------------------------------------------------------------------------------- /.github/workflows/qa.yml: -------------------------------------------------------------------------------- 1 | name: Контроль качества 2 | 3 | on: 4 | push: 5 | pull_request: 6 | workflow_dispatch: 7 | 8 | jobs: 9 | sonar: 10 | uses: autumn-library/workflows/.github/workflows/sonar.yml@coverage 11 | with: 12 | github_repository: autumn-library/autumn 13 | coveralls: true 14 | secrets: 15 | SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} 16 | 17 | -------------------------------------------------------------------------------- /.github/workflows/re-run-workflows.yml: -------------------------------------------------------------------------------- 1 | on: 2 | issue_comment: 3 | types: [created] 4 | 5 | jobs: 6 | rerun_pr_tests: 7 | name: rerun_pr_tests 8 | if: ${{ github.event.issue.pull_request }} 9 | runs-on: ubuntu-latest 10 | steps: 11 | - uses: estroz/rerun-actions@main 12 | with: 13 | repo_token: ${{ secrets.GITHUB_TOKEN }} 14 | comment_id: ${{ github.event.comment.id }} 15 | -------------------------------------------------------------------------------- /.github/workflows/rebase.yml: -------------------------------------------------------------------------------- 1 | name: Automatic Rebase 2 | on: 3 | issue_comment: 4 | types: [created] 5 | jobs: 6 | rebase: 7 | name: Rebase 8 | if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/rebase') 9 | runs-on: ubuntu-latest 10 | steps: 11 | - name: Checkout the latest code 12 | uses: actions/checkout@v4 13 | with: 14 | token: ${{ secrets.GITHUB_TOKEN }} 15 | fetch-depth: 0 # otherwise, you will fail to push refs to dest repo 16 | - name: Automatic Rebase 17 | uses: cirrus-actions/rebase@1.8 18 | env: 19 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} 20 | -------------------------------------------------------------------------------- /.github/workflows/release.yml: -------------------------------------------------------------------------------- 1 | name: Публикация релиза 2 | 3 | on: 4 | release: 5 | types: 6 | - published 7 | workflow_dispatch: 8 | 9 | jobs: 10 | release: 11 | uses: autumn-library/workflows/.github/workflows/release.yml@main 12 | with: 13 | package_mask: "autumn-*.ospx" 14 | secrets: 15 | PUSH_TOKEN: ${{ secrets.PUSH_TOKEN }} 16 | -------------------------------------------------------------------------------- /.github/workflows/testing.yml: -------------------------------------------------------------------------------- 1 | name: Тестирование 2 | 3 | on: 4 | push: 5 | pull_request: 6 | workflow_dispatch: 7 | 8 | jobs: 9 | test: 10 | strategy: 11 | fail-fast: false 12 | matrix: 13 | oscript_version: ['dev', 'lts-dev', 'default'] 14 | uses: autumn-library/workflows/.github/workflows/test.yml@main 15 | with: 16 | oscript_version: ${{ matrix.oscript_version }} 17 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | out/ 2 | oscript_modules/ 3 | *.ospx 4 | -------------------------------------------------------------------------------- /.vscode/launch.json: -------------------------------------------------------------------------------- 1 | { 2 | // Используйте IntelliSense, чтобы узнать о возможных атрибутах. 3 | // Наведите указатель мыши, чтобы просмотреть описания существующих атрибутов. 4 | // Для получения дополнительной информации посетите: https://go.microsoft.com/fwlink/?linkid=830387 5 | "version": "0.2.0", 6 | "configurations": [ 7 | { 8 | "name": "Отладка 1Script", 9 | "type": "oscript", 10 | "request": "launch", 11 | "program": "${file}", 12 | "args": [], 13 | "cwd": "${workspaceRoot}", 14 | "env": {}, 15 | "windows": { 16 | "runtimeExecutable": "${env:OVM_OSCRIPTBIN}/oscript.exe" 17 | }, 18 | "linux": { 19 | "runtimeExecutable": "${env:OVM_OSCRIPTBIN}/oscript" 20 | }, 21 | "osx": { 22 | "runtimeExecutable": "${env:OVM_OSCRIPTBIN}/oscript" 23 | }, 24 | "runtimeArgs": [], 25 | "debugPort": 2801 26 | } 27 | ] 28 | } -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Руководство осеннего контрибьютера 2 | 3 | ## Введение 4 | 5 | Здравствуй, если ты здесь, значит осень захватила тебя, и ты решил превратить нашу еще пока сырую осень, в замечательную золотую осень. 6 | Впереди долгий путь, и тебе нужно быть сильным и смлым. А это руководство поможет тебе. 7 | 8 | ## Настройка окружения 9 | 10 | * Необходимо установить oscript и ovm - последних версий. Осень - инновационный продукт, и использует все новые возможности языка. Потому для корректной работы, необходима последнияя версия oscript. 11 | 12 | * Установи Git 13 | 14 | * Желательно, но не обязательно поставить [Visual studio code](https://code.visualstudio.com/) c расширениями [1C (BSL) Extension Pack](https://marketplace.visualstudio.com/items?itemName=astrizhachuk.1c-extension-pack). 15 | 16 | ## Перед тем как приступить 17 | 18 | * Сделай форк этого репозитория себе. 19 | 20 | * Склонируй свою версию репозитория к себе в рабочее окружение. 21 | 22 | ```cmd 23 | git clone 24 | ``` 25 | 26 | * Перейди в созданную папку и создай ветку в которой ты будешь делать свои доработки 27 | 28 | ```cmd 29 | git checkout -b <ИмяТвоейВетки> 30 | ``` 31 | 32 | ## Инициализация зависимостей 33 | 34 | * Для корректной работы и проверки необходимо инициализировать зависимости. 35 | 36 | ```cmd 37 | Opm install -l --dev 38 | ``` 39 | 40 | Для целей разработки используются версии пакетов которые установятся в папку `oscript_modules` 41 | 42 | * Можете проверить что все равботает запустив тесты 43 | 44 | ```cmd 45 | Oscript tasks/test.os 46 | ``` 47 | 48 | Если все прошло гладко, вы получите мини отчет, что то в этом духе 49 | 50 | ![РезультатПрогонаТестов](docs/img/РезультатПрогонаТестов.png) 51 | 52 | ## Настройка отладки 53 | Как известно, нормальному программисту отладка не нужна, отлаживай через вызватьИсключение. 54 | 55 | Но если ты все таки слаб духом, то: 56 | 57 | 1. Открывай вкладку "Запуск и отладка"(Плагин для отладки мы установили ранее вместе с 1C (BSL) Extension Pack) 58 | 59 | 2. Проверяй, что в файле [launch.json](.vscode/launch.json) актуальные настройки 60 | 61 | 3. Открывай файл, который ты хочешь запустить с отладкой(например [test.os](tasks/test.os)) 62 | 63 | 4. Нажимай кнопку "Начать отладку" 64 | ![Пример отладки](docs/img/Отладчик.png) 65 | 66 | ## Начни с тестов 67 | 68 | Если ты делаешь новый функционал, то его надо будет как-то проверить, а заодно, было бы здорово, чтобы любой другой мог проверить потом, что не разломал твой код после очередного обновления. 69 | 70 | На данный момент существует несколько основных наборов тестов наборов тестов. 71 | 72 | * [Базовый набор](tests/Поделка.os) Зесь размещается основной набор тестов базовой функциональности осени 73 | * [Тесты функционала внешнего приложения](tests/ВнешнееПриложение.os) здесь собираются тесты связанные с заготовками и тд. 74 | * [Тесты производительности приложения](performance_tests/Производительность.os) здесь собираются svt-тесты 75 | 76 | Выбери куда должны быть добавлены твои тесты и опиши их примерно так: 77 | ![ПримерОписанияТеста](docs/img/ПримерТеста.png) 78 | 79 | ## Разработка 80 | 81 | Если ты дошел до этого пункта - вряд-ли тебе нужны какие-то советы по разработке. 82 | ![Просто делай нормально](https://i.pinimg.com/originals/3a/7a/77/3a7a7730943d7fbf3d45adb272d9769e.jpg) 83 | 84 | ## Перед тем как завершить 85 | 86 | 1. Прогони тесты, падающих быть не дожно. Если ты меняешь функционал так, что тесты и не должны работать - откорректируй их. В этом случае обязательно оставь в ПР комментарий, почему тесты которые ты правишь - больше не актуальны. 87 | 2. Если ты добавил новую фичу - опиши ее в документации. Неописаная фича - работа в стол, вероятность что ей будут активно пользоваться очень мала. 88 | 3. перед отправкой изменений - обязательно проверь, что ничего лишнего не попало в репозиторий. 89 | В удаленном репозитории не должно быть папки `oscript_modules` и `out`, не должно быть никаких лишних, не относящихся к твоей фиче файлов 90 | 91 | ## Создай Pull-request 92 | 93 | Все, новая фича готова чтобы показать ее миру! Самое время создать ПР и поделиться ей с сообществом. -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | ===================== 3 | 4 | Copyright © `2022` `Nikita Fedkin ` 5 | 6 | Permission is hereby granted, free of charge, to any person 7 | obtaining a copy of this software and associated documentation 8 | files (the “Software”), to deal in the Software without 9 | restriction, including without limitation the rights to use, 10 | copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | copies of the Software, and to permit persons to whom the 12 | Software is furnished to do so, subject to the following 13 | conditions: 14 | 15 | The above copyright notice and this permission notice shall be 16 | included in all copies or substantial portions of the Software. 17 | 18 | THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, 19 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | OTHER DEALINGS IN THE SOFTWARE. 26 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Autumn/ОСень 2 | 3 | [![Тестирование](https://github.com/autumn-library/autumn/actions/workflows/testing.yml/badge.svg?branch=master)](https://github.com/autumn-library/autumn/actions/workflows/testing.yml) 4 | [![Статус порога качества](https://sonar.openbsl.ru/api/project_badges/measure?project=autumn&metric=alert_status)](https://sonar.openbsl.ru/dashboard?id=autumn) 5 | 6 | > Что такое осень - это желудь! 7 | 8 | 🍂 https://autumn-library.github.io 🍂 9 | 10 | Осень…. прекрасная пора. Ею вдохновлялся Пушкин, говорил, что осенью его особенно прёт. Именно это и произошло с авторами фреймворка "ОСень". Потому что осень - это прекрасно. 11 | Когда приложение становится большим, вам потребуется дерево (желательно дуб) и немного пластилина. Ах, да, обязательно творческое осеннее настроение, чай и стабильная психика. 12 | 13 | Фреймворк компонентных приложений для 1Script под названием "ОСень" поможет вам невероятным магическим образом компоновать ваше приложение из компонентов, которым не нужно заниматься собственным созданием или настройкой. И все это будет щедро обмазано пластилином и приятно пахнуть дубовыми вениками. 14 | 15 | --- 16 | 17 | Подробная документация по библиотеке доступна на сайте: https://autumn-library.github.io 18 | 19 | Исходный код документации располагается в каталоге [/docs](./docs) 20 | 21 | Приятного пользования! 🍂 22 | -------------------------------------------------------------------------------- /autumn-properties.json: -------------------------------------------------------------------------------- 1 | { 2 | "ПростаяНастройка": "Значение простой настройки", 3 | "Настройки": { 4 | "ОченьХитраяНастройка": "Значение очень хитрой настройки" 5 | }, 6 | "МассивНастроек":[1,2,3] 7 | } 8 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/010-Желудь.md: -------------------------------------------------------------------------------- 1 | # АннотацияЖелудь 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Помечает указанный класс как желудь - компонент, жизненным циклом которого управляет фреймворк ОСень. 7 | // 8 | // Размещается над конструктором класса. 9 | // 10 | // Параметры: 11 | // Значение - Строка - Имя желудя. По умолчанию будет использовано имя типа объекта, 12 | // как оно возвращается функцией `ТипЗнч`. 13 | // 14 | // Пример: 15 | // &Желудь 16 | // Процедура ПриСозданииОбъекта() 17 | // КонецПроцедуры 18 | // 19 | Процедура ПриСозданииОбъекта(Значение = "") 20 | ``` 21 | 22 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/020-Пластилин.md: -------------------------------------------------------------------------------- 1 | # АннотацияПластилин 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Маркерная аннотация для указания, что прилепляемая частица 7 | // является желудем. Основной способ связывания желудей между собой. 8 | // 9 | // Может быть использована над параметром конструктора/метода завязи желудя, полем класса 10 | // или методом установки значения. 11 | // 12 | // Параметры: 13 | // Значение - Строка - Имя прилепляемого желудя. Если не заполнено, используется имя параметра конструктора/поля 14 | // класса или часть имени метода для установки значения. 15 | // Тип - Строка - Тип прилепляемого желудя. В случае передачи значения "Желудь", будет внедрен желудь как таковой. 16 | // Так же может быть указан тип-коллекция: "Массив", "ТаблицаЗначений" и другие. Полный список 17 | // доступных типов см. в библиотеке 18 | // [autumn-collections](https://github.com/autumn-library/autumn-collections). 19 | // Блестяшка - Произвольный - Повторяемый параметр. Передаваемые в прилепляемый желудь произвольные значения. 20 | // 21 | // Пример: 22 | // 23 | // 1. 24 | // &Желудь 25 | // Процедура ПриСозданииОбъекта(&Пластилин ДругойЖелудь) 26 | // 27 | // 2. 28 | // &Желудь 29 | // Процедура ПриСозданииОбъекта( 30 | // . &Пластилин(Значение = "ДругойЖелудь", Тип = "Массив", Блестяшка = "Парам1", Блестяшка = "Парам2") Зависимость 31 | // ) 32 | // 33 | // 3. 34 | // &Пластилин 35 | // Перем ДругойЖелудь; 36 | // 37 | // 4. 38 | // &Завязь 39 | // Функция МойЖелудь(&Пластилин ДругойЖелудь) Экспорт 40 | // 41 | // 5. 42 | // &Пластилин 43 | // Процедура УстановитьДругойЖелудь(Зависимость) Экспорт 44 | // 45 | Процедура ПриСозданииОбъекта(Повторяемый = Блестяшка = Неопределено) 46 | ``` 47 | 48 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/030-Дуб.md: -------------------------------------------------------------------------------- 1 | # АннотацияДуб 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Помечает указанный класс как фабрику компонентов - дуб, из которого появляются желуди. 7 | // `&Дуб` сам по себе тоже является желудем, то есть может запрашивать прилепление частиц, 8 | // является объектом для обработки `&Напильник`ом, может иметь `&Спецификация` и так далее. 9 | // 10 | // Дуб обычно содержит методы, помеченные аннотацией `&Завязь`, которые возвращают желуди, но 11 | // может содержать и другие методы, не связанные непосредственно с созданием желудей. 12 | // 13 | // Размещается над конструктором класса. 14 | // 15 | // Параметры: 16 | // Значение - Строка - Имя желудя. По умолчанию будет использовано имя типа объекта, 17 | // как оно возвращается функцией `ТипЗнч`. 18 | // Пример: 19 | // &Дуб 20 | // Процедура ПриСозданииОбъекта() 21 | // КонецПроцедуры 22 | // . 23 | // &Завязь 24 | // Функция ПользовательскийЖелудь() Экспорт 25 | // . Возврат Новый ПользовательскийЖелудь(); 26 | // КонецФункции 27 | // 28 | Процедура ПриСозданииОбъекта(Значение = "") 29 | ``` 30 | 31 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/040-Завязь.md: -------------------------------------------------------------------------------- 1 | # АннотацияЗавязь 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Помечает функцию как функцию, создающую желудь. 7 | // 8 | // Может иметь параметры, каждый из которых должен быть промаркирован как &Пластилин, &Деталька или &Блестяшка. 9 | // В указанные параметры автоматически будут прилеплены соответствующие частицы при создании желудя. 10 | // 11 | // Может размещаться над экспортной функцией в классе, проаннотированном как `&Дуб`, или над методом-лямбдой, 12 | // передаваемой в качестве параметра в `Поделка.ДобавитьЗавязь()`. 13 | // 14 | // Параметры: 15 | // Значение - Строка - Имя создаваемого желудя. По умолчанию будет использовано имя метода. 16 | // Тип - Строка - Тип создаваемого желудя. 17 | // Требуется если по имени желудя не получается однозначного определить его тип. 18 | // 19 | // Пример: 20 | // &Завязь 21 | // Функция ПользовательскийЖелудь(&Пластилин Зависимость, &Деталька ВажнаяНастройка) Экспорт 22 | // . Возврат Новый ПользовательскийЖелудь(Зависимость, ВажнаяНастройка); 23 | // КонецФункции 24 | // 25 | Процедура ПриСозданииОбъекта(Значение = "", Тип = "") 26 | ``` 27 | 28 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/050-Деталька.md: -------------------------------------------------------------------------------- 1 | # АннотацияДеталька 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Маркерная аннотация для указания, что прилепляемая частица 7 | // является настройкой приложения. 8 | // 9 | // Может быть использована над параметром конструктора/метода завязи желудя, полем класса 10 | // или методом установки значения. 11 | // 12 | // Параметры: 13 | // Значение - Строка - Ключ настройки. См. библиотеку [configor](https://github.com/oscript-library/configor) 14 | // для полного описания синтаксиса. 15 | // Если не заполнено, используется имя параметра конструктора/поля класса 16 | // или часть имени метода для установки значения. 17 | // ЗначениеПоУмолчанию - Произвольный - Значение, которое принимает деталька, если не задано из-вне. 18 | // 19 | // Пример: 20 | // 21 | // 1. 22 | // &Деталька 23 | // Перем ПутьКФайлу; 24 | // 25 | // 2. 26 | // &Деталька(Значение = "Настройки.ПутьКФайлу", ЗначениеПоУмолчанию = "./file.txt") 27 | // Перем ПутьКФайлу; 28 | // 29 | // 3. 30 | // &Желудь 31 | // Процедура ПриСозданииОбъекта(&Деталька ПутьКФайлу) 32 | // 33 | // 4. 34 | // &Деталька 35 | // Процедура УстановитьПутьКФайлу(Значение) Экспорт 36 | // 37 | // 5. 38 | // &Завязь 39 | // Функция МойЖелудь(&Деталька ПутьКФайлу) Экспорт 40 | // 41 | Процедура ПриСозданииОбъекта(Значение = "", ЗначениеПоУмолчанию = Неопределено) 42 | ``` 43 | 44 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/060-Блестяшка.md: -------------------------------------------------------------------------------- 1 | # АннотацияБлестяшка 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Маркерная аннотация для указания, что прилепляемая частица 7 | // является произвольным значением, передаваемым в конструктор желудя. 8 | // 9 | // Может быть использована только над параметром конструктора/метода завязи желудя. 10 | // 11 | // Пример: 12 | // 13 | // 1. 14 | // &Желудь 15 | // Процедура ПриСозданииОбъекта(&Блестяшка ПроизвольноеЗначение) 16 | // 17 | // 2. 18 | // &Завязь 19 | // Функция МойЖелудь(&Блестяшка ПроизвольноеЗначение) Экспорт 20 | // 21 | Процедура ПриСозданииОбъекта() 22 | ``` 23 | 24 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/070-Табакерка.md: -------------------------------------------------------------------------------- 1 | # АннотацияТабакерка 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Пометка, что прилепляемая частица прилепляется не непосредственно, а через специальный объект 7 | // типа `Табакерка`, который позволяет получить частицу программно и отложенно. 8 | // 9 | // Может использоваться для внедрения компанейских желудей, внедрения желудя самого в себя, 10 | // для разрыва циклических зависимостей, для передачи дополнительных параметров прилепляемого желудя и т.п. 11 | // 12 | // Используется совместно с аннотациями `&Пластилин` и `&Деталька`. 13 | // 14 | // Пример: 15 | // 16 | // 1. 17 | // &Табакерка 18 | // &Пластилин("ДругойЖелудь") 19 | // Перем ТабакеркаСДругимЖелудем; 20 | // . 21 | // ДругойЖелудь = ТабакеркаСДругимЖелудем.Достать(); 22 | // ДругойЖелудь.КакойТоМетод(); 23 | // ... 24 | // 2. 25 | // &Табакерка 26 | // &Пластилин("ДругойЖелудь") 27 | // Перем ТабакеркаСДругимЖелудем; 28 | // . 29 | // МассивБлестяшек = Новый Массив; 30 | // МассивБлестяшек.Добавить("Парам1"); 31 | // . 32 | // ДругойЖелудь = ТабакеркаСДругимЖелудем.Достать(МассивБлестяшек); 33 | // ДругойЖелудь.КакойТоМетод(); 34 | // 35 | Процедура ПриСозданииОбъекта() 36 | ``` 37 | 38 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/080-ФинальныйШтрих.md: -------------------------------------------------------------------------------- 1 | # АннотацияФинальныйШтрих 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Процедуры, помеченные аннотацией "ФинальныйШтрих" будут вызваны в конце инициализации желудя, 7 | // после отработки конструктора/метода завязи и всех напильников, применяемых на желуде. 8 | // Во время выполнения процедуры доступны все прилепляемые частицы, прилепленные как через конструктор, 9 | // так и через поля класса и методы-сеттеры. 10 | // 11 | // Желудь может содержать несколько процедур, помеченных аннотацией "ФинальныйШтрих". 12 | // Порядок их вызова не гарантируется. 13 | // 14 | // Процедура должна быть помечена `Экспорт`ная. 15 | // 16 | // Пример: 17 | // 18 | // &ФинальныйШтрих 19 | // Процедура ПостИнициализация() Экспорт 20 | // . Сообщить("Я выполнилась после конструктора объекта"); 21 | // КонецПроцедуры 22 | // . 23 | // &Желудь 24 | // Процедура ПриСозданииОбъекта() 25 | // КонецПроцедуры 26 | // 27 | Процедура ПриСозданииОбъекта() 28 | ``` 29 | 30 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/081-Напильник.md: -------------------------------------------------------------------------------- 1 | # АннотацияНапильник 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Специальный тип желудя для дополнительной обработки других желудей в процессе их создания. 7 | // 8 | // Может использоваться для добавления дополнительных действий или свойств создаваемым желудям. Метод `ОбработатьЖелудь` 9 | // **может** возвращать другой объект, который подменит текущий желудь, или обертку-декоратор над текущим желудем. 10 | // 11 | // Каждый `&Напильник` дополнительно имеет `&Прозвище("Напильник")`. 12 | // 13 | // Напильник сам по себе является желудем, однако в силу своей специфики он может запрашивать прилепление только 14 | // &Деталек и Поделки. 15 | // 16 | // Желудь, помеченный аннотацией `&Напильник`, должен реализовать следующий интерфейс: 17 | // * `Функция ОбработатьЖелудь(Желудь, ОпределениеЖелудя) Экспорт` 18 | // 19 | // Размещается над конструктором класса. 20 | // 21 | // Параметры: 22 | // Значение - Строка - Имя желудя, под которым напильник добавляется в контекст Поделки. 23 | // ПрименяетсяТолькоНа - Строка - Повторяемый параметр. Ограничивает применение напильника только на желудях 24 | // с указанными именами. 25 | // 26 | // Пример: 27 | // &Напильник 28 | // Процедура ПриСозданииОбъекта() 29 | // КонецПроцедуры 30 | // 31 | Процедура ПриСозданииОбъекта(Повторяемый = ПрименяетсяТолькоНа = Неопределено) 32 | ``` 33 | 34 | ## МожетПрименятьсяНа 35 | 36 | ```bsl 37 | // Проверить, может ли текущий напильник применяться на указанном желуде. 38 | // 39 | // Параметры: 40 | // ОпределениеЖелудя - ОпределениеЖелудя - Определение желудя, для которого проверяется 41 | // применимость текущего напильника. 42 | // 43 | // Возвращаемое значение: 44 | // Булево - Истина, если напильник может применяться на указанном желуде, иначе Ложь. 45 | // 46 | Функция МожетПрименятьсяНа(ОпределениеЖелудя) 47 | ``` 48 | 49 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/100-Заготовка.md: -------------------------------------------------------------------------------- 1 | # АннотацияЗаготовка 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Специальный тип желудя для выполнения дополнительных действий в момент помещения класса в контекст Поделки. 7 | // 8 | // Может использоваться для добавления динамической загрузки новых классов в систему типов OneScript или 9 | // дополнительных импортов библиотек через директиву `#Использовать`. 10 | // 11 | // Каждая `&Заготовка` дополнительно имеет `&Прозвище("Заготовка")` и &Спецификация("Инициализация"). 12 | // 13 | // Желудь, помеченный аннотацией `&Заготовка`, должен реализовать следующий интерфейс: 14 | // * `Процедура ПриИнициализацииПоделки(Поделка) Экспорт` 15 | // 16 | // Размещается над конструктором класса. 17 | // 18 | // Параметры: 19 | // Значение - Строка - Имя желудя, под которым заготовка добавляется в контекст Поделки. 20 | // 21 | // Пример: 22 | // &Заготовка 23 | // Процедура ПриСозданииОбъекта() 24 | // КонецПроцедуры 25 | // 26 | Процедура ПриСозданииОбъекта(Значение = "") 27 | ``` 28 | 29 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/110-Рогатка.md: -------------------------------------------------------------------------------- 1 | # АннотацияРогатка 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Специальный тип желудя, автоматически выполняемый при запуске приложения (`Поделка.ЗапуститьПриложение()`). 7 | // 8 | // Желудь, помеченный аннотацией `&Рогатка`, должен реализовать следующий интерфейс: 9 | // * `Процедура ПриЗапускеПриложения() Экспорт` 10 | // 11 | // Каждая `&Рогатка` дополнительно имеет `&Прозвище("Рогатка")`. 12 | // 13 | // `&Рогатка` сама по себе тоже является желудем, то есть может запрашивать прилепление частиц, 14 | // является объектом для обработки `&Напильник`ом, может иметь `&Спецификация` и так далее. 15 | // 16 | // Размещается над конструктором класса. 17 | // 18 | // Параметры: 19 | // Значение - Строка - Имя желудя, под которым рогатка добавляется в контекст Поделки. 20 | // ЗапускатьВФоне - Булево - Если Истина, то рогатка будет запущена в фоновом задании. 21 | // Если Ложь, то рогатка будет запущена в текущем потоке. 22 | // ОжидатьЗавершения - Булево - Если Истина и `ЗапускатьВФоне` = Истина, 23 | // то после запуска рогатки будет ожидаться её завершение. 24 | // Пример: 25 | // Процедура ПриЗапускеПриложения() Экспорт 26 | // . Сообщить("Привет из рогатки!"); 27 | // КонецПроцедуры 28 | // . 29 | // &Рогатка 30 | // Процедура ПриСозданииОбъекта() 31 | // КонецПроцедуры 32 | // 33 | Процедура ПриСозданииОбъекта(Значение = "", ЗапускатьВФоне = Истина, ОжидатьЗавершения = Истина) 34 | ``` 35 | 36 | ## ЗапускатьВФоне 37 | 38 | ```bsl 39 | // Флаг необходимости запуска рогатки в фоновом задании. 40 | // 41 | // Возвращаемое значение: 42 | // Булево 43 | // 44 | Функция ЗапускатьВФоне() 45 | ``` 46 | 47 | ## ОжидатьЗавершения 48 | 49 | ```bsl 50 | // Флаг необходимости ожидания завершения рогатки при ее запуске в фоновом задании. 51 | // 52 | // Возвращаемое значение: 53 | // Булево 54 | // 55 | Функция ОжидатьЗавершения() 56 | ``` 57 | 58 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/120-Приемка.md: -------------------------------------------------------------------------------- 1 | # АннотацияПриемка 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Специальный тип желудя для обработки определений желудей. 7 | // 8 | // Аналог &Напильника для `ОпределениеЖелудя`. Срабатывает каждый раз, когда в контекст добавляется новое 9 | // определение желудя. При добавлении самой Приемки в контекст, все ранее добавленные определения желудей 10 | // передаются в Приемку для проверки. 11 | // 12 | // Класс, помеченный аннотацией `&Приемка`, должен реализовать следующий интерфейс: 13 | // * `Процедура ПриДобавленииОпределенияЖелудя(ОпределениеЖелудя) Экспорт` 14 | // 15 | // Каждая `&Приемка` так же имеет `&Характер("Компанейский")`, `&Прозвище("Приемка")` и `&Спецификация("Инициализация")` 16 | // 17 | // Размещается над конструктором класса. 18 | // 19 | // Параметры: 20 | // Значение - Строка - Имя желудя, под которым приемка добавляется в контекст Поделки. 21 | // 22 | // Пример: 23 | // 24 | // Процедура ПриДобавленииОпределенияЖелудя(ОпределениеЖелудя) Экспорт 25 | // . Сообщить("Определение желудя: " + ОпределениеЖелудя.Имя()); 26 | // КонецПроцедуры 27 | // . 28 | // &Приемка 29 | // Процедура ПриСозданииОбъекта() 30 | // КонецПроцедуры 31 | // 32 | Процедура ПриСозданииОбъекта(Значение = "") 33 | ``` 34 | 35 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/130-Прозвище.md: -------------------------------------------------------------------------------- 1 | # АннотацияПрозвище 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Добавляет к желудю дополнительный идентификатор, по которому его можно в последствии доставать из Поделки. 7 | // Желудь может иметь несколько прозвищ. Одно и то же прозвище может использоваться для нескольких желудей. 8 | // 9 | // Может быть использовано, например, для группировки желудей и получении их в виде массива. 10 | // 11 | // Размещается над конструктором класса или над методом `&Завязи`. 12 | // 13 | // Параметры: 14 | // Значение - Строка - Задаваемое прозвище. 15 | // 16 | // Пример: 17 | // 18 | // &Прозвище("ПодписчикНаСобытие") 19 | // &Прозвище("ПользовательскийЖелудь") 20 | // &Желудь("МойЖелудь") 21 | // Процедура ПриСозданииОбъекта() 22 | // КонецПроцедуры 23 | // 24 | Процедура ПриСозданииОбъекта(Значение) 25 | ``` 26 | 27 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/140-Верховный.md: -------------------------------------------------------------------------------- 1 | # АннотацияВерховный 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Помечает желудь как имеющий приоритет среди других желудей с таким же именем или `&Прозвищем`. 7 | // В случае конфликта имен при получении желудей или их регистрации, будет использован желудь с аннотацией `&Верховный`. 8 | // 9 | // При наличии нескольких желудей с одним и тем же прозвищем позволяет определить, какой из них следует возвращать 10 | // при поиске конкретного желудя по его прозвищу. 11 | // 12 | // Если несколько желудей с одним и тем же именем/прозвищем имеют аннотацию `&Верховный`, будет вызвано исключение. 13 | // 14 | // Размещается над определением желудя - конструктором или методом &Завязи. 15 | // 16 | // Пример: 17 | // 1. 18 | // &Верховный 19 | // &Желудь("ПереопределяемыйЖелудь") 20 | // Процедура ПриСозданииОбъекта() 21 | // КонецПроцедуры 22 | // . 23 | // 2. 24 | // &Верховный 25 | // &Завязь 26 | // Функция ПереопределяемыйЖелудь() Экспорт 27 | // КонецФункции 28 | // 29 | Процедура ПриСозданииОбъекта() 30 | ``` 31 | 32 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/150-Порядок.md: -------------------------------------------------------------------------------- 1 | # АннотацияПорядок 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Управляет порядком инициализации и использования желудя. Не может быть меньше 1 или больше 999998. 7 | // 8 | // Если размещается над обычным `&Желудем` или `&Завязью`, то влияет на порядок сортировки, при получении 9 | // коллекции желудей по прозвищу. 10 | // 11 | // Если размещается над `&Напильником`, влияет на порядок применения напильников к желудям. 12 | // 13 | // Если размещается над `&Рогаткой`, влияет на порядок запуска рогаток при старте приложения. 14 | // 15 | // Параметры: 16 | // Значение - Число - Задаваемый порядок. 17 | // 18 | Процедура ПриСозданииОбъекта(Значение = 1) 19 | ``` 20 | 21 | ## Значение 22 | 23 | ```bsl 24 | // Порядок, заданный аннотацией. 25 | // 26 | // Возвращаемое значение: 27 | // Число 28 | // 29 | Функция Значение() Экспорт 30 | ``` 31 | 32 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/160-Характер.md: -------------------------------------------------------------------------------- 1 | # АннотацияХарактер 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Задает способ управления жизненным циклом желудя. 7 | // 8 | // ОСень содержит два базовых характера желудя: "Одиночка" и "Компанейский". 9 | // 10 | // По умолчанию все желуди имеют характер "Одиночка", означающий, что желудь 11 | // инициализируется один раз. При каждом запросе желудя будет возвращаться один и тот же 12 | // экземпляр. 13 | // 14 | // Характер "Компанейский" означает, что каждый раз при запросе желудя будет создаваться 15 | // новый экземпляр. 16 | // 17 | // Размещается над конструктором класса или над методом `&Завязи`. 18 | // 19 | // Параметры: 20 | // Значение - Строка - Характер желудя. 21 | // 22 | // Пример: 23 | // &Характер("Компанейский") 24 | // &Желудь 25 | // Процедура ПриСозданииОбъекта() 26 | // КонецПроцедуры 27 | // 28 | Процедура ПриСозданииОбъекта(Значение) 29 | ``` 30 | 31 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/170-ОсобоеОбращение.md: -------------------------------------------------------------------------------- 1 | # АннотацияОсобоеОбращение 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Маркерная аннотация, показывающая, что желудь требует изменений в процессе своего создания. 7 | // 8 | // Параметры аннотации конфликтуют между собой. Если отключаются все напильники, то нельзя задавать ограничения на 9 | // применение конкретных напильников или отключение конкретных напильников. Если задано ограничение на применение только 10 | // конкретных напильников, то нельзя задавать ограничение на отключение конкретных напильников (и наоборот). 11 | // 12 | // Размещается над конструктором класса или над методом `&Завязи`. 13 | // 14 | // Параметры: 15 | // ОтключитьВсеНапильники - Булево - Не применять на желуде никакие напильники. 16 | // ПрименятьТолькоНапильник - Строка - Повторяемый параметр. Применять на желуде только напильник с указанным именем. 17 | // НеПрименятьНапильник - Строка - Повторяемый параметр. Не применять на желуде напильник с указанным именем. 18 | // 19 | Процедура ПриСозданииОбъекта(Повторяемый = НеПрименятьНапильник = Неопределено) 20 | ``` 21 | 22 | ## НапильникМожетПрименяться 23 | 24 | ```bsl 25 | // Проверяет, может ли указанный напильник применяться над желудем, помеченным аннотацией `&ОсобоеОбращение`. 26 | // 27 | // Параметры: 28 | // ИмяНапильника - Строка - Имя напильника для проверки применимости. 29 | // 30 | // Возвращаемое значение: 31 | // Булево - Истина, если напильник может применяться на текущем желуде, иначе Ложь. 32 | // 33 | Функция НапильникМожетПрименяться(ИмяНапильника) Экспорт 34 | ``` 35 | 36 | 37 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/180-Спецификация.md: -------------------------------------------------------------------------------- 1 | # АннотацияСпецификация 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // Аннотация для указания жизненного цикла приложения, начиная с которого разрешено создавать желудь. 7 | // 8 | // По умолчанию все желуди имеют спецификацию "Выполнение", означающую, что желудь может быть создан только после вызова 9 | // `Поделка.ЗапуститьПриложение()`. 10 | // 11 | // К желудям со спецификацией "Инициализация" не применяются напильники. 12 | // 13 | // Размещается над конструктором класса или над методом `&Завязи`. 14 | // 15 | // Параметры: 16 | // Значение - Строка - Состояние приложения, на котором разрешено создавать желудь. См. СостоянияПриложения. 17 | // 18 | // Пример: 19 | // &Спецификация("Инициализация") 20 | // &Желудь 21 | // Процедура ПриСозданииОбъекта() 22 | // КонецПроцедуры 23 | // 24 | Процедура ПриСозданииОбъекта(Значение = "Выполнение") 25 | ``` 26 | 27 | ## Значение 28 | 29 | ```bsl 30 | // Сохраненное значение спецификации. 31 | // 32 | // Возвращаемое значение: 33 | // Строка 34 | // 35 | Функция Значение() Экспорт 36 | ``` 37 | 38 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/190-ПрилепляемаяКоллекция.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [autumn-collections](../../autumn-collections/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/200-Аннотация.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [annotations](../../annotations/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/010-Аннотации/210-Повторяемый.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [annotations](../../annotations/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/020-Желуди/010-Поделка.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Поделка 3 | --- 4 | 5 | # Поделка 6 | 7 | ## ПриСозданииОбъекта 8 | 9 | ```bsl 10 | 11 | Процедура ПриСозданииОбъекта(Знач СоветДругогоМастера = Неопределено) 12 | ``` 13 | 14 | ## ПолучитьОпределенияЖелудей 15 | 16 | ```bsl 17 | 18 | Функция ПолучитьОпределенияЖелудей(Имя = Неопределено) Экспорт 19 | ``` 20 | 21 | ## ПолучитьОпределенияАннотаций 22 | 23 | ```bsl 24 | 25 | Функция ПолучитьОпределенияАннотаций() Экспорт 26 | ``` 27 | 28 | ## ПолучитьОпределениеЖелудя 29 | 30 | ```bsl 31 | 32 | Функция ПолучитьОпределениеЖелудя(Имя) Экспорт 33 | ``` 34 | 35 | ## ПолучитьОпределениеАннотации 36 | 37 | ```bsl 38 | 39 | Функция ПолучитьОпределениеАннотации(Имя) Экспорт 40 | ``` 41 | 42 | ## НайтиЖелудь 43 | 44 | ```bsl 45 | 46 | Функция НайтиЖелудь(Имя, ПрилепляемыеЧастицы = Неопределено) Экспорт 47 | ``` 48 | 49 | ## НайтиЖелуди 50 | 51 | ```bsl 52 | 53 | Функция НайтиЖелуди(Имя, ПрилепляемыеЧастицы = Неопределено, ТипЖелудя = "Массив") Экспорт 54 | ``` 55 | 56 | ## НайтиДетальку 57 | 58 | ```bsl 59 | 60 | Функция НайтиДетальку(ИмяДетальки, ЗначениеПоУмолчанию = Неопределено) Экспорт 61 | ``` 62 | 63 | ## ДобавитьЖелудь 64 | 65 | ```bsl 66 | 67 | Функция ДобавитьЖелудь(Тип, Имя = "") Экспорт 68 | ``` 69 | 70 | ## ДобавитьДуб 71 | 72 | ```bsl 73 | 74 | Функция ДобавитьДуб(Тип) Экспорт 75 | ``` 76 | 77 | ## ДобавитьНапильник 78 | 79 | ```bsl 80 | 81 | Функция ДобавитьНапильник(Тип) Экспорт 82 | ``` 83 | 84 | ## ДобавитьЗаготовку 85 | 86 | ```bsl 87 | 88 | Функция ДобавитьЗаготовку(Тип) Экспорт 89 | ``` 90 | 91 | ## ДобавитьРогатку 92 | 93 | ```bsl 94 | 95 | Функция ДобавитьРогатку(Тип) Экспорт 96 | ``` 97 | 98 | ## ДобавитьАннотацию 99 | 100 | ```bsl 101 | 102 | Функция ДобавитьАннотацию(Тип) Экспорт 103 | ``` 104 | 105 | ## ПросканироватьКаталог 106 | 107 | ```bsl 108 | 109 | Функция ПросканироватьКаталог(Каталог) Экспорт 110 | ``` 111 | 112 | ## ДобавитьЗавязь 113 | 114 | ```bsl 115 | 116 | Функция ДобавитьЗавязь(Лямбда, Контекст = Неопределено) Экспорт 117 | ``` 118 | 119 | ## ЗапуститьПриложение 120 | 121 | ```bsl 122 | 123 | Процедура ЗапуститьПриложение() Экспорт 124 | ``` 125 | 126 | -------------------------------------------------------------------------------- /docs/api/020-Желуди/020-РазворачивательАннотаций.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [annotations](../../annotations/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/020-Желуди/030-КонтейнерАннотаций.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [annotations](../../annotations/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/020-Желуди/040-ПрилепляторЧастиц.md: -------------------------------------------------------------------------------- 1 | # ПрилепляторЧастиц 2 | 3 | ## ПриСозданииОбъекта 4 | 5 | ```bsl 6 | // @internal 7 | Процедура ПриСозданииОбъекта(пПоделка, пУправляющийПрилепляемымиКоллекциями) 8 | ``` 9 | 10 | ## ДанныеОПрилепляемойЧастице 11 | 12 | ```bsl 13 | 14 | Функция ДанныеОПрилепляемойЧастице(Свойство, Знач ИмяСвойства = Неопределено) Экспорт 15 | ``` 16 | 17 | ## НайтиПрилепляемуюЧастицу 18 | 19 | ```bsl 20 | 21 | Функция НайтиПрилепляемуюЧастицу(ДанныеОПрилепляемойЧастице, Знач ПрилепляемыеЧастицы = Неопределено) Экспорт 22 | ``` 23 | 24 | -------------------------------------------------------------------------------- /docs/api/030-Детальки/core/ЗапускатьРогатки.md: -------------------------------------------------------------------------------- 1 | # core.ЗапускатьРогатки 2 | 3 | ## Тип 4 | 5 | Булево 6 | 7 | ## Описание 8 | 9 | Определяет следует ли запускать все рогатки при старте приложения. 10 | -------------------------------------------------------------------------------- /docs/api/040-Прилепляемые-коллекции/010-Массив.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [autumn-collections](../../autumn-collections/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/040-Прилепляемые-коллекции/020-ТаблицаЗначений.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [autumn-collections](../../autumn-collections/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/040-Прилепляемые-коллекции/030-Соответствие.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [autumn-collections](../../autumn-collections/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/040-Прилепляемые-коллекции/040-Карта.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [autumn-collections](../../autumn-collections/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/040-Прилепляемые-коллекции/050-Множество.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [autumn-collections](../../autumn-collections/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/040-Прилепляемые-коллекции/060-Список.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [autumn-collections](../../autumn-collections/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/050-Классы/20-СоветДругогоМастера.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: СоветДругогоМастера 3 | --- 4 | 5 | # СоветДругогоМастера 6 | 7 | ## ПриСозданииОбъекта 8 | 9 | ```bsl 10 | // Советы по созданию поделки, упакованные в объект. 11 | // 12 | Процедура ПриСозданииОбъекта() 13 | ``` 14 | 15 | ## ЗначенияДеталек 16 | 17 | ```bsl 18 | // Установить/получить значения деталек. 19 | // 20 | // Параметры: 21 | // НовоеЗначение - Соответствие - устанавливаемые значения деталек. 22 | // 23 | // Возвращаемое значение: 24 | // Соответствие, СоветДругогоМастера - Текущее установленное значение для гетера, ЭтотОбъект для сеттера. 25 | // 26 | Функция ЗначенияДеталек(НовоеЗначение = Неопределено) Экспорт 27 | ``` 28 | 29 | ## ПрефиксПеременныхСреды 30 | 31 | ```bsl 32 | // Установить/получить префикс переменных среды, хранящих значения деталек. 33 | // 34 | // Параметры: 35 | // НовоеЗначение - Строка - устанавливаемый префикс переменных среды. 36 | // 37 | // Возвращаемое значение: 38 | // Строка, СоветДругогоМастера - Текущее установленное значение для гетера, ЭтотОбъект для сеттера. 39 | // 40 | Функция ПрефиксПеременныхСреды(НовоеЗначение = Неопределено) Экспорт 41 | ``` 42 | 43 | ## ИмяФайлаСоЗначениямиДеталек 44 | 45 | ```bsl 46 | // Установить/получить имя файла (без расширения), в котором хранятся значения деталек. 47 | // 48 | // Параметры: 49 | // НовоеЗначение - Строка - устанавливаемое имя файла. 50 | // 51 | // Возвращаемое значение: 52 | // Строка, СоветДругогоМастера - Текущее установленное значение для гетера, ЭтотОбъект для сеттера. 53 | // 54 | Функция ИмяФайлаСоЗначениямиДеталек(НовоеЗначение = Неопределено) Экспорт 55 | ``` 56 | 57 | ## ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек 58 | 59 | ```bsl 60 | // Установить/получить относительный путь к каталогу, где хранятся файл со значениями деталек. 61 | // 62 | // Параметры: 63 | // НовоеЗначение - Строка - устанавливаемый путь к каталогу. 64 | // 65 | // Возвращаемое значение: 66 | // Строка, СоветДругогоМастера - Текущее установленное значение для гетера, ЭтотОбъект для сеттера. 67 | // 68 | Функция ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек(НовоеЗначение = Неопределено) Экспорт 69 | ``` 70 | -------------------------------------------------------------------------------- /docs/api/050-Классы/30-Табакерка.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Табакерка 3 | --- 4 | 5 | # Табакерка 6 | 7 | ## ПриСозданииОбъекта 8 | 9 | ```bsl 10 | // Конструктор объекта. 11 | // 12 | // Параметры: 13 | // ПрилепляторЧастиц - ПрилепляторЧастиц - Прилеплятор частиц, который будет использоваться для поиска. 14 | // БазоваяПрилепляемаяЧастица - ПрилепляемаяЧастица - Прилепляемая частица, в которой описано то, что должно 15 | // доставаться из Табакерки. 16 | // 17 | Процедура ПриСозданииОбъекта(ПрилепляторЧастиц, БазоваяПрилепляемаяЧастица) 18 | ``` 19 | 20 | ## Достать 21 | 22 | ```bsl 23 | // Достать частицу из табакерки 24 | // 25 | // Параметры: 26 | // ПрилепляемыеЧастицы - Массив - массив прилепляемых частиц, которые передадутся как зависимости доставаемой частицы. 27 | // 28 | // Возвращаемое значение: 29 | // Произвольный - Желудь, блестяшка или деталька, хранимая в табакерке. 30 | // 31 | Функция Достать(ПрилепляемыеЧастицы = Неопределено) Экспорт 32 | ``` 33 | -------------------------------------------------------------------------------- /docs/api/050-Классы/40-ОпределениеЖелудя.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: ОпределениеЖелудя 3 | --- 4 | 5 | # ОпределениеЖелудя 6 | 7 | ## ПриСозданииОбъекта 8 | 9 | ```bsl 10 | 11 | Процедура ПриСозданииОбъекта(РазворачивательАннотаций, ТипЖелудя, Имя, Характер, ПрилепляемыеЧастицы, Завязь, Прозвища, Порядок, Верховный, Спецификация, КорневаяАннотация) 12 | ``` 13 | 14 | ## Имя 15 | 16 | ```bsl 17 | 18 | Функция Имя() Экспорт 19 | ``` 20 | 21 | ## ТипЖелудя 22 | 23 | ```bsl 24 | 25 | Функция ТипЖелудя() Экспорт 26 | ``` 27 | 28 | ## Характер 29 | 30 | ```bsl 31 | 32 | Функция Характер() Экспорт 33 | ``` 34 | 35 | ## ПрилепляемыеЧастицы 36 | 37 | ```bsl 38 | 39 | Функция ПрилепляемыеЧастицы() Экспорт 40 | ``` 41 | 42 | ## Завязь 43 | 44 | ```bsl 45 | 46 | Функция Завязь() Экспорт 47 | ``` 48 | 49 | ## Прозвища 50 | 51 | ```bsl 52 | 53 | Функция Прозвища() Экспорт 54 | ``` 55 | 56 | ## Порядок 57 | 58 | ```bsl 59 | 60 | Функция Порядок() Экспорт 61 | ``` 62 | 63 | ## Верховный 64 | 65 | ```bsl 66 | 67 | Функция Верховный() Экспорт 68 | ``` 69 | 70 | ## Спецификация 71 | 72 | ```bsl 73 | 74 | Функция Спецификация() Экспорт 75 | ``` 76 | 77 | ## КорневаяАннотация 78 | 79 | ```bsl 80 | 81 | Функция КорневаяАннотация() Экспорт 82 | ``` 83 | 84 | ## Свойства 85 | 86 | ```bsl 87 | 88 | Функция Свойства() Экспорт 89 | ``` 90 | 91 | ## Методы 92 | 93 | ```bsl 94 | 95 | Функция Методы() Экспорт 96 | ``` 97 | 98 | ## РефлекторОбъекта 99 | 100 | ```bsl 101 | 102 | Функция РефлекторОбъекта() Экспорт 103 | ``` 104 | 105 | ## НайтиМетодыСАннотациями 106 | 107 | ```bsl 108 | 109 | Функция НайтиМетодыСАннотациями(АннотацияФильтр) Экспорт 110 | ``` 111 | -------------------------------------------------------------------------------- /docs/api/050-Классы/50-ОпределениеАннотации.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [annotations](../../annotations/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/050-Классы/60-Завязь.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Завязь 3 | --- 4 | 5 | # Завязь 6 | 7 | ## ПриСозданииОбъекта 8 | 9 | ```bsl 10 | // Дата-класс для хранения данных о способе создания жёлудя. 11 | // 12 | // Параметры: 13 | // Родитель - Сценарий - Класс, содержащий указанный метод завязи. 14 | // ИмяМетода - Строка - Имя метода, которым можно создать жёлудь. 15 | // ДанныеМетода - Структура - Данные метода, как из возвращает рефлектор. 16 | // Действие - Действие - Делегат, который можно вызвать, чтобы создать жёлудь. 17 | // ЭтоКонструктор - Булево - Флаг, что делегат ведет на конструктор класса, а не на &Завязь-метод. 18 | // 19 | Процедура ПриСозданииОбъекта(Родитель, ИмяМетода, ДанныеМетода, Действие, ЭтоКонструктор) 20 | ``` 21 | 22 | ## Родитель 23 | 24 | ```bsl 25 | // Класс, содержащий указанный метод завязи. 26 | // 27 | // Возвращаемое значение: 28 | // Сценарий 29 | // 30 | Функция Родитель() Экспорт 31 | ``` 32 | 33 | ## ИмяМетода 34 | 35 | ```bsl 36 | // Имя метода, которым можно создать жёлудь. 37 | // 38 | // Возвращаемое значение: 39 | // Строка 40 | // 41 | Функция ИмяМетода() Экспорт 42 | ``` 43 | 44 | ## ДанныеМетода 45 | 46 | ```bsl 47 | // Данные метода, как из возвращает рефлектор. 48 | // 49 | // Возвращаемое значение: 50 | // Структура 51 | // 52 | Функция ДанныеМетода() Экспорт 53 | ``` 54 | 55 | ## Действие 56 | 57 | ```bsl 58 | // Делегат, который можно вызвать, чтобы создать жёлудь. 59 | // 60 | // Возвращаемое значение: 61 | // Действие 62 | // 63 | Функция Действие() Экспорт 64 | ``` 65 | 66 | ## ЭтоКонструктор 67 | 68 | ```bsl 69 | // Флаг, что делегат ведет на конструктор класса, а не на &Завязь-метод. 70 | // 71 | // Возвращаемое значение: 72 | // Булево 73 | // 74 | Функция ЭтоКонструктор() Экспорт 75 | ``` 76 | 77 | -------------------------------------------------------------------------------- /docs/api/050-Классы/70-ПрилепляемаяЧастица.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: ПрилепляемаяЧастица 3 | --- 4 | 5 | # ПрилепляемаяЧастица 6 | 7 | ## ПриСозданииОбъекта 8 | 9 | ```bsl 10 | 11 | Процедура ПриСозданииОбъекта(ТипЧастицы, ИмяЧастицы, Аннотация, БазоваяПрилепляемаяЧастица = Неопределено) 12 | ``` 13 | 14 | ## ТипЧастицы 15 | 16 | ```bsl 17 | 18 | Функция ТипЧастицы() Экспорт 19 | ``` 20 | 21 | ## ИмяЧастицы 22 | 23 | ```bsl 24 | 25 | Функция ИмяЧастицы() Экспорт 26 | ``` 27 | 28 | ## Аннотация 29 | 30 | ```bsl 31 | 32 | Функция Аннотация() Экспорт 33 | ``` 34 | 35 | ## БазоваяПрилепляемаяЧастица 36 | 37 | ```bsl 38 | 39 | Функция БазоваяПрилепляемаяЧастица() Экспорт 40 | ``` 41 | 42 | -------------------------------------------------------------------------------- /docs/api/060-Модули/РаботаСАннотациями.md: -------------------------------------------------------------------------------- 1 | > [!INFO] 2 | > Документация из библиотеки [annotations](../../annotations/index.md). 3 | 4 | 5 | -------------------------------------------------------------------------------- /docs/api/070-Напильники/ОбработкаНапильникомПластилинаНаПолях.md: -------------------------------------------------------------------------------- 1 | ## ОбработкаНапильникомПластилинаНаПолях 2 | 3 | ### ПриСозданииОбъекта 4 | 5 | ```bsl 6 | 7 | Процедура ПриСозданииОбъекта(&Пластилин ПрилепляторЧастиц) 8 | ``` 9 | 10 | ### ОбработатьЖелудь 11 | 12 | ```bsl 13 | 14 | Функция ОбработатьЖелудь(Желудь, ОпределениеЖелудя) Экспорт 15 | ``` 16 | 17 | -------------------------------------------------------------------------------- /docs/api/070-Напильники/ОбработкаНапильникомФинальныйШтрих.md: -------------------------------------------------------------------------------- 1 | ## ОбработкаНапильникомФинальныйШтрих 2 | 3 | ### ПриСозданииОбъекта 4 | 5 | ```bsl 6 | 7 | Процедура ПриСозданииОбъекта() 8 | ``` 9 | 10 | ### ОбработатьЖелудь 11 | 12 | ```bsl 13 | 14 | Функция ОбработатьЖелудь(Желудь, ОпределениеЖелудя) Экспорт 15 | ``` 16 | 17 | -------------------------------------------------------------------------------- /docs/api/080-Приемки/Заготовка.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/autumn-library/autumn/058ea22968dad5d2a254eb25a78c747f160c1a15/docs/api/080-Приемки/Заготовка.md -------------------------------------------------------------------------------- /docs/api/080-Приемки/Приемка.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/autumn-library/autumn/058ea22968dad5d2a254eb25a78c747f160c1a15/docs/api/080-Приемки/Приемка.md -------------------------------------------------------------------------------- /docs/api/080-Приемки/Рогатка.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/autumn-library/autumn/058ea22968dad5d2a254eb25a78c747f160c1a15/docs/api/080-Приемки/Рогатка.md -------------------------------------------------------------------------------- /docs/api/090-Перечисления/10-ТипыПрилепляемыхЧастиц.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: ТипыПрилепляемыхЧастиц 3 | --- 4 | 5 | # ТипыПрилепляемыхЧастиц 6 | 7 | ## Деталька 8 | 9 | ```bsl 10 | 11 | Функция Деталька() Экспорт 12 | ``` 13 | 14 | ## Желудь 15 | 16 | ```bsl 17 | 18 | Функция Желудь() Экспорт 19 | ``` 20 | 21 | ## Блестяшка 22 | 23 | ```bsl 24 | 25 | Функция Блестяшка() Экспорт 26 | ``` 27 | 28 | ## Табакерка 29 | 30 | ```bsl 31 | 32 | Функция Табакерка() Экспорт 33 | ``` 34 | 35 | -------------------------------------------------------------------------------- /docs/api/090-Перечисления/20-ХарактерыЖелудей.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: ХарактерыЖелудей 3 | --- 4 | 5 | # ХарактерыЖелудей 6 | 7 | ## Компанейский 8 | 9 | ```bsl 10 | 11 | Функция Компанейский() Экспорт 12 | ``` 13 | 14 | ## Одиночка 15 | 16 | ```bsl 17 | 18 | Функция Одиночка() Экспорт 19 | ``` 20 | 21 | ## ЭтоХарактерЖелудя 22 | 23 | ```bsl 24 | 25 | Функция ЭтоХарактерЖелудя(Характер) Экспорт 26 | ``` -------------------------------------------------------------------------------- /docs/api/index.md: -------------------------------------------------------------------------------- 1 | # Публичный интерфейс библиотеки `autumn` 2 | 3 | ## Аннотации 4 | 5 | ::: details Список аннотаций 6 | 7 | * [Желудь](Аннотации/Желудь.md) 8 | * [Пластилин](Аннотации/Пластилин.md) 9 | * [Дуб](Аннотации/Дуб.md) 10 | * [Завязь](Аннотации/Завязь.md) 11 | * [Деталька](Аннотации/Деталька.md) 12 | * [Блестяшка](Аннотации/Блестяшка.md) 13 | * [Табакерка](Аннотации/Табакерка.md) 14 | * [ФинальныйШтрих](Аннотации/ФинальныйШтрих.md) 15 | * [Напильник](Аннотации/Напильник.md) 16 | * [Заготовка](Аннотации/Заготовка.md) 17 | * [Рогатка](Аннотации/Рогатка.md) 18 | * [Приемка](Аннотации/Приемка.md) 19 | * [Прозвище](Аннотации/Прозвище.md) 20 | * [Верховный](Аннотации/Верховный.md) 21 | * [Порядок](Аннотации/Порядок.md) 22 | * [Характер](Аннотации/Характер.md) 23 | * [ОсобоеОбращение](Аннотации/ОсобоеОбращение.md) 24 | * [Спецификация](Аннотации/Спецификация.md) 25 | * [ПрилепляемаяКоллекция](Аннотации/ПрилепляемаяКоллекция.md) 26 | * [Аннотация](Аннотации/Аннотация.md) 27 | * [Повторяемый](Аннотации/Повторяемый.md) 28 | 29 | ::: 30 | 31 | ## Желуди 32 | 33 | * [Поделка](Желуди/Поделка.md) 34 | * [РазворачивательАннотаций](Желуди/РазворачивательАннотаций.md) 35 | * [КонтейнерАннотаций](Желуди/КонтейнерАннотаций.md) 36 | * [ПрилепляторЧастиц](Желуди/ПрилепляторЧастиц.md) 37 | 38 | ## Детальки 39 | 40 | * [core.ЗапускатьРогатки](Детальки/core/ЗапускатьРогатки.md) 41 | 42 | ## Прилепляемые коллекции 43 | 44 | * [Массив](Прилепляемые-коллекции/Массив.md) 45 | * [ТаблицаЗначений](Прилепляемые-коллекции/ТаблицаЗначений.md) 46 | * [Соответствие](Прилепляемые-коллекции/Соответствие.md) 47 | * [Карта](Прилепляемые-коллекции/Карта.md) 48 | * [Множество](Прилепляемые-коллекции/Множество.md) 49 | * [Список](Прилепляемые-коллекции/Список.md) 50 | 51 | ## Классы 52 | 53 | * [СоветДругогоМастера](Классы/СоветДругогоМастера) 54 | * [Завязь](Классы/Завязь.md) 55 | * [Табакерка](Классы/Табакерка.md) 56 | * [ОпределениеЖелудя](Классы/ОпределениеЖелудя.md) 57 | * [ОпределениеАннотации](Классы/ОпределениеАннотации.md) 58 | * [ПрилепляемаяЧастица](Классы/ПрилепляемаяЧастица.md) 59 | 60 | ## Модули 61 | 62 | * [РаботаСАннотациями](Модули/РаботаСАннотациями.md) 63 | 64 | ## Напильники 65 | 66 | * [ОбработкаНапильникомПластилинаНаПолях](Напильники/ОбработкаНапильникомПластилинаНаПолях.md) 67 | * [ОбработкаНапильникомФинальныйШтрих](Напильники/ОбработкаНапильникомФинальныйШтрих.md) 68 | 69 | ## Приемки 70 | 71 | * [Заготовка](Приемки/Заготовка.md) 72 | * [Приемка](Приемки/Приемка.md) 73 | * [Рогатка](Приемки/Рогатка.md) 74 | 75 | ## Перечисления 76 | 77 | * [ТипыПрилепляемыхЧастиц](Перечисления/ТипыПрилепляемыхЧастиц.md) 78 | * [ХарактерыЖелудей](Перечисления/ХарактерыЖелудей.md) 79 | -------------------------------------------------------------------------------- /docs/img/Отладчик.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/autumn-library/autumn/058ea22968dad5d2a254eb25a78c747f160c1a15/docs/img/Отладчик.png -------------------------------------------------------------------------------- /docs/img/ПримерТеста.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/autumn-library/autumn/058ea22968dad5d2a254eb25a78c747f160c1a15/docs/img/ПримерТеста.png -------------------------------------------------------------------------------- /docs/img/РезультатПрогонаТестов.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/autumn-library/autumn/058ea22968dad5d2a254eb25a78c747f160c1a15/docs/img/РезультатПрогонаТестов.png -------------------------------------------------------------------------------- /docs/product/framework-elements/010-component-declaration.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Объявление компонента 3 | --- 4 | 5 | # Объявление компонента 6 | 7 | Как вы, наверное, догадались по словосочетанию "компонентное приложение", основой вашего приложения становится `Желудь`. Жёлудь - это всё, и всё есть жёлудь. `ОбновляторВерсии1С`? Жёлудь. `ПроверяторУстановленныхВерсий`? Тоже Жёлудь. И даже логин с паролем - это тоже в некотором роде жёлуди. 8 | 9 | Основной способ обозначения класса как желудя - это навешивание аннотации `&Желудь` над конструктором объекта. Вроде такого: 10 | 11 | ::: code-group 12 | 13 | ```bsl [Классы/ПроверяторВерсий.os] 14 | &Желудь 15 | Процедура ПриСозданииОбъекта() 16 | 17 | КонецПроцедуры 18 | 19 | ... прочая очень нужная, но абсолютно не интересная логика класса. 20 | ``` 21 | 22 | ::: 23 | 24 | Главной характеристикой желудя является его имя. По умолчанию имя берется из имени типа (`ПроверяторВерсий` для случая выше), но может быть переопределено в параметре аннотации `&Желудь`. 25 | -------------------------------------------------------------------------------- /docs/product/framework-elements/020-component-instance.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Получение экземпляра компонента 3 | --- 4 | 5 | # Получение экземпляра компонента 6 | 7 | Мы определили желудь, настало время его создать! 8 | 9 | В создании компонентов нам поможет `Поделка`. Зря что ли мы накидывали в нее желудей? 10 | 11 | ::: code-group 12 | 13 | ```bsl [main.os] 14 | ПроверяторВерсий = Поделка.НайтиЖелудь("ПроверяторВерсий"); 15 | 16 | ПроверяторВерсий.ЧтоНибудьПроверить(); 17 | ``` 18 | 19 | ::: 20 | 21 | В результате выполнения куска кода выше в переменную `ПроверяторВерсий` прилетит свеженький блестящий желудь, добавленный ранее под именем "ПроверяторВерсий". Легко и просто, не правда ли? 22 | -------------------------------------------------------------------------------- /docs/product/framework-elements/030-components-binding.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Связывание компонентов между собой 3 | --- 4 | 5 | # Связывание компонентов между собой 6 | 7 | Что нужно двум многоуважаемым Желудям для связи друг с другом? Правильно, пластилин. Каждый ребенок знает, что хорошая поделка - это желуди, пластилин и г... Мы немного отвлеклись. 8 | 9 | Для указания зависимостей желудя служит аннотация `&Пластилин`. 10 | 11 | ::: code-group 12 | 13 | ```bsl [Классы/ОбновляторВерсий.os] 14 | Перем _ПроверяторВерсий; 15 | Перем _Логин; 16 | Перем _Пароль; 17 | 18 | &Желудь 19 | Процедура ПриСозданииОбъекта( 20 | &Пластилин ПроверяторВерсий, 21 | &Пластилин Логин, 22 | &Пластилин Пароль 23 | ) 24 | _ПроверяторВерсий = ПроверяторВерсий; 25 | _Логин = Логин; 26 | _Пароль = Пароль; 27 | КонецПроцедуры 28 | ``` 29 | 30 | ::: 31 | 32 | Как же создать такой сложный желудь, сверху донизу обмазанный пластилином? Точно так же. 33 | 34 | ::: code-group 35 | 36 | ```bsl [main.os] 37 | ОбновляторВерсий = Поделка.НайтиЖелудь("ОбновляторВерсий"); 38 | 39 | ОбновляторВерсий.ОбновисьЧтоБыТамНеСтояло(); 40 | ``` 41 | 42 | ::: 43 | 44 | Заметьте, никаких зависимостей передавать не нужно. "ОСень" все взяла на себя - по именам параметров нашла зарегистрированные желуди и передала их в конструктор объекта. 45 | 46 | Если вы начитались Гомера в оригинале или в вас вселился СОТОНА, а может просто потеряли совесть и захотели греческих букв в именах переменных, вы можете подсказать "ОСени", что за зависимость нужна в данном конкретном случае. 47 | 48 | ```bsl 49 | &Желудь 50 | Процедура ПриСозданииОбъекта( 51 | &Пластилин("ПроверяторВерсий") μ, 52 | &Пластилин(Значение = "Логин") ξ, 53 | &Пластилин("Пароль") ὦ 54 | ) 55 | _ПроверяторВерсий = μ; 56 | _Логин = ξ; 57 | _Пароль = ὦ; 58 | КонецПроцедуры 59 | ``` 60 | 61 | > Имя нужного желудя передается в параметре "Значение" аннотации "&Пластилин". Если аннотация имеет один параметр или вы передаете только значение параметра "Значение", то имя параметра можно опустить. 62 | -------------------------------------------------------------------------------- /docs/product/framework-elements/040-components-factory.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Фабрика компонентов 3 | --- 4 | 5 | # Фабрика компонентов 6 | 7 | Не все желуди обязаны являться полноценными классами с точки зрения системы типов 1Script. Согласитесь, странно заводить целый класс для хранения логина от ИТС, просто потому что кто-то пережарил желудей. 8 | 9 | Философский вопрос в зал: откуда берутся желуди? Кто-нибудь? Может быть вы, в свитере цвета осенней листвы? Правильно, желуди растут на дубах! Дуб является источником желудей. На ветвях образуются цветочки, из цветочков появляются завязи, а из завязи - желуди. 10 | 11 | И что самое приятное, дуб когда-то тоже был желудем, а значит, к нему применимы те правила игры, что и к обычным компонентам-желудям. 12 | 13 | Итак, мы хотим передать Обновлятору логин и пароль в виде желудей. Для этого в новом классе, помеченном аннотацией `&Дуб`, нужно объявить два метода, помеченные аннотацией `&Завязь`. На дубе завязи, из завязей получатся желуди. Логично? Логично. Поехали! 14 | 15 | ::: code-group 16 | 17 | ```bsl [Классы/ДанныеАвторизации.os] 18 | &Дуб 19 | Процедура ПриСозданииОбъекта() 20 | КонецПроцедуры 21 | 22 | &Завязь(Тип = "Строка") 23 | Функция Логин() Экспорт 24 | Возврат ПеременныеСреды().USERNAME; 25 | КонецФункции 26 | 27 | &Завязь(Тип = "Строка") 28 | Функция Пароль(&Пластилин Логин) Экспорт 29 | Если Логин = "user" Тогда 30 | Возврат "password"; 31 | КонецЕсли; 32 | 33 | Возврат ПеременныеСреды().PASSWORD; 34 | КонецФункции 35 | ``` 36 | 37 | ::: 38 | 39 | В листинге выше объявляются две функции-конструктора, возвращающие желуди. Как вы видите, желудь может быть чем угодно, а что угодно (в данном случае - строка) может быть желудем. 40 | 41 | Т. к. `Дуб` - это тоже желудь, а методы с "Завязью" - это псевдо-конструкторы, то такой метод может быть скреплен пластилином с другими желудями. Плохие желуди могут даже хардкодить значения паролей, но мы закроем на это глаза. 42 | 43 | В листинге выше `&Завязь` содержит параметр `Тип`. Он требуется, если из имени функции непонятно, что за тип она вернет. Ну, нам-то с вами понятно, что `Пароль` - это строка, но вот глупой железке надо немного помочь. 44 | 45 | С другой стороны, если вы объявляете желудь с "типовым" именем, то и параметр добавлять не нужно: 46 | 47 | ```bsl 48 | &Завязь 49 | Функция Строка(&Пластилин Логин, &Пластилин Пароль) Экспорт 50 | Возврат Логин + ":" + Пароль; 51 | КонецФункции 52 | ``` 53 | -------------------------------------------------------------------------------- /docs/product/framework-elements/050-dependency-injection.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Внедрение зависимостей в поля и функции-сеттеры 3 | --- 4 | 5 | # Внедрение зависимостей в поля и функции-сеттеры 6 | 7 | Не всегда бывает удобно пихать желуди прямо в конструктор. Например, желуди могут так сильно зависеть друг от друга, что образуют циклическую зависимость. Как Заяц-Волк, только Желудь-Желудь. В таком случае внедрить зависимости через конструктор не получится. На помощь нам придут внедрение желудей через поля и функции, принимающие значения. 8 | 9 | ::: code-group 10 | 11 | ```bsl [Классы/Обновлятор1С.os] 12 | &Пластилин 13 | Перем Логин; 14 | 15 | Перем Пароль; 16 | 17 | &Пластилин 18 | Процедура УстановитьПароль(Значение) Экспорт 19 | Пароль = Значение; 20 | КонецПроцедуры 21 | 22 | &Желудь 23 | Процедура ПриСозданииОбъекта() 24 | КонецПроцедуры 25 | ``` 26 | 27 | ::: 28 | 29 | При получении желудя `Обновлятор1С` зависимость `Логин` будет внедрена в поле напрямую, а зависимость `Пароль` установлена через процедуру `УстановитьПароль`. 30 | 31 | Как и в случае с подстановкой желудей в конструктор, имя конкретного желудя может быть переопределено в параметре аннотации `&Пластилин`. По умолчанию имя внедряемого желудя берется либо из имени поля ("Логин") либо из имени метода, из которого отбрасывается префикс "Установить": `УстановитьПароль` `->` `Пароль`. 32 | -------------------------------------------------------------------------------- /docs/product/framework-elements/060-app-settings-injection.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Внедрение настроек приложения 3 | --- 4 | 5 | # Внедрение настроек приложения 6 | 7 | Хорошая поделка состоит не только из желудей и пластилина, но и обвешана маленькими приятными глазу детальками. Причем разные поделки, собранные по одному и тому же чертежу, могут только этими детальками и отличаться. 8 | 9 | В примере выше мы передавали Обновлятору1С данные авторизации через переменные среды, читающиеся с помощью `&Дуба` и его `&Завязей`. Но это не единственный способ работы с настройками приложения. 10 | 11 | Осень содержит в себе механизм передачи желудю настроек приложения напрямую из конфигурационного файла. Для этого служит аннотация `&Деталька`. `&Пластилин` помогает связать между собой несколько полноценных `&Желудей`, тогда как `&Деталька` налепляется сразу на нужный `&Желудь`. 12 | 13 | > Поддержка загрузки настроек из переменных окружения и аргументов командной строки в ближайших планах разработки. Еще год-два и точно запилим, честно-честно! 14 | 15 | Конфигурационный файл может быть в виде `json`, `yaml` или `ini` файла, называется `autumn-properties.json`/`autumn-properties.yml`/`autumn-properties.ini` соответственно и ищется ОСенью в каталоге запуска приложения или в подкаталоге `src`. 16 | 17 | ::: code-group 18 | 19 | ```json [autumn-properties.json] 20 | { 21 | "Логин": "user", 22 | "Пароль": "pass", 23 | "ПрочиеНастройки": { 24 | "Настроение": "Хорошее" 25 | } 26 | } 27 | ``` 28 | 29 | ::: 30 | 31 | 32 | А вот так их можно использовать в жёлуде: 33 | 34 | ::: code-group 35 | 36 | ```bsl [Классы/Обновлятор1С.os] 37 | &Деталька 38 | Перем Логин; 39 | 40 | &Деталька 41 | Перем Пароль; 42 | 43 | &Деталька("ПрочиеНастройки.Настроение") 44 | Перем Настроение; 45 | 46 | &Деталька(Значение = "ПрочиеНастройки.ОтветНаГлавныйВопросЖизниВселеннойИВсегоОстального", ЗначениеПоУмолчанию = 42) 47 | Перем Ответ; 48 | 49 | &Желудь 50 | Процедура ПриСозданииОбъекта() 51 | КонецПроцедуры 52 | ``` 53 | 54 | ::: 55 | 56 | Вы можете добавлять к желудю любые детальки вне зависимости от того, есть они в конфигурационном файле или нет. 57 | 58 | По умолчанию "ОСень" будет пытаться найти значение настройки по имени параметра конструктора: в json есть параметры "Логин" и "Пароль", в конструкторе есть параметры "Логин" и "Пароль", искра, буря, безумие! 59 | 60 | JSON обычно содержит вложенные объекты и массивы. Путь к настройкам в таких вложенных структурах можно указать в параметре аннотации `&Деталька` в формате библиотеки [configor](https://github.com/khorevaa/configor), используя точки для объектов и квадратные скобки для массивов. 61 | 62 | Не обязательно заставлять пользователя указывать все настройки в конфигурационном файле, если ему могут подойти значения настроек по умолчанию. Для указания значения по умолчанию в `&Детальке` есть параметр `ЗначениеПоУмолчанию`. Поразительно, не правда ли? 63 | -------------------------------------------------------------------------------- /docs/product/framework-elements/070-custom-arguments.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Произвольные аргументы конструктора 3 | --- 4 | 5 | # Произвольные аргументы конструктора 6 | 7 | Иногда понимание того, что же еще добавить в поделку, приходит в самый последний момент. Буквально после запуска приложения, кодом, на основании какой-то хитрой логики. Да, можно сделать хитрый `&Дуб`, передать в него в виде желудя расчетчик этой самой бизнес-логики, который выдаст нужную циферку, но порой хочется просто передать `42` в конструктор желудя. 8 | 9 | Для таких случаев в ОСени есть аннотация `&Блестяшка`. 10 | 11 | ::: code-group 12 | 13 | ```bsl [Классы/ЛенивыйЖелудь.os] 14 | &Желудь 15 | Процедура ПриСозданииОбъекта( 16 | &Пластилин ПроверяторВерсий 17 | &Блестяшка ФормулировкаВопроса 18 | ) 19 | КонецПроцедуры 20 | ``` 21 | 22 | ::: 23 | 24 | Как ее использовать? Двумя способами. Первый - это передать все параметры конструктора в виде массива в метод `Поделка.НайтиЖелудь()`: 25 | 26 | ```bsl 27 | ПараметрыКонструктора = Новый Массив; 28 | ПараметрыКонструктора.Добавить(Поделка.НайтиЖелудь("ПроверяторВерсий")); 29 | ПараметрыКонструктора.Добавить("Главный вопрос жизни, вселенной и всего такого"); 30 | 31 | ЛенивыйЖелудь = Поделка.НайтиЖелудь( 32 | "ЛенивыйЖелудь", 33 | ПараметрыКонструктора 34 | ); 35 | ``` 36 | 37 | Второй - передать только блестяшки. А весь `&Пластилин` и `&Детальки` ОСень подставит сама: 38 | 39 | ```bsl 40 | ПараметрыКонструктора = Новый Массив; 41 | ПараметрыКонструктора.Добавить("Главный вопрос жизни, вселенной и всего такого"); 42 | 43 | ЛенивыйЖелудь = Поделка.НайтиЖелудь( 44 | "ЛенивыйЖелудь", 45 | ПараметрыКонструктора 46 | ); 47 | ``` 48 | 49 | `&Блестяшки` можно внедрять только в конструктор желудя. Внедрение в поля и методы жёлудя не поддерживается. Однако вы можете объявить `&Дуб` и `&Завязь`, куда `&Блестяшку` передать таки можно: 50 | 51 | ::: code-group 52 | 53 | ```bsl [Классы/ДубСЛенивымЖелудем.os] 54 | &Дуб 55 | Процедура ПриСозданииОбъекта() 56 | КонецПроцедуры 57 | 58 | &Завязь 59 | Процедура ЛенивыйЖелудь( 60 | &Пластилин ПроверяторВерсий 61 | &Блестяшка ФормулировкаВопроса 62 | ) 63 | ЛенивыйЖелудь = Новый ЛенивыйЖелудь(ПроверяторВерсий); 64 | ЛенивыйЖелудь.ЗадатьВопрос(ФормулировкаВопроса); 65 | 66 | Возврат ЛенивыйЖелудь; 67 | КонецПроцедуры 68 | ``` 69 | 70 | ::: 71 | 72 | И в заключение темы, `ЛенивыйЖелудь` (не важно, созданный конструктором или `&Завязью`) можно внедрить в другой желудь, воспользовавшись повторяемым параметром `Блестяшка` в аннотации `&Пластилин`: 73 | 74 | ::: code-group 75 | 76 | ```bsl [Классы/ЛюбительЛенивыхЖелудей.os] 77 | &Пластилин(Блестяшка = "Шестью девять?") 78 | Перем ЛенивыйЖелудь; 79 | 80 | &Желудь 81 | Процедура ПриСозданииОбъекта() 82 | КонецПроцедуры 83 | ``` 84 | 85 | ::: 86 | 87 | При поиске любителя ленивых желудей в него будет прилеплен `ЛенивыйЖелудь` с вопросом `Шестью девять?`. 88 | 89 | Повторяемые параметры аннотаций позволяют указывать один и тот же параметр аннотации несколько раз с разными значениями. Например, если у желудя в конструктор принимается несколько блестяшек, то и внедрить такой желудь можно указав несколько блестяшек в аннотации `&Пластилин`: 90 | 91 | ```bsl 92 | &Пластилин(Блестяшка = "Первое значение", Блестяшка = "Второе значение") 93 | Перем ЖелудьСДвумяБлестяшками; 94 | ``` 95 | -------------------------------------------------------------------------------- /docs/product/framework-elements/080-instance-generator.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Генератор экземпляров компонентов 3 | --- 4 | 5 | # Генератор экземпляров компонентов 6 | 7 | Иногда возникает необходимость получить желудь-зависимость отложено. Например, по какому-то условию или с передачей произвольных параметров. Эту задачу можно решить через внедрение в желудь `Поделки` целиком, но умные книжки учат нас, что зависеть от глобального контекста приложения - это вообще-то фу-фу-фу и не надо так. Для уменьшения связывания полезного кода с инфраструктурным в ОСени есть дополнительная аннотация `&Табакерка`. Если ее навесить над полем или параметром метода, над которым уже висит `&Пластилин`, `&Деталька` или `&Блестяшка`, то вместо внедрения в поле или параметр непосредственно нужного значения будет внедрен специальный объект типа `Табакерка`, который позволяет достать желудь/детальку/блестяшку по требованию. 8 | 9 | ::: code-group 10 | 11 | ```bsl [Классы/КлассСТабакеркой.os] 12 | &Табакерка 13 | &Пластилин 14 | Перем ПроверяторВерсий; 15 | 16 | Функция ЧтоНибудьОтложеноПроверить(Версия) Экспорт 17 | РеальныйПроверяторВерсий = ПроверяторВерсий.Достать(); 18 | 19 | Возврат РеальныйПроверяторВерсий.Проверить(Версия); 20 | КонецФункции 21 | 22 | &Желудь 23 | Процедура ПриСозданииОбъекта() 24 | КонецПроцедуры 25 | ``` 26 | 27 | ::: 28 | 29 | В примере выше в поле `ПроверяторВерсий` будет внедрен объект типа `Табакерка`, который позволит получить желудь `ПроверяторВерсий` по требованию. 30 | 31 | В метод `Табакерка.Достать()` можно передать параметр-массив с прилепляемыми частицами, аналогично тому, как это делается для `Поделка.НайтиЖелудь(ИмяЖелудя, МассивПрилепляемыхЧастиц)`. Таким образом, можно получить желудь с прилепленными к нему блестяшками или другими рассчитываемыми желудями. 32 | -------------------------------------------------------------------------------- /docs/product/framework-elements/090-aliases.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Алиасы компонентов 3 | --- 4 | 5 | # Алиасы компонентов 6 | 7 | У желудей все как у людей. Есть свои увлечения, субкультуры и даже может быть `&Прозвище`. Желудь `Василий` в силу своего темного прошлого "у своих" зовется не иначе как `Васян`. Как это отразить в ОСени? 8 | 9 | ::: code-group 10 | 11 | ```bsl [Классы/Василий.os] 12 | &Желудь 13 | &Прозвище("Васян") 14 | Процедура ПриСозданииОбъекта() 15 | КонецПроцедуры 16 | 17 | ``` 18 | 19 | ::: 20 | 21 | Как же разные группы желудей могут обращаться к нашему Василию? Сделать это можно и по имени и по прозвищу. И отзовётся при этом один и тот же желудь: 22 | 23 | ::: code-group 24 | 25 | ```bsl [main.os] 26 | Василий = Поделка.НайтиЖелудь("Василий"); 27 | Васян = Поделка.НайтиЖелудь("Васян"); 28 | 29 | Ожидаем.Что(Василий).Равен(Васян); 30 | ``` 31 | 32 | ::: 33 | 34 | Василий может иметь много прозвищ. Поэтому аннотация &Прозвище повторяемая, т. е. на желудь ее можно навесить несколько раз с разными значениями и величать кого угодно и как угодно. 35 | -------------------------------------------------------------------------------- /docs/product/framework-elements/100-aliases-grouping.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Группировка компонентов по алиасу 3 | --- 4 | 5 | # Группировка компонентов по алиасу 6 | 7 | Представьте себе компанию панков. Каждый из них уникален, каждый - личность. Но при этом у них есть и что-то общее - все они панки. К каждому можно обратиться как: "Эй, ты, панк!", и он не только отзовется громогласным "Хой!", но возможно даже предложит Вам пива. 8 | 9 | Попробуем описать нашу небольшую и дружную компанию: 10 | 11 | ::: code-group 12 | 13 | ```bsl [Классы/ДжонниРоттен.os] 14 | &Желудь 15 | &Прозвище("Панк") 16 | Процедура ПриСозданииОбъекта() 17 | КонецПроцедуры 18 | ``` 19 | 20 | ```bsl [Классы/СтивДжонс.os] 21 | &Желудь 22 | &Прозвище("Панк") 23 | Процедура ПриСозданииОбъекта() 24 | КонецПроцедуры 25 | ``` 26 | 27 | ```bsl [Классы/ПолКук.os] 28 | &Желудь 29 | &Прозвище("Панк") 30 | Процедура ПриСозданииОбъекта() 31 | КонецПроцедуры 32 | ``` 33 | 34 | ```bsl [Классы/СидВишес.os] 35 | &Желудь 36 | &Прозвище("Панк") 37 | Процедура ПриСозданииОбъекта() 38 | КонецПроцедуры 39 | ``` 40 | 41 | ::: 42 | 43 | Чудесная компания собралась, неправда ли? Что же мы можем сделать с этими красавцами? Получить их как пачку желудей! В этом нам поможет метод `Поделка.НайтиЖелуди()`: 44 | 45 | ```bsl 46 | Панки = Поделка.НайтиЖелуди("Панк"); 47 | 48 | Ожидаем.Что(Панки).ИмеетТип("Массив"); 49 | Ожидаем.Что(Панки.Количество()).Равно(4); 50 | 51 | Для Каждого Панк Из Панки Цикл 52 | Панк.Хой(); 53 | КонецЦикла; 54 | ``` 55 | 56 | Этот бэнд можно получить не только императивно, через `НайтиЖелуди`, но и внедрить в качестве зависимости. Для указания того, что мы ждем массив из панков, а не какого-то конкретного, у аннотации `&Пластилин` есть параметр `Тип`, который может принимать значения всех `&ПрилепляемаяКоллекция`, в частности `Массив`: 57 | 58 | ::: code-group 59 | 60 | ```bsl [Классы/РокБэнд.os] 61 | Процедура ПриСозданииОбъекта(&Пластилин(Значение = "Панк", Тип = "Массив") Панки) 62 | Для Каждого Панк Из Панки Цикл 63 | Панк.Хой(); 64 | КонецЦикла; 65 | КонецПроцедуры 66 | ``` 67 | 68 | ::: 69 | 70 | Аналогичный параметр (третий) есть и у метода `НайтиЖелуди`: 71 | 72 | ```bsl 73 | Панки = Поделка.НайтиЖелуди("Панк", , "Массив"); 74 | ``` 75 | 76 | По умолчанию, через `&Пластилин` внедряется единичный `Желудь`, а метод `НайтиЖелуди` возвращает `Массив`. 77 | 78 | Помимо единичного желудя и массива, РокБэнд можно получить в виде соответствия (`"Соответствие"`), где ключом будет имя ~~панка~~ жёлудя, а значением - сам жёлудь, и в виде таблицы значений (`"ТаблицаЗначений"`), в каждой строке которой будет содержаться `Имя`, `ОпределениеЖелудя` и сам `Желудь`. 79 | 80 | > И вообще, загляните в документацию библиотеки [autumn-collections](https://github.com/autumn-library/autumn-collections), там много вкусных типов! 81 | 82 | И даже больше, РокБэнд можно получить своим собственным способом, для этого нужно создать у себя свой уникальный `СобирательПанков.os`, в котором нужно определить два метода, один который получает на входе панка и его описание, а второй который возвращает собранную банду 83 | 84 | ```bsl 85 | // СобирательПанков.os 86 | 87 | Перем Банда; 88 | 89 | // Тут нам на вход приходит очередной панк 90 | Процедура Добавить(Панк, ОпределениеПанка) Экспорт 91 | 92 | Для Каждого РольИИсполнитель Из Банда Цикл 93 | 94 | Если Не ЗначениеЗаполнено(РольИИсполнитель.Значение) Тогда 95 | 96 | Банда.Вставить(РольИИсполнитель.Ключ, Желудь); 97 | Прервать; 98 | 99 | КонецЕсли; 100 | 101 | КонецЦикла; 102 | 103 | Коллекция.Добавить(ОпределениеЖелудя.Имя()); 104 | 105 | КонецПроцедуры 106 | 107 | // А тут нам надо вернуть собранную банду 108 | Функция Получить() Экспорт 109 | Возврат Новый ФиксированнаяСтруктура(Банда); 110 | КонецФункции 111 | 112 | &ПрилепляемаяКоллекция("СобирательПанков") 113 | Процедура ПриСозданииОбъекта() 114 | 115 | Банда = Новый Структура( 116 | "Гитарист, Барабанщик, БасГитарист, Вокалист" 117 | ); 118 | 119 | КонецПроцедуры 120 | ``` 121 | 122 | Теперь нам вернётся целая собранная группа: 123 | 124 | ```bsl 125 | 126 | Панки = Поделка.НайтиЖелуди("Панк", , "СобирательПанков"); 127 | 128 | // > Панки.Гитарист 129 | // > Панки.Барабанщик 130 | // > Панки.БасГитарист 131 | // > Панки.Вокалист 132 | 133 | ``` 134 | -------------------------------------------------------------------------------- /docs/product/framework-elements/110-components-sorting.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Упорядочивание компонентов при получении в виде сортированных коллекций 3 | --- 4 | 5 | # Упорядочивание компонентов при получении в виде сортированных коллекций 6 | 7 | Если вы прилепляете себе несколько желудей с общим прозвищем в виде массива или таблицы значений, вам может понадобиться расставить их по некоторому порядку. Не будем вдаваться в подробности, кто в SexPistols третий панк, а кто второй, но точно можно предположить, что сессионные музыканты должны быть в самом конце массива панков. В этом нам поможет аннотация `&Порядок`, принимающая числовое значение порядка. 8 | 9 | ::: code-group 10 | 11 | ```bsl [Классы/СессионныйМузыкант.os] 12 | &Желудь 13 | &Прозвище("Панк") 14 | &Порядок(5) 15 | Процедура ПриСозданииОбъекта() 16 | КонецПроцедуры 17 | ``` 18 | 19 | ::: 20 | 21 | По умолчанию, каждый желудь имеет порядок, равный единице. 22 | 23 | > &Рогатка и &Напильник тоже могут быть упорядочены! 24 | -------------------------------------------------------------------------------- /docs/product/framework-elements/120-components-prioritization.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Приоритизация компонентов с общим алиасом 3 | --- 4 | 5 | # Приоритизация компонентов с общим алиасом 6 | 7 | Но давайте будем честны. Когда мы говорим про Sex Pistols, то в первую очередь вспоминаем Сида Вишеса, и только потом уже Джонни Роттена и остальных. А какой у него получился алко-my-way, ух! Аннотация `&Верховный` подскажет "ОСени", кого вы считаете панком "по умолчанию": 8 | 9 | ::: code-group 10 | 11 | ```bsl [Классы/ДжонниРоттен.os] 12 | &Желудь 13 | &Прозвище("Панк") 14 | Процедура ПриСозданииОбъекта() 15 | КонецПроцедуры 16 | 17 | --- 18 | // file: Классы/СидВишес.os 19 | 20 | &Верховный 21 | &Желудь 22 | &Прозвище("Панк") 23 | Процедура ПриСозданииОбъекта() 24 | КонецПроцедуры 25 | ``` 26 | 27 | ::: 28 | 29 | Без аннотации `&Верховный` следующий код выдал бы ошибку, но с ней он прекрасно работает: 30 | 31 | ```bsl 32 | Панк = Поделка.НайтиЖелудь("Панк"); 33 | 34 | Ожидаем.Что(Панк).ИмеетТип("СидВишес"); 35 | ``` 36 | -------------------------------------------------------------------------------- /docs/product/framework-elements/130-component-overriding.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Переопределение компонента по имени 3 | --- 4 | 5 | # Переопределение компонента по имени 6 | 7 | Сила Верховного желудя настолько велика, что он может вытеснить данные о более слабом желуде из Поделки. 8 | 9 | Вспомним любимые "типовые". Представьте, что есть некая типовая форма документа, которая нам почему-то не нравится. Например, хотим ее упростить для пользователя. Или как-нибудь ее покорежить. Можно влезть в код формы, но не всегда хочется так делать, а иногда и просто нельзя (привет, расширения и базовые конфигурации). На помощь нам может прийти копирование формы (с последующей модификацией) и/или подмена базовой формы собственной реализацией. Причем тут желуди? 10 | 11 | От "типовой" нам пришла реализация некоего "важного компонента". 12 | 13 | ::: code-group 14 | 15 | ```bsl [Классы/ТиповойКомпонент.os] 16 | // важная, но все еще ненужная логика класса. 17 | 18 | &Желудь("ВажныйКомпонент") 19 | Процедура ПриСозданииОбъекта() 20 | КонецПроцедуры 21 | ``` 22 | 23 | ::: 24 | 25 | Но она нам не нравится, и мы хотим подменить этот желудь собственной реализацией. 26 | 27 | ::: code-group 28 | 29 | ```bsl [Классы/НашСобственныйКомпонент.os] 30 | // важная, но все еще ненужная логика класса. 31 | 32 | &Верховный 33 | &Желудь("ВажныйКомпонент") 34 | Процедура ПриСозданииОбъекта() 35 | КонецПроцедуры 36 | ``` 37 | 38 | ::: 39 | 40 | Обратите внимание, что оба желудя описывают себя как "ВажныйКомпонент", то есть имеют одинаковое *имя*. В обычной ситуации ОСень выкинула бы исключение, т. к. не может быть двух желудей с одним именем. 41 | 42 | Но использование аннотации `&Верховный` подсказывает ОСени, что наша собственная реализация должна превалировать над типовой реализацией и позволит заместить желудь "ВажныйКомпонент" нашей версией. 43 | 44 | > Два &Верховных желудя с одинаковым именем ожидаемо выкинут исключение. 45 | > 46 | > There can be only one! 47 | -------------------------------------------------------------------------------- /docs/product/framework-elements/140-component-post-initialization.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Пост-инициализация компонента 3 | --- 4 | 5 | # Пост-инициализация компонента 6 | 7 | Если вы все еще внимательно следите за нитью документации, у вас мог возникнуть вопрос вида ~~"Что за херня тут происходит"~~ "В каком порядке внедряются зависимости желудя?". И это очень хороший вопрос. 8 | 9 | Установить значения в поля несозданного объекта или вызвать в нем какой-либо метод довольно проблематично. Поэтому: 10 | 11 | - объект сначала создается (и вызывается его конструктор `ПриСозданииОбъекта`); 12 | - затем пластилином обмазываются поля класса; 13 | - оставшиеся куски пластилина идут на внедрение зависимостей через вызов методов. 14 | 15 | В такой ситуации может возникнуть желание что-нибудь поделать с желудем, когда в него уже всё-всё внедрено. И такая возможность есть! Создаем новый метод (на этот раз без пластилина) и указываем над им аннотацию `&ФинальныйШтрих`. 16 | 17 | ::: code-group 18 | 19 | ```bsl [Классы/КлассСПостИнициализацией.os] 20 | &Пластилин 21 | Перем Логин; 22 | 23 | &ФинальныйШтрих 24 | Процедура Напоследочек() Экспорт 25 | Сообщить("Логин здесь уже доступен: " + Логин); 26 | КонецПроцедуры 27 | 28 | &Желудь 29 | Процедура ПриСозданииОбъекта() 30 | КонецПроцедуры 31 | ``` 32 | 33 | ::: 34 | -------------------------------------------------------------------------------- /docs/product/framework-elements/150-component-uniqueness.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Уникальность экземпляров компонентов 3 | --- 4 | 5 | # Уникальность экземпляров компонентов 6 | 7 | Желуди почти как люди. У каждого есть свой `&Характер`. Кто-то показывает его явно, а кто-то ведет себя "как все". 8 | 9 | Большинство желудей характеризуют себя как `Одиночка`. Все желуди, которым понадобился `ОбновляторВерсий` как зависимость, получат один и тот же экземпляр Обновлятора с одним и тем же (очень одиноким) состоянием. Ну, вы знаете. Одинокий одиночка, одиноко идущий по одинокой дороге. Один. 10 | 11 | Однако не всегда это удобно. Предположим, вы написали свой супер-пупер уникальный генератор случайных чисел, который дает чудесное распределение. И хотите предоставить приложению возможность получать результат работы генератора в виде желудя, как зависимость. Будет не очень здорово, если все компоненты вашего приложения получат абсолютно случайно попавшееся число 42, не правда ли? Нам не подходят желуди-одиночки, нужно что-то более дружелюбное. Компанейское! 12 | 13 | В решении этой проблемы нам поможет аннотация `&Характер`. 14 | 15 | ::: code-group 16 | 17 | ```bsl [Классы/МойГенератор.os] 18 | Перем ГСЧ; 19 | 20 | &Завязь 21 | &Характер("Компанейский") 22 | Функция СлучайноеЦелое() Экспорт 23 | Возврат ГСЧ.СлучайноеЦелое(); 24 | КонецФункции 25 | 26 | &Дуб 27 | Процедура ПриСозданииОбъекта() 28 | ГСЧ = Новый ГенераторСлучайныхЧисел(); 29 | КонецПроцедуры 30 | ``` 31 | 32 | ::: 33 | 34 | Данный уникальный в своем роде генератор случайных чисел является "Дубом", то есть источником желудей. Его отличительной особенностью является его `Компанейский` характер. Теперь любой желудь, который попросит себе зависимость `СлучайноеЧисло`, действительно получит случайное число! 35 | -------------------------------------------------------------------------------- /docs/product/framework-elements/160-additional-processing.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Дополнительная обработка компонента 3 | --- 4 | 5 | # Дополнительная обработка компонента 6 | 7 | Предположим, вы хотите сделать лошадку из желудей. Что для этого нужно? Для начала надо взять несколько желудей. Они будут немного отличаться друг от друга: тот, что покрупнее, пойдет на тело лошадки, тонкие желуди пойдут ноги, а вот этот смешной желудь в виде конуса будет мордой нашей лошадки. Конечно же, обмажем все пластилином, чтобы оно держалось вместе. 8 | 9 | Вы смотрите на получившуюся лошадку и понимаете: что-то не то. Желуди-то все блестящие, полированные! А вы так мечтали о теплой и матовой лошадке. Что же делать? Есть решение: желуди нужно обработать напильником, чтобы придать им приятный матовый оттенок. 10 | 11 | Конечно же вы можете добавить нужный код по приведению желудя к матовому цвету, например, в `ПриСозданииОбъекта`. Но желуди-то разные, копипастить код между разными компонентами... Как-то фу. Хорошо, что "ОСень" может нам помочь. 12 | 13 | Для дополнительной обработки объекта помимо "желудей" и "дубов" можно использовать `&Напильник`. Это специальный объект с методом `ОбработатьЖелудь`, который будет вызываться при каждом создании нового желудя. 14 | 15 | ::: code-group 16 | 17 | ```bsl [Классы/ПриданиеМатовогоЦветаЖелудям.os] 18 | Функция ОбработатьЖелудь(Желудь, ОпределениеЖелудя) Экспорт 19 | ВжухнутьРазочек(Желудь); 20 | 21 | Возврат Желудь; 22 | КонецФункции 23 | 24 | &Напильник 25 | &Порядок(10) 26 | Процедура ПриСозданииОбъекта() 27 | КонецПроцедуры 28 | ``` 29 | 30 | ::: 31 | 32 | Метод обработки напильником возвращает желудь, причем не обязательно возвращать *тот же самый* желудь. Вам может захотеться обернуть его в объект-контейнер и накинуть на него несколько новых методов, например, с помощью [decorator](https://github.com/nixel2007/decorator). 33 | 34 | Не каждый напильник стоит применять ко всем желудям. Вспоминая замечательный пример с панками, мы можем захотеть добавить напильник для полировки заклепок на напульсниках наших музыкантов. При этом очевидно, что далеко не все носят напульсники, да еще и с заклепками. В задаче ограничения применения напильника поможет повторяемый параметр аннотации `&Напильник` под названием `ПрименяетсяТолькоНа`. В нем можно указать имена или прозвища желудей, к которым применяется данный напильник. 35 | 36 | ::: code-group 37 | 38 | ```bsl [Классы/ПолировщикЗаклепок.os] 39 | &Напильник(ПрименяетсяТолькоНа = "Панк") 40 | Процедура ПриСозданииОбъекта() 41 | 42 | КонецПроцедуры 43 | ``` 44 | 45 | С другой стороны сам желудь может захотеть ограничить список напильников, которые могут по нему вжухнуть. Или даже вовсе отключить вжухание всех напильников. Для этого на желудь можно навесить аннотацию `&ОсобоеОбращение`, которая может принимать булев параметр `ОтключитьВсеНапильники`, повторяемый строковый параметр `ПрименятьТолькоНапильник` и опять же повторяемый строковый параметр `НеПрименятьНапильник`. Назначение первого параметра, надеемся, достаточно очевидно, поэтому вот пример работы с одним из других: 46 | 47 | ::: code-group 48 | 49 | ```bsl [Классы/ПозерВНапульсниках.os] 50 | &Желудь 51 | &ОсобоеОбращение( 52 | ПрименятьТолькоНапильник = "ПолировщикЗаклепок" 53 | ) 54 | Процедура ПриСозданииОбъекта() 55 | КонецПроцедуры 56 | ``` 57 | 58 | Зачем все это может быть нужно? Перфоманса ради, например. В случае большого количества компанейских желудей, которые не нуждаются в обработке напильником, можно отключить работу всех напильников для них. Ведь зачем тратить время на обработку, если она не нужна? При этом можно сохранить все плюшки от внедрения зависимостей и деталек через конструктор. Удобненько. 59 | 60 | Напильник в этой удивительной осенней вселенной тоже является желудем, поэтому может иметь зависимости от других желудей. Но тут надо аккуратно - можно окончательно упороться и улететь таки на дно циклических зависимостей. 61 | 62 | > Чтобы уберечь себя ото дна, все напильники инициализируются перед запуском приложения. Как в жизни - сначала разложил рядом инструменты, а потом начинаешь творить. 63 | 64 | "ОСень" в своем составе уже содержит два напильника: один отвечает за внедрение желудей в поля и методы установки значений, а второй - за вызовы методов `&ФинальныйШтрих`. 65 | 66 | Любой порядок стремится к хаосу, а несколько напильников - к порядку. Чтобы не запутаться, кто в какой последовательности вжухает по желудю каждому `Напильнику` в аннотации `&Порядок` можно/нужно задать порядок исполнения. Напильник внедрения зависимостей имеет порядок `0`, а напильник "Финального штриха" - `999999`. Вы вольны занять любое значение порядка между этими границами. 67 | -------------------------------------------------------------------------------- /docs/product/framework-elements/170-app-context.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Использование контекста приложения 3 | --- 4 | 5 | # Использование контекста приложения 6 | 7 | `Поделка` является входной точкой для работы вашего приложения. Через него вы собираете информацию о ваших желудях, инициализируете их. Приятной особенностью "поделки" является то, что он сам по себе тоже является желудем! Все есть желудь, помните же? 8 | 9 | Поэтому вам никто не запретит с помощью `Пластилина` прилепить `Поделка` в ваш `Желудь`, `Дуб` или даже `Напильник`. Главное - берегите свое ментальное здоровье. 10 | -------------------------------------------------------------------------------- /docs/product/framework-elements/180-conditional-registration.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Условная регистрация компонентов в контексте приложения 3 | --- 4 | 5 | # Условная регистрация компонентов в контексте приложения 6 | 7 | Иногда вам может потребоваться выбирать, какие именно классы вы хотите добавлять в свою поделку. Например, вы хотите загружать определенный класс только при выполнении какого-нибудь условия (из-за конфликта имен, к примеру). На помощь придёт объект `&Заготовка`, который можно расценивать как готовый набор желудей, добавляемый в поделку. 8 | 9 | `&Заготовка` - это очень хитрый `&Желудь`! В отличие от обычных желудей он автоматически создается на фазе инициализации приложения, а затем у него вызывается метод `ПриИнициализацииПоделки(Поделка)`. Желудёвость заготовки позволяет пользоваться частью возможностей обычных желудей - на нем могут срабатывать `&Напильники`, добавленные в `Поделку` до `&Заготовки`, однако из всего многообразия ~~веществ~~ зависимостей ему доступны только `&Детальки` с настройками приложения. Ни тебе `&Пластилина`, ни `&Блестяшек` навесить на `&Заготовку` нельзя. 10 | 11 | ::: code-group 12 | 13 | ```bsl [Классы/НаборЖелудей.os] 14 | Перем _ПереопределитьПроверятор; 15 | 16 | &Заготовка 17 | Процедура ПриСозданииОбъекта(&Деталька(ЗначениеПоУмолчанию = Ложь) ПереопределитьПроверятор) 18 | _ПереопределитьПроверятор = ПереопределитьПроверятор; 19 | КонецПроцедуры 20 | 21 | Процедура ПриИнициализацииПоделки(Поделка) Экспорт 22 | 23 | ПутьКСценарию = "./ОбычныйПроверятор.os"; 24 | 25 | Если _ПереопределитьПроверятор Тогда 26 | ПутьКСценарию = "./НеобычныйПроверятор.os"; 27 | КонецЕсли; 28 | 29 | ПодключитьСценарий(ПутьКСценарию, "Проверятор"); 30 | 31 | КонецПроцедуры 32 | ``` 33 | 34 | ::: 35 | -------------------------------------------------------------------------------- /docs/product/framework-elements/190-launch-control-inversion.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Инверсия управления запуском приложения 3 | --- 4 | 5 | # Инверсия управления запуском приложения 6 | 7 | Одной из конечных точкой использования фреймворка для внедрения зависимостей является отказ от какой-либо логики при запуске приложения. В конце концов мы же жёлуди в поделку добавляем не просто так, а чтобы они могли `Сообщить("Привет, мир!")`. 8 | 9 | Вместо императивного стиля в виде поиска желудя и вызова у него нужного метода, мы можем добавить в `Поделку`... ещё один жёлудь с аннотацией `&Рогатка`. 10 | 11 | `&Рогатка` - это специальный желудь, содержащий метод `ПриЗапускеПриложения()`, который вызовется при, кхм, запуске приложения. Если еще точнее, при вызове `Поделка.ЗапуститьПриложение()`. 12 | 13 | ::: code-group 14 | 15 | ```bsl [Классы/ПришедшийСМиром.os] 16 | &Деталька(ЗначениеПоУмолчанию = "Привет, Мир!") 17 | Перем Приветствие; 18 | 19 | &Рогатка 20 | Процедура ПриСозданииОбъекта() 21 | КонецПроцедуры 22 | 23 | Процедура ПриЗапускеПриложения() Экспорт 24 | Сообщить(Приветствие); 25 | КонецПроцедуры 26 | ``` 27 | 28 | ::: 29 | 30 | `&Рогатка` является полноценным желудем, поэтому может принимать с свой конструктор и поля `&Детальки` и `&Пластилин`, а так же вжухается напильниками после создания. 31 | 32 | По умолчанию, все `&Рогатки` запускаются в фоновом задании (да, в OneScript есть фоновые задания!), затем ОСень начинает ожидать завершения работы каждой `&Рогатки` и выводить сообщения об ошибке, если вдруг выстрел не удался. Это поведение можно переопределить с помощью параметров аннотации с говорящими названиями `ЗапускатьВФоне` и `ОжидатьЗавершения`. 33 | 34 | ::: code-group 35 | 36 | ```bsl [Классы/СинхронноПришедшийСМиром.os] 37 | &Рогатка(ЗапускатьВФоне = Ложь) 38 | Процедура ПриСозданииОбъекта() 39 | КонецПроцедуры 40 | 41 | Процедура ПриЗапускеПриложения() Экспорт 42 | Сообщить("Привет, Мир!"); 43 | КонецПроцедуры 44 | ``` 45 | 46 | ::: 47 | 48 | > Следует аккуратно писать код в `&Рогатках`, запускаемых не в фоновом режиме, т.к. в этом случае `Поделка` будет ожидать завершения такой не-фоновой `&Рогатки` и не запускать остальные `&Рогатки`. Если же `ПриЗапускеПриложения()` в такой `&Рогатке` выбросит исключение, то запуск приложения остановится, а работа приложения завершится. 49 | 50 | Как и любой `&Желудь`, `&Рогатка` может иметь аннотацию `&Порядок`. Она будет влиять на порядок запуска рогаток, что особенно важно для рогаток, запускающихся не в фоне. 51 | -------------------------------------------------------------------------------- /docs/product/framework-elements/200-custom-annotations.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Собственные аннотации 3 | --- 4 | 5 | # Собственные аннотации 6 | 7 | OneScript могуч. В отличие от материнской платформы, над любым методом может быть любое количество произвольных аннотаций, у них могут быть именованные и неименованные параметры. Аннотации даже могут быть над `Перем`енными модуля и параметрами методов! Как тебе такое, УанЭс Энтерпрайз? 8 | 9 | Но с большой силой приходит большая ответственность. Произвольные параметры произвольных аннотаций довольно сложно контролировать и единообразно обрабатывать. Поэтому ОСень с одной стороны немного загоняет Вас в рамки, а с другой - дает возможность проверять корректность использования аннотаций пользователем Вашего приложения или библиотеки. Даже если это Вы сами. Будем честными, больше всего со своим кодом косячим мы сами. 10 | 11 | Помимо `&Пластилина`, `&Желудей` и прочих осенних продуктов, Вы можете описать собственную аннотацию. Для этого нужно создать новый класс, и навесить на него аннотацию `&Аннотация`. Здорово, правда? `(c)` 12 | 13 | ::: code-group 14 | 15 | ```bsl [Классы/МояАннотация.os] 16 | &Аннотация("МояХитраяАннотация") 17 | Процедура ПриСозданииОбъекта(Значение = "Трррунь", ОбязательныйПараметр) 18 | 19 | КонецПроцедуры 20 | ``` 21 | 22 | ::: 23 | 24 | По аналогии с `&Желудем`, у `&Аннотации` можно переопределить имя. Конструктор аннотации может принимать в себя любое количество именованных `&Параметров`, в том числе "волшебный" параметр с именем `Значение`. Так же для параметра можно указать значение по умолчанию. 25 | 26 | > Слышали про дог-фудинг?.. 27 | > 28 | > Каждая аннотация в ОСени представлена отдельным классом АннотацияИмя с навешенной `&Аннотацией` над конструктором. 29 | > 30 | > Да, в ОСени есть аннотация `&Аннотация`, описание которой расположено в классе с именем `АннотацияАннотация.os`, над конструктором которого висит аннотация `&Аннотация` со `Значение` = `Аннотация`. Вот такая вот метафизика. 31 | 32 | Если вы хотите разрешить пользователю ваших аннотаций указывать несколько значений для одного и того же параметра, его нужно пометить аннотацией `&Повторяемый`. Например, вот так выглядит описание аннотации `&Пластилин`: 33 | 34 | ```bsl 35 | &Аннотация("Пластилин") 36 | Процедура ПриСозданииОбъекта(Значение = "", Тип = "", &Повторяемый Блестяшка = Неопределено) 37 | 38 | КонецПроцедуры 39 | ``` 40 | -------------------------------------------------------------------------------- /docs/product/framework-elements/210-annotation-inheritance.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Наследование аннотаций 3 | --- 4 | 5 | # Наследование аннотаций 6 | 7 | Представьте себе ситуацию, когда над несколькими компонентами системы нужно развесить несколько аннотаций по одному и тому же принципу. Например, объявить много компанейских `&Желудей` с одинаковыми `&Прозвищами`. Чтобы упростить себе жизнь, можно создать новую аннотацию, в которой скомбинировать несколько других. Например: 8 | 9 | ::: code-group 10 | 11 | ```bsl [Классы/МояАннотация.os] 12 | &Аннотация("КомпанейскийОбозванныйЖелудь") 13 | &Характер("Компанейский") 14 | &Желудь 15 | &Прозвище("Обозванный") 16 | Процедура ПриСозданииОбъекта() 17 | 18 | КонецПроцедуры 19 | ``` 20 | 21 | ::: 22 | 23 | Имея такую аннотацию, можно применить ее к любому компоненту: 24 | 25 | ::: code-group 26 | 27 | ```bsl [Классы/Компонент.os] 28 | &КомпанейскийОбозванныйЖелудь 29 | Процедура ПриСозданииОбъекта() 30 | 31 | КонецПроцедуры 32 | ``` 33 | 34 | ::: 35 | 36 | При инициализации контекста этот компонент будет автоматически помечен как `компанейский` `&Желудь` и с `&Прозвищем` "Обозванный". 37 | 38 | Можно добавить в нашу новую аннотацию универсальности, объявив в конструкторе новый `&Параметр` и доопределив метод `ПриРазворачиванииАннотации`: 39 | 40 | ::: code-group 41 | 42 | ```bsl [Классы/МояАннотация.os] 43 | Перем СохраненноеЗначение; 44 | 45 | &Аннотация("КомпанейскийОбозванныйЖелудь") 46 | &Характер("Компанейский") 47 | &Желудь 48 | &Прозвище("Заглушка") 49 | Процедура ПриСозданииОбъекта(Значение) 50 | СохраненноеЗначение = Значение; 51 | КонецПроцедуры 52 | 53 | Процедура ПриРазворачиванииАннотации(ОпределениеАннотации, ПодчиненныеАннотации, ТипВладельцаСвойств, Свойство) Экспорт 54 | Аннотация = РаботаСАннотациями.НайтиАннотацию( 55 | ПодчиненныеАннотации, 56 | "Прозвище" 57 | ); 58 | 59 | РаботаСАннотациями.УстановитьЗначениеПараметраАннотации( 60 | Аннотация, 61 | "Значение", 62 | СохраненноеЗначение 63 | ); 64 | КонецПроцедуры 65 | ``` 66 | 67 | ```bsl [Классы/Компонент.os] 68 | &КомпанейскийОбозванныйЖелудь("Каштан") 69 | Процедура ПриСозданииОбъекта() 70 | 71 | КонецПроцедуры 72 | ``` 73 | 74 | ::: 75 | 76 | Пример кода выше хоть и может вызвать дикое желание записаться на курсы французского языка в Балашихе, сам по себе довольно прост. Значение нового `&Параметр`, принятого в конструктор аннотации, сохраняется в переменную `СохраненноеЗначение`. 77 | 78 | При инициализации поделки происходит "разворачивание" всех имеющихся аннотаций как над свойствами так и над методами. Если в Вашей аннотации объявлен метод `ПриРазворачиванииАннотации`, то он будет вызван с параметром `ОпределениеАннотации`, содержащей информацию о текущей аннотации и всех подчиненных аннотациях первого уровня. 79 | 80 | В примере выше среди подчиненных аннотаций ищется аннотация `Прозвище` и ей устанавливается значение из переменной `СохраненноеЗначение`. Таким образом для `Компонент` будет установлено `&Прозвище` `"Каштан"`. 81 | -------------------------------------------------------------------------------- /docs/product/framework-elements/220-annotations-processing.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Обработка аннотаций 3 | --- 4 | 5 | # Обработка аннотаций 6 | 7 | Если Вы уже попробовали делать свои `&Напильники`, то скорее всего ознакомились с классом `ОпределениеЖелудя`. Помимо хранения метаинформации о собственно желуде, методы `Свойства()` и `Методы()` возвращают информацию об аннотациях над свойствами и методами уже в "развернутом" и плоском виде. 8 | 9 | Если же у Вас на руках только тип объекта, голый рефлектор и необходимость работы с аннотациями в обход "ОСени" (не надо так), то с помощью `&Пластилина` можно прилепить к себе желудь `РазворачивательАннотаций`, в котором можно найти методы `РазвернутьАннотацииСвойств` и `РазвернутьАннотацииСвойства`. И да, данные метода от рефлектора туда тоже можно передать. 10 | 11 | Для всего остального есть модуль `РаботаСАннотациями`. 12 | -------------------------------------------------------------------------------- /docs/product/framework-elements/980-changelog.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: В предыдущих сериях 3 | --- 4 | 5 | # В предыдущих сериях 6 | 7 | В прошлых версиях библиотеки и/или документации вы могли встречать описание таких вещей как: 8 | 9 | * методы `Поделка.ДобавитьЖелудь()`/`Поделка.ДобавитьДуб()` и другие методы добавления желудей в поделку; 10 | * метод `Поделка.ПросканироватьКаталог()`; 11 | * модуль `Осень` и автоматическую регистрацию заготовок для запуска при создании поделки; 12 | * модуль `ТипыПрилепляемыхЖелудей`; 13 | 14 | Все это устарело и теперь либо не используется, либо просто не нужно. Да, следить за чейнджлогами полезно! 15 | -------------------------------------------------------------------------------- /docs/product/framework-elements/990-end.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Заключение 3 | --- 4 | 5 | # Заключение 6 | 7 | Если вы думаете, что мы упоролись, то вы в чем-то даже правы. Напоследок отмечу, что среди вариантов именования аннотаций "ОСени" еще была связка Гриб/Грибница/Спора/Рецепт для Желудь/Дуб/Завязь/Напильник соответственно. Так что еще не все потеряно. Надеюсь. 8 | 9 | Спасибо, что дочитали. <3 10 | -------------------------------------------------------------------------------- /docs/product/getting-started/10-about-autumn.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Что такое Autumn? 3 | --- 4 | 5 | ![autumn](../../../static/autumn/cover.png) 6 | 7 | # Добро пожаловать! 8 | 9 | Осень…. прекрасная пора. Ею вдохновлялся Пушкин, говорил, что осенью его особенно прёт. Именно это и произошло с авторами фреймворка "ОСень". Потому что осень - это прекрасно. 10 | Когда приложение становится большим, вам потребуется дерево (желательно дуб) и немного пластилина. Ах, да, обязательно творческое осеннее настроение, чай и стабильная психика. 11 | 12 | **Autumn** (ОСень) - это фреймворк компонентных приложений для OneScript. Он позволяет упростить процесс создания приложения и поддержки большого количества компонентов, которым больше не нужно заниматься собственным созданием или настройкой. Невероятным и магическим образом оно будет работать ✨само✨. И все это щедро обмазано пластилином и приятно пахнет дубовыми вениками. 13 | 14 | ## Принцип работы 15 | 16 | Допустим, существует объект, у которого объявлен конструктор с параметрами. И есть много мест, где он создается. Параметры этого конструктора называются *зависимостями*. То есть, объект не может жить без передачи ему этих параметров, он от них *зависит.* 17 | А где взять значения этих параметров, чтобы передать в объект? Очевидно что их тоже надо создать (через `Новый` или откуда-то получить). А у них тоже есть зависимости, и у зависимостей зависимостей есть зависимости. 18 | 19 | ## Зависимости 20 | 21 | *Зависимость*. Да, вот слово, которое приходит в голову, когда изучаешь API "ОСени". Зависимость у авторов явно есть. Но это неправда. Мы зависимы только от просмотра ~~зоопорно~~ красивого кода и вообще, не одобряем нехороших веществ, разве что пластилин (не тот) и желуди. Даа, желуди нам определенно нравятся, ведь они овальные и в смешных шапочках. 22 | 23 | Но! шутки в сторону. В ваших руках не просто пластилин и желуди, в ваших руках - Dependency Injection Framework для любимого языка программирования. Теперь ваши объекты будут ~~опрятными и шелковистыми~~ создаваться сами, и не нужно будет думать как добыть параметры конструирования, сколько их, в каком порядке они идут. Достаточно сказать: "Хочу класс УгольныйКомбайн" - а марка колес, двигатель и прочие запчасти КАК-ТО создадутся и передадутся в конструктор. 24 | 25 | ## Компонентный подход 26 | 27 | Теперь приложение может состоять из сложных компонентов, которые намного проще менять и перенастраивать. Вот был у вас класс `ОбновляторВерсии1С`. В конструкторе получал логин/пароль пользователя. И все было хорошо, но понадобилось вам в этот класс добавить знание об уже установленных версиях 1С, чтобы не скачивать лишние с сайта. Можно прямо в этом классе написать проверку установленных версий, но это нарушение ПЕО (Принцип Единой Ответственности): проверятор версий не надо смешивать с обновлятором. Мало ли в каких еще местах пригодится проверятор версий, а мы его жестко внутрь другого класса зашьем… Повторное использование - наше все. 28 | 29 | Чтобы всё было по красоте, нам надо передать в конструктор объект `ПроверяторВерсий`, который предоставит `Обновлятору1С` информацию о том, что за версии у нас уже установлены. И все бы ничего, но `Обновлятор1С` создается через `Новый` в тысяче мест. В эти места нужно залезть, и дополнительно там создать `ПроверяторВерсий` и передать его в конструктор... А если `Проверятор` тоже имеет зависимость (а кто ее не имеет в наше сложное время, а?), тогда придется протащить всё дерево зависимостей через все методы и компоненты чуть ли не от самого старта приложения. Так жить нельзя, такая жесткая связность будет мешать развитию приложения и усложнять его. 30 | 31 | Осенью, когда вам хочется создать `Обновлятор1С`, вы просто говорите ~~"Лунная призма, дай мне силы!"~~ `Осень.НайтиЖелудь("Обновлятор1С")` - и все зависимости зависимостей создадутся сами. Сколько у них параметров в конструкторе, как они создаются, кто им передает параметры и где берет - это знает только "ОСень". К чему вдаваться в метафизику… "ОСень" возьмет ваши проблемы на себя, главное - показать ей, где лежит пластилин... 32 | -------------------------------------------------------------------------------- /docs/product/getting-started/20-first-steps.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Как с этим работать? 3 | --- 4 | 5 | # Как с этим работать? 6 | 7 | ## Инициализация приложения 8 | 9 | "ОСень" - это вам non penis canina est, а фреймворк. Любой порядочный фреймворк нужно немножечко сконфигурировать, чтобы дальше все заработало. 10 | 11 | Для инициализации контекста "ОСени" служит класс `Поделка`, который необходимо создать через `Новый` (один разочек можно и написать это вредное слово), а затем наполнить Желудями, Дубами и Напильниками. Нет, мы не упоролись, скоро расскажем, что тут к чему. 12 | 13 | Инициализировать контекст можно так: 14 | 15 | ::: code-group 16 | 17 | ```bsl [main.os] 18 | #Использовать autumn 19 | 20 | Поделка = Новый Поделка(); 21 | ``` 22 | 23 | ::: 24 | 25 | И... всё. 26 | 27 | При создании Поделки ОСень автоматически просканирует все доступные в системе типов классы, определит, кто их них желудь, а то дуб, и последовательно добавит их в контекст. 28 | 29 | Вероятно, помимо загрузки собственно ОСени, вы захотите так же зарегистрировать и собственные классы. Единственное, что для этого нужно, это выполнить обычное для OneScript подключение библиотек по имени или пути: 30 | 31 | ::: code-group 32 | 33 | ```bsl [main.os] 34 | #Использовать autumn 35 | #Использовать "." // [!code focus] 36 | 37 | Поделка = Новый Поделка(); 38 | ``` 39 | 40 | ::: 41 | 42 | ## Запуск приложения 43 | 44 | После добавления всех желудей, дубов и прочих частей в нашу поделку мы готовы к запуску приложения. 45 | 46 | ::: code-group 47 | 48 | ```bsl [main.os] 49 | #Использовать autumn 50 | #Использовать "." 51 | 52 | Поделка = Новый Поделка(); 53 | Поделка.ЗапуститьПриложение(); // [!code focus] 54 | ``` 55 | 56 | ::: 57 | 58 | 61 | 62 | В чем суть? Жизненный цикл нашей поделки разделен на две фазы: 63 | 64 | - фаза инициализации, когда мы можем только добавлять в поделку новые компоненты, но еще не разрешаем им взаимодействовать; 65 | - фаза выполнения, когда в нашу поделку вдыхается жизнь ~~и выдыхаются желуди~~, наше приложение запускается и мы можем наконец начать делать что-то полезное. 66 | -------------------------------------------------------------------------------- /docs/static/cover.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/autumn-library/autumn/058ea22968dad5d2a254eb25a78c747f160c1a15/docs/static/cover.png -------------------------------------------------------------------------------- /packagedef: -------------------------------------------------------------------------------- 1 | //////////////////////////////////////////////////////////// 2 | // Описание пакета для сборки и установки 3 | // Полную документацию см. на hub.oscript.io/packaging 4 | // 5 | 6 | 7 | Описание.Имя("autumn") 8 | .Версия("4.3.9") 9 | .Автор("Nikita Fedkin") 10 | .АдресАвтора("nixel2007@gmail.com") 11 | .Описание("Dependency injection framework для OneScript") 12 | .ВерсияСреды("1.9.2") 13 | .ВключитьФайл("src") 14 | .ВключитьФайл("tests") 15 | .ВключитьФайл("LICENSE.md") 16 | .ВключитьФайл("README.md") 17 | .ЗависитОт("annotations", "1.2.0") 18 | .ЗависитОт("asserts", "1.4.0") 19 | .ЗависитОт("configor", "0.9.1") 20 | .ЗависитОт("logos", "1.7.1") 21 | .ЗависитОт("fluent", "0.6.1") 22 | .ЗависитОт("reflector", "0.7.1") 23 | .ЗависитОт("semaphore", "1.1.0") 24 | .ЗависитОт("collectionos", "0.7.2") 25 | .ЗависитОт("autumn-collections", "0.1.0") 26 | .ЗависитОт("lambdas", "0.3.2") 27 | 28 | .РазработкаЗависитОт("1testrunner") 29 | .РазработкаЗависитОт("asserts") 30 | .РазработкаЗависитОт("coverage") 31 | .РазработкаЗависитОт("fs") 32 | .РазработкаЗависитОт("decorator", "1.7.1") 33 | 34 | .ОпределяетКласс("Поделка", "src/Классы/Поделка.os") 35 | .ОпределяетКласс("Завязь", "src/Классы/Завязь.os") 36 | .ОпределяетКласс("ОпределениеЖелудя", "src/Классы/ОпределениеЖелудя.os") 37 | .ОпределяетКласс("ПрилепляемаяЧастица", "src/Классы/ПрилепляемаяЧастица.os") 38 | .ОпределяетКласс("Табакерка", "src/Классы/Табакерка.os") 39 | .ОпределяетКласс("СоветДругогоМастера", "src/Классы/СоветДругогоМастера.os") 40 | .ОпределяетМодуль("Осень", "src/Модули/Осень.os") 41 | .ОпределяетМодуль("СостоянияПриложения", "src/Модули/СостоянияПриложения.os") 42 | .ОпределяетМодуль("ТипыПрилепляемыхЖелудей", "src/Модули/ТипыПрилепляемыхЖелудей.os") 43 | .ОпределяетМодуль("ТипыПрилепляемыхЧастиц", "src/Модули/ТипыПрилепляемыхЧастиц.os") 44 | .ОпределяетМодуль("ХарактерыЖелудей", "src/Модули/ХарактерыЖелудей.os") 45 | ; 46 | -------------------------------------------------------------------------------- /performance_tests/Производительность.os: -------------------------------------------------------------------------------- 1 | #Использовать ".." 2 | #Использовать asserts 3 | #Использовать "../tests/ТестКлассы" 4 | 5 | Перем ВремяНачалаЗамера; 6 | Перем ВремяВыполненияВСекундах; 7 | 8 | Процедура ПередЗапускомТеста() Экспорт 9 | ВремяНачалаЗамера = Неопределено; 10 | ВремяВыполненияВСекундах = Неопределено; 11 | КонецПроцедуры 12 | 13 | Процедура ПослеЗапускаТеста() Экспорт 14 | 15 | КонецПроцедуры 16 | 17 | &Тест 18 | Процедура ПроверкаПроизводительностиСозданияКомпанейскихЖелудей() Экспорт 19 | 20 | // Дано 21 | Поделка = Новый Поделка(); 22 | Поделка.ЗапуститьПриложение(); 23 | 24 | 25 | КоличествоИтераций = КоличествоИтерацийСозданияОбъектов(); 26 | ПорогПрохождения = ДопустимыйПорогПрохожденияВСекундах(); 27 | 28 | // Когда 29 | 30 | НачатьЗамерВремени(); 31 | 32 | Для _Н = 1 по КоличествоИтераций Цикл 33 | Желудь = Поделка.НайтиЖелудь("КомпанейскийЖелудь"); 34 | КонецЦикла; 35 | 36 | ЗавершитьЗамерВремени(); 37 | 38 | ИнформацияОВремениВыполненияТеста("Создание компанейских желудей"); 39 | 40 | // Тогда 41 | Ожидаем.Что(ВремяВыполненияВСекундах, "Компанейские желуди создаются слишком долго").Меньше(ПорогПрохождения); 42 | 43 | КонецПроцедуры 44 | 45 | &Тест 46 | Процедура ПроверкаПроизводительностиСозданияКомпанейскихЖелудейТабакеркой() Экспорт 47 | 48 | // Дано 49 | Поделка = Новый Поделка(); 50 | Поделка.ЗапуститьПриложение(); 51 | 52 | Желудь = Поделка.НайтиЖелудь("ЖелудьСКомпанейскойТабакеркой"); 53 | 54 | 55 | КоличествоИтераций = КоличествоИтерацийСозданияОбъектов(); 56 | ПорогПрохождения = ДопустимыйПорогПрохожденияВСекундах(); 57 | 58 | // Когда 59 | 60 | НачатьЗамерВремени(); 61 | 62 | Для _Н = 1 по КоличествоИтераций Цикл 63 | КомпанейскийЖелудь = Желудь.КомпанейскийЖелудь.Достать(); 64 | КонецЦикла; 65 | 66 | ЗавершитьЗамерВремени(); 67 | 68 | ИнформацияОВремениВыполненияТеста("Создание компанейских желудей из табакерки"); 69 | 70 | // Тогда 71 | Ожидаем.Что(ВремяВыполненияВСекундах, "Компанейские желуди из табакерки создаются слишком долго").Меньше(ПорогПрохождения); 72 | 73 | КонецПроцедуры 74 | 75 | &Тест 76 | Процедура ПроверкаПроизводительностиИнициализацииПоделки() Экспорт 77 | 78 | // Дано 79 | ПорогПрохождения = 1; 80 | 81 | // Когда 82 | НачатьЗамерВремени(); 83 | Поделка = Новый Поделка(); 84 | Поделка.ЗапуститьПриложение(); 85 | ЗавершитьЗамерВремени(); 86 | 87 | ИнформацияОВремениВыполненияТеста("Инициализация пустой поделки"); 88 | 89 | // Тогда 90 | Ожидаем.Что(ВремяВыполненияВСекундах, "Время инициализация пустой поделки слишком велико").Меньше(ПорогПрохождения); 91 | 92 | КонецПроцедуры 93 | 94 | &Тест 95 | Процедура ПроверкаПроизводительностиСозданияКомпанейскихЖелудейСПластилиномНаПолнях() Экспорт 96 | 97 | // Дано 98 | Поделка = Новый Поделка(); 99 | Поделка.ЗапуститьПриложение(); 100 | 101 | 102 | КоличествоИтераций = КоличествоИтерацийСозданияОбъектов(); 103 | ПорогПрохождения = ДопустимыйПорогПрохожденияВСекундах() * 3; 104 | 105 | // Когда 106 | 107 | НачатьЗамерВремени(); 108 | 109 | Для _Н = 1 по КоличествоИтераций Цикл 110 | Желудь = Поделка.НайтиЖелудь("КомпанейскийЖелудьСПластилиномНаПолях"); 111 | КонецЦикла; 112 | 113 | ЗавершитьЗамерВремени(); 114 | 115 | ИнформацияОВремениВыполненияТеста("Создание компанейских желудей с пластилином на полях"); 116 | 117 | // Тогда 118 | Ожидаем.Что(ВремяВыполненияВСекундах, "Компанейские желуди с пластилином на полях создаются слишком долго").Меньше(ПорогПрохождения); 119 | 120 | КонецПроцедуры 121 | 122 | &Тест 123 | Процедура ПроверкаПроизводительностиСозданияКомпанейскихЖелудейСПластилиномВКонструкторе() Экспорт 124 | 125 | // Дано 126 | Поделка = Новый Поделка(); 127 | Поделка.ЗапуститьПриложение(); 128 | 129 | 130 | КоличествоИтераций = КоличествоИтерацийСозданияОбъектов(); 131 | ПорогПрохождения = ДопустимыйПорогПрохожденияВСекундах() * 3; 132 | 133 | // Когда 134 | 135 | НачатьЗамерВремени(); 136 | 137 | Для _Н = 1 по КоличествоИтераций Цикл 138 | Желудь = Поделка.НайтиЖелудь("КомпанейскийЖелудьСПластилиномВКонструкторе"); 139 | КонецЦикла; 140 | 141 | ЗавершитьЗамерВремени(); 142 | 143 | ИнформацияОВремениВыполненияТеста("Создание компанейских желудей с пластилином в конструкторе"); 144 | 145 | // Тогда 146 | Ожидаем.Что(ВремяВыполненияВСекундах, "Компанейские желуди с пластилином на полях создаются слишком долго").Меньше(ПорогПрохождения); 147 | 148 | КонецПроцедуры 149 | 150 | Процедура НачатьЗамерВремени() 151 | ВремяНачалаЗамера = ТекущаяУниверсальнаяДатаВМиллисекундах(); 152 | КонецПроцедуры 153 | 154 | Процедура ЗавершитьЗамерВремени() 155 | ВремяВыполненияВСекундах = (ТекущаяУниверсальнаяДатаВМиллисекундах() - ВремяНачалаЗамера) / 1000; 156 | КонецПроцедуры 157 | 158 | Процедура ИнформацияОВремениВыполненияТеста(СодержаниеТеста) 159 | ТекстСообщения = СтрШаблон("Время выполнения <%1> составило %2 сек.", СодержаниеТеста, ВремяВыполненияВСекундах); 160 | Сообщить(ТекстСообщения); 161 | КонецПроцедуры 162 | 163 | Функция КоличествоИтерацийСозданияОбъектов() 164 | Возврат 100000; 165 | КонецФункции 166 | 167 | Функция ДопустимыйПорогПрохожденияВСекундах() 168 | Возврат 30; 169 | КонецФункции -------------------------------------------------------------------------------- /sonar-project.properties: -------------------------------------------------------------------------------- 1 | sonar.projectKey=autumn 2 | sonar.projectName=autumn 3 | sonar.sources=./src 4 | sonar.tests=./tests 5 | sonar.sourceEncoding=UTF-8 6 | sonar.coverageReportPaths=out/genericCoverage.xml 7 | -------------------------------------------------------------------------------- /src/internal/Классы/_ПриемкаПриемка.os: -------------------------------------------------------------------------------- 1 | Перем _Поделка; 2 | 3 | Перем _ИнтерфейсПриемка; 4 | 5 | Процедура ПриДобавленииОпределенияЖелудя(Знач ОпределениеЖелудя) Экспорт 6 | 7 | ЭтоПриемка = ОпределениеЖелудя.Прозвища().Найти("Приемка") <> Неопределено; 8 | Если НЕ ЭтоПриемка Тогда 9 | Возврат; 10 | КонецЕсли; 11 | 12 | Если НЕ _ИнтерфейсПриемка.Реализован(ОпределениеЖелудя.Методы()) Тогда 13 | ТекстСообщения = СтрШаблон( 14 | "Определение желудя %1 не реализует методы интерфейса &Приемка", 15 | ОпределениеЖелудя.Имя() 16 | ); 17 | ВызватьИсключение ТекстСообщения; 18 | КонецЕсли; 19 | 20 | Приемка = _Поделка.НайтиЖелудь(ОпределениеЖелудя.Имя()); 21 | 22 | ВсеОпределенияЖелудей = _Поделка.ПолучитьОпределенияЖелудей(); 23 | Для Каждого КлючИЗначение Из ВсеОпределенияЖелудей Цикл 24 | 25 | ИмяЖелудя = КлючИЗначение.Ключ; 26 | 27 | Если ИмяЖелудя = ОпределениеЖелудя.Имя() Тогда 28 | Продолжить; 29 | КонецЕсли; 30 | 31 | Приемка.ПриДобавленииОпределенияЖелудя(ОпределениеЖелудя); 32 | 33 | КонецЦикла; 34 | 35 | КонецПроцедуры 36 | 37 | &Приемка("ПриемкаПриемка") 38 | Процедура ПриСозданииОбъекта(&Пластилин Поделка) 39 | _Поделка = Поделка; 40 | 41 | _ИнтерфейсПриемка = Новый ИнтерфейсОбъекта() 42 | .ПроцедураИнтерфейса("ПриДобавленииОпределенияЖелудя", 1); 43 | 44 | КонецПроцедуры 45 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияБлестяшка.os: -------------------------------------------------------------------------------- 1 | // Маркерная аннотация для указания, что прилепляемая частица 2 | // является произвольным значением, передаваемым в конструктор желудя. 3 | // 4 | // Может быть использована только над параметром конструктора/метода завязи желудя. 5 | // 6 | // Пример: 7 | // 8 | // 1. 9 | // &Желудь 10 | // Процедура ПриСозданииОбъекта(&Блестяшка ПроизвольноеЗначение) 11 | // 12 | // 2. 13 | // &Завязь 14 | // Функция МойЖелудь(&Блестяшка ПроизвольноеЗначение) Экспорт 15 | // 16 | &Аннотация("Блестяшка") 17 | Процедура ПриСозданииОбъекта() 18 | 19 | КонецПроцедуры 20 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияВерховный.os: -------------------------------------------------------------------------------- 1 | // Помечает желудь как имеющий приоритет среди других желудей с таким же именем или `&Прозвищем`. 2 | // В случае конфликта имен при получении желудей или их регистрации, будет использован желудь с аннотацией `&Верховный`. 3 | // 4 | // При наличии нескольких желудей с одним и тем же прозвищем позволяет определить, какой из них следует возвращать 5 | // при поиске конкретного желудя по его прозвищу. 6 | // 7 | // Если несколько желудей с одним и тем же именем/прозвищем имеют аннотацию `&Верховный`, будет вызвано исключение. 8 | // 9 | // Размещается над определением желудя - конструктором или методом &Завязи. 10 | // 11 | // Пример: 12 | // 1. 13 | // &Верховный 14 | // &Желудь("ПереопределяемыйЖелудь") 15 | // Процедура ПриСозданииОбъекта() 16 | // КонецПроцедуры 17 | // . 18 | // 2. 19 | // &Верховный 20 | // &Завязь 21 | // Функция ПереопределяемыйЖелудь() Экспорт 22 | // КонецФункции 23 | // 24 | &Аннотация("Верховный") 25 | Процедура ПриСозданииОбъекта() 26 | 27 | КонецПроцедуры 28 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияДеталька.os: -------------------------------------------------------------------------------- 1 | // Маркерная аннотация для указания, что прилепляемая частица 2 | // является настройкой приложения. 3 | // 4 | // Может быть использована над параметром конструктора/метода завязи желудя, полем класса 5 | // или методом установки значения. 6 | // 7 | // Параметры: 8 | // Значение - Строка - Ключ настройки. См. библиотеку [configor](https://github.com/oscript-library/configor) 9 | // для полного описания синтаксиса. 10 | // Если не заполнено, используется имя параметра конструктора/поля класса 11 | // или часть имени метода для установки значения. 12 | // ЗначениеПоУмолчанию - Произвольный - Значение, которое принимает деталька, если не задано из-вне. 13 | // 14 | // Пример: 15 | // 16 | // 1. 17 | // &Деталька 18 | // Перем ПутьКФайлу; 19 | // 20 | // 2. 21 | // &Деталька(Значение = "Настройки.ПутьКФайлу", ЗначениеПоУмолчанию = "./file.txt") 22 | // Перем ПутьКФайлу; 23 | // 24 | // 3. 25 | // &Желудь 26 | // Процедура ПриСозданииОбъекта(&Деталька ПутьКФайлу) 27 | // 28 | // 4. 29 | // &Деталька 30 | // Процедура УстановитьПутьКФайлу(Значение) Экспорт 31 | // 32 | // 5. 33 | // &Завязь 34 | // Функция МойЖелудь(&Деталька ПутьКФайлу) Экспорт 35 | // 36 | &Аннотация("Деталька") 37 | Процедура ПриСозданииОбъекта(Значение = "", ЗначениеПоУмолчанию = Неопределено) 38 | 39 | КонецПроцедуры 40 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияДуб.os: -------------------------------------------------------------------------------- 1 | // Помечает указанный класс как фабрику компонентов - дуб, из которого появляются желуди. 2 | // `&Дуб` сам по себе тоже является желудем, то есть может запрашивать прилепление частиц, 3 | // является объектом для обработки `&Напильник`ом, может иметь `&Спецификация` и так далее. 4 | // 5 | // Дуб обычно содержит методы, помеченные аннотацией `&Завязь`, которые возвращают желуди, но 6 | // может содержать и другие методы, не связанные непосредственно с созданием желудей. 7 | // 8 | // Размещается над конструктором класса. 9 | // 10 | // Параметры: 11 | // Значение - Строка - Имя желудя. По умолчанию будет использовано имя типа объекта, 12 | // как оно возвращается функцией `ТипЗнч`. 13 | // Пример: 14 | // &Дуб 15 | // Процедура ПриСозданииОбъекта() 16 | // КонецПроцедуры 17 | // . 18 | // &Завязь 19 | // Функция ПользовательскийЖелудь() Экспорт 20 | // . Возврат Новый ПользовательскийЖелудь(); 21 | // КонецФункции 22 | // 23 | &Аннотация("Дуб") 24 | Процедура ПриСозданииОбъекта(Значение = "") 25 | 26 | КонецПроцедуры 27 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияЖелудь.os: -------------------------------------------------------------------------------- 1 | // Помечает указанный класс как желудь - компонент, жизненным циклом которого управляет фреймворк ОСень. 2 | // 3 | // Размещается над конструктором класса. 4 | // 5 | // Параметры: 6 | // Значение - Строка - Имя желудя. По умолчанию будет использовано имя типа объекта, 7 | // как оно возвращается функцией `ТипЗнч`. 8 | // 9 | // Пример: 10 | // &Желудь 11 | // Процедура ПриСозданииОбъекта() 12 | // КонецПроцедуры 13 | // 14 | &Аннотация("Желудь") 15 | Процедура ПриСозданииОбъекта(Значение = "") 16 | 17 | КонецПроцедуры 18 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияЗавязь.os: -------------------------------------------------------------------------------- 1 | // Помечает функцию как функцию, создающую желудь. 2 | // 3 | // Может иметь параметры, каждый из которых должен быть промаркирован как &Пластилин, &Деталька или &Блестяшка. 4 | // В указанные параметры автоматически будут прилеплены соответствующие частицы при создании желудя. 5 | // 6 | // Может размещаться над экспортной функцией в классе, проаннотированном как `&Дуб`, или над методом-лямбдой, 7 | // передаваемой в качестве параметра в `Поделка.ДобавитьЗавязь()`. 8 | // 9 | // Параметры: 10 | // Значение - Строка - Имя создаваемого желудя. По умолчанию будет использовано имя метода. 11 | // Тип - Строка - Тип создаваемого желудя. 12 | // Требуется если по имени желудя не получается однозначного определить его тип. 13 | // 14 | // Пример: 15 | // &Завязь 16 | // Функция ПользовательскийЖелудь(&Пластилин Зависимость, &Деталька ВажнаяНастройка) Экспорт 17 | // . Возврат Новый ПользовательскийЖелудь(Зависимость, ВажнаяНастройка); 18 | // КонецФункции 19 | // 20 | &Аннотация("Завязь") 21 | Процедура ПриСозданииОбъекта(Значение = "", Тип = "") 22 | 23 | КонецПроцедуры 24 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияЗаготовка.os: -------------------------------------------------------------------------------- 1 | // Специальный тип желудя для выполнения дополнительных действий в момент помещения класса в контекст Поделки. 2 | // 3 | // Может использоваться для добавления динамической загрузки новых классов в систему типов OneScript или 4 | // дополнительных импортов библиотек через директиву `#Использовать`. 5 | // 6 | // Каждая `&Заготовка` дополнительно имеет `&Прозвище("Заготовка")` и &Спецификация("Инициализация"). 7 | // 8 | // Желудь, помеченный аннотацией `&Заготовка`, должен реализовать следующий интерфейс: 9 | // * `Процедура ПриИнициализацииПоделки(Поделка) Экспорт` 10 | // 11 | // Размещается над конструктором класса. 12 | // 13 | // Параметры: 14 | // Значение - Строка - Имя желудя, под которым заготовка добавляется в контекст Поделки. 15 | // 16 | // Пример: 17 | // &Заготовка 18 | // Процедура ПриСозданииОбъекта() 19 | // КонецПроцедуры 20 | // 21 | &Аннотация("Заготовка") 22 | &Прозвище("Заготовка") 23 | &Спецификация("Инициализация") 24 | Процедура ПриСозданииОбъекта(Значение = "") 25 | 26 | КонецПроцедуры 27 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияНапильник.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать collectionos 3 | 4 | Перем _ПрименяетсяТолькоНа; 5 | 6 | // Проверить, может ли текущий напильник применяться на указанном желуде. 7 | // 8 | // Параметры: 9 | // ОпределениеЖелудя - ОпределениеЖелудя - Определение желудя, для которого проверяется 10 | // применимость текущего напильника. 11 | // 12 | // Возвращаемое значение: 13 | // Булево - Истина, если напильник может применяться на указанном желуде, иначе Ложь. 14 | // 15 | Функция МожетПрименятьсяНа(ОпределениеЖелудя) Экспорт 16 | 17 | НапильникМожетПрименяться = Ложь; 18 | 19 | Если _ПрименяетсяТолькоНа.Количество() = 0 Тогда 20 | НапильникМожетПрименяться = Истина; 21 | Иначе 22 | 23 | Для Каждого Идентификатор Из ОпределениеЖелудя.Прозвища() Цикл 24 | Если _ПрименяетсяТолькоНа.Содержит(Идентификатор) Тогда 25 | НапильникМожетПрименяться = Истина; 26 | Прервать; 27 | КонецЕсли; 28 | КонецЦикла; 29 | 30 | КонецЕсли; 31 | 32 | Возврат НапильникМожетПрименяться; 33 | 34 | КонецФункции 35 | 36 | // Специальный тип желудя для дополнительной обработки других желудей в процессе их создания. 37 | // 38 | // Может использоваться для добавления дополнительных действий или свойств создаваемым желудям. Метод `ОбработатьЖелудь` 39 | // **может** возвращать другой объект, который подменит текущий желудь, или обертку-декоратор над текущим желудем. 40 | // 41 | // Каждый `&Напильник` дополнительно имеет `&Прозвище("Напильник")`. 42 | // 43 | // Напильник сам по себе является желудем, однако в силу своей специфики он может запрашивать прилепление только 44 | // &Деталек и Поделки. 45 | // 46 | // Желудь, помеченный аннотацией `&Напильник`, должен реализовать следующий интерфейс: 47 | // * `Функция ОбработатьЖелудь(Желудь, ОпределениеЖелудя) Экспорт` 48 | // 49 | // Размещается над конструктором класса. 50 | // 51 | // Параметры: 52 | // Значение - Строка - Имя желудя, под которым напильник добавляется в контекст Поделки. 53 | // ПрименяетсяТолькоНа - Строка - Повторяемый параметр. Ограничивает применение напильника только на желудях 54 | // с указанными именами. 55 | // 56 | // Пример: 57 | // &Напильник 58 | // Процедура ПриСозданииОбъекта() 59 | // КонецПроцедуры 60 | // 61 | &Аннотация("Напильник") 62 | &Прозвище("Напильник") 63 | Процедура ПриСозданииОбъекта(Значение = "", &Повторяемый ПрименяетсяТолькоНа = Неопределено) 64 | 65 | _ПрименяетсяТолькоНа = Новый МножествоСоответствие(); 66 | Для Каждого МестоПрименения Из ПрименяетсяТолькоНа Цикл 67 | Ожидаем.Что(МестоПрименения, "Ограничение применения напильника должно быть задано строкой").ИмеетТип("Строка"); 68 | 69 | _ПрименяетсяТолькоНа.Добавить(МестоПрименения); 70 | КонецЦикла; 71 | 72 | КонецПроцедуры 73 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияОсобоеОбращение.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | 3 | Перем _ОтключитьВсеНапильники; 4 | Перем _ПрименятьТолькоНапильники; 5 | Перем _НеПрименятьНапильники; 6 | 7 | // Проверяет, может ли указанный напильник применяться над желудем, помеченным аннотацией `&ОсобоеОбращение`. 8 | // 9 | // Параметры: 10 | // ИмяНапильника - Строка - Имя напильника для проверки применимости. 11 | // 12 | // Возвращаемое значение: 13 | // Булево - Истина, если напильник может применяться на текущем желуде, иначе Ложь. 14 | // 15 | Функция НапильникМожетПрименяться(ИмяНапильника) Экспорт 16 | 17 | Если _ОтключитьВсеНапильники Тогда 18 | Возврат Ложь; 19 | КонецЕсли; 20 | 21 | Если _ПрименятьТолькоНапильники.Количество() > 0 Тогда 22 | Возврат _ПрименятьТолькоНапильники.Найти(ИмяНапильника) <> Неопределено; 23 | Иначе 24 | Возврат _НеПрименятьНапильники.Найти(ИмяНапильника) = Неопределено; 25 | КонецЕсли; 26 | 27 | КонецФункции 28 | 29 | // Маркерная аннотация, показывающая, что желудь требует изменений в процессе своего создания. 30 | // 31 | // Параметры аннотации конфликтуют между собой. Если отключаются все напильники, то нельзя задавать ограничения на 32 | // применение конкретных напильников или отключение конкретных напильников. Если задано ограничение на применение только 33 | // конкретных напильников, то нельзя задавать ограничение на отключение конкретных напильников (и наоборот). 34 | // 35 | // Размещается над конструктором класса или над методом `&Завязи`. 36 | // 37 | // Параметры: 38 | // ОтключитьВсеНапильники - Булево - Не применять на желуде никакие напильники. 39 | // ПрименятьТолькоНапильник - Строка - Повторяемый параметр. Применять на желуде только напильник с указанным именем. 40 | // НеПрименятьНапильник - Строка - Повторяемый параметр. Не применять на желуде напильник с указанным именем. 41 | // 42 | &Аннотация("ОсобоеОбращение") 43 | Процедура ПриСозданииОбъекта( 44 | ОтключитьВсеНапильники = Ложь, 45 | &Повторяемый ПрименятьТолькоНапильник = Неопределено, 46 | &Повторяемый НеПрименятьНапильник = Неопределено 47 | ) 48 | 49 | Для Каждого МестоПрименения Из ПрименятьТолькоНапильник Цикл 50 | Ожидаем.Что(МестоПрименения, "Ограничение ""только"" применения напильника должно быть задано строкой") 51 | .ИмеетТип("Строка"); 52 | КонецЦикла; 53 | 54 | Для Каждого МестоПрименения Из НеПрименятьНапильник Цикл 55 | Ожидаем.Что(МестоПрименения, "Ограничение ""не"" применения напильника должно быть задано строкой") 56 | .ИмеетТип("Строка"); 57 | КонецЦикла; 58 | 59 | Если ОтключитьВсеНапильники И ПрименятьТолькоНапильник.Количество() > 0 Тогда 60 | ВызватьИсключение "Нельзя одновременно отключать все напильники и задавать ограничения ""только"""; 61 | КонецЕсли; 62 | 63 | Если ОтключитьВсеНапильники И НеПрименятьНапильник.Количество() > 0 Тогда 64 | ВызватьИсключение "Нельзя одновременно отключать все напильники и задавать ограничения ""не"""; 65 | КонецЕсли; 66 | 67 | Если ПрименятьТолькоНапильник.Количество() > 0 И НеПрименятьНапильник.Количество() > 0 Тогда 68 | ВызватьИсключение "Нельзя одновременно задавать ограничения ""только"" и ""не"""; 69 | КонецЕсли; 70 | 71 | _ОтключитьВсеНапильники = ОтключитьВсеНапильники; 72 | _ПрименятьТолькоНапильники = ПрименятьТолькоНапильник; 73 | _НеПрименятьНапильники = НеПрименятьНапильник; 74 | 75 | КонецПроцедуры 76 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияПластилин.os: -------------------------------------------------------------------------------- 1 | // Маркерная аннотация для указания, что прилепляемая частица 2 | // является желудем. Основной способ связывания желудей между собой. 3 | // 4 | // Может быть использована над параметром конструктора/метода завязи желудя, полем класса 5 | // или методом установки значения. 6 | // 7 | // Параметры: 8 | // Значение - Строка - Имя прилепляемого желудя. Если не заполнено, используется имя параметра конструктора/поля 9 | // класса или часть имени метода для установки значения. 10 | // Тип - Строка - Тип прилепляемого желудя. В случае передачи значения "Желудь", будет внедрен желудь как таковой. 11 | // Так же может быть указан тип-коллекция: "Массив", "ТаблицаЗначений" и другие. Полный список 12 | // доступных типов см. в библиотеке 13 | // [autumn-collections](https://github.com/autumn-library/autumn-collections). 14 | // Блестяшка - Произвольный - Повторяемый параметр. Передаваемые в прилепляемый желудь произвольные значения. 15 | // 16 | // Пример: 17 | // 18 | // 1. 19 | // &Желудь 20 | // Процедура ПриСозданииОбъекта(&Пластилин ДругойЖелудь) 21 | // 22 | // 2. 23 | // &Желудь 24 | // Процедура ПриСозданииОбъекта( 25 | // . &Пластилин(Значение = "ДругойЖелудь", Тип = "Массив", Блестяшка = "Парам1", Блестяшка = "Парам2") Зависимость 26 | // ) 27 | // 28 | // 3. 29 | // &Пластилин 30 | // Перем ДругойЖелудь; 31 | // 32 | // 4. 33 | // &Завязь 34 | // Функция МойЖелудь(&Пластилин ДругойЖелудь) Экспорт 35 | // 36 | // 5. 37 | // &Пластилин 38 | // Процедура УстановитьДругойЖелудь(Зависимость) Экспорт 39 | // 40 | &Аннотация("Пластилин") 41 | Процедура ПриСозданииОбъекта(Значение = "", Тип = "", &Повторяемый Блестяшка = Неопределено) 42 | 43 | КонецПроцедуры 44 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияПорядок.os: -------------------------------------------------------------------------------- 1 | Перем _Значение; 2 | 3 | // Порядок, заданный аннотацией. 4 | // 5 | // Возвращаемое значение: 6 | // Число 7 | // 8 | Функция Значение() Экспорт 9 | Возврат _Значение; 10 | КонецФункции 11 | 12 | // Управляет порядком инициализации и использования желудя. Не может быть меньше 1 или больше 999998. 13 | // 14 | // Если размещается над обычным `&Желудем` или `&Завязью`, то влияет на порядок сортировки, при получении 15 | // коллекции желудей по прозвищу. 16 | // 17 | // Если размещается над `&Напильником`, влияет на порядок применения напильников к желудям. 18 | // 19 | // Если размещается над `&Рогаткой`, влияет на порядок запуска рогаток при старте приложения. 20 | // 21 | // Параметры: 22 | // Значение - Число - Задаваемый порядок. 23 | // 24 | &Аннотация("Порядок") 25 | Процедура ПриСозданииОбъекта(Значение = 1) 26 | _Значение = Значение; 27 | КонецПроцедуры 28 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияПриемка.os: -------------------------------------------------------------------------------- 1 | // Специальный тип желудя для обработки определений желудей. 2 | // 3 | // Аналог &Напильника для `ОпределениеЖелудя`. Срабатывает каждый раз, когда в контекст добавляется новое 4 | // определение желудя. При добавлении самой Приемки в контекст, все ранее добавленные определения желудей 5 | // передаются в Приемку для проверки. 6 | // 7 | // Класс, помеченный аннотацией `&Приемка`, должен реализовать следующий интерфейс: 8 | // * `Процедура ПриДобавленииОпределенияЖелудя(ОпределениеЖелудя) Экспорт` 9 | // 10 | // Каждая `&Приемка` так же имеет `&Характер("Компанейский")`, `&Прозвище("Приемка")` и `&Спецификация("Инициализация")` 11 | // 12 | // Размещается над конструктором класса. 13 | // 14 | // Параметры: 15 | // Значение - Строка - Имя желудя, под которым приемка добавляется в контекст Поделки. 16 | // 17 | // Пример: 18 | // 19 | // Процедура ПриДобавленииОпределенияЖелудя(ОпределениеЖелудя) Экспорт 20 | // . Сообщить("Определение желудя: " + ОпределениеЖелудя.Имя()); 21 | // КонецПроцедуры 22 | // . 23 | // &Приемка 24 | // Процедура ПриСозданииОбъекта() 25 | // КонецПроцедуры 26 | // 27 | &Аннотация("Приемка") 28 | &Прозвище("Приемка") 29 | &Характер("Компанейский") 30 | &Спецификация("Инициализация") 31 | Процедура ПриСозданииОбъекта(Значение = "") 32 | КонецПроцедуры 33 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияПрозвище.os: -------------------------------------------------------------------------------- 1 | // Добавляет к желудю дополнительный идентификатор, по которому его можно в последствии доставать из Поделки. 2 | // Желудь может иметь несколько прозвищ. Одно и то же прозвище может использоваться для нескольких желудей. 3 | // 4 | // Может быть использовано, например, для группировки желудей и получении их в виде массива. 5 | // 6 | // Размещается над конструктором класса или над методом `&Завязи`. 7 | // 8 | // Параметры: 9 | // Значение - Строка - Задаваемое прозвище. 10 | // 11 | // Пример: 12 | // 13 | // &Прозвище("ПодписчикНаСобытие") 14 | // &Прозвище("ПользовательскийЖелудь") 15 | // &Желудь("МойЖелудь") 16 | // Процедура ПриСозданииОбъекта() 17 | // КонецПроцедуры 18 | // 19 | &Аннотация("Прозвище") 20 | Процедура ПриСозданииОбъекта(Значение) 21 | 22 | КонецПроцедуры 23 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияРогатка.os: -------------------------------------------------------------------------------- 1 | Перем _ЗапускатьВФоне; 2 | Перем _ОжидатьЗавершения; 3 | 4 | // Флаг необходимости запуска рогатки в фоновом задании. 5 | // 6 | // Возвращаемое значение: 7 | // Булево 8 | // 9 | Функция ЗапускатьВФоне() Экспорт 10 | Возврат _ЗапускатьВФоне; 11 | КонецФункции 12 | 13 | // Флаг необходимости ожидания завершения рогатки при ее запуске в фоновом задании. 14 | // 15 | // Возвращаемое значение: 16 | // Булево 17 | // 18 | Функция ОжидатьЗавершения() Экспорт 19 | Возврат _ОжидатьЗавершения; 20 | КонецФункции 21 | 22 | // Специальный тип желудя, автоматически выполняемый при запуске приложения (`Поделка.ЗапуститьПриложение()`). 23 | // 24 | // Желудь, помеченный аннотацией `&Рогатка`, должен реализовать следующий интерфейс: 25 | // * `Процедура ПриЗапускеПриложения() Экспорт` 26 | // 27 | // Каждая `&Рогатка` дополнительно имеет `&Прозвище("Рогатка")`. 28 | // 29 | // `&Рогатка` сама по себе тоже является желудем, то есть может запрашивать прилепление частиц, 30 | // является объектом для обработки `&Напильник`ом, может иметь `&Спецификация` и так далее. 31 | // 32 | // Размещается над конструктором класса. 33 | // 34 | // Параметры: 35 | // Значение - Строка - Имя желудя, под которым рогатка добавляется в контекст Поделки. 36 | // ЗапускатьВФоне - Булево - Если Истина, то рогатка будет запущена в фоновом задании. 37 | // Если Ложь, то рогатка будет запущена в текущем потоке. 38 | // ОжидатьЗавершения - Булево - Если Истина и `ЗапускатьВФоне` = Истина, 39 | // то после запуска рогатки будет ожидаться её завершение. 40 | // Пример: 41 | // Процедура ПриЗапускеПриложения() Экспорт 42 | // . Сообщить("Привет из рогатки!"); 43 | // КонецПроцедуры 44 | // . 45 | // &Рогатка 46 | // Процедура ПриСозданииОбъекта() 47 | // КонецПроцедуры 48 | // 49 | &Аннотация("Рогатка") 50 | &Прозвище("Рогатка") 51 | Процедура ПриСозданииОбъекта(Значение = "", ЗапускатьВФоне = Истина, ОжидатьЗавершения = Истина) 52 | _ЗапускатьВФоне = ЗапускатьВФоне; 53 | _ОжидатьЗавершения = ОжидатьЗавершения; 54 | КонецПроцедуры 55 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияСпецификация.os: -------------------------------------------------------------------------------- 1 | Перем _Значение; 2 | 3 | // Сохраненное значение спецификации. 4 | // 5 | // Возвращаемое значение: 6 | // Строка 7 | // 8 | Функция Значение() Экспорт 9 | Возврат _Значение; 10 | КонецФункции 11 | 12 | // Аннотация для указания жизненного цикла приложения, начиная с которого разрешено создавать желудь. 13 | // 14 | // По умолчанию все желуди имеют спецификацию "Выполнение", означающую, что желудь может быть создан только после вызова 15 | // `Поделка.ЗапуститьПриложение()`. 16 | // 17 | // К желудям со спецификацией "Инициализация" не применяются напильники. 18 | // 19 | // Размещается над конструктором класса или над методом `&Завязи`. 20 | // 21 | // Параметры: 22 | // Значение - Строка - Состояние приложения, на котором разрешено создавать желудь. См. СостоянияПриложения. 23 | // 24 | // Пример: 25 | // &Спецификация("Инициализация") 26 | // &Желудь 27 | // Процедура ПриСозданииОбъекта() 28 | // КонецПроцедуры 29 | // 30 | &Аннотация("Спецификация") 31 | Процедура ПриСозданииОбъекта(Значение = "Выполнение") 32 | 33 | _Значение = Значение; 34 | 35 | Если СостоянияПриложения.Значения().Найти(_Значение) = Неопределено Тогда 36 | ТекстСообщения = СтрШаблон( 37 | "Неверное значение спецификации %1", 38 | _Значение 39 | ); 40 | 41 | ВызватьИсключение ТекстСообщения; 42 | КонецЕсли; 43 | 44 | КонецПроцедуры 45 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияТабакерка.os: -------------------------------------------------------------------------------- 1 | // Пометка, что прилепляемая частица прилепляется не непосредственно, а через специальный объект 2 | // типа `Табакерка`, который позволяет получить частицу программно и отложенно. 3 | // 4 | // Может использоваться для внедрения компанейских желудей, внедрения желудя самого в себя, 5 | // для разрыва циклических зависимостей, для передачи дополнительных параметров прилепляемого желудя и т.п. 6 | // 7 | // Используется совместно с аннотациями `&Пластилин` и `&Деталька`. 8 | // 9 | // Пример: 10 | // 11 | // 1. 12 | // &Табакерка 13 | // &Пластилин("ДругойЖелудь") 14 | // Перем ТабакеркаСДругимЖелудем; 15 | // . 16 | // ДругойЖелудь = ТабакеркаСДругимЖелудем.Достать(); 17 | // ДругойЖелудь.КакойТоМетод(); 18 | // ... 19 | // 2. 20 | // &Табакерка 21 | // &Пластилин("ДругойЖелудь") 22 | // Перем ТабакеркаСДругимЖелудем; 23 | // . 24 | // МассивБлестяшек = Новый Массив; 25 | // МассивБлестяшек.Добавить("Парам1"); 26 | // . 27 | // ДругойЖелудь = ТабакеркаСДругимЖелудем.Достать(МассивБлестяшек); 28 | // ДругойЖелудь.КакойТоМетод(); 29 | // 30 | &Аннотация("Табакерка") 31 | Процедура ПриСозданииОбъекта() 32 | 33 | КонецПроцедуры 34 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияФинальныйШтрих.os: -------------------------------------------------------------------------------- 1 | // Процедуры, помеченные аннотацией "ФинальныйШтрих" будут вызваны в конце инициализации желудя, 2 | // после отработки конструктора/метода завязи и всех напильников, применяемых на желуде. 3 | // Во время выполнения процедуры доступны все прилепляемые частицы, прилепленные как через конструктор, 4 | // так и через поля класса и методы-сеттеры. 5 | // 6 | // Желудь может содержать несколько процедур, помеченных аннотацией "ФинальныйШтрих". 7 | // Порядок их вызова не гарантируется. 8 | // 9 | // Процедура должна быть помечена `Экспорт`ная. 10 | // 11 | // Пример: 12 | // 13 | // &ФинальныйШтрих 14 | // Процедура ПостИнициализация() Экспорт 15 | // . Сообщить("Я выполнилась после конструктора объекта"); 16 | // КонецПроцедуры 17 | // . 18 | // &Желудь 19 | // Процедура ПриСозданииОбъекта() 20 | // КонецПроцедуры 21 | // 22 | &Аннотация("ФинальныйШтрих") 23 | Процедура ПриСозданииОбъекта() 24 | 25 | КонецПроцедуры 26 | -------------------------------------------------------------------------------- /src/internal/Классы/АннотацияХарактер.os: -------------------------------------------------------------------------------- 1 | // Задает способ управления жизненным циклом желудя. 2 | // 3 | // ОСень содержит два базовых характера желудя: "Одиночка" и "Компанейский". 4 | // 5 | // По умолчанию все желуди имеют характер "Одиночка", означающий, что желудь 6 | // инициализируется один раз. При каждом запросе желудя будет возвращаться один и тот же 7 | // экземпляр. 8 | // 9 | // Характер "Компанейский" означает, что каждый раз при запросе желудя будет создаваться 10 | // новый экземпляр. 11 | // 12 | // Размещается над конструктором класса или над методом `&Завязи`. 13 | // 14 | // Параметры: 15 | // Значение - Строка - Характер желудя. 16 | // 17 | // Пример: 18 | // &Характер("Компанейский") 19 | // &Желудь 20 | // Процедура ПриСозданииОбъекта() 21 | // КонецПроцедуры 22 | // 23 | &Аннотация("Характер") 24 | Процедура ПриСозданииОбъекта(Значение) 25 | 26 | КонецПроцедуры 27 | -------------------------------------------------------------------------------- /src/internal/Классы/ЗапускательПриложения.os: -------------------------------------------------------------------------------- 1 | #Использовать annotations 2 | #Использовать logos 3 | 4 | &Пластилин 5 | Перем Поделка; 6 | 7 | &Пластилин(Значение = "Рогатка", Тип = "ТаблицаЗначений") 8 | Перем Рогатки; 9 | 10 | &Деталька(Значение = "core.ЗапускатьРогатки", ЗначениеПоУмолчанию = Истина) 11 | Перем ЗапускатьРогатки; 12 | 13 | Перем Лог; 14 | 15 | Процедура ЗапуститьПриложение() Экспорт 16 | 17 | Если НЕ ЗапускатьРогатки Тогда 18 | Лог.Информация("Запуск рогаток отключен."); 19 | Возврат; 20 | КонецЕсли; 21 | 22 | КоличествоРогаток = Рогатки.Количество(); 23 | Если КоличествоРогаток = 0 Тогда 24 | Лог.Отладка("Список рогаток пуст."); 25 | Возврат; 26 | КонецЕсли; 27 | 28 | ОпределениеАннотацииРогатка = Поделка.ПолучитьОпределенияАннотаций().Получить("рогатка"); 29 | 30 | Лог.Отладка("Запускаю %1 рогаток.", КоличествоРогаток); 31 | 32 | ЗапущенныеРогатки = Новый Массив; 33 | 34 | Для Каждого ДанныеРогатки Из Рогатки Цикл 35 | ОпределениеРогатки = ДанныеРогатки.ОпределениеЖелудя; 36 | Лог.Отладка("Запускаю рогатку %1", ОпределениеРогатки.Имя()); 37 | 38 | Конструктор = ОпределениеРогатки.Завязь().ДанныеМетода(); 39 | АннотацияРогатка = РаботаСАннотациями.ПолучитьАннотацию(Конструктор, "Рогатка"); 40 | ОбъектАннотации = ОпределениеАннотацииРогатка.СоздатьОбъектАннотации(АннотацияРогатка); 41 | ЗапускатьВФоне = ОбъектАннотации.ЗапускатьВФоне(); 42 | ОжидатьЗавершения = ОбъектАннотации.ОжидатьЗавершения(); 43 | 44 | Рогатка = ДанныеРогатки.Желудь; 45 | 46 | Если ЗапускатьВФоне Тогда 47 | ДлительнаяЗадача = Истина; 48 | ФоновоеЗадание = ФоновыеЗадания.Выполнить(Рогатка, "ПриЗапускеПриложения", , ДлительнаяЗадача); 49 | 50 | Если ОжидатьЗавершения Тогда 51 | ЗапущенныеРогатки.Добавить(ФоновоеЗадание); 52 | КонецЕсли; 53 | Иначе 54 | Рогатка.ПриЗапускеПриложения(); 55 | КонецЕсли; 56 | КонецЦикла; 57 | 58 | Если ЗапущенныеРогатки.Количество() = 0 Тогда 59 | Возврат; 60 | КонецЕсли; 61 | 62 | Пока ЗапущенныеРогатки.Количество() > 0 Цикл 63 | ИндексЗадания = ФоновыеЗадания.ОжидатьЛюбое(ЗапущенныеРогатки); 64 | ФоновоеЗадание = ЗапущенныеРогатки[ИндексЗадания]; 65 | 66 | Если ФоновоеЗадание.Состояние = СостояниеФоновогоЗадания.ЗавершеноАварийно Тогда 67 | Лог.Ошибка( 68 | "Ошибка запуска рогатки %1%2%3", 69 | Строка(ФоновоеЗадание.Объект), 70 | Символы.ПС, 71 | ПодробноеПредставлениеОшибки(ФоновоеЗадание.ИнформацияОбОшибке) 72 | ); 73 | КонецЕсли; 74 | 75 | ЗапущенныеРогатки.Удалить(ИндексЗадания); 76 | КонецЦикла; 77 | 78 | Лог.Отладка("Запуск приложения завершен"); 79 | 80 | КонецПроцедуры 81 | 82 | &Желудь 83 | Процедура ПриСозданииОбъекта() 84 | 85 | Лог = Логирование.ПолучитьЛог("oscript.lib.autumn.ЗапускательПриложения"); 86 | 87 | КонецПроцедуры 88 | -------------------------------------------------------------------------------- /src/internal/Классы/ОбработкаНапильникомПластилинаНаПолях.os: -------------------------------------------------------------------------------- 1 | #Использовать annotations 2 | #Использовать reflector 3 | 4 | Перем _Рефлектор; 5 | Перем _ПрилепляторЧастиц; 6 | 7 | Функция ОбработатьЖелудь(Желудь, ОпределениеЖелудя) Экспорт // BSLLS:UnusedParameters-off 8 | 9 | ОбработатьАннотацию("Пластилин", Желудь, ОпределениеЖелудя); 10 | ОбработатьАннотацию("Деталька", Желудь, ОпределениеЖелудя); 11 | 12 | Возврат Желудь; 13 | 14 | КонецФункции 15 | 16 | Процедура ОбработатьАннотацию(ИмяАннотации, Желудь, ОпределениеЖелудя) 17 | 18 | Свойства = ОпределениеЖелудя.Свойства(); 19 | Для Каждого Свойство Из Свойства Цикл 20 | 21 | Аннотация = РаботаСАннотациями.ПолучитьАннотацию(Свойство, ИмяАннотации); 22 | 23 | Если Аннотация = Неопределено Тогда 24 | Продолжить; 25 | КонецЕсли; 26 | 27 | ДанныеОПрилепляемойЧастице = _ПрилепляторЧастиц.ДанныеОПрилепляемойЧастице(Свойство); 28 | ПрилепляемаяЧастица = _ПрилепляторЧастиц.НайтиПрилепляемуюЧастицу(ДанныеОПрилепляемойЧастице); 29 | 30 | _Рефлектор.УстановитьСвойство(Желудь, Свойство.Имя, ПрилепляемаяЧастица); 31 | 32 | КонецЦикла; 33 | 34 | Методы = ОпределениеЖелудя.НайтиМетодыСАннотациями(ИмяАннотации); 35 | Для Каждого Метод Из Методы Цикл 36 | 37 | Аннотация = РаботаСАннотациями.ПолучитьАннотацию(Метод, ИмяАннотации); 38 | 39 | Если Аннотация = Неопределено Тогда 40 | Продолжить; 41 | КонецЕсли; 42 | 43 | ПрототипИмениПрилепляемойЧастицы = СтрЗаменить(Метод.Имя, "Установить", ""); 44 | 45 | ДанныеОПрилепляемойЧастице = _ПрилепляторЧастиц.ДанныеОПрилепляемойЧастице(Метод, ПрототипИмениПрилепляемойЧастицы); 46 | ПрилепляемаяЧастица = _ПрилепляторЧастиц.НайтиПрилепляемуюЧастицу(ДанныеОПрилепляемойЧастице); 47 | 48 | ПараметрыМетода = Новый Массив(); 49 | ПараметрыМетода.Добавить(ПрилепляемаяЧастица); 50 | 51 | _Рефлектор.ВызватьМетод(Желудь, Метод.Имя, ПараметрыМетода); 52 | КонецЦикла; 53 | 54 | КонецПроцедуры 55 | 56 | &Напильник 57 | &Порядок(0) 58 | Процедура ПриСозданииОбъекта(&Пластилин ПрилепляторЧастиц) 59 | _Рефлектор = Новый Рефлектор(); 60 | _ПрилепляторЧастиц = ПрилепляторЧастиц; 61 | КонецПроцедуры 62 | -------------------------------------------------------------------------------- /src/internal/Классы/ОбработкаНапильникомФинальныйШтрих.os: -------------------------------------------------------------------------------- 1 | #Использовать reflector 2 | 3 | Перем _Рефлектор; 4 | 5 | Функция ОбработатьЖелудь(Желудь, ОпределениеЖелудя) Экспорт // BSLLS:UnusedParameters-off 6 | 7 | Методы = ОпределениеЖелудя.НайтиМетодыСАннотациями("ФинальныйШтрих"); 8 | 9 | Для Каждого Метод Из Методы Цикл 10 | _Рефлектор.ВызватьМетод(Желудь, Метод.Имя, Новый Массив()); 11 | КонецЦикла; 12 | 13 | Возврат Желудь; 14 | КонецФункции 15 | 16 | &Напильник 17 | &Порядок(999999) 18 | Процедура ПриСозданииОбъекта() 19 | _Рефлектор = Новый Рефлектор(); 20 | КонецПроцедуры 21 | -------------------------------------------------------------------------------- /src/internal/Классы/ПриемкаЗаготовка.os: -------------------------------------------------------------------------------- 1 | #Использовать reflector 2 | 3 | Процедура ПриДобавленииОпределенияЖелудя(Знач ОпределениеЖелудя) Экспорт 4 | 5 | ЭтоЗаготовка = ОпределениеЖелудя.Прозвища().Найти("Заготовка") <> Неопределено; 6 | Если НЕ ЭтоЗаготовка Тогда 7 | Возврат; 8 | КонецЕсли; 9 | 10 | РефлекторОбъекта = Новый РефлекторОбъекта(ОпределениеЖелудя.ТипЖелудя()); 11 | 12 | Ожидаем 13 | .Что( 14 | РефлекторОбъекта.ЕстьПроцедура("ПриИнициализацииПоделки", 1), 15 | "Заготовка должна иметь процедуру ПриИнициализацииПоделки(Поделка)" 16 | ) 17 | .ЭтоИстина(); 18 | 19 | КонецПроцедуры 20 | 21 | &Приемка 22 | Процедура ПриСозданииОбъекта() 23 | 24 | КонецПроцедуры -------------------------------------------------------------------------------- /src/internal/Классы/ПриемкаРогатка.os: -------------------------------------------------------------------------------- 1 | #Использовать reflector 2 | 3 | Процедура ПриДобавленииОпределенияЖелудя(Знач ОпределениеЖелудя) Экспорт 4 | 5 | ЭтоРогатка = ОпределениеЖелудя.Прозвища().Найти("Рогатка") <> Неопределено; 6 | Если НЕ ЭтоРогатка Тогда 7 | Возврат; 8 | КонецЕсли; 9 | 10 | РефлекторОбъекта = Новый РефлекторОбъекта(ОпределениеЖелудя.ТипЖелудя()); 11 | 12 | Ожидаем 13 | .Что( 14 | РефлекторОбъекта.ЕстьПроцедура("ПриЗапускеПриложения", 0), 15 | "Рогатка должна иметь процедуру ПриЗапускеПриложения()" 16 | ) 17 | .ЭтоИстина(); 18 | 19 | КонецПроцедуры 20 | 21 | &Приемка 22 | Процедура ПриСозданииОбъекта() 23 | 24 | КонецПроцедуры -------------------------------------------------------------------------------- /src/internal/Классы/ПрилепляторЧастиц.os: -------------------------------------------------------------------------------- 1 | #Использовать annotations 2 | 3 | Перем Поделка; 4 | Перем УправляющийПрилепляемымиКоллекциями; 5 | 6 | Функция ДанныеОПрилепляемойЧастице(Свойство, Знач ИмяСвойства = Неопределено) Экспорт 7 | 8 | Если ИмяСвойства = Неопределено Тогда 9 | ИмяСвойства = Свойство.Имя; 10 | КонецЕсли; 11 | 12 | АннотацияПластилин = РаботаСАннотациями.ПолучитьАннотацию(Свойство, "Пластилин"); 13 | АннотацияДеталька = РаботаСАннотациями.ПолучитьАннотацию(Свойство, "Деталька"); 14 | АннотацияБлестяшка = РаботаСАннотациями.ПолучитьАннотацию(Свойство, "Блестяшка"); 15 | 16 | Если АннотацияПластилин <> Неопределено Тогда 17 | ТипЧастицы = ТипыПрилепляемыхЧастиц.Желудь(); 18 | ИмяЧастицы = РаботаСАннотациями.ПолучитьЗначениеПараметраАннотации( 19 | АннотацияПластилин, 20 | , 21 | ИмяСвойства 22 | ); 23 | 24 | Аннотация = АннотацияПластилин; 25 | 26 | ИначеЕсли АннотацияДеталька <> Неопределено Тогда 27 | ТипЧастицы = ТипыПрилепляемыхЧастиц.Деталька(); 28 | ИмяЧастицы = РаботаСАннотациями.ПолучитьЗначениеПараметраАннотации( 29 | АннотацияДеталька, 30 | , 31 | ИмяСвойства 32 | ); 33 | Аннотация = АннотацияДеталька; 34 | ИначеЕсли АннотацияБлестяшка <> Неопределено Тогда 35 | ТипЧастицы = ТипыПрилепляемыхЧастиц.Блестяшка(); 36 | ИмяЧастицы = ИмяСвойства; 37 | Аннотация = АннотацияБлестяшка; 38 | Иначе 39 | ВызватьИсключение СтрШаблон( 40 | "Неизвестный тип прилепляемой частицы в свойстве/методе %1", 41 | ИмяСвойства 42 | ); 43 | КонецЕсли; 44 | 45 | ПрилепляемаяЧастица = Новый ПрилепляемаяЧастица(ТипЧастицы, ИмяЧастицы, Аннотация); 46 | 47 | АннотацияТабакерка = РаботаСАннотациями.ПолучитьАннотацию(Свойство, "Табакерка"); 48 | Если АннотацияТабакерка <> Неопределено Тогда 49 | ТипЧастицы = ТипыПрилепляемыхЧастиц.Табакерка(); 50 | Аннотация = АннотацияТабакерка; 51 | БазоваяПрилепляемаяЧастица = ПрилепляемаяЧастица; 52 | 53 | ПрилепляемаяЧастица = Новый ПрилепляемаяЧастица(ТипЧастицы, ИмяЧастицы, Аннотация, БазоваяПрилепляемаяЧастица); 54 | КонецЕсли; 55 | 56 | Возврат ПрилепляемаяЧастица; 57 | 58 | КонецФункции 59 | 60 | Функция НайтиПрилепляемуюЧастицу( 61 | ДанныеОПрилепляемойЧастице, 62 | Знач ПрилепляемыеЧастицы = Неопределено) Экспорт 63 | 64 | ТипЧастицы = ДанныеОПрилепляемойЧастице.ТипЧастицы(); 65 | ИмяЧастицы = ДанныеОПрилепляемойЧастице.ИмяЧастицы(); 66 | Аннотация = ДанныеОПрилепляемойЧастице.Аннотация(); 67 | БазоваяПрилепляемаяЧастица = ДанныеОПрилепляемойЧастице.БазоваяПрилепляемаяЧастица(); 68 | 69 | Если ТипЧастицы = ТипыПрилепляемыхЧастиц.Табакерка() Тогда 70 | ПрилепляемаяЧастица = Новый Табакерка(ЭтотОбъект, БазоваяПрилепляемаяЧастица); 71 | ИначеЕсли ТипЧастицы = ТипыПрилепляемыхЧастиц.Желудь() Тогда 72 | 73 | ТипЖелудя = РаботаСАннотациями.ПолучитьЗначениеПараметраАннотации( 74 | Аннотация, 75 | "Тип", 76 | "Желудь" 77 | ); 78 | 79 | Если ПрилепляемыеЧастицы = Неопределено Тогда 80 | ПараметрыАннотации = РаботаСАннотациями.ПолучитьПараметрыАннотации(Аннотация, "Блестяшка"); 81 | ПрилепляемыеЧастицы = Новый Массив; 82 | Для Каждого ПараметрБлестяшка Из ПараметрыАннотации Цикл 83 | ПрилепляемыеЧастицы.Добавить(ПараметрБлестяшка.Значение); 84 | КонецЦикла; 85 | КонецЕсли; 86 | 87 | Если ТипЖелудя = "Желудь" Тогда 88 | ПрилепляемаяЧастица = Поделка.НайтиЖелудь(ИмяЧастицы, ПрилепляемыеЧастицы); 89 | ИначеЕсли УправляющийПрилепляемымиКоллекциями.ЕстьПрилепляемаяКоллекция(ТипЖелудя) Тогда 90 | ПрилепляемаяЧастица = Поделка.НайтиЖелуди(ИмяЧастицы, ПрилепляемыеЧастицы, ТипЖелудя); 91 | Иначе 92 | ВызватьИсключение "Неизвестный тип прилепляемого через &Пластилин значения"; 93 | КонецЕсли; 94 | 95 | ИначеЕсли ТипЧастицы = ТипыПрилепляемыхЧастиц.Деталька() Тогда 96 | 97 | ЗначениеПоУмолчанию = РаботаСАннотациями.ПолучитьЗначениеПараметраАннотации( 98 | Аннотация, 99 | "ЗначениеПоУмолчанию", 100 | Неопределено, 101 | Истина 102 | ); 103 | 104 | ПрилепляемаяЧастица = Поделка.НайтиДетальку(ИмяЧастицы, ЗначениеПоУмолчанию); 105 | Иначе 106 | ВызватьИсключение "Неизвестная аннотация " + Аннотация.Имя(); 107 | КонецЕсли; 108 | 109 | Возврат ПрилепляемаяЧастица; 110 | 111 | КонецФункции 112 | 113 | Процедура ПриСозданииОбъекта(пПоделка, пУправляющийПрилепляемымиКоллекциями) 114 | Поделка = пПоделка; 115 | УправляющийПрилепляемымиКоллекциями = пУправляющийПрилепляемымиКоллекциями; 116 | КонецПроцедуры -------------------------------------------------------------------------------- /src/internal/Классы/СлужебныйДубОсени.os: -------------------------------------------------------------------------------- 1 | &Завязь 2 | &Спецификация("Инициализация") 3 | Функция КонтейнерАннотаций(&Пластилин Поделка) Экспорт 4 | Рефлектор = Новый Рефлектор(); 5 | КонтейнерАннотаций = Рефлектор.ПолучитьСвойство(Поделка, "КонтейнерАннотаций"); 6 | 7 | Возврат КонтейнерАннотаций; 8 | КонецФункции 9 | 10 | &Завязь 11 | &Спецификация("Инициализация") 12 | Функция РазворачивательАннотаций(&Пластилин Поделка) Экспорт 13 | // TODO: переделать на пластилин, когда можно будет внедрять пластилин в желуди инициализации 14 | Рефлектор = Новый Рефлектор(); 15 | КонтейнерАннотаций = Рефлектор.ПолучитьСвойство(Поделка, "КонтейнерАннотаций"); 16 | 17 | Возврат КонтейнерАннотаций.ПолучитьРазворачивательАннотаций(); 18 | КонецФункции 19 | 20 | &Завязь 21 | &Спецификация("Инициализация") 22 | Функция ПрилепляторЧастиц(&Пластилин Поделка) Экспорт 23 | Рефлектор = Новый Рефлектор(); 24 | ПрилепляторЧастиц = Рефлектор.ПолучитьСвойство(Поделка, "ПрилепляторЧастиц"); 25 | 26 | Возврат ПрилепляторЧастиц; 27 | КонецФункции 28 | 29 | &Дуб 30 | &Спецификация("Инициализация") 31 | Процедура ПриСозданииОбъекта() 32 | КонецПроцедуры 33 | -------------------------------------------------------------------------------- /src/internal/Модули/ФабричныеМетоды.os: -------------------------------------------------------------------------------- 1 | Функция КонструкторОбъекта(ТипЖелудя, ПередаваемыеПараметрыКонструктора) Экспорт 2 | 3 | Возврат Новый(ТипЖелудя, ПередаваемыеПараметрыКонструктора); 4 | 5 | КонецФункции 6 | 7 | Функция МетодЗавязи(Поделка, ТипДуба, ИмяМетода, ПередаваемыеПараметрыМетода) Экспорт 8 | 9 | Дуб = Поделка.НайтиЖелудь(ТипДуба); 10 | 11 | Рефлектор = Новый Рефлектор(); 12 | Возврат Рефлектор.ВызватьМетод(Дуб, ИмяМетода, ПередаваемыеПараметрыМетода); 13 | 14 | КонецФункции -------------------------------------------------------------------------------- /src/Классы/Завязь.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | 3 | #Область ОписаниеПеременных 4 | 5 | // Сценарий - класс, содержащий указанный метод завязи. 6 | Перем _Родитель; 7 | 8 | // Строка - Имя метода, которым можно создать жёлудь. 9 | Перем _ИмяМетода; 10 | 11 | // Структура - данные метода, как из возвращает рефлектор: 12 | Перем _ДанныеМетода; 13 | 14 | // Действие - делегат, который можно вызвать, чтобы создать жёлудь. 15 | Перем _Действие; 16 | 17 | // Булево - флаг, что делегат ведет на конструктор класса, а не на &Завязь-метод. 18 | Перем _ЭтоКонструктор; 19 | 20 | #КонецОбласти 21 | 22 | #Область ПубличныйПрограммныйИнтерфейс 23 | 24 | // Класс, содержащий указанный метод завязи. 25 | // 26 | // Возвращаемое значение: 27 | // Сценарий 28 | // 29 | Функция Родитель() Экспорт 30 | Возврат _Родитель; 31 | КонецФункции 32 | 33 | // Имя метода, которым можно создать жёлудь. 34 | // 35 | // Возвращаемое значение: 36 | // Строка 37 | // 38 | Функция ИмяМетода() Экспорт 39 | Возврат _ИмяМетода; 40 | КонецФункции 41 | 42 | // Данные метода, как из возвращает рефлектор. 43 | // 44 | // Возвращаемое значение: 45 | // Структура 46 | // 47 | Функция ДанныеМетода() Экспорт 48 | Возврат _ДанныеМетода; 49 | КонецФункции 50 | 51 | // Делегат, который можно вызвать, чтобы создать жёлудь. 52 | // 53 | // Возвращаемое значение: 54 | // Действие 55 | // 56 | Функция Действие() Экспорт 57 | Возврат _Действие; 58 | КонецФункции 59 | 60 | // Флаг, что делегат ведет на конструктор класса, а не на &Завязь-метод. 61 | // 62 | // Возвращаемое значение: 63 | // Булево 64 | // 65 | Функция ЭтоКонструктор() Экспорт 66 | Возврат _ЭтоКонструктор; 67 | КонецФункции 68 | 69 | #КонецОбласти 70 | 71 | #Область Инициализация 72 | 73 | // Дата-класс для хранения данных о способе создания жёлудя. 74 | // 75 | // Параметры: 76 | // Родитель - Сценарий - Класс, содержащий указанный метод завязи. 77 | // ИмяМетода - Строка - Имя метода, которым можно создать жёлудь. 78 | // ДанныеМетода - Структура - Данные метода, как из возвращает рефлектор. 79 | // Действие - Действие - Делегат, который можно вызвать, чтобы создать жёлудь. 80 | // ЭтоКонструктор - Булево - Флаг, что делегат ведет на конструктор класса, а не на &Завязь-метод. 81 | // 82 | Процедура ПриСозданииОбъекта(Родитель, ИмяМетода, ДанныеМетода, Действие, ЭтоКонструктор) 83 | Ожидаем.Что(Родитель).ИмеетТип("Строка"); 84 | Ожидаем.Что(ИмяМетода).ИмеетТип("Строка"); 85 | Ожидаем.Что(ДанныеМетода).ИмеетТип("СтрокаТаблицыЗначений"); 86 | Ожидаем.Что(Действие).ИмеетТип("Действие"); 87 | Ожидаем.Что(ЭтоКонструктор).ИмеетТип("Булево"); 88 | 89 | _Родитель = Родитель; 90 | _ИмяМетода = ИмяМетода; 91 | _ДанныеМетода = ДанныеМетода; 92 | _Действие = Действие; 93 | _ЭтоКонструктор = ЭтоКонструктор; 94 | КонецПроцедуры 95 | 96 | #КонецОбласти 97 | -------------------------------------------------------------------------------- /src/Классы/ОпределениеЖелудя.os: -------------------------------------------------------------------------------- 1 | #Использовать "../internal" 2 | #Использовать annotations 3 | #Использовать asserts 4 | 5 | Перем _Имя; 6 | Перем _ТипЖелудя; 7 | Перем _Характер; 8 | Перем _ПрилепляемыеЧастицы; 9 | Перем _Завязь; 10 | Перем _Прозвища; 11 | Перем _Верховный; 12 | Перем _Порядок; 13 | Перем _Спецификация; 14 | Перем _КорневаяАннотация; 15 | Перем _РефлекторОбъекта; 16 | Перем _РазворачивательАннотаций; 17 | 18 | Перем Свойства; 19 | Перем Методы; 20 | 21 | Перем ЭтоПримитивныйТип; 22 | 23 | Перем КешМетодовПоАннотациям; 24 | Перем КешПрилепляемыеЧастицы; 25 | 26 | Функция Имя() Экспорт 27 | Возврат _Имя; 28 | КонецФункции 29 | 30 | Функция ТипЖелудя() Экспорт 31 | Возврат _ТипЖелудя; 32 | КонецФункции 33 | 34 | Функция Характер() Экспорт 35 | Возврат _Характер; 36 | КонецФункции 37 | 38 | Функция ПрилепляемыеЧастицы() Экспорт 39 | Если КешПрилепляемыеЧастицы = Неопределено Тогда 40 | КешПрилепляемыеЧастицы = Новый ФиксированныйМассив(_ПрилепляемыеЧастицы); 41 | КонецЕсли; 42 | 43 | Возврат КешПрилепляемыеЧастицы; 44 | КонецФункции 45 | 46 | Функция Завязь() Экспорт 47 | Возврат _Завязь; 48 | КонецФункции 49 | 50 | Функция Прозвища() Экспорт 51 | Возврат _Прозвища; 52 | КонецФункции 53 | 54 | Функция Порядок() Экспорт 55 | Возврат _Порядок; 56 | КонецФункции 57 | 58 | Функция Верховный() Экспорт 59 | Возврат _Верховный; 60 | КонецФункции 61 | 62 | Функция Спецификация() Экспорт 63 | Возврат _Спецификация; 64 | КонецФункции 65 | 66 | Функция КорневаяАннотация() Экспорт 67 | Возврат _КорневаяАннотация; 68 | КонецФункции 69 | 70 | Функция Свойства() Экспорт 71 | Если Свойства = Неопределено Тогда 72 | Свойства = ?(ЭтоПримитивныйТип, Новый ТаблицаЗначений, _РефлекторОбъекта.ПолучитьТаблицуСвойств(Неопределено, Истина)); 73 | Для Каждого Свойство Из Свойства Цикл 74 | _РазворачивательАннотаций.РазвернутьАннотацииСвойства(Свойство, ТипЖелудя()); 75 | КонецЦикла; 76 | КонецЕсли; 77 | 78 | Возврат Свойства; 79 | КонецФункции 80 | 81 | Функция Методы() Экспорт 82 | Если Методы = Неопределено Тогда 83 | Методы = ?(ЭтоПримитивныйТип, Новый ТаблицаЗначений, _РефлекторОбъекта.ПолучитьТаблицуМетодов()); 84 | Для Каждого Метод Из Методы Цикл 85 | _РазворачивательАннотаций.РазвернутьАннотацииСвойства(Метод, ТипЖелудя()); 86 | КонецЦикла; 87 | КонецЕсли; 88 | 89 | Возврат Методы; 90 | КонецФункции 91 | 92 | Функция РефлекторОбъекта() Экспорт 93 | Возврат _РефлекторОбъекта; 94 | КонецФункции 95 | 96 | Процедура ПриСозданииОбъекта( 97 | РазворачивательАннотаций, 98 | ТипЖелудя, 99 | Имя, 100 | Характер, 101 | ПрилепляемыеЧастицы, 102 | Завязь, 103 | Прозвища, 104 | Порядок, 105 | Верховный, 106 | Спецификация, 107 | КорневаяАннотация 108 | ) 109 | Ожидаем.Что(РазворачивательАннотаций).ИмеетТип("РазворачивательАннотаций"); 110 | Ожидаем.Что(ТипЖелудя).ИмеетТип("Тип"); 111 | Ожидаем.Что(Имя).ИмеетТип("Строка"); 112 | Ожидаем.Что(СтрДлина(Имя)).Больше(0); 113 | Ожидаем.Что(Характер).ИмеетТип("Строка"); 114 | Ожидаем.Что(ПрилепляемыеЧастицы).ИмеетТип("Массив"); 115 | Ожидаем.Что(Завязь).ИмеетТип("Завязь"); 116 | Ожидаем.Что(Прозвища).ИмеетТип("Массив"); 117 | Ожидаем.Что(Прозвища.Количество()).Больше(0); 118 | Ожидаем.Что(Порядок).ИмеетТип("Число"); 119 | Ожидаем.Что(Верховный).ИмеетТип("Булево"); 120 | Ожидаем.Что(Спецификация).ИмеетТип("Строка"); 121 | Ожидаем.Что(КорневаяАннотация).Не_().ИмеетТип("СтрокаТаблицыЗначений"); 122 | 123 | Если Спецификация = СостоянияПриложения.Инициализация() Тогда 124 | ТекстСообщения = СтрШаблон( 125 | "К желудю времени инициализации %1 можно прилеплять только детальки.", 126 | Имя 127 | ); 128 | Для Каждого ПрилепляемаяЧастица Из ПрилепляемыеЧастицы Цикл 129 | Если (ПрилепляемаяЧастица.ТипЧастицы() <> ТипыПрилепляемыхЧастиц.Деталька()) И (ПрилепляемаяЧастица.ИмяЧастицы() <> "Поделка") Тогда 130 | ВызватьИсключение ТекстСообщения; 131 | КонецЕсли; 132 | КонецЦикла; 133 | КонецЕсли; 134 | 135 | _Имя = Имя; 136 | _ТипЖелудя = ТипЖелудя; 137 | _Характер = Характер; 138 | _ПрилепляемыеЧастицы = ПрилепляемыеЧастицы; 139 | _Завязь = Завязь; 140 | _Прозвища = Прозвища; 141 | _Порядок = Порядок; 142 | _Верховный = Верховный; 143 | _Спецификация = Спецификация; 144 | _КорневаяАннотация = КорневаяАннотация; 145 | 146 | _РазворачивательАннотаций = РазворачивательАннотаций; 147 | _РефлекторОбъекта = Новый РефлекторОбъекта(ТипЖелудя); 148 | 149 | КешМетодовПоАннотациям = Новый Соответствие(); 150 | ЭтоПримитивныйТип = _ТипЖелудя = Тип("Строка") 151 | Или _ТипЖелудя = Тип("Дата") 152 | Или _ТипЖелудя = Тип("Число") 153 | Или _ТипЖелудя = Тип("Булево"); 154 | 155 | // Прогрев кэша РефлекторОбъекта для исправления ошибки работы в многопоточной среде 156 | Свойства(); 157 | Методы(); 158 | 159 | КонецПроцедуры 160 | 161 | Функция НайтиМетодыСАннотациями(АннотацияФильтр) Экспорт 162 | 163 | ИзКеша = КешМетодовПоАннотациям[АннотацияФильтр]; 164 | Если НЕ ИзКеша = Неопределено Тогда 165 | Возврат ИзКеша; 166 | КонецЕсли; 167 | 168 | Результат = РаботаСАннотациями.НайтиМетодыСАннотацией(Методы(), АннотацияФильтр); 169 | 170 | КешМетодовПоАннотациям.Вставить(АннотацияФильтр, Результат); 171 | 172 | Возврат Результат; 173 | 174 | КонецФункции 175 | -------------------------------------------------------------------------------- /src/Классы/ПрилепляемаяЧастица.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | 3 | Перем _ТипЧастицы; 4 | Перем _ИмяЧастицы; 5 | Перем _Аннотация; 6 | Перем _БазоваяПрилепляемаяЧастица; 7 | 8 | Функция ТипЧастицы() Экспорт 9 | Возврат _ТипЧастицы; 10 | КонецФункции 11 | 12 | Функция ИмяЧастицы() Экспорт 13 | Возврат _ИмяЧастицы; 14 | КонецФункции 15 | 16 | Функция Аннотация() Экспорт 17 | Возврат _Аннотация; 18 | КонецФункции 19 | 20 | Функция БазоваяПрилепляемаяЧастица() Экспорт 21 | Возврат _БазоваяПрилепляемаяЧастица; 22 | КонецФункции 23 | 24 | Процедура ПриСозданииОбъекта(ТипЧастицы, ИмяЧастицы, Аннотация, БазоваяПрилепляемаяЧастица = Неопределено) 25 | 26 | Утверждения.ПроверитьТип(ТипЧастицы, "Строка"); 27 | Утверждения.ПроверитьТип(ИмяЧастицы, "Строка"); 28 | Утверждения.ПроверитьТип(Аннотация, "СтрокаТаблицыЗначений"); 29 | Если БазоваяПрилепляемаяЧастица <> Неопределено Тогда 30 | Утверждения.ПроверитьТип(БазоваяПрилепляемаяЧастица, "ПрилепляемаяЧастица"); 31 | КонецЕсли; 32 | 33 | _ТипЧастицы = ТипЧастицы; 34 | _ИмяЧастицы = ИмяЧастицы; 35 | _Аннотация = Аннотация; 36 | _БазоваяПрилепляемаяЧастица = БазоваяПрилепляемаяЧастица; 37 | 38 | КонецПроцедуры -------------------------------------------------------------------------------- /src/Классы/СоветДругогоМастера.os: -------------------------------------------------------------------------------- 1 | #Область ОписаниеПеременных 2 | 3 | // Соответствие - Значения деталек в виде соответствия 4 | // для последующей передачи в МенеджерПараметров. 5 | // 6 | Перем ЗначенияДеталек; 7 | 8 | // Строка - префикс переменных среды, хранящих значения деталек. 9 | // 10 | Перем ПрефиксПеременныхСреды; 11 | 12 | // Строка - имя файла (без расширения), в котором хранятся значения деталек. 13 | // 14 | Перем ИмяФайлаСоЗначениямиДеталек; 15 | 16 | // Строка - Относительный путь к каталогу, где хранятся файл со значениями деталек. 17 | // 18 | Перем ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек; 19 | 20 | #КонецОбласти 21 | 22 | #Область ПрограммныйИнтерфейс 23 | 24 | // Установить/получить значения деталек. 25 | // 26 | // Параметры: 27 | // НовоеЗначение - Соответствие - устанавливаемые значения деталек. 28 | // 29 | // Возвращаемое значение: 30 | // Соответствие, СоветДругогоМастера - Текущее установленное значение для гетера, ЭтотОбъект для сеттера. 31 | // 32 | Функция ЗначенияДеталек(НовоеЗначение = Неопределено) Экспорт 33 | 34 | Если НовоеЗначение <> Неопределено Тогда 35 | ЗначенияДеталек = НовоеЗначение; 36 | Возврат ЭтотОбъект; 37 | КонецЕсли; 38 | 39 | Возврат ЗначенияДеталек; 40 | 41 | КонецФункции 42 | 43 | // Установить/получить префикс переменных среды, хранящих значения деталек. 44 | // 45 | // Параметры: 46 | // НовоеЗначение - Строка - устанавливаемый префикс переменных среды. 47 | // 48 | // Возвращаемое значение: 49 | // Строка, СоветДругогоМастера - Текущее установленное значение для гетера, ЭтотОбъект для сеттера. 50 | // 51 | Функция ПрефиксПеременныхСреды(НовоеЗначение = Неопределено) Экспорт 52 | 53 | Если НовоеЗначение <> Неопределено Тогда 54 | ПрефиксПеременныхСреды = НовоеЗначение; 55 | Возврат ЭтотОбъект; 56 | КонецЕсли; 57 | 58 | Возврат ПрефиксПеременныхСреды; 59 | 60 | КонецФункции 61 | 62 | // Установить/получить имя файла (без расширения), в котором хранятся значения деталек. 63 | // 64 | // Параметры: 65 | // НовоеЗначение - Строка - устанавливаемое имя файла. 66 | // 67 | // Возвращаемое значение: 68 | // Строка, СоветДругогоМастера - Текущее установленное значение для гетера, ЭтотОбъект для сеттера. 69 | // 70 | Функция ИмяФайлаСоЗначениямиДеталек(НовоеЗначение = Неопределено) Экспорт 71 | 72 | Если НовоеЗначение <> Неопределено Тогда 73 | ИмяФайлаСоЗначениямиДеталек = НовоеЗначение; 74 | Возврат ЭтотОбъект; 75 | КонецЕсли; 76 | 77 | Возврат ИмяФайлаСоЗначениямиДеталек; 78 | 79 | КонецФункции 80 | 81 | // Установить/получить относительный путь к каталогу, где хранятся файл со значениями деталек. 82 | // 83 | // Параметры: 84 | // НовоеЗначение - Строка - устанавливаемый путь к каталогу. 85 | // 86 | // Возвращаемое значение: 87 | // Строка, СоветДругогоМастера - Текущее установленное значение для гетера, ЭтотОбъект для сеттера. 88 | // 89 | Функция ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек(НовоеЗначение = Неопределено) Экспорт 90 | 91 | Если НовоеЗначение <> Неопределено Тогда 92 | ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек = НовоеЗначение; 93 | Возврат ЭтотОбъект; 94 | КонецЕсли; 95 | 96 | Возврат ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек; 97 | 98 | КонецФункции 99 | 100 | #КонецОбласти 101 | 102 | #Область Инициализация 103 | 104 | // Советы по созданию поделки, упакованные в объект. 105 | // 106 | Процедура ПриСозданииОбъекта() 107 | 108 | ЗначенияДеталек = Новый Соответствие(); 109 | ПрефиксПеременныхСреды = ""; 110 | ИмяФайлаСоЗначениямиДеталек = "autumn-properties"; 111 | ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек = "src"; 112 | 113 | КонецПроцедуры 114 | 115 | #КонецОбласти 116 | -------------------------------------------------------------------------------- /src/Классы/Табакерка.os: -------------------------------------------------------------------------------- 1 | Перем _ПрилепляторЧастиц; 2 | Перем _БазоваяПрилепляемаяЧастица; 3 | 4 | // Достать частицу из табакерки 5 | // 6 | // Параметры: 7 | // ПрилепляемыеЧастицы - Массив - массив прилепляемых частиц, которые передадутся как зависимости доставаемой частицы. 8 | // 9 | // Возвращаемое значение: 10 | // Произвольный - Желудь, блестяшка или деталька, хранимая в табакерке. 11 | // 12 | Функция Достать(ПрилепляемыеЧастицы = Неопределено) Экспорт 13 | 14 | Возврат _ПрилепляторЧастиц.НайтиПрилепляемуюЧастицу( 15 | _БазоваяПрилепляемаяЧастица, 16 | ПрилепляемыеЧастицы 17 | ); 18 | 19 | КонецФункции 20 | 21 | // Конструктор объекта. 22 | // 23 | // Параметры: 24 | // ПрилепляторЧастиц - ПрилепляторЧастиц - Прилеплятор частиц, который будет использоваться для поиска. 25 | // БазоваяПрилепляемаяЧастица - ПрилепляемаяЧастица - Прилепляемая частица, в которой описано то, что должно 26 | // доставаться из Табакерки. 27 | // 28 | Процедура ПриСозданииОбъекта(ПрилепляторЧастиц, БазоваяПрилепляемаяЧастица) 29 | _ПрилепляторЧастиц = ПрилепляторЧастиц; 30 | _БазоваяПрилепляемаяЧастица = БазоваяПрилепляемаяЧастица; 31 | КонецПроцедуры 32 | -------------------------------------------------------------------------------- /src/Модули/Осень.os: -------------------------------------------------------------------------------- 1 | // BSLLS:UnusedParameters-off 2 | 3 | #Использовать logos 4 | 5 | #Область ОписаниеПеременных 6 | 7 | // Список заготовок для запуска при инициализации поделки. 8 | Перем Заготовки; 9 | 10 | // Логгер. 11 | Перем Лог; 12 | 13 | #КонецОбласти 14 | 15 | #Область ПрограммныйИнтерфейс 16 | 17 | // Добавляет данные о заготовке в очередь для запуска при инициализации поделки. 18 | // 19 | // Параметры: 20 | // ИмяТипаЗаготовки - Строка - Имя типа для заготовки. 21 | // 22 | Процедура ДобавитьЗаготовкуДляАвтоИнициализации(ИмяТипаЗаготовки) Экспорт 23 | Лог.Отладка("Метод ДобавитьЗаготовкуДляАвтоИнициализации устарел."); 24 | КонецПроцедуры 25 | 26 | // Служебный. 27 | // 28 | Процедура ОчиститьЗаготовкиДляАвтоИнициализации() Экспорт 29 | Лог.Отладка("Метод ОчиститьЗаготовкиДляАвтоИнициализации устарел."); 30 | КонецПроцедуры 31 | 32 | #КонецОбласти 33 | 34 | #Область СлужебныйПрограммныйИнтерфейс 35 | 36 | // Служебный. 37 | // 38 | // Возвращаемое значение: 39 | // Массив - список заготовок для автоматической инициализации. 40 | // 41 | Функция ПолучитьЗаготовкиДляАвтоИнициализации() Экспорт 42 | Возврат Новый ФиксированныйМассив(Заготовки); 43 | КонецФункции 44 | 45 | #КонецОбласти 46 | 47 | #Область Инициализация 48 | 49 | Заготовки = Новый Массив; 50 | Лог = Логирование.ПолучитьЛог("oscript.lib.autumn.static-initializer"); 51 | 52 | #КонецОбласти 53 | -------------------------------------------------------------------------------- /src/Модули/СостоянияПриложения.os: -------------------------------------------------------------------------------- 1 | Перем Значения; 2 | 3 | Функция Инициализация() Экспорт 4 | Возврат "Инициализация"; 5 | КонецФункции 6 | 7 | Функция Выполнение() Экспорт 8 | Возврат "Выполнение"; 9 | КонецФункции 10 | 11 | Функция Значения() Экспорт 12 | Возврат Значения; 13 | КонецФункции 14 | 15 | Значения = Новый Массив; 16 | 17 | Значения.Добавить(Инициализация()); 18 | Значения.Добавить(Выполнение()); 19 | 20 | Значения = Новый ФиксированныйМассив(Значения); 21 | -------------------------------------------------------------------------------- /src/Модули/ТипыПрилепляемыхЖелудей.os: -------------------------------------------------------------------------------- 1 | // Логгер. 2 | Перем Лог; 3 | 4 | Функция Желудь() Экспорт 5 | Лог.Предупреждение("Метод ТипыПриепляемыхЖелудей.Желудь() устарел и будет удален в следующих версиях."); 6 | Возврат "Желудь"; 7 | КонецФункции 8 | 9 | Функция Массив() Экспорт 10 | Лог.Предупреждение("Метод ТипыПриепляемыхЖелудей.Массив() устарел и будет удален в следующих версиях."); 11 | Возврат "Массив"; 12 | КонецФункции 13 | 14 | Функция Соответствие() Экспорт 15 | Лог.Предупреждение("Метод ТипыПриепляемыхЖелудей.Соответствие() устарел и будет удален в следующих версиях."); 16 | Возврат "Соответствие"; 17 | КонецФункции 18 | 19 | Функция ТаблицаЗначений() Экспорт 20 | Лог.Предупреждение("Метод ТипыПриепляемыхЖелудей.ТаблицаЗначений() устарел и будет удален в следующих версиях."); 21 | Возврат "ТаблицаЗначений"; 22 | КонецФункции 23 | 24 | Лог = Логирование.ПолучитьЛог("oscript.lib.autumn.acorn-types"); 25 | -------------------------------------------------------------------------------- /src/Модули/ТипыПрилепляемыхЧастиц.os: -------------------------------------------------------------------------------- 1 | Функция Деталька() Экспорт 2 | Возврат "Деталька"; 3 | КонецФункции 4 | 5 | Функция Желудь() Экспорт 6 | Возврат "Желудь"; 7 | КонецФункции 8 | 9 | Функция Блестяшка() Экспорт 10 | Возврат "Блестяшка"; 11 | КонецФункции 12 | 13 | Функция Табакерка() Экспорт 14 | Возврат "Табакерка"; 15 | КонецФункции 16 | -------------------------------------------------------------------------------- /src/Модули/ХарактерыЖелудей.os: -------------------------------------------------------------------------------- 1 | Перем Характеры; 2 | 3 | Функция Компанейский() Экспорт 4 | Возврат "Компанейский"; 5 | КонецФункции 6 | 7 | Функция Одиночка() Экспорт 8 | Возврат "Одиночка"; 9 | КонецФункции 10 | 11 | Функция ЭтоХарактерЖелудя(Характер) Экспорт 12 | Возврат Характеры.Найти(Характер) <> Неопределено; 13 | КонецФункции 14 | 15 | Характеры = Новый Массив(); 16 | Характеры.Добавить(Компанейский()); 17 | Характеры.Добавить(Одиночка()); 18 | -------------------------------------------------------------------------------- /tasks/coverage.os: -------------------------------------------------------------------------------- 1 | #Использовать 1commands 2 | #Использовать fs 3 | #Использовать coverage 4 | 5 | СистемнаяИнформация = Новый СистемнаяИнформация; 6 | ЭтоWindows = Найти(НРег(СистемнаяИнформация.ВерсияОС), "windows") > 0; 7 | 8 | ФС.ОбеспечитьПустойКаталог("out"); 9 | ПутьКСтат = "out/stat.json"; 10 | 11 | Команда = Новый Команда; 12 | Команда.УстановитьКоманду("oscript"); 13 | Если НЕ ЭтоWindows Тогда 14 | Команда.ДобавитьПараметр("-encoding=utf-8"); 15 | КонецЕсли; 16 | Команда.ДобавитьПараметр(СтрШаблон("-codestat=%1", ПутьКСтат)); 17 | Команда.ДобавитьПараметр("tasks/test.os"); // Файла запуска тестов 18 | Команда.ПоказыватьВыводНемедленно(Истина); 19 | 20 | КодВозврата = Команда.Исполнить(); 21 | 22 | ПроцессорГенерации = Новый ГенераторОтчетаПокрытия(); 23 | 24 | ПроцессорГенерации.ОтносительныеПути() 25 | .РабочийКаталог("out") 26 | .ИмяФайлаСтатистики() 27 | .GenericCoverage() 28 | .Cobertura() 29 | .Сформировать(); 30 | 31 | ЗавершитьРаботу(КодВозврата); 32 | -------------------------------------------------------------------------------- /tasks/oscript.cfg: -------------------------------------------------------------------------------- 1 | lib.system=../oscript_modules 2 | systemLanguage=ru 3 | -------------------------------------------------------------------------------- /tasks/performance.os: -------------------------------------------------------------------------------- 1 | #Использовать 1testrunner 2 | #Использовать fs 3 | 4 | Функция ПрогнатьТесты() 5 | 6 | Тестер = Новый Тестер; 7 | Тестер.УстановитьФорматЛогФайла(Тестер.ФорматыЛогФайла().GenericExec); 8 | 9 | ПутьКТестам = "performance_tests"; 10 | ПутьКОтчетуJUnit = "out"; 11 | 12 | ФС.ОбеспечитьПустойКаталог(ПутьКОтчетуJUnit); 13 | 14 | РезультатТестирования = Тестер.ТестироватьКаталог( 15 | Новый Файл(ПутьКТестам), 16 | Новый Файл(ПутьКОтчетуJUnit) 17 | ); 18 | 19 | Успешно = РезультатТестирования = 0; 20 | 21 | Возврат Успешно; 22 | КонецФункции // ПрогнатьТесты() 23 | 24 | // основной код 25 | 26 | ТекКаталог = ТекущийКаталог(); 27 | 28 | Попытка 29 | ТестыПрошли = ПрогнатьТесты(); 30 | Исключение 31 | ТестыПрошли = Ложь; 32 | Сообщить(СтрШаблон("Тесты через 1testrunner выполнены неудачно 33 | |%1", ПодробноеПредставлениеОшибки(ИнформацияОбОшибке()))); 34 | КонецПопытки; 35 | 36 | УстановитьТекущийКаталог(ТекКаталог); 37 | 38 | Если Не ТестыПрошли Тогда 39 | ВызватьИсключение "Тестирование завершилось неудачно!"; 40 | Иначе 41 | Сообщить(СтрШаблон("Результат прогона тестов <%1> 42 | |", ТестыПрошли)); 43 | КонецЕсли; 44 | -------------------------------------------------------------------------------- /tasks/test.os: -------------------------------------------------------------------------------- 1 | #Использовать 1testrunner 2 | #Использовать fs 3 | #Использовать 1commands 4 | 5 | Функция ПрогнатьТесты() 6 | 7 | Тестер = Новый Тестер; 8 | Тестер.УстановитьФорматЛогФайла(Тестер.ФорматыЛогФайла().GenericExec); 9 | 10 | ПутьКТестам = "tests"; 11 | ПутьКОтчетуJUnit = "out"; 12 | 13 | ФС.ОбеспечитьПустойКаталог(ПутьКОтчетуJUnit); 14 | 15 | РезультатТестирования = Тестер.ТестироватьКаталог( 16 | Новый Файл(ПутьКТестам), 17 | Новый Файл(ПутьКОтчетуJUnit) 18 | ); 19 | 20 | ИзолированныеТесты = НайтиФайлы(ОбъединитьПути("tests", "ИзолированныеТесты"), "*.os"); 21 | 22 | Для Каждого Тест Из ИзолированныеТесты Цикл 23 | 24 | Команда = Новый Команда; 25 | 26 | Команда.ПоказыватьВыводНемедленно(Истина); 27 | 28 | Команда.УстановитьИсполнениеЧерезКомандыСистемы(Ложь); 29 | 30 | Команда.УстановитьКоманду("oscript"); 31 | Команда.ДобавитьПараметр(ОбъединитьПути("tasks", "testIsolated.os")); 32 | Команда.ДобавитьПараметр(Тест.ПолноеИмя); 33 | 34 | КодВозврата = Команда.Исполнить(); 35 | 36 | РезультатТестирования = Макс(РезультатТестирования, КодВозврата); 37 | 38 | КонецЦикла; 39 | 40 | Успешно = РезультатТестирования = 0; 41 | 42 | Возврат Успешно; 43 | 44 | КонецФункции // ПрогнатьТесты() 45 | 46 | // основной код 47 | 48 | ТекКаталог = ТекущийКаталог(); 49 | 50 | Попытка 51 | ТестыПрошли = ПрогнатьТесты(); 52 | Исключение 53 | ТестыПрошли = Ложь; 54 | Сообщить(СтрШаблон("Тесты через 1testrunner выполнены неудачно 55 | |%1", ПодробноеПредставлениеОшибки(ИнформацияОбОшибке()))); 56 | КонецПопытки; 57 | 58 | УстановитьТекущийКаталог(ТекКаталог); 59 | 60 | Если Не ТестыПрошли Тогда 61 | ВызватьИсключение "Тестирование завершилось неудачно!"; 62 | Иначе 63 | Сообщить(СтрШаблон("Результат прогона тестов <%1> 64 | |", ТестыПрошли)); 65 | КонецЕсли; 66 | -------------------------------------------------------------------------------- /tasks/testIsolated.os: -------------------------------------------------------------------------------- 1 | #Использовать 1testrunner 2 | 3 | Тестер = Новый Тестер; 4 | Тестер.УстановитьФорматЛогФайла(Тестер.ФорматыЛогФайла().GenericExec); 5 | 6 | ПутьКОтчетуJUnit = "out"; 7 | 8 | РезультатТестирования = Тестер.ТестироватьФайл( 9 | Новый Файл(АргументыКоманднойСтроки[0]), 10 | Новый Файл(ПутьКОтчетуJUnit) 11 | ); 12 | 13 | ЗавершитьРаботу(РезультатТестирования); 14 | -------------------------------------------------------------------------------- /tests/oscript.cfg: -------------------------------------------------------------------------------- 1 | lib.system=../oscript_modules 2 | -------------------------------------------------------------------------------- /tests/ВнешнееПриложение.os: -------------------------------------------------------------------------------- 1 | #Использовать ".." 2 | #Использовать asserts 3 | #Использовать "./ТестКлассы" 4 | #Использовать "./Заготовки" 5 | 6 | Процедура ПослеЗапускаТеста() Экспорт 7 | Осень.ОчиститьЗаготовкиДляАвтоИнициализации(); 8 | КонецПроцедуры 9 | 10 | &Тест 11 | Процедура ПриЗапускеПриложенияОтрабатываетРогатка() Экспорт 12 | 13 | // Дано 14 | Поделка = Новый Поделка; 15 | 16 | // Когда 17 | Поделка.ЗапуститьПриложение(); 18 | 19 | // Тогда 20 | Массив = Поделка.НайтиЖелудь("Массив"); 21 | Ожидаем.Что(Массив).ИмеетДлину(5); 22 | 23 | КонецПроцедуры 24 | 25 | &Тест 26 | Процедура ИнициализацияПоделкиСоСтороныПриложенияЧерезСтатическийИнициализатор() Экспорт 27 | 28 | // Когда 29 | Осень.ДобавитьЗаготовкуДляАвтоИнициализации(Тип("ТестовыйИнициализатор")); 30 | 31 | // Дано 32 | Поделка = Новый Поделка; 33 | 34 | // Когда 35 | Поделка.ЗапуститьПриложение(); 36 | 37 | // Тогда 38 | Желудь = Поделка.НайтиЖелудь("ЖелудьНижнегоУровня"); 39 | Ожидаем.Что(Желудь).Не_().Равно(Неопределено); 40 | 41 | КонецПроцедуры 42 | 43 | &Тест 44 | Процедура ЗаготовкиВСтатическийИнициализаторДобавляютсяТолькоОдинРаз() Экспорт 45 | 46 | // Дано 47 | Осень.ДобавитьЗаготовкуДляАвтоИнициализации("ТестовыйИнициализатор"); 48 | Осень.ДобавитьЗаготовкуДляАвтоИнициализации("ТестовыйИнициализатор"); 49 | 50 | // Когда 51 | Заготовки = Осень.ПолучитьЗаготовкиДляАвтоИнициализации(); 52 | 53 | // Тогда 54 | Ожидаем.Что(Заготовки, "Заготовки задублированы").ИмеетДлину(0); // Не используется 55 | 56 | КонецПроцедуры 57 | 58 | &Тест 59 | Процедура ЗаготовкаРегистрируетПодчиненныеЖелуди() Экспорт 60 | 61 | // Дано 62 | Поделка = Новый Поделка; 63 | 64 | // Когда 65 | Поделка.ЗапуститьПриложение(); 66 | 67 | // Тогда 68 | Желудь = Поделка.НайтиЖелудь("ЖелудьНижнегоУровня"); 69 | Ожидаем.Что(Желудь).Не_().Равно(Неопределено); 70 | 71 | КонецПроцедуры 72 | 73 | &Тест 74 | Процедура ВЗаготовкуМожноПрилепитьДетальку() Экспорт 75 | 76 | // Дано 77 | Поделка = Новый Поделка; 78 | 79 | // Когда 80 | Поделка.ЗапуститьПриложение(); 81 | 82 | // Тогда 83 | Желудь = Поделка.НайтиЖелудь("ЗаготовкаСДеталькой"); 84 | Ожидаем.Что(Желудь.ПростаяНастройка()).Равно("Значение простой настройки"); 85 | 86 | КонецПроцедуры 87 | 88 | &Тест 89 | Процедура ВсеРогаткиЗапускаютсяКорректно() Экспорт 90 | 91 | // Дано 92 | Поделка = Новый Поделка; 93 | 94 | // Когда 95 | Поделка.ЗапуститьПриложение(); 96 | 97 | // Тогда 98 | ДолгаяРогатка = Поделка.НайтиЖелудь("ДолгаяРогатка"); 99 | Ожидаем.Что(ДолгаяРогатка.Значение).Равно(0); 100 | 101 | // Когда 102 | Приостановить(1500); 103 | 104 | // Тогда 105 | Ожидаем.Что(ДолгаяРогатка.Значение).Равно(1); 106 | 107 | КонецПроцедуры 108 | -------------------------------------------------------------------------------- /tests/Заготовки/Классы/ЗаготовкаСДеталькой.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | Перем _ПростаяНастройка; 3 | 4 | Функция ПростаяНастройка() Экспорт 5 | Возврат _ПростаяНастройка; 6 | КонецФункции 7 | 8 | Процедура ПриИнициализацииПоделки(Поделка) Экспорт 9 | 10 | КонецПроцедуры 11 | 12 | &Заготовка 13 | Процедура ПриСозданииОбъекта(&Деталька ПростаяНастройка) 14 | _ПростаяНастройка = ПростаяНастройка; 15 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/Заготовки/Классы/ТестовыйИнициализатор.os: -------------------------------------------------------------------------------- 1 | 2 | Процедура ПриИнициализацииПоделки(Поделка) Экспорт 3 | Поделка.ДобавитьЖелудь(Тип("ЖелудьНижнегоУровня")); 4 | КонецПроцедуры 5 | 6 | &Заготовка 7 | Процедура ПриСозданииОбъекта() 8 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ИзолированныеТесты/oscript.cfg: -------------------------------------------------------------------------------- 1 | lib.system=../../oscript_modules 2 | -------------------------------------------------------------------------------- /tests/ИзолированныеТесты/ВЗаготовкуНельзяПрилепитьПластилин.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать "../../src" 3 | #Использовать "../ОшибочныеКлассы/ЗаготовкаСПластилином" 4 | 5 | &Тест 6 | Процедура ВЗаготовкуНельзяПрилепитьПластилин() Экспорт 7 | 8 | БылаОшибка = Ложь; 9 | 10 | Попытка 11 | Поделка = Новый Поделка(); // BSLLS:UnusedLocalVariable-off 12 | Исключение 13 | БылаОшибка = Истина; 14 | Ожидаем.Что(ИнформацияОбОшибке().Описание) 15 | .Содержит("К желудю времени инициализации ЗаготовкаСПластилином можно прилеплять только детальки"); 16 | КонецПопытки; 17 | 18 | Ожидаем.Что(БылаОшибка).ЭтоИстина(); 19 | 20 | КонецПроцедуры 21 | -------------------------------------------------------------------------------- /tests/ИзолированныеТесты/ДваЖелудяСОднимИменемКонфликтуют.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать "../../src" 3 | #Использовать "../ОшибочныеКлассы/ДваЖелудяСОднимИменем" 4 | 5 | &Тест 6 | Процедура ДваЖелудяСОднимИменемКонфликтуют() Экспорт 7 | 8 | БылаОшибка = Ложь; 9 | 10 | Попытка 11 | Поделка = Новый Поделка(); // BSLLS:UnusedLocalVariable-off 12 | Исключение 13 | БылаОшибка = Истина; 14 | Ожидаем.Что(ИнформацияОбОшибке().Описание) 15 | .Содержит("Определение желудя с именем ""ТестовыйЖелудь"" уже существует"); 16 | КонецПопытки; 17 | 18 | Ожидаем.Что(БылаОшибка).ЭтоИстина(); 19 | 20 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ИзолированныеТесты/ДвухВерховныхЖелудейБытьНеМожет.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать "../../src" 3 | #Использовать "../ОшибочныеКлассы/ДваВерховныхЖелудя" 4 | 5 | &Тест 6 | Процедура ДвухВерховныхЖелудейБытьНеМожет() Экспорт 7 | 8 | БылаОшибка = Ложь; 9 | 10 | Попытка 11 | Поделка = Новый Поделка(); // BSLLS:UnusedLocalVariable-off 12 | Исключение 13 | БылаОшибка = Истина; 14 | Ожидаем.Что(ИнформацияОбОшибке().Описание) 15 | .Содержит("Определение верховного желудя с именем ""ТестовыйЖелудь"" уже существует"); 16 | КонецПопытки; 17 | 18 | Ожидаем.Что(БылаОшибка).ЭтоИстина(); 19 | 20 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ИзолированныеТесты/ПадениеРогаткиДолжноБытьЗалогировано.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать "../../src" 3 | #Использовать "../ТестКлассы" 4 | #Использовать "../ОшибочныеКлассы/ПадающаяРогатка" 5 | 6 | &Тест 7 | Процедура ПадениеРогаткиДолжноБытьЗалогировано() Экспорт // BSLLS:Typo-off 8 | 9 | // Дано 10 | МокАппендера = Новый МокАппендера(); 11 | Лог = Логирование.ПолучитьЛог("oscript.lib.autumn.ЗапускательПриложения"); 12 | Лог.ДобавитьСпособВывода(МокАппендера, УровниЛога.Ошибка); 13 | 14 | Поделка = Новый Поделка; 15 | 16 | // Когда 17 | Поделка.ЗапуститьПриложение(); 18 | Сообщения = МокАппендера.Сообщения; 19 | 20 | // Тогда 21 | Ожидаем.Что(Сообщения.Количество(), "Количество сообщений").Равно(1); 22 | Ожидаем.Что(Сообщения[0], "Сообщение об ошибке").Содержит("ОШИБКА - Ошибка запуска рогатки ПадающаяРогатка"); 23 | 24 | КонецПроцедуры 25 | -------------------------------------------------------------------------------- /tests/ИзолированныеТесты/ПовторениеНеповторяемыхПараметровКидаетИсключение.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать "../../src" 3 | #Использовать "../ОшибочныеКлассы/АннотацияСПовторяемымиПараметрами" 4 | 5 | &Тест 6 | Процедура ПовторениеНеповторяемыхПараметровКидаетИсключение() Экспорт 7 | 8 | БылаОшибка = Ложь; 9 | 10 | Попытка 11 | Поделка = Новый Поделка(); // BSLLS:UnusedLocalVariable-off 12 | Исключение 13 | БылаОшибка = Истина; 14 | Ожидаем.Что(ИнформацияОбОшибке().Описание).Содержит("но параметр не помечен аннотацией ""Повторяемый"""); 15 | КонецПопытки; 16 | 17 | Ожидаем.Что(БылаОшибка).ЭтоИстина(); 18 | 19 | КонецПроцедуры 20 | -------------------------------------------------------------------------------- /tests/ИзолированныеТесты/ПроверкаНекорректногоХарактера.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать "../../src" 3 | #Использовать "../ОшибочныеКлассы/ЖелудьСНекорректнымХарактером" 4 | 5 | &Тест 6 | Процедура ПроверкаНекорректногоХарактера() Экспорт 7 | 8 | БылаОшибка = Ложь; 9 | 10 | Попытка 11 | Поделка = Новый Поделка(); // BSLLS:UnusedLocalVariable-off 12 | Исключение 13 | БылаОшибка = Истина; 14 | Ожидаем.Что(ИнформацияОбОшибке().Описание).Содержит("Неизвестный характер желудя"); 15 | КонецПопытки; 16 | 17 | Ожидаем.Что(БылаОшибка).ЭтоИстина(); 18 | 19 | КонецПроцедуры 20 | -------------------------------------------------------------------------------- /tests/КаталогНастроекСОтключеннымиРогатками/autumn-properties.json: -------------------------------------------------------------------------------- 1 | { 2 | "core": 3 | { 4 | "ЗапускатьРогатки": false 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /tests/ОдноименныеЖелуди/lib.config: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /tests/ОдноименныеЖелуди/Классы/ВерховныйКругляш.os: -------------------------------------------------------------------------------- 1 | &Верховный 2 | &Желудь 3 | &Прозвище("Кругляш") 4 | Процедура ПриСозданииОбъекта() 5 | 6 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОдноименныеЖелуди/Классы/ВерховныйТестовыйЖелудь.os: -------------------------------------------------------------------------------- 1 | &Желудь("ТестовыйЖелудь") 2 | &Верховный 3 | Процедура ПриСозданииОбъекта() 4 | 5 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОдноименныеЖелуди/Классы/Желудь1.os: -------------------------------------------------------------------------------- 1 | &Желудь("ТестовыйЖелудь") 2 | &Прозвище("Кругляш") 3 | &Прозвище("Мелкий") 4 | Процедура ПриСозданииОбъекта() 5 | 6 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОдноименныеЖелуди/Классы/Желудь2.os: -------------------------------------------------------------------------------- 1 | &Желудь("ТестовыйЖелудь") 2 | Процедура ПриСозданииОбъекта() 3 | 4 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОдноименныеЖелуди/Классы/Желудь3.os: -------------------------------------------------------------------------------- 1 | &Желудь 2 | &Прозвище("Кругляш") 3 | Процедура ПриСозданииОбъекта() 4 | 5 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОдноименныеЖелуди/Классы/Желудь4.os: -------------------------------------------------------------------------------- 1 | &Желудь 2 | &Прозвище("Мелкий") 3 | Процедура ПриСозданииОбъекта() 4 | 5 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОдноименныеЖелуди/Классы/Желудь5.os: -------------------------------------------------------------------------------- 1 | &Желудь 2 | &Прозвище("Мелкий") 3 | Процедура ПриСозданииОбъекта() 4 | 5 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОшибочныеКлассы/АннотацияСПовторяемымиПараметрами/Классы/АннотацияСПовторяемымиПараметрами.os: -------------------------------------------------------------------------------- 1 | &Аннотация("АннотацияСПовторяемымиПараметрами") 2 | Процедура ПриСозданииОбъекта(НеповторяемыйПараметр, &Повторяемый ПовторяемыйПараметр) 3 | 4 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОшибочныеКлассы/АннотацияСПовторяемымиПараметрами/Классы/ЖелудьСНекорректнымиНеПовторяемымиПараметрами.os: -------------------------------------------------------------------------------- 1 | &Желудь 2 | &АннотацияСПовторяемымиПараметрами( 3 | НеповторяемыйПараметр = 1, 4 | НеповторяемыйПараметр = 2, 5 | ПовторяемыйПараметр = 3, 6 | ПовторяемыйПараметр = 4 7 | ) 8 | Процедура ПриСозданииОбъекта() 9 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОшибочныеКлассы/ДваВерховныхЖелудя/Классы/ВерховныйТестовыйЖелудь.os: -------------------------------------------------------------------------------- 1 | &Желудь("ТестовыйЖелудь") 2 | &Верховный 3 | Процедура ПриСозданииОбъекта() 4 | 5 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОшибочныеКлассы/ДваВерховныхЖелудя/Классы/ВторойВерховныйТестовыйЖелудь.os: -------------------------------------------------------------------------------- 1 | &Желудь("ТестовыйЖелудь") 2 | &Верховный 3 | Процедура ПриСозданииОбъекта() 4 | 5 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОшибочныеКлассы/ДваЖелудяСОднимИменем/Классы/Желудь1.os: -------------------------------------------------------------------------------- 1 | &Желудь("ТестовыйЖелудь") 2 | &Прозвище("Кругляш") 3 | &Прозвище("Мелкий") 4 | Процедура ПриСозданииОбъекта() 5 | 6 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОшибочныеКлассы/ДваЖелудяСОднимИменем/Классы/Желудь2.os: -------------------------------------------------------------------------------- 1 | &Желудь("ТестовыйЖелудь") 2 | Процедура ПриСозданииОбъекта() 3 | 4 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОшибочныеКлассы/ЖелудьСНекорректнымХарактером/Классы/ЖелудьСНекорректнымХарактером.os: -------------------------------------------------------------------------------- 1 | &Желудь 2 | &Характер("Ошибочный") 3 | Процедура ПриСозданииОбъекта() 4 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОшибочныеКлассы/ЗаготовкаСПластилином/Классы/ЗаготовкаСПластилином.os: -------------------------------------------------------------------------------- 1 | Процедура ПриИнициализацииПоделки(Поделка) Экспорт 2 | 3 | КонецПроцедуры 4 | 5 | &Заготовка 6 | Процедура ПриСозданииОбъекта(&Пластилин ЖелудьНижнегоУровня) 7 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ОшибочныеКлассы/ПадающаяРогатка/Классы/ПадающаяРогатка.os: -------------------------------------------------------------------------------- 1 | Процедура ПриЗапускеПриложения() Экспорт 2 | ВызватьИсключение "Ошибка"; 3 | КонецПроцедуры 4 | 5 | &Рогатка 6 | Процедура ПриСозданииОбъекта() 7 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/СоветДругогоМастера.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать ".." 3 | 4 | Перем Рефлектор; // Рефлектор 5 | 6 | &Тест 7 | Процедура ЗначенияДеталек_Получить() Экспорт 8 | 9 | // Дано 10 | 11 | ЗначенияДеталек = Новый Соответствие; 12 | ЗначенияДеталек.Вставить("Ключ", "Значение"); 13 | 14 | СоветДругогоМастера = Новый СоветДругогоМастера(); 15 | 16 | Рефлектор.УстановитьСвойство(СоветДругогоМастера, "ЗначенияДеталек", ЗначенияДеталек); 17 | 18 | // Когда 19 | 20 | Результат = СоветДругогоМастера.ЗначенияДеталек(); 21 | 22 | // Тогда 23 | 24 | Ожидаем.Что(Результат).Равно(ЗначенияДеталек); 25 | 26 | КонецПроцедуры 27 | 28 | &Тест 29 | Процедура ЗначенияДеталек_Установить() Экспорт 30 | 31 | // Дано 32 | 33 | ЗначенияДеталек = Новый Соответствие; 34 | ЗначенияДеталек.Вставить("Ключ", "Значение"); 35 | 36 | СоветДругогоМастера = Новый СоветДругогоМастера(); 37 | 38 | // Когда 39 | 40 | Результат = СоветДругогоМастера.ЗначенияДеталек(ЗначенияДеталек); 41 | 42 | // Тогда 43 | 44 | Ожидаем.Что(Результат).Равно(СоветДругогоМастера); 45 | Ожидаем.Что(Рефлектор.ПолучитьСвойство(СоветДругогоМастера, "ЗначенияДеталек")).Равно(ЗначенияДеталек); 46 | 47 | КонецПроцедуры 48 | 49 | &Тест 50 | Процедура ПрефиксПеременныхСреды_Получить() Экспорт 51 | 52 | // Дано 53 | 54 | ПрефиксПеременныхСреды = "Тест"; 55 | 56 | СоветДругогоМастера = Новый СоветДругогоМастера(); 57 | 58 | Рефлектор.УстановитьСвойство(СоветДругогоМастера, "ПрефиксПеременныхСреды", ПрефиксПеременныхСреды); 59 | 60 | // Когда 61 | 62 | Результат = СоветДругогоМастера.ПрефиксПеременныхСреды(); 63 | 64 | // Тогда 65 | 66 | Ожидаем.Что(Результат).Равно(ПрефиксПеременныхСреды); 67 | 68 | КонецПроцедуры 69 | 70 | &Тест 71 | Процедура ПрефиксПеременныхСреды_Установить() Экспорт 72 | 73 | // Дано 74 | 75 | ПрефиксПеременныхСреды = "Тест"; 76 | 77 | СоветДругогоМастера = Новый СоветДругогоМастера(); 78 | 79 | // Когда 80 | 81 | Результат = СоветДругогоМастера.ПрефиксПеременныхСреды(ПрефиксПеременныхСреды); 82 | 83 | // Тогда 84 | 85 | Ожидаем.Что(Результат).Равно(СоветДругогоМастера); 86 | Ожидаем.Что(Рефлектор.ПолучитьСвойство(СоветДругогоМастера, "ПрефиксПеременныхСреды")).Равно(ПрефиксПеременныхСреды); 87 | 88 | КонецПроцедуры 89 | 90 | &Тест 91 | Процедура ИмяФайлаСоЗначениямиДеталек_Получить() Экспорт 92 | 93 | // Дано 94 | 95 | ИмяФайлаСоЗначениямиДеталек = "/path/to/file"; 96 | 97 | СоветДругогоМастера = Новый СоветДругогоМастера(); 98 | 99 | Рефлектор.УстановитьСвойство(СоветДругогоМастера, "ИмяФайлаСоЗначениямиДеталек", ИмяФайлаСоЗначениямиДеталек); 100 | 101 | // Когда 102 | 103 | Результат = СоветДругогоМастера.ИмяФайлаСоЗначениямиДеталек(); 104 | 105 | // Тогда 106 | 107 | Ожидаем.Что(Результат).Равно(ИмяФайлаСоЗначениямиДеталек); 108 | 109 | КонецПроцедуры 110 | 111 | &Тест 112 | Процедура ИмяФайлаСоЗначениямиДеталек_Установить() Экспорт 113 | 114 | // Дано 115 | 116 | ИмяФайлаСоЗначениямиДеталек = "/path/to/file"; 117 | 118 | СоветДругогоМастера = Новый СоветДругогоМастера(); 119 | 120 | // Когда 121 | 122 | Результат = СоветДругогоМастера.ИмяФайлаСоЗначениямиДеталек(ИмяФайлаСоЗначениямиДеталек); 123 | 124 | // Тогда 125 | 126 | Ожидаем.Что(Результат).Равно(СоветДругогоМастера); 127 | Ожидаем.Что(Рефлектор.ПолучитьСвойство(СоветДругогоМастера, "ИмяФайлаСоЗначениямиДеталек")) 128 | .Равно(ИмяФайлаСоЗначениямиДеталек); 129 | 130 | КонецПроцедуры 131 | 132 | &Тест 133 | Процедура ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек_Получить() Экспорт 134 | 135 | // Дано 136 | 137 | ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек = "/path/to/dir"; 138 | 139 | СоветДругогоМастера = Новый СоветДругогоМастера(); 140 | 141 | Рефлектор.УстановитьСвойство( 142 | СоветДругогоМастера, 143 | "ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек", 144 | ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек 145 | ); 146 | 147 | // Когда 148 | 149 | Результат = СоветДругогоМастера.ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек(); 150 | 151 | // Тогда 152 | 153 | Ожидаем.Что(Результат).Равно(ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек); 154 | 155 | КонецПроцедуры 156 | 157 | &Тест 158 | Процедура ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек_Установить() Экспорт 159 | 160 | // Дано 161 | 162 | ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек = "/path/to/dir"; 163 | 164 | СоветДругогоМастера = Новый СоветДругогоМастера(); 165 | 166 | // Когда 167 | 168 | Результат = СоветДругогоМастера.ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек( 169 | ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек 170 | ); 171 | 172 | // Тогда 173 | 174 | Ожидаем.Что(Результат).Равно(СоветДругогоМастера); 175 | Ожидаем.Что(Рефлектор.ПолучитьСвойство(СоветДругогоМастера, "ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек")) 176 | .Равно(ДополнительныйКаталогПоискаФайлаСоЗначениямиДеталек); 177 | 178 | КонецПроцедуры 179 | 180 | Рефлектор = Новый Рефлектор(); 181 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/АннотацияКонструкторМассива.os: -------------------------------------------------------------------------------- 1 | // BSLLS:UnusedParameters-off 2 | Перем Элементы; 3 | 4 | Процедура ПриРазворачиванииАннотации(ОпределениеАннотации, ПодчиненныеАннотации, ТипВладельцаСвойств, Свойство) Экспорт 5 | 6 | Аннотация = РаботаСАннотациями.НайтиАннотацию(ПодчиненныеАннотации, "Пластилин"); 7 | Аннотация.Параметры[1].Значение = Элементы; 8 | 9 | КонецПроцедуры 10 | 11 | &Аннотация("КонструкторМассива") 12 | &Пластилин(Значение = "КонструкторМассива", Блестяшка = "") 13 | Процедура ПриСозданииОбъекта(Значение = "", &Повторяемый Элемент = Неопределено) 14 | Элементы = Элемент; 15 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/АннотацияКонтроллер.os: -------------------------------------------------------------------------------- 1 | &Аннотация(Значение = "Контроллер") 2 | &Желудь 3 | &Прозвище("Контроллер") 4 | Процедура ПриСозданииОбъекта(Значение = "/") 5 | 6 | КонецПроцедуры 7 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/АннотацияМетаБлестяшка.os: -------------------------------------------------------------------------------- 1 | &Аннотация(Значение = "МетаБлестяшка") 2 | &Блестяшка 3 | Процедура ПриСозданииОбъекта() 4 | 5 | КонецПроцедуры 6 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/АннотацияМетаЗавязь.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:UnusedParameters-off 3 | Перем _Значение; 4 | Перем _Тип; 5 | 6 | Процедура ПриРазворачиванииАннотации(ОпределениеАннотации, ПодчиненныеАннотации, ТипВладельцаСвойств, Свойство) Экспорт 7 | 8 | Аннотация = РаботаСАннотациями.НайтиАннотацию(ПодчиненныеАннотации, "Завязь"); 9 | Если _Значение <> "" Тогда 10 | РаботаСАннотациями.УстановитьЗначениеПараметраАннотации(Аннотация, "Значение", _Значение); 11 | КонецЕсли; 12 | 13 | Если _Тип <> "" Тогда 14 | РаботаСАннотациями.УстановитьЗначениеПараметраАннотации(Аннотация, "Тип", _Тип); 15 | КонецЕсли; 16 | 17 | КонецПроцедуры 18 | 19 | &Аннотация(Значение = "МетаЗавязь") 20 | &Завязь 21 | Процедура ПриСозданииОбъекта(Значение = "", Тип = "") 22 | 23 | _Значение = Значение; 24 | _Тип = Тип; 25 | 26 | КонецПроцедуры 27 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/АннотацияМетаПрозвище.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:UnusedParameters-off 3 | Перем Имя; 4 | 5 | Процедура ПриРазворачиванииАннотации(ОпределениеАннотации, ПодчиненныеАннотации, ТипВладельцаСвойств, Свойство) Экспорт 6 | 7 | Аннотация = РаботаСАннотациями.НайтиАннотацию(ПодчиненныеАннотации, "Прозвище"); 8 | РаботаСАннотациями.УстановитьЗначениеПараметраАннотации(Аннотация, "Значение", Имя); 9 | 10 | КонецПроцедуры 11 | 12 | &Аннотация("МетаПрозвище") 13 | &Прозвище(Значение = "") 14 | Процедура ПриСозданииОбъекта(Значение) 15 | Имя = Значение; 16 | КонецПроцедуры 17 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ВерхнеУровневыйЖелудь.os: -------------------------------------------------------------------------------- 1 | // BSLLS:ExportVariables-off 2 | // BSLLS:MissingVariablesDescription-off 3 | Перем _ЖелудьНижнегоУровня; 4 | 5 | &Пластилин("ЖелудьНижнегоУровня") 6 | Перем ВнедряемыйЖелудьНижнегоУровня Экспорт; 7 | 8 | &Пластилин(Значение = "Кругляш", Тип = "Массив") 9 | Перем ВнедряемыеЖелудиПоПрозвищу Экспорт; 10 | 11 | Перем ВнедряемыйЖелудьНижнегоУровняЧерезСеттер; 12 | 13 | Перем ВнедряемыйЖелудьНижнегоУровняЧерезСеттерСоСтраннымИменем; 14 | 15 | Перем ПеременнаяВИнит; 16 | 17 | &Пластилин("ЖелудьНижнегоУровня") 18 | Перем ПриватныйЖелудь; 19 | 20 | Функция ПолучитьПриватныйЖелудь() Экспорт 21 | Возврат ПриватныйЖелудь; 22 | КонецФункции 23 | 24 | Функция ЖелудьНижнегоУровня() Экспорт 25 | Возврат _ЖелудьНижнегоУровня; 26 | КонецФункции 27 | 28 | Функция ВнедряемыйЖелудьНижнегоУровня() Экспорт 29 | Возврат ВнедряемыйЖелудьНижнегоУровня; 30 | КонецФункции 31 | 32 | Функция ВнедряемыйЖелудьНижнегоУровняЧерезСеттер() Экспорт 33 | Возврат ВнедряемыйЖелудьНижнегоУровняЧерезСеттер; 34 | КонецФункции 35 | 36 | Функция ВнедряемыйЖелудьНижнегоУровняЧерезСеттерСоСтраннымИменем() Экспорт 37 | Возврат ВнедряемыйЖелудьНижнегоУровняЧерезСеттерСоСтраннымИменем; 38 | КонецФункции 39 | 40 | Функция ПеременнаяВИнит() Экспорт 41 | Возврат ПеременнаяВИнит; 42 | КонецФункции 43 | 44 | &Пластилин 45 | Процедура УстановитьЖелудьНижнегоУровня(Значение) Экспорт 46 | ВнедряемыйЖелудьНижнегоУровняЧерезСеттер = Значение; 47 | КонецПроцедуры 48 | 49 | &Пластилин("ЖелудьНижнегоУровня") 50 | Процедура УстановитьЖелудьНижнегоУровняСоСтраннымИменемСеттера(Значение) Экспорт 51 | ВнедряемыйЖелудьНижнегоУровняЧерезСеттерСоСтраннымИменем = Значение; 52 | КонецПроцедуры 53 | 54 | &ФинальныйШтрих 55 | Процедура Инит() Экспорт 56 | ПеременнаяВИнит = 1; 57 | КонецПроцедуры 58 | 59 | &Желудь 60 | Процедура ПриСозданииОбъекта( 61 | &Пластилин ЖелудьНижнегоУровня 62 | ) 63 | _ЖелудьНижнегоУровня = ЖелудьНижнегоУровня; 64 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ГлавныйДуб.os: -------------------------------------------------------------------------------- 1 | 2 | &Завязь(Значение = "Структура", Тип = "Структура") 3 | Функция Структурочка() Экспорт 4 | Структура = Новый Структура(); 5 | Структура.Вставить("Ключ", 0); 6 | 7 | Возврат Структура; 8 | КонецФункции 9 | 10 | &Завязь 11 | Функция Массив(&Пластилин Структура) Экспорт 12 | Массив = Новый Массив(); 13 | Массив.Добавить(Структура); 14 | 15 | Возврат Массив; 16 | КонецФункции 17 | 18 | &Завязь(Тип = "Число") 19 | Функция ЗначениеСтруктуры(&Пластилин Структура) Экспорт 20 | Возврат Структура.Ключ; 21 | КонецФункции 22 | 23 | &МетаЗавязь(Значение = "МетаМассив", Тип = "Массив") 24 | Функция МетаМассив() Экспорт 25 | Массив = Новый Массив; 26 | Массив.Добавить(1); 27 | 28 | Возврат Массив; 29 | КонецФункции 30 | 31 | &МетаЗавязь(Значение = "ВторойМетаМассив", Тип = "Массив") 32 | Функция МетаВторойМетаМассив() Экспорт 33 | Массив = Новый Массив; 34 | Массив.Добавить(1); 35 | 36 | Возврат Массив; 37 | КонецФункции 38 | 39 | &Дуб 40 | Процедура ПриСозданииОбъекта() 41 | 42 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ДолгаяРогатка.os: -------------------------------------------------------------------------------- 1 | Перем Значение Экспорт; // BSLLS:ExportVariables-off 2 | 3 | Процедура ПриЗапускеПриложения() Экспорт 4 | Приостановить(1000); 5 | Значение = 1; 6 | КонецПроцедуры 7 | 8 | &Рогатка(ОжидатьЗавершения = Ложь) 9 | Процедура ПриСозданииОбъекта() 10 | Значение = 0; 11 | КонецПроцедуры 12 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ДубКонструктора.os: -------------------------------------------------------------------------------- 1 | &Дуб 2 | Процедура ПриСозданииОбъекта() 3 | 4 | КонецПроцедуры 5 | 6 | &Завязь(Тип = "Массив") 7 | &Характер("Компанейский") 8 | Функция КонструкторМассива(&Блестяшка Элементы) Экспорт 9 | Возврат Элементы; 10 | КонецФункции -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ДубСБлестяшкамиВПластилине.os: -------------------------------------------------------------------------------- 1 | &Завязь(Тип = "Число") 2 | &Прозвище("ЧислоСБлестяшками") 3 | Функция ВнедренноеСложноеЧисло(&Пластилин(Блестяшка = 1, Блестяшка = 2) СложноеЧисло) Экспорт 4 | Возврат СложноеЧисло; 5 | КонецФункции 6 | 7 | &Завязь(Тип = "Число") 8 | &Прозвище("ЧислоСБлестяшками") 9 | Функция ВтороеВнедренноеСложноеЧисло(&Пластилин(Блестяшка = 1, Блестяшка = 2) СложноеЧисло) Экспорт 10 | Возврат СложноеЧисло; 11 | КонецФункции 12 | 13 | &Завязь(Тип = "Число") 14 | Функция СложноеЧисло(&Блестяшка Параметр1, &Блестяшка Параметр2) Экспорт 15 | Возврат Параметр1 + Параметр2; 16 | КонецФункции 17 | 18 | &Дуб 19 | Процедура ПриСозданииОбъекта() 20 | 21 | КонецПроцедуры 22 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьИзбирательноПрименяющийНапильники.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:ExportVariables-off 3 | 4 | &Пластилин 5 | Перем ЖелудьНижнегоУровня Экспорт; 6 | 7 | Перем ВторойЖелудьНижнегоУровня Экспорт; 8 | 9 | &ФинальныйШтрих 10 | Процедура Инит() Экспорт 11 | ВторойЖелудьНижнегоУровня = ЖелудьНижнегоУровня; 12 | КонецПроцедуры 13 | 14 | &Желудь 15 | &ОсобоеОбращение( 16 | ПрименятьТолькоНапильник = "ОбработкаНапильникомПластилинаНаПолях" 17 | ) 18 | Процедура ПриСозданииОбъекта() 19 | 20 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьНижнегоУровня.os: -------------------------------------------------------------------------------- 1 | &Желудь 2 | Процедура ПриСозданииОбъекта() 3 | 4 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьСБлестяшкой.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | Перем ХранимаяБлестяшка; 3 | 4 | &Желудь 5 | Процедура ПриСозданииОбъекта(&Блестяшка Число) 6 | ХранимаяБлестяшка = Число; 7 | КонецПроцедуры 8 | 9 | Функция ПолучитьХранимуюБлестяшку() Экспорт 10 | Возврат ХранимаяБлестяшка; 11 | КонецФункции -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьСБлестяшкойВТабакерке.os: -------------------------------------------------------------------------------- 1 | // BSLLS:ExportVariables-off 2 | &Пластилин 3 | &Табакерка 4 | Перем ЖелудьСБлестяшкой Экспорт; 5 | 6 | &Желудь 7 | Процедура ПриСозданииОбъекта() 8 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьСБлестяшкойПластелиномДеталькой.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:ExportVariables-off 3 | Перем ХранимаяБлестяшка; 4 | Перем ЕщеХранимаяБлестяшка; 5 | 6 | Перем Настройка Экспорт; 7 | Перем ЖелудьИзПластилина Экспорт; 8 | 9 | &Желудь 10 | Процедура ПриСозданииОбъекта(&Пластилин ЖелудьНижнегоУровня, 11 | &Блестяшка Число1, 12 | &Блестяшка Число2, 13 | &Деталька(ЗначениеПоУмолчанию = 123) ЧисловаяНастройка 14 | ) 15 | ХранимаяБлестяшка = Число1; 16 | ЕщеХранимаяБлестяшка = Число2; 17 | Настройка = ЧисловаяНастройка; 18 | ЖелудьИзПластилина = ЖелудьНижнегоУровня; 19 | КонецПроцедуры 20 | 21 | Функция ПолучитьХранимуюБлестяшку() Экспорт 22 | Возврат ХранимаяБлестяшка; 23 | КонецФункции 24 | 25 | Функция ПолучитьВторуюХранимуюБлестяшку() Экспорт 26 | Возврат ЕщеХранимаяБлестяшка; 27 | КонецФункции -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьСДеталькойИзСоответствия.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:ExportVariables-off 3 | 4 | &Деталька("Моя.Настройка") 5 | Перем Деталька Экспорт; 6 | 7 | &Желудь 8 | Процедура ПриСозданииОбъекта() 9 | КонецПроцедуры 10 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьСКомпанейскойТабакеркой.os: -------------------------------------------------------------------------------- 1 | // BSLLS:ExportVariables-off 2 | &Пластилин 3 | &Табакерка 4 | Перем КомпанейскийЖелудь Экспорт; 5 | 6 | &Желудь 7 | Процедура ПриСозданииОбъекта() 8 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьСКонструкторомМассива.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:ExportVariables-off 3 | 4 | &КонструкторМассива( 5 | Элемент = 1, 6 | Элемент = "2" 7 | ) 8 | Перем Массив Экспорт; 9 | 10 | &Желудь 11 | Процедура ПриСозданииОбъекта() 12 | 13 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьСМетаБлестяшкой.os: -------------------------------------------------------------------------------- 1 | // BSLLS:ExportVariables-off 2 | Перем СохраненныйПараметр Экспорт; 3 | 4 | &Желудь 5 | Процедура ПриСозданииОбъекта(&МетаБлестяшка Параметр) 6 | СохраненныйПараметр = Параметр; 7 | КонецПроцедуры 8 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьСНастройками.os: -------------------------------------------------------------------------------- 1 | // BSLLS:ExportVariables-off 2 | // BSLLS:MissingVariablesDescription-off 3 | 4 | &Деталька 5 | Перем ПростаяНастройка Экспорт; 6 | 7 | &Деталька("Настройки.ОченьХитраяНастройка") 8 | Перем ХитраяНастройка Экспорт; 9 | 10 | &Деталька 11 | Перем МассивНастроек Экспорт; 12 | 13 | &Деталька(ЗначениеПоУмолчанию = 123) 14 | Перем ЧисловаяНастройка Экспорт; 15 | 16 | Перем НеЭкспортнаяЧисловаяНастройка; 17 | 18 | Перем ЖелудьНижнегоУровня; 19 | Перем ЖелудьНижнегоУровняЧерезСеттер; 20 | Перем ЖелудьНижнегоУровняЧерезСеттерПоУмолчанию; 21 | 22 | Функция ЧисловаяНастройка() Экспорт 23 | Возврат НеЭкспортнаяЧисловаяНастройка; 24 | КонецФункции 25 | 26 | Функция ЖелудьНижнегоУровня() Экспорт 27 | Возврат ЖелудьНижнегоУровня; 28 | КонецФункции 29 | 30 | Функция ЖелудьНижнегоУровняЧерезСеттер() Экспорт 31 | Возврат ЖелудьНижнегоУровняЧерезСеттер; 32 | КонецФункции 33 | 34 | Функция ЖелудьНижнегоУровняЧерезСеттерПоУмолчанию() Экспорт 35 | Возврат ЖелудьНижнегоУровняЧерезСеттерПоУмолчанию; 36 | КонецФункции 37 | 38 | &Пластилин("ЖелудьНижнегоУровня") 39 | Процедура УстановитьЖелудьНижнегоУровняЧерезСеттер(Значение) Экспорт 40 | ЖелудьНижнегоУровняЧерезСеттер = Значение; 41 | КонецПроцедуры 42 | 43 | &Пластилин 44 | Процедура УстановитьЖелудьНижнегоУровня(Значение) Экспорт 45 | ЖелудьНижнегоУровняЧерезСеттерПоУмолчанию = Значение; 46 | КонецПроцедуры 47 | 48 | &Желудь 49 | Процедура ПриСозданииОбъекта( 50 | &Деталька(ЗначениеПоУмолчанию = 123) ЧисловаяНастройка, 51 | &Пластилин("ЖелудьНижнегоУровня") _ЖелудьНижнегоУровня 52 | ) 53 | НеЭкспортнаяЧисловаяНастройка = ЧисловаяНастройка; 54 | ЖелудьНижнегоУровня = _ЖелудьНижнегоУровня; 55 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьСОтключеннымиНапильниками.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:ExportVariables-off 3 | 4 | &Пластилин 5 | Перем ЖелудьНижнегоУровня Экспорт; 6 | 7 | Перем ВторойЖелудьНижнегоУровня Экспорт; 8 | 9 | &ФинальныйШтрих 10 | Процедура Инит() Экспорт 11 | ВторойЖелудьНижнегоУровня = ЖелудьНижнегоУровня; 12 | КонецПроцедуры 13 | 14 | &Желудь 15 | &ОсобоеОбращение( 16 | ОтключитьВсеНапильники = Истина 17 | ) 18 | Процедура ПриСозданииОбъекта() 19 | 20 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ЖелудьСТабакеркой.os: -------------------------------------------------------------------------------- 1 | // BSLLS:ExportVariables-off 2 | &Пластилин 3 | &Табакерка 4 | Перем ТестовыйЖелудь Экспорт; 5 | 6 | &Желудь 7 | Процедура ПриСозданииОбъекта() 8 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/КомпанейскийЖелудь.os: -------------------------------------------------------------------------------- 1 | &Желудь 2 | &Характер("Компанейский") 3 | Процедура ПриСозданииОбъекта() 4 | 5 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/КомпанейскийЖелудьСПластилиномВКонструкторе.os: -------------------------------------------------------------------------------- 1 | // BSLLS:UnusedLocalVariable-off 2 | Перем _КомпанейскийЖелудь; 3 | 4 | &Желудь 5 | &Характер("Компанейский") 6 | Процедура ПриСозданииОбъекта(&Пластилин КомпанейскийЖелудь) 7 | _КомпанейскийЖелудь = КомпанейскийЖелудь; 8 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/КомпанейскийЖелудьСПластилиномНаПолях.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:UnusedLocalVariable-off 3 | &Пластилин Перем КомпанейскийЖелудь; 4 | 5 | &Желудь 6 | &Характер("Компанейский") 7 | Процедура ПриСозданииОбъекта() 8 | 9 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/МногоимённыйЖелудь.os: -------------------------------------------------------------------------------- 1 | &Желудь("МногоимённыйЖелудь") // BSLLS:Typo-off 2 | &Прозвище("СуперКругляш") 3 | &Прозвище("СуперМелкий") 4 | Процедура ПриСозданииОбъекта() 5 | 6 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/МокАппендера.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:ExportVariables-off 3 | 4 | Перем Сообщения Экспорт; 5 | 6 | Процедура ПриСозданииОбъекта() 7 | Сообщения = Новый Массив(); 8 | КонецПроцедуры 9 | 10 | Процедура Вывести(Знач Сообщение, УровеньСообщения) Экспорт // BSLLS:UnusedParameters-off 11 | Сообщения.Добавить(Сообщение); 12 | КонецПроцедуры 13 | 14 | Процедура Закрыть() Экспорт 15 | Сообщения = Новый Массив(); 16 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/НапильникПрименяющийсяТолькоНаКонкретномЖелуде.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:ExportVariables-off 3 | 4 | Перем СработалоРаз Экспорт; 5 | 6 | Функция ОбработатьЖелудь(Желудь, ОпределениеЖелудя) Экспорт // BSLLS:UnusedParameters-off 7 | СработалоРаз = СработалоРаз + 1; 8 | Возврат Желудь; 9 | КонецФункции 10 | 11 | &Напильник(ПрименяетсяТолькоНа = "КомпанейскийЖелудь") 12 | Процедура ПриСозданииОбъекта() 13 | СработалоРаз = 0; 14 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/НапильникПрименяющийсяТолькоНаКругляшах.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | // BSLLS:ExportVariables-off 3 | 4 | Перем СработалоРаз Экспорт; 5 | 6 | Функция ОбработатьЖелудь(Желудь, ОпределениеЖелудя) Экспорт // BSLLS:UnusedParameters-off 7 | СработалоРаз = СработалоРаз + 1; 8 | Возврат Желудь; 9 | КонецФункции 10 | 11 | &Напильник(ПрименяетсяТолькоНа = "Кругляш") 12 | Процедура ПриСозданииОбъекта() 13 | СработалоРаз = 0; 14 | КонецПроцедуры -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/НапильникСЖелудемВКонструкторе.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | Перем ЖелудьНижнегоУровня; 3 | 4 | &Напильник 5 | &Порядок(10) 6 | Процедура ПриСозданииОбъекта( 7 | &Пластилин("ЖелудьНижнегоУровня") _ЖелудьНижнегоУровня 8 | ) 9 | 10 | ЖелудьНижнегоУровня = _ЖелудьНижнегоУровня; 11 | КонецПроцедуры 12 | 13 | Функция ОбработатьЖелудь(Желудь, ОпределениеЖелудя) Экспорт // BSLLS:UnusedParameters-off 14 | Возврат Желудь; 15 | КонецФункции 16 | 17 | Функция ПолучитьЖелудьНижнегоУровня() Экспорт 18 | Возврат ЖелудьНижнегоУровня; 19 | КонецФункции -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ПользовательскийКонтроллер.os: -------------------------------------------------------------------------------- 1 | &Контроллер 2 | &Верховный 3 | Процедура ПриСозданииОбъекта() 4 | 5 | КонецПроцедуры 6 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ПользовательскийКонтроллерСМаршрутом.os: -------------------------------------------------------------------------------- 1 | &Контроллер("/hello") 2 | Процедура ПриСозданииОбъекта() 3 | 4 | КонецПроцедуры 5 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/ПрилепляемаяКоллекцияСтрока.os: -------------------------------------------------------------------------------- 1 | Перем Коллекция; 2 | 3 | Процедура Добавить(Желудь, ОпределениеЖелудя) Экспорт 4 | Коллекция.Добавить(ОпределениеЖелудя.Имя()); 5 | КонецПроцедуры 6 | 7 | Функция Получить() Экспорт 8 | Возврат СтрСоединить(Коллекция, ", "); 9 | КонецФункции 10 | 11 | &ПрилепляемаяКоллекция("Строка") 12 | Процедура ПриСозданииОбъекта() 13 | Коллекция = Новый Массив(); 14 | КонецПроцедуры 15 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/РогаткаМеняющаяМассив.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | Перем _Массив; 3 | 4 | Процедура ПриЗапускеПриложения() Экспорт 5 | _Массив.Добавить(0); 6 | КонецПроцедуры 7 | 8 | &Рогатка(ЗапускатьВФоне = Ложь) 9 | Процедура ПриСозданииОбъекта(&Пластилин Массив) 10 | _Массив = Массив; 11 | КонецПроцедуры 12 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/РогаткаПриоритет1.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | Перем _Массив; 3 | 4 | Процедура ПриЗапускеПриложения() Экспорт 5 | _Массив.Добавить(1); 6 | КонецПроцедуры 7 | 8 | &Рогатка(ЗапускатьВФоне = Ложь) 9 | &Порядок(5) 10 | Процедура ПриСозданииОбъекта(&Пластилин Массив) 11 | _Массив = Массив; 12 | КонецПроцедуры 13 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/РогаткаПриоритет2.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | Перем _Массив; 3 | 4 | Процедура ПриЗапускеПриложения() Экспорт 5 | _Массив.Добавить(2); 6 | КонецПроцедуры 7 | 8 | &Рогатка(ЗапускатьВФоне = Ложь) 9 | &Порядок(7) 10 | Процедура ПриСозданииОбъекта(&Пластилин Массив) 11 | _Массив = Массив; 12 | КонецПроцедуры 13 | -------------------------------------------------------------------------------- /tests/ТестКлассы/Классы/РогаткаПриоритет3.os: -------------------------------------------------------------------------------- 1 | // BSLLS:MissingVariablesDescription-off 2 | Перем _Массив; 3 | 4 | Процедура ПриЗапускеПриложения() Экспорт 5 | _Массив.Добавить(3); 6 | КонецПроцедуры 7 | 8 | &Рогатка(ЗапускатьВФоне = Ложь) 9 | &Порядок(9) 10 | Процедура ПриСозданииОбъекта(&Пластилин Массив) 11 | _Массив = Массив; 12 | КонецПроцедуры 13 | --------------------------------------------------------------------------------