An evented streaming XML parser in JavaScript
Schematics specific to Angular
Utilities for packing and unpacking npm packages
Persistent ordered mapping from strings
A tiny, PEG-like system for building language grammars with regexes.
Utility functions to deal with references in objects
Low footprint ECMAScript source code parser
An evented streaming XML parser in JavaScript
A collection of fast approximations to common geographic measurements.
a glob matcher in javascript
An LRU cache of weak references
A sorted list of key-value pairs in a fast, typed in-memory B+ tree with a powerful API.
Display intelligible realtime output from concurrent processes
Language service for CSS, LESS and SCSS
Easily handle defaults for your options
Escape RegExp special characters
Find the position of grapheme cluster breaks in a string
An evented streaming XML parser in JavaScript
Blazing fast input validation and transformation ⚡
Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a bet
Reads segments from a m3u8 or dash playlist into a consumable stream.
Types for the DOM, and other web technologies in browsers
Temporary file and directory creator
Language service for HTML
Add "not given" default values to your objects.
A library for queues that can only release so much information over a given timespan
Converts between fractional, decimal and moneyline odds for betting and gambling. Calculates how much can be won on a given stake.
You can easily make your plain Ruby Test::Unit test cases clean and clear with Given/When/Then, placeholder values, and textual descriptions without resorting to metaprogramming or complex frameworks. Use as much or as little as you like
Creates enumerators that step through integers from a union of two multiples. A pattern from the two numbers is determined (much like two frequencies create a pattern) and the resulting palindrome is given to a custom Enumerator for you to use.
This gem provides an easy way to estimate how much income tax you owe in a given year. This is to be used as an estimate only. This gem is not a replacement for CPA services. Please consult your CPA for anything tax related.
Log4jruby is a thin wrapper around the Log4j Logger. It is geared more toward those who are using JRuby to integrate with and build on top of Java code that uses Log4j. The Log4jruby::Logger provides an interface much like the standard ruby Logger. Your ruby loggers are given a .jruby prefix and can be configured along with the loggers for your Java code.
A job dollar is an objective measure of the strength of the job market for entry-level workers using a given programming language and framework. It is a composite measure of work, like kilowatt-hours or Joules, and it measures how much work the market has done for you.
What if I ask you: "What country is 'ontario'", or "where is 'ca'"? I would answer: Ontario is a state in Canada and a city in California. CA is the ISO abbreviation for Canada, and also the abbreviation for California. The goal of this gem is such: Given a string, do your very best to identify all possible locations, and order them by significance. Provide as much information as possible; What kind of region is this? Country? City? Island? Continent?
<p>Sass or the much better approach of scss is really helpful and a big silver bullet for my css structuring in ruby projects.</p> \ <p>Standard sass command works for whole directories or single files only. In general it gets the jobs we want done, but in practical usage i think the sass command tool is a little bit unconvinient. A common scenario for me is, \ that you have whole bunch of sass files, which you want to compile to a single compressed output file. But if you have splitted your sass files in component based modules and you want to watch the complete folder you have to care for dependency handling in each file, because each file will be compiled for its own.</p> \ <pre># compiling a complete folder with scss ~ $ sass css/scss:css/compiled</pre> \ <p>So converting the whole folder is not what i want, because i don\'t want to import for example my color.sass config file in each module again. Compiling a single file seems to be the better solution, and it works in general, as expected, but the devil is in the detail. </p> <pre># compiling a single file where the other files are imported. ~ $ sass css/scss/main.scss:css/compiled/main.css</pre> \ <p>If we change a file with impact to our main.sass file, the --watch handle will not get it, because it observes only the timestamp of the given main.sass.</p> <p>Here is it, where mindful_sass tries to help out. You use it according to the single file variant of sass, but it tries to observe the whole folder the given sass file is placed. If a timestamp of file in the sass folder or its children changes it will compile the specified main.sass again.</p> \ <p>This gem is not aimed to replace anything in the sass universe. It is only a wrapper to avoid the described unconvinience, and i hope that it gets useless as fast as possible, because the sass development gets this feature done for themselves.</p> \ <p>Thanks anyway to the sass developer team.</p>
== FEATURES/PROBLEMS: * Failure is incredibly ungraceful, though generally unlikely, given that the requirements for accessing the Trac site are roughly the same as those for accessing the repository. * Currently, the trac user/pass must be the same as the SCM user/pass. It remains to be seen how much of a problem this will be. == SYNOPSIS: Include the recipes: require 'capistrano_trac/recipes' For the trac tasks to work, the :trac_url variable must be set to the root of your trac site. For example: set :trac_url, "http://www.yourtrachost/trac/yourproject" The 2 trac ticketing tasks are designed to be run in conjunction with a deployment or rollback, although this isn't mandatory. To automatically document deployments and rollbacks in your capistrano deployment, add the lines: * after "deploy", "trac:record_deployment" * before "deploy:rollback", "trac:record_rollback" Order is important, otherwise the tasks will be looking at the wrong revisions. To manually record changes, simply run the record_deployment task to document the most recent deployment changes, or the record_rollback task to document a rollback that is about to be run. == REQUIREMENTS: * capistrano >= 2.0.0 * mechanize >= 0.6.10 == INSTALL: * sudo gem install capistrano_trac == LICENSE: (The MIT License) Copyright (c) 2007 FIX Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
# SecureDataBag / Knife Secure Bag Knife Secure Bag provides a consistent interface to DataBagItem, EncryptedDataBagItem as well as the custom created SecureDataBagItem while also providing a few extra handy features to help in your DataBag workflows. SecureDataBagItem, can not only manage your existing DataBagItems and EncryptedDataBagItems, but it also provides you with a DataBag type which enables you to selectively encrypt only some of the fields in your DataBag thus allowing you to be able to search for the remaining fields. ## Installation To build and install the plugin add it your Gemfile or run: ```shell gem install secure_data_bag ``` ## Configuration #### Knife Secure Bag Defaults for the Knife command may be provided in your _knife.rb_ file. ```ruby knife[:secure_data_bag][:encrypted_keys] = %w( password ssh_keys ssh_ids public_keys private_keys keys secret ) knife[:secure_data_bag][:secret_file] = "#{local_dir}/secret.pem" knife[:secure_data_bag][:export_root] = "#{kitchen_dir}/data_bags" knife[:secure_data_bag][:export_on_upload] = true knife[:secure_data_bag][:defaults][:secrets][:export_format] = 'plain' ``` To break this up: `knife[:secure_data_bag][:encrypted_keys] = []` When Knife Secure Bag encrypts a hash with an _encryption format_ of *nested*, it will recursively walk through the hash from the bottom up and encrypt any key found within this array. `knife[:secure_data_bag][:secret_file]` When encryption is required, the shared secret found at this location will be loaded. `knife[:secure_data_bag][:export_root]` When exporting a data\_bag\_item, files will be created in below this root directory. Typically this would be the data\_bag folder located within your kitchen. `knife[:secure_data_bag][:export_on_upload]` When a data\_bag\_item is edited using `knife secure bag edit`, it may be automatically exported to the _export\_root_. `knife[:secure_data_bag][:defaults][:secrets][:export_format]` The configuration file additionally supports the _defaults_ hash which provides default values for all _command line arguments_ that one might use. Of all of them only the _export\_format_ key is likely to be of much use. ## Examples #### Chef cookbook recipe ```ruby metadata = {} # Define the keys we wish to encrypt metadata[:encrypted_keys] = %w(encoded) # Optionally load a specific shared secret. Otherwise, the global # encrypted\_data\_bag\_secret will be automatically used. secret_key = SecureDataBagItem.load_key("/path/to/secret") # Create a hash of data to use as an exampe raw_data = { id: "item", data_bag: "data_bag", encoded: "my string", unencoded: "other string" } # Instantiate a SecureDataBagItem from a hash item = SecureDataBagItem.from_hash(data, metadata) # Or more explicitely item = SecureDataBagItem.from_hash(data, encrypted_keys: %w(encoded)) # Or load from server item = SecureDataBagItem.load("data_bag", "item") # Print the un-encrypted raw data pp item.raw_data # Print the un-encrypted `encoded` key pp item['encoded'] # Print the encrypted hash as a data_bag_item hash pp item.to_hash =begin { id: "item", data_bag: "data_bag", encoded: { encrypted_data: "encoded", cipher: aes-256-cbc, iv: 13453453dkgfefg== version: 1 } unencoded: "other string", } =end ``` ## Usage #### Knife commands Print an DataBagItem, EncryptedDataBagItem or SecureDataBagItem, auto-detecting the encryption method used as plain text. ```shell knife secure bag show -F js secrets secret_item ``` Print an DataBagItem, EncryptedDataBagItem or SecureDataBagItem, auto-detecting the encryption method used as a SecureDataBagItem in encrypted format. ```shell knife secure bag show -F js secrets secret_item --enc-format nested ``` Edit an EncryptedDataBagItem, preserve it's encryption type, and export a copy to the _data\_bag_ folder in your kitchen. ```shell knife secure bag edit secrets secret_item --export ``` ## Knife SubCommands Most of the SubCommands support the following command-line options: `--enc-format [plain,encrypted,nested]` Ensure that, when displaying or uploading the data\_bag\_item, we forcibly encrypt the data\_bag\_item using the specified format instead of preserving the existing format. In this case: - plain: refers to a DataBagItem - encrypted: refers to an EnrytpedDataBagItem - nested: refers to a SecureDataBagItem `--dec-format [plain,encrypted,nested]` Attempt to decrypt the data\_bag\_item using the given format rather than the auto-detected one. The only real reason to use this is when you wish to specifically select _plain_ as the format so as to not decrypt the item. `--enc-keys key1,key2,key3` Provide a comma delimited list of hash keys which should be encrypted when encrypting the data\_bag\_item. This list will be concatenated with any key names listed in the configuration file or which were previously encrypted. `--export` Export the data\_bag\_item to json file in either of _export-format_ or _enc-format_. `--export-format` Overrides the encryption format only for the _export_ feature. `--export-root` Root directly under which a folder should exist for each _data_bag_ into which to export _data_bag_items_ as json files. When displaying the content of the _data\_bag\_item_, an additional key of *_secure_metadata* will be added to the output which contains gem specific metadata such as the encryption formats and any encrypted keys found. This key will _not_ be saved with the item, however it may be manipulated to alter the behavior of the _edit_ or _export_ commands. #### knife secure bag show DATA_BAG ITEM This command functions just like `knife data bag show` and is used to print out the content of either a DataBagItem, EncryptedDataBagItem or SecureDataBagItem. By default, it will auto-detect the Item type, and print it's unencrypted version to the terminal. This behavior, however, may be altered using the previously mentioned command line options. #### knife secure bag open PATH This commands functions much like `knife secure bag show`, however it is designed to load a _data\_bag\_item_ from disk as opposed to loading it from Chef server. This may be of use when view the content of an exported encrypted file. #### knife secure bag edit DATA_BAG DATA_BAG_ITEM This command functions just like `knife data bag edit` and is used to edit either a DataBagItem, EncryptedDataBagItem or a SecureDataBagItem. It supports all of the same options as `knife secure bag show`. #### knife secure bag from file DATA_BAG PATH This command functions just like `knife data bag from file` and is used to upload either a DataBagItem, EncryptedDataBagItem or a SecureDataBagItem. It supports all of the same options as `knife secure bag show`. ## Recipe DSL The gem additionally provides a few Recipe DSL methods which may be useful. ```ruby load_secure_item = secure_data_bag_item( data_bag_name, data_bag_item, cache: false ) load_plain_item = data_bag_item(data_bag_name, data_bag_item) convert_plain_to_secure = secure_data_bag_item!(load_plain_item) ```