Environment Variables

Library which allows you to check and sanitize you environment variables, raising exception if required variables are not configured, type-casting non-string variables and exposing them using an idiomatic API.

The `envfile(1)` program is a program to run another program; much like `sudo(1)` or `chroot(1)`. The difference is that this program is designed to modify environment variables before that.

Create configuration files from templates using environment variables or property lists. Save as text, yaml and json

ROS Ruby Client: rosruby ======= [ROS](http://ros.org) is Robot Operating System developed by [Willow Garage](http://www.willowgarage.com/) and open source communities. This project supports ruby ROS client. You can program robots by ruby, very easily. **Homepage**: http://otl.github.com/rosruby **Git**: http://github.com/OTL/rosruby **Author**: Takashi Ogura **Copyright**: 2012 **License**: new BSD License **Latest Version**: 0.2.0 Requirements ---------- - ruby (1.8.x/1.9.x) - ROS (electric/fuerte) - ROS requires python2.7 or more libraries Let's start --------------- Install ROS and ruby first. ROS document is [http://ros.org/wiki/ROS/Installation](http://ros.org/wiki/ROS/Installation) . You can install ruby by apt. ```bash $ sudo apt-get install ruby ``` Download rosruby into your ROS_PACKAGE_PATH. ````bash $ git clone git://github.com/OTL/rosruby.git ``` please add RUBYLIB environment variable, like below (if you are using bash). ```bash $ echo "export RUBYLIB=`rospack find rosruby`/lib" >> ~/.bashrc $ source ~/.bashrc ``` To use with precompiled electric release ----------------------- If you are using precompiled ROS distro, use the msg/srv generation script (rosruby_genmsg.py) If you are using ROS from source, it requires just recompile the msg/srv packages by rosmake rosruby. ```bash $ rosrun rosruby rosruby_genmsg.py ``` This converts msg/srv to .rb which is needed by sample programs. If you want to make other packages, add package names for args. For example, ```bash $ rosrun rosruby rosruby_genmsg.py geometry_msgs nav_msgs ``` Sample Source -------------- ## Subscriber ```ruby #!/usr/bin/env ruby require 'ros' require 'std_msgs/String' node = ROS::Node.new('/rosruby/sample_subscriber') node.subscribe('/chatter', Std_msgs::String) do |msg| puts "message come! = \'#{msg.data}\'" end while node.ok? node.spin_once sleep(1) end ``` ## Publisher ```ruby #!/usr/bin/env ruby require 'ros' require 'std_msgs/String' node = ROS::Node.new('/rosruby/sample_publisher') publisher = node.advertise('/chatter', Std_msgs::String) msg = Std_msgs::String.new i = 0 while node.ok? msg.data = "Hello, rosruby!: #{i}" publisher.publish(msg) sleep(1.0) i += 1 end ``` Note ---------------- Ruby requires 'Start with Capital letter' for class or module names. So please use **S**td_msgs::String class instead of **s**td_msgs::String. Try Publish and Subscribe ---------------------- You needs three terminal as it is often for ROS users. Then you run roscore if is not running. ```bash $ roscore ``` run publisher sample ```bash $ rosrun rosruby sample_publisher.rb ``` run subscription sample ```bash $ rosrun rosruby sample_subscriber.rb ``` you can check publication by using rostopic. ```bash $ rostopic list $ rostopic echo /chatter ``` Try Service? ---------------------- ```bash $ rosrun rosruby add_two_ints_server.rb ``` run client with args ('a' and 'b' for roscpp_tutorials/TwoInts) ```bash $ rosrun rosruby add_two_ints_client.rb 10 20 ``` and more... ---------------------- You need more tools for testing, generating documentations. ```bash $ sudo apt-get install rake gem $ sudo gem install yard redcarpet simplecov ``` do all tests ------------------------- run roscore if is not running. ```bash $ roscore ``` and run the unit tests. ```bash $ roscd rosruby $ rake test ``` documents -------------------------- you can generate API documents using yard. Document generation needs yard and redcarpet. You can install these by gem command like this. ```bash $ gem install yard redcarpet ``` Then try to generate documentds. ```bash $ rake yard ``` You can access to the generated documents from [here](http://otl.github.com/rosruby/doc/).

sw, or SourceWinBat, is a utility to run Windows batch files from WSL / MSYS2 / Cygwin and sync environment variables, doskeys, and working directories between batch files and their UNIX shell environments.

Allows smtp settings to be defined as URL in environment variable, then converted to hash for use in Mail/ActionMailer

Instance variables from the raised exception are included as parameters in the Airbrake notification. Currently only active in DelayedJob jobs. Meant to be used in a Rails environment.

Gem to unify reading configuration from env variables.

This plugin adds a dbdump command which dumps your Rails database out. This master branch supports Rails 3.0 and above, as a gem command. For Rails 2.3, use the rails_2_3 branch from github and install as a plugin. Like rails dbconsole, it takes your database connection details from config/database.yml, and supports mysql, mysql2, postgresql, and sqlite. It takes the same options as rails dbconsole, ie. -p to supply the password to your dump program for mysql and postgresql. (Note that for mysql, this means that the password is visible when other users on the system run 'ps'. Postgresql does not have this problem as it uses an environment variable set in ENV before execing and so not visible in ps.)

When environment variables are not enough and you need to store secrets within files, cici is your friend. Store secret files in your source code repository with ease. Can be used without a CI server, but tool is primarily designed for your CI server to decrypt these secret files for deployment.

Makes writing TextMate commands easier by providing convient methods for getting environment variables and getting user input.

Manage environment variables in Ruby

The Kiosk framework allows you to divide your software system to be divided into small, single-purpose software components. Parameters and return values are passed as data that can be expressed in JSON maps. Components can be deployed in-process or in another process or on another machine. Components don't have to know who is calling them and references to other components are injected using environment variables. These components can make use of a consistent and simple specification and testing framework built on cucumber.

Loads container configuration values from environment variables, secrets, and credentials.

An easy way to manage environment variables with types besides plain strings.

Generates a shell script from Figaro's application.yml to set environment variables on an Elastic Beanstalk instance.

Check environment variable presence with minimal YAML file

A Vagrant plugin which configures environment variables using Dotenv.

Set parameters acquired from AWS EC2 Parameter Store as environment variables.

A Gem to manage environment variables

Allows rejecting jobs by configuration of environment variables.

Hood gives you a standard way to define environment variable requirements for your app.

Parse and set environment variables on hosting providers

By requesting trigger build to Wercker with an environment variable which instruct wercker.yml to execute this script, bundle update is invoked, then commit changes and send pull request to GitHub repository if there some changes exist.

Simple implementation of the 'Feature Flags' pattern as a Ruby gem. Allows you to set defaults in a Hash of the form: ```{ feature_name_1: true, feature_name_2: false, feature_with_variations: 'A' }``` and override them with correspondingly-named environment variables. In the example above, you could enable the feature 'feature_name_2' with the environment variable 'FEATURE_NAME_2'.

A library for enabling Gemfiles to specify gem locations from environment variables.

Autoload environment variables from dotgpg-encrypted files into Rails.

Allows Net:SSH to use an external program to prompt for passwords, via the SSH_ASKPASS environment variable.

Environment variable manipulation using a ruby array syntax.

Loads environment variables with dotenv-schema in Rails

Manage and share Terraform variables, environments, and states securely.

A rubygems plugin that monkey-patches rubygems to support the no_proxy environment variable

Use environment-specific YAML for configuration while allowing for ENV variables to override

Creates environment variables with paths to Rubymine projects.

Provides a way to get the master key in Rails other than environment variables and key files.

EnvTestHelpers is a collection of helpers to work with environment variables in tests. Right now is only working with Rspec.

[DEPRECATED] Vagrant plugin to load environment variables from env.bash. Use envbash-ruby instead.

Helpers for dealing with environment variables, with the option of adding the functionality to ENV.

Simple tool for generating encrypted environment variables

Envolve provides a consistent and validating way to access your application configuration that is set via environment variables. This is double beneficial if you are configuring your entire application with environment variables. See. http://12factor.net/config

Read secrets out of a dotenv file without populating environment variables.

Ruby gem for defining which environment variables must be set in order for your Rails application to function properly.

Loads environment variables from spore.

Configures Redis connection with environment variable.

A gem to access environment variables in a OOP way. Rather than relying on ENV and strings, Environ lets you access the variables as objects.

Store environment variables securely on S3 away from your application

Manipulates your HOME environment variable.

This gem defines one proceedure `SAFE_ENV` which works like `ENV` with one important difference. It will raise an error if the environment variable does not exists.

A CLI environment variable manager. View, set, unset and manage environment variables (strings, lists, paths) on bash and on cmd.

Easily pull Heroku environment variables into non-Heroku environments.