Results for com-class

com-rb common library classes.

Adiciona classes e metodos para se trabalhar com cotação de moedas

# COM # COM is an object-oriented wrapper around WIN32OLE. COM makes it easy to add behavior to WIN32OLE objects, making them easier to work with from Ruby. ## Usage ## Using COM is rather straightforward. There’s basically four concepts to keep track of: 1. COM objects 2. Instantiable COM objects 3. COM events 4. COM errors Let’s look at each concept separately, using the following example as a base. module Word end class Word::Application < COM::Instantiable def without_interaction with_properties('displayalerts' => Word::WdAlertsNone){ yield } end def documents Word::Documents.new(com.documents) end def quit(saving = Word::WdDoNotSaveChanges, *args) com.quit saving, *args end end ### COM Objects ### A COM::Object is a wrapper around a COM object. It provides error specialization, which is discussed later and a few utility methods. You typically use it to wrap COM objects that are returned by COM methods. If we take the example given in the introduction, Word::Documents is a good candidate: class Word::Documents < COM::Object DefaultOpenOptions = { 'confirmconversions' => false, 'readonly' => true, 'addtorecentfiles' => false, 'visible' => false }.freeze def open(path, options = {}) options = DefaultOpenOptions.merge(options) options['filename'] = Pathname(path).to_com Word::Document.new(com.open(options)) end end Here we override the #open method to be a bit easier to use, providing sane defaults for COM interaction. Worth noting is the use of the #com method to access the actual COM object to invoke the #open method on it. Also note that Word::Document is also a COM::Object. COM::Object provides a convenience method called #with_properties, which is used in the #without_interaction method above. It lets you set properties on the COM::Object during the duration of a block, restoring them after it exits (successfully or with an error). ### Instantiable COM Objects ### Instantiable COM objects are COM objects that we can connect to and that can be created. The Word::Application object can, for example, be created. Instantiable COM objects should inherit from COM::Instantiable. Instantiable COM objects can be told what program ID to use, whether or not to allow connecting to an already running object, and to load its associated constants upon creation. The program ID is used to determine what instantiable COM object to connect to. By default the name of the COM::Instantiable class’ name is used, taking the last two double-colon-separated components and joining them with a dot. For Word::Application, the program ID is “Word.Application”. The program ID can be set by using the .program_id method: class IDontCare::ForConventions < COM::Instantiable program_id 'Word.Application' end The program ID can be accessed with the same method: Word::Application.program_id # ⇒ 'Word.Application' Connecting to an already running COM object is not done by default, but is sometimes desirable: the COM object might take a long time to create, or some common state needs to be accessed. If the default for a certain instantiable COM object should be to connect, this can be done using the .connect method: class Word::Application < COM::Instantiable connect end If no running COM object is available, then a new COM object will be created in its stead. Whether or not a class uses the connection method can be queried with the .connect? method: Word::Application.connect? # ⇒ true Whether or not to load constants associated with an instantiable COM object is set with the .constants method: class Word::Application < COM::Instantiable constants true end and can similarly be checked: Word::Application.constants? # ⇒ true Constants are loaded by default. When an instance of the instantiable COM object is created, a check is run to see if constants should be loaded and whether or not they already have been loaded. If they should be loaded and they haven’t already been loaded, they’re, you guessed it, loaded. The constants are added to the module containing the COM::Instantiable. Thus, for Word::Application, the Word module will contain all the constants. Whether or not the constants have already been loaded can be checked with .constants_loaded?: Word::Application.constants_loaded # ⇒ false That concludes the class-level methods. Let’s begin with the #connected? method among the instance-level methods. This method queries whether or not this instance connected to an already running COM object: Word::Application.new.connected? # ⇒ false This can be very important in determining how shutdown of a COM object should be done. If you connected to an already COM object it might be foolish to shut it down if someone else is using it. The #initialize method takes a couple of options: * connect: whether or not to connect to a running instance * constants: whether or not to load constants These options will, when given, override the class-level defaults. ### Events ### COM events are easily dealt with: class Word::Application < COM::Instantiable def initialize(options = {}) super @events = COM::Events.new(com, 'ApplicationEvents', 'OnQuit') end def quit(saving = Word::WdDoNotSaveChanges, *args) @events.observe('OnQuit', proc{ com.quit saving, *args }) do yield if block_given? end end end To tell you the truth this API sucks and will most likely be rewritten. The reason that it is the way it is is that WIN32OLE, which COM wraps, sucks. It’s event API is horrid and the implementation is buggy. It will keep every registered event block in memory for ever, freeing neither the blocks nor the COM objects that yield the events. ### Errors ### All errors generated by COM methods descend from COM::Error, except for those cases where a Ruby error already exists. The following HRESULT error codes are turned into Ruby errors: HRESULT Error Code | Error Class -------------------|------------ 0x80004001 | NotImplementedError 0x80020005 | TypeError 0x80020006 | NoMethodError 0x8002000e | ArgumentError 0x800401e4 | ArgumentError There are also a couple of other HRESULT error codes that are turned into more specific errors than COM::Error: HRESULT Error Code | Error Class -------------------|------------ 0x80020003 | MemberNotFoundError 0x800401e3 | OperationUnavailableError Finally, when a method results in any other error, a COM::MethodInvocationError will be raised, which can be queried for the specifics, specifically #message, #method, #server, #code, #hresult_code, and #hresult_message. ### Pathname ### The Pathname object receives an additional method, #to_com. This method is useful for when you want to pass a Pathname object to a COM method. Simply call #to_com to turn it into a String of the right encoding for COM: Word::Application.new.documents.open(Pathname('a.docx').to_com) # ⇒ Word::Document ## Installation ## Install COM with % gem install com ## License ## You may use, copy and redistribute this library under the same [terms][1] as Ruby itself. [1]: http://www.ruby-lang.org/en/LICENSE.txt ## Contributors ## * Nikolai Weibull

Think of Executable as a COM, a Commandline Object Mapper, in much the same way that ActiveRecord is an ORM. A class utilizing Executable can define a complete command line tool using nothing more than Ruby's own method definitions.

Compatible with Resque 1.x. Use Resque.push if you are using >= 2.x. Resque is great. So is job processing with redis. Our biggest drawback has been that resque requires the class that will be processing a job to be loaded when the job is enqueued. But what happens when the implementing job is defined in a separate application and isn't currently loaded into memory? Enter Resque Remote. Resque Remote's simple goal is to allow you to add a job to a queue with a string identifier for the class rather than the class constant. It is assumed that the worker-side of the equation _will_ have the class in memory and hence will be able to run it no problem. Feedback, comments and questions are welcome at bj [dot] neilsen [at] gmail [dot] com.

SemillaGen let's you create (Actionscript3.0 based) projects and classes with ease. SemillaGen generated projects or classes are customizable via templates. The default templates setup the project for Continuous Integration using FlexUnit. the default class template creates a class and a test case automatically. usage: To create a new project run: $ semillagen project MyAwesomeProject $ ls MyAwesomeProject To create a new class with test case: $ cd MyAwesomeProject $ semillagen class com.semilla.MillionDollarClass You will see that semillagen created the following files: src/com/semilla/MillionDollarClass.as test-src/com/semilla/MillionDollarClassTest.as The default template is ready for building as soon as created. To build and test your project we use rake. $ rake Rake will build a debug and release versions of your project. It will also create a FlexUnit test swf and run the test. You will see the results of the tests and also you will see some xml files under the [test-report] folder. These reports are JUnit compatible. You can use a CI tool like Jenkins to automatically build and test your project.

== Glossa is a tool for generating simple naming language generators (which can in turn generate names). Note: Version 1.0.0 is an (almost) direct port of {mewo2's JavaScript naming-language generator}[https://github.com/mewo2/naming-language]. These initial ideas are his, and I have changed very little of the actual inner-workings (other than basically turn it into a class). I would _highly_ encourage everybody to go and checkout his original repo (link above), {read his documentation on how the language generator works}[http://mewo2.com/notes/naming-language/], and {follow @unchartedatlas}[https://twitter.com/unchartedatlas]

# StudioGame (Alec) Jogo de terminal em Ruby com **jogadores, dados, tesouros e variações de jogadores** (Clumsy e Berserk), empacotado como gem. > Nome do gem (exemplo): `studio_game_alec` --- ## 🚀 Instalação e execução ### Rodando direto do código-fonte No diretório do projeto: ```bash ruby bin/studio_game ``` Se você não passar um arquivo de jogadores via CLI, o script usa o `players.csv` que fica em `bin/` por padrão. Também funciona passando um CSV na linha de comando: ```bash ruby bin/studio_game my_favorite_players.csv ``` ### Como gem (local) Empacote e instale localmente: ```bash gem build studio_game.gemspec gem install studio_game_alec-<versao>.gem ``` Depois rode: ```bash studio_game ``` > No Windows, o executável será resolvido pelo RubyGems. Se preferir, rode: `ruby bin/studio_game`. --- ## 📁 Estrutura do projeto ``` games/ ├─ bin/ │ ├─ studio_game # script principal (tem shebang) │ └─ players.csv # CSV padrão (nome,vida) ├─ lib/ │ └─ studio_game/ │ ├─ auditable.rb │ ├─ berserk_player.rb │ ├─ clumsy_player.rb │ ├─ die.rb │ ├─ game.rb │ ├─ game_turn.rb │ ├─ loaded_die.rb │ ├─ playable.rb │ ├─ player.rb │ └─ treasure_trove.rb ├─ spec/ │ └─ studio_game/ # specs RSpec ├─ LICENSE ├─ README.md └─ studio_game.gemspec ``` - **Namespace:** todo o código vive dentro do módulo `StudioGame` para evitar colisões. - **bin/studio_game:** script CLI com shebang (`#!/usr/bin/env ruby`). Faz _fallback_ do `$LOAD_PATH` para `lib` quando usado fora da gem. - **lib/studio_game/**: código da biblioteca (classes/módulos). - **spec/**: testes RSpec. --- ## 🧩 Conceitos principais - **Player** (`player.rb`): representa um jogador com `name`, `health`, coleta tesouros e calcula `score` (= `health` + `points`). Inclui o mixin **Playable**. - **Playable** (`playable.rb`): mixin com `w00t`, `blam` e `strong?` (altera/consulta `health` via getters/setters). - **TreasureTrove** (`treasure_trove.rb`): define `Treasure = Struct.new(:name,:points)` e a constante `TREASURES`; possui `.random`. - **Die/LoadedDie** (`die.rb`, `loaded_die.rb`): rolam valores (o carregado favorece 1,1,2,5,6,6). Ambos incluem **Auditable**. - **Auditable** (`auditable.rb`): imprime “Rolled a X (DieClass)” após cada rolagem. - **Game** (`game.rb`): agrega jogadores, carrega CSV, executa rodadas, soma pontos e salva _high scores_. - **GameTurn** (`game_turn.rb`): executa a lógica de um turno para um jogador (rola dado, aplica `blam/w00t/skip` e concede tesouro). - **ClumsyPlayer / BerserkPlayer**: variações de `Player` que modificam comportamento de `w00t` e de coleta de tesouros. --- ## 🧪 Testes Rode todos os testes: ```bash rspec ``` Principais coisas testadas: - Ordenação de jogadores por `score` (usa `<=>` em `Player`). - Cálculo de `points` e `score` (soma de tesouros + vida). - Efeitos de `w00t`/`blam` e força (`strong?`). - Lógica de turno com _stubs_ de dado (`allow_any_instance_of(LoadedDie).to receive(:roll).and_return(n)`). - Comportamentos de `ClumsyPlayer` e `BerserkPlayer`. --- ## 📦 CSVs e caminhos - `bin/studio_game` resolve o CSV padrão assim: ```ruby default_player_file = File.join(File.dirname(__FILE__), 'players.csv') game.load_players(ARGV.shift || default_player_file) ``` - Você pode passar um arquivo `.csv` via CLI como primeiro argumento. Formato do CSV: ``` Moe,100 Larry,60 Curly,125 ``` --- ## 🧾 High Scores Após sair do loop, o jogo grava `high_score.txt` com as entradas ordenadas. Cada linha é formatada por `Game#high_score_entry`: ``` <nome com padding de pontos> <score> ``` --- ## 🛠️ Dicas de desenvolvimento - Use `require 'studio_game/arquivo'` quando a gem estiver instalada. - No script binário, o `begin/rescue LoadError` faz _fallback_ para `$LOAD_PATH` local, útil fora da gem. - Para debugar I/O em testes, o spec redireciona `STDOUT` (`$stdout = StringIO.new`). --- ## 📚 Licença MIT – veja o arquivo `LICENSE`.

= dm-is-published This plugin makes it very easy to add different states to your models, like 'draft' vs 'live'. By default it also adds validations of the field value. Originally inspired by the Rails plugin +acts_as_publishable+ by &lt;b&gt;fr.ivolo.us&lt;/b&gt;. == Installation # Add GitHub to your RubyGems sources $ gem sources -a http://gems.github.com $ (sudo)? gem install kematzy-dm-is-published &lt;b&gt;NB! Depends upon the whole DataMapper suite being installed, and has ONLY been tested with DM 0.10.0 (next branch).&lt;/b&gt; == Getting Started First of all, for a better understanding of this gem, make sure you study the '&lt;tt&gt;dm-is-published/spec/integration/published_spec.rb&lt;/tt&gt;' file. ---- Require +dm-is-published+ in your app. require 'dm-core' # must be required first require 'dm-is-published' Lets say we have an Article class, and each Article can have a current state, ie: whether it's Live, Draft or an Obituary awaiting the death of someone famous (real or rumored) class Article include DataMapper::Resource property :id, Serial property :title, String ...&lt;snip&gt; is :published end Once you have your Article model we can create our Articles just as normal Article.create(:title =&gt; 'Example 1') The instance of &lt;tt&gt;Article.get(1)&lt;/tt&gt; now has the following things for free: * a &lt;tt&gt;:publish_status&lt;/tt&gt; attribute with the value &lt;tt&gt;'live'&lt;/tt&gt;. Default choices are &lt;tt&gt;[ :live, :draft, :hidden ]&lt;/tt&gt;. * &lt;tt&gt;:is_live?, :is_draft? or :is_hidden?&lt;/tt&gt; methods that returns true/false based upon the state. * &lt;tt&gt;:save_as_live&lt;/tt&gt;, &lt;tt&gt;:save_as_draft&lt;/tt&gt; or &lt;tt&gt;:save_as_hidden&lt;/tt&gt; converts the instance to the state and saves it. * &lt;tt&gt;:publishable?&lt;/tt&gt; method that returns true for models where &lt;tt&gt;is :published &lt;/tt&gt; has been declared, but &lt;b&gt;false&lt;/b&gt; for those where it has not been declared. The Article class also gets a bit of new functionality: Article.all(:draft) =&gt; finds all Articles with :publish_status = :draft Article.all(:draft, :author =&gt; @author_joe ) =&gt; finds all Articles with :publish_status = :draft and author == Joe Todo Need to write more documentation here.. == Usage Scenarios In a Blog/Publishing scenario you could use it like this: class Article ...&lt;snip&gt;... is :published :live, :draft, :hidden end Whereas in another scenario - like in a MenuItem model for a Restaurant - you could use it like this: class MenuItem ...&lt;snip&gt;... is :published :on, :off # the item is either on the menu or not end == RTFM As I said above, for a better understanding of this gem/plugin, make sure you study the '&lt;tt&gt;dm-is-published/spec/integration/published_spec.rb&lt;/tt&gt;' file. == Errors / Bugs If something is not behaving intuitively, it is a bug, and should be reported. Report it here: http://github.com/kematzy/dm-is-published/issues == Credits Copyright (c) 2009-07-11 [kematzy gmail com] Loosely based on the ActsAsPublishable plugin by [http://fr.ivolo.us/posts/acts-as-publishable] == Licence Released under the MIT license.

# Crowdfund (Alec) Ferramenta de linha de comando e biblioteca Ruby para simular um programa de **arrecadação de fundos** com rodadas, promessas (pledges) e diferentes tipos de projetos (básico, com *matching*, e *grant*). ## Instalação ```bash gem install crowdfund_alec ``` Ou rode a partir do código-fonte: ```bash ruby bin/crowdfund ``` ## Como funciona - Você carrega projetos via CSV (nome, fundos_iniciais, meta). - Em cada rodada, um dado é rolado para **adicionar** (+25) ou **remover** (–15) fundos do projeto. - Em paralelo, o projeto recebe **pledges** aleatórios: bronze ($50), silver ($75), gold ($100). - Projetos podem ter comportamento especial: - **MatchingProject**: quando chega a 50% da meta, cada `add_fund` passa a dobrar (+50). - **GrantProject**: nunca perde fundos em `remove_fund`. - Ao sair, o relatório salva os **subfinanciados** em `needmoremoney.txt` e imprime estatísticas. ## Uso (CLI) ```bash # (1) CSV padrão (bin/projects.csv) ruby bin/crowdfund # (2) Informando um CSV customizado ruby bin/crowdfund caminho/para/projetos.csv ``` Durante a execução: - Digite um número para a quantidade de rodadas. - Digite `q` ou `e` para sair e ver o relatório final. ### Formato do CSV ``` NomeDoProjeto,fundos_iniciais,meta BuyaBoat,5,10000 TraveltoVictoriaIsland,5,3000 GetaPuppy,5,300 ``` ## Saída esperada - Resumo por rodada dos fundos e pledges recebidos. - Arquivo `needmoremoney.txt` contendo: - Título do relatório. - Projetos totalmente financiados. - Projetos subfinanciados ordenados por **quanto falta**. - Snapshot CSV de todos os projetos. ## API (uso como biblioteca) Requerendo as classes principais: ```ruby require 'crowdfund/project' require 'crowdfund/fund_request' ``` Criando projetos e executando rodadas: ```ruby project = Project.new("My App", 500, 2000) funding = FundRequest.new("Startup do Alec") funding.add_project(project) funding.request_funding(5) funding.print_results ``` ### Classes principais - `Project` - Atributos: `name`, `fund_amount`, `target_fund_amount` - Métodos: `add_fund`, `remove_fund`, `funds_needed`, `funded?`, `received_pledge`, `pledges`, `total_funds`, `each_received_pledge`, `to_csv`, `status` - `FundRequest` - Gerencia lista de projetos, executa rodadas, imprime e salva relatórios. - `MatchingProject < Project` - Dobra `add_fund` quando `halfway_funded?` (>= 50% da meta). - `GrantProject < Project` - Sobrescreve `remove_fund` para nunca diminuir fundos. - `Pledgesmod` - Constante `PLEDGES` e `.random` para escolher bronze/silver/gold. - `FundingRound` - Regras de uma rodada: rola `Die`, aplica `add/remove`, atribui pledge. - `Fundable` (mixin) - Implementa `add_fund`, `remove_fund`, `funds_needed`, `funded?`. - `Die` - D6 simples com `roll`. ## Testes Rodar todos os testes: ```bash rspec ``` Principais cenários cobertos: - Regras de `add_fund`/`remove_fund`. - Comportamento de `MatchingProject` e `GrantProject`. - Integração de `FundingRound` e `Pledgesmod`. - Geração do relatório em `FundRequest`. ## Licença MIT — consulte o arquivo `LICENSE`.

No description provided.

No description provided.

No description provided.

No description provided.

No description provided.

No description provided.

No description provided.

No description provided.

No description provided.

No description provided.

No description provided.

No description provided.