bpmn-js extension which makes sure that `isExecutable` is set on `bpmn:Process`
Camunda Modeler moddle extensions
endpoints sdk cli
A simple element template chooser
Camunda Connectors Store with all out of the box connectors
A bpmn-js extension which allows to render selected elements as images
A simple properties panel for bpmn-js
Adding native (cross-browser and application) copy and paste to bpmn-js
Linting for Camunda
A toolbox for displaying and modifying diagrams on the web
Align diagrams to the diagram origin
bpmn-js token simulation extension
bpmn-js plugin for handling external variable providers
Add execution platform meta-data to BPMN and DMN diagrams
[](https://circleci.com/gh/ProcessMaker/modeler)
A visual grid for diagram-js
AutoRest Modeler Version Four (component)
bpmn-js extension which disables modeling collapsed subprocess via replace menu
A headless version of bpmn-js
Element templates for bpmn-js
Helper functions for bundling your Camunda Modeler client plugins
[](https://github.com/camunda/improved-canvas/actions?query=workflow:CI)
Embeddable Camunda modeling distributions based on bpmn-js
BPMNLint plugin for BPM ProcessMaker
Modeling require object in MES system
A CLI tool that scans the `/app/models` directory in a Rails application to identify 'fat models' based on conditions defined in this gem.
Test Dummy allows you to define how to fake models automatically so that you can use dummy data for testing instead of fixtures. Dummy models are always generated using the current schema and don't need to me migrated like fixtures.
This gem was originally made by Umai and Peter for me but has been rewritten to fit new project model.
This gem will give you only two scopes and a method for handling published/unpublished stuff. Nothing remarkable bur saved me a lot of typing when I wrote it for a project with an huge number of publishable models. Suggestions are more than welcome.
A simple gem for dealing with quarter logic. I happen to have a project where half the models in the database recur every three months as part of a "quarter" of the year. Within the code, we constantly are asking "what quarter is this for?", or "show me all the records for this quarter". Well, now I need the same power on another application, so say hello to "quarter_time".
Building the Packer JSON configurations in raw JSON can be quite an adventure. There's limited facilities for variable expansion and absolutely no support for nice things like comments. I decided it would just be easier to have an object model to build the Packer configurations in that would easily write to the correct JSON format. It also saved me having to remember the esoteric Packer syntax for referencing variables and whatnot in the JSON.
Sem4r is a library to access google adwords api. It will works with ruby 1.9 and ruby 1.8 without soap4r. It uses a high level model instead of a low level api. You think about clients, campaigns, keywords and not about operations, operands, selectors, service calls. This is a ALPHA version.rb don't use in production. If you are interested in this project let me now: install it and update periodically, so the gemcutter download counter go up. Or subscribe to my feed at sem4r.com. Or watch the project on github. Or simply drop me a line in email. However I will know there is someone out of here.
= Ungulate According to Wikipedia, this can mean "hoofed animal". Camels have hooves. This is a gem for uploading and processing images using an Amazon Web Services stack. It comes with a few goodies: * ungulate_server.rb - simple queue runner that expects a YAML-encoded job description for RMagick * Ungulate::FileUpload - a model for e.g. Rails that does some cryptography stuff - example to follow * A view helper for Rails: "ungulate_upload_form_for" == Installation gem install ungulate == Documentation http://wiki.github.com/camelpunch/ungulate/ == Note on Patches/Pull Requests * Fork the project. * Make your feature addition or bug fix. * Add tests for it. This is important so I don't break it in a future version unintentionally. * Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull) * Send me a pull request. Bonus points for topic branches. == Copyright Copyright (c) 2011 Camel Punch Limited. See LICENSE for details.
<!-- TABLE OF CONTENTS --> <details open="open"> <summary>Table of Contents</summary> <ol> <li> <a href="#about-the-project">About The Project</a> <ul> <li><a href="#built-with">Built With</a></li> </ul> </li> <li> <a href="#getting-started">Getting Started</a> <ul> <li><a href="#prerequisites">Prerequisites</a></li> <li><a href="#installation">Installation</a></li> </ul> </li> <li><a href="#usage">Usage</a></li> <li><a href="#roadmap">Roadmap</a></li> <li><a href="#contributing">Contributing</a></li> <li><a href="#license">License</a></li> <li><a href="#contact">Contact</a></li> <li><a href="#acknowledgements">Acknowledgements</a></li> </ol> </details> <!-- ABOUT THE PROJECT --> ## About The Project [![Product Name Screen Shot][Screenshot of gameplay and test list]](https://www.dropbox.com/s/mu1rrbx2mqowjkn/studio-game.png?dl=0) This game is a project built following the [Pragmatic Studio Ruby Course](https://online.pragmaticstudio.com/courses/ruby/). I absolutely adored going through this course, because it was unlike other courses in that the main focus wasn't syntax, but how to build a principle-driven, object-oriented program that contains many of the skills we'd need to build real-world projects. The instructors purposefully created exercises to let us build a program using the skills they demonstrated by building a different program. This wasn't a copy and paste kind of course. This game was actually my second run-through, where I test-drove everything from the start based on the objectives only. Skills I valued developing further with this project: - Test-driven development (50+ tests). - Using inheritance to model "is-a" relationships. For example, a clumsy player *is a* kind of player. - Using mixins (modules) to reuse behaviours that are common between classes, but should not be modeled with an inheritance relationship. A good tip was to look for 'able' behaviors in a class to extract, like 'playable', 'printable', 'taxable' etc. - Using a file block which lets you add in class usage examples that are only run when you run the class file specifically. - Overriding default methods (like sort, and renaming things so that they keep a specific format) Things I struggled with: - Testing behaviour that uses blocks. I had a lightbulb moment when I realised I should test the behaviour performed inside the block on a single item. Testing the output of an entire block is like testing Ruby syntax works. Alternatively, test the before and after state of something that changes as a result of using a block. Cooool. - Puts. It felt wrong to use puts to show the output in the console. I'd like to learn how to seperate the view logic for a command-line project later. Things I did to make it my own: - Wrote a lot more tests for my second run-through. - Noticed and extracted further 'able' behaviours into modules (like printing stats, formatting output and handling csv files). ### Built With * [Ruby (language)](https://www.ruby-lang.org/en/) * [RSpec (framework)](https://rspec.info/) * [Vim (text-editor)](https://www.vim.org/) <!-- GETTING STARTED --> ## Getting Started To get a local copy up and running follow these steps: ### Prerequisites This is an example of how to list things you need to use the software and how to install them. * gem ```sh npm install npm@latest -g ``` ### Installation 1. Install the gem ```sh gem install studio_game_2021 ``` <!-- USAGE EXAMPLES --> ## Usage To play a game from the command-line, open a new command project and run the command-line script like so: ```sh studio_game ``` Or, if you'd like to use the game as a library, here's an example of how to use it in `irb`. You can also check the bottom of each class or module file for further usage instructions ``` >> require 'studio_game/game' => true >> game = StudioGame::Game.new("Knuckleheads") => #<StudioGame::Game:0x007fdea10252d8 @title="Knuckleheads", @players=[]> >> player = StudioGame::Player.new("Moe", 90) => I'm Moe with health = 90, points = 0, and score = 90. >> game.add_player(player) => [I'm Moe with health = 90, points = 0, and score = 90.] >> game.play(1) ``` <!-- ROADMAP --> ## Roadmap I plan to customize this game further now that I have a solid foundation to explore from. It'll be fun to let the players interact with each other more, like swapping treasures, and maybe add some kind of board game with it's own features. That's my next focus. ## Contributing Feel free to fork this project and play around with it. Open to feedback-related pr requests. <!-- LICENSE --> ## License Distributed under the MIT License. See `LICENSE` for more information. <!-- CONTACT --> ## Contact Becca - [@becca9941](https://twitter.com/Becca9941) - becca@essentialistdev.com Project Link: [https://gitlab.com/EssentialistDev/studio-game](https://gitlab.com/EssentialistDev/studio-game) <!-- ACKNOWLEDGEMENTS --> ## Acknowledgements - [Pragmatic Studio](https://online.pragmaticstudio.com/courses/ruby/) for empowering me with awesome new development skills. - [Best-README-Template](https://github.com/Becca9941/Best-README-Template) for helping me write a README for this project.