A simple but secure password storage solution using git and crypt

Push_dir allows for easy working directory management. No more old_pwd = Dir.pwd!

:title: The Ruby API :section: PYAPNS::Client There's python in my ruby! This is a class used to send notifications, provision applications and retrieve feedback using the Apple Push Notification Service. PYAPNS is a multi-application APS provider, meaning it is possible to send notifications to any number of different applications from the same application and same server. It is also possible to scale the client to any number of processes and servers, simply balanced behind a simple web proxy. It may seem like overkill for such a bare interface - after all, the APS service is rather simplistic. However, PYAPNS takes no shortcuts when it comes to completeness/compliance with the APNS protocol and allows the user many optimization and scaling vectors not possible with other libraries. No bandwidth is wasted, connections are persistent and the server is asynchronous therefore notifications are delivered immediately. PYAPNS takes after the design of 3rd party push notification service that charge a fee each time you push a notification, and charge extra for so-called 'premium' service which supposedly gives you quicker access to the APS servers. However, PYAPNS is free, as in beer and offers more scaling opportunities without the financial draw. :section: Provisioning To add your app to the PYAPNS server, it must be `provisioned` at least once. Normally this is done once upon the start-up of your application, be it a web service, desktop application or whatever... It must be done at least once to the server you're connecting to. Multiple instances of PYAPNS will have to have their applications provisioned individually. To provision an application manually use the `PYAPNS::Client#provision` method. require 'pyapns' client = PYAPNS::Client.configure client.provision :app_id => 'cf', :cert => '/home/ss/cert.pem', :env => 'sandbox', :timeout => 15 This basically says "add an app reference named 'cf' to the server and start a connection using the certification, and if it can't within 15 seconds, raise a `PYAPNS::TimeoutException` That's all it takes to get started. Of course, this can be done automatically by using PYAPNS::ClientConfiguration middleware. `PYAPNS::Client` is a singleton class that is configured using the class method `PYAPNS::Client#configure`. It is sensibly configured by default, but can be customized by specifying a hash See the docs on `PYAPNS::ClientConfiguration` for a list of available configuration parameters (some of these are important, and you can specify initial applications) to be configured by default. :section: Sending Notifications Once your client is configured, and application provisioned (again, these should be taken care of before you write notification code) you can begin sending notifications to users. If you're wondering how to acquire a notification token, you've come to the wrong place... I recommend using google. However, if you want to send hundreds of millions of notifications to users, here's how it's done, one at a time... The `PYAPNS::Client#notify` is a sort of polymorphic method which can notify any number of devices at a time. It's basic form is as follows: client.notify 'cf', 'long ass app token', {:aps=> {:alert => 'hello?'}} However, as stated before, it is sort of polymorphic: client.notify 'cf', ['token', 'token2', 'token3'], [alert, alert2, alert3] client.notify :app_id => 'cf', :tokens => 'mah token', :notifications => alertHash client.notify 'cf', 'token', PYAPNS::Notification('hello tits!') As you can see, the method accepts paralell arrays of tokens and notifications meaning any number of notifications can be sent at once. Hashes will be automatically converted to `PYAPNS::Notification` objects so they can be optimized for the wire (nil values removed, etc...), and you can pass `PYAPNS::Notification` objects directly if you wish. :section: Retrieving Feedback The APS service offers a feedback functionality that allows application servers to retrieve a list of device tokens it deems to be no longer in use, and the time it thinks they stopped being useful (the user uninstalled your app, better luck next time...) Sounds pretty straight forward, and it is. Apple recommends you do this at least once an hour. PYAPNS will return a list of 2-element lists with the date and the token: feedbacks = client.feedback 'cf' :section: Asynchronous Calls PYAPNS::Client will, by default, perform no funny stuff and operate entirely within the calling thread. This means that certain applications may hang when, say, sending a notification, if only for a fraction of a second. Obviously not a desirable trait, all `provision`, `feedback` and `notify` methods also take a block, which indicates to the method you want to call PYAPNS asynchronously, and it will be done so handily in another thread, calling back your block with a single argument when finished. Note that `notify` and `provision` return absolutely nothing (nil, for you rub--wait you are ruby developers!). It is probably wise to always use this form of operation so your calling thread is never blocked (especially important in UI-driven apps and asynchronous servers) Just pass a block to provision/notify/feedback like so: PYAPNS::Client.instance.feedback do |feedbacks| feedbacks.each { |f| trim_token f } end :section: PYAPNS::ClientConfiguration A middleware class to make `PYAPNS::Client` easy to use in web contexts Automates configuration of the client in Rack environments using a simple confiuration middleware. To use `PYAPNS::Client` in Rack environments with the least code possible `use PYAPNS::ClientConfiguration` (no, really, in some cases, that's all you need!) middleware with an optional hash specifying the client variables. Options are as follows: use PYAPNS::ClientConfiguration( :host => 'http://localhost/' :port => 7077, :initial => [{ :app_id => 'myapp', :cert => '/home/myuser/apps/myapp/cert.pem', :env => 'sandbox', :timeout => 15 }]) Where the configuration variables are defined: :host String the host where the server can be found :port Number the port to which the client should connect :initial Array OPTIONAL - an array of INITIAL hashes INITIAL HASHES: :app_id String the id used to send messages with this certification can be a totally arbitrary value :cert String a path to the certification or the certification file as a string :env String the environment to connect to apple with, always either 'sandbox' or 'production' :timoeut Number The timeout for the server to use when connecting to the apple servers :section: PYAPNS::Notification An APNS Notification You can construct notification objects ahead of time by using this class. However unnecessary, it allows you to programmatically generate a Notification like so: note = PYAPNS::Notification.new 'alert text', 9, 'flynn.caf', {:extra => 'guid'} -- or -- note = PYAPNS::Notification.new 'alert text' These can be passed to `PYAPNS::Client#notify` the same as hashes

PythonConfig is a module with classes for parsing and writing Python configuration files created by the ConfigParser classes in Python. These files are structured like this: [Section Name] key = value otherkey: othervalue [Other Section] key: value3 otherkey = value4 Leading whitespace before values are trimmed, and the key must be the at the start of the line - no leading whitespace there. You can use : or = . Multiline values are supported, as long as the second (or third, etc.) lines start with whitespace: [Section] bigstring: This is a very long string, so I'm not sure I'll be able to fit it on one line, but as long as there is one space before each line, I'm ok. Tabs work too. Also, this class supports interpolation: [Awards] output: Congratulations for winning %(prize)! prize: the lottery Will result in: config.sections["Awards"]["output"] == "Congratulations for winning the lottery!" You can also access the sections with the dot operator, but only with all-lowercase: [Awards] key:value [prizes] lottery=3.2 million config.awards["key"] #=> "value" config.prizes["lottery"] #=> "3.2 million" You can modify any values you want, though to add sections, you should use the add_section method. config.sections["prizes"]["lottery"] = "100 dollars" # someone hit the jackpot config.add_section("Candies") config.candies["green"] = "tasty" When you want to output a configuration, just call its +to_s+ method. File.open("output.ini","w") do |out| out.write config.to_s end

QA Robusta is an automation framework easing pain points away from automation test case writers. How is pain relieved? * Elements, such as links, buttons, and other html objects are defined in one location. This ensures over time the user won't have definitions spread out throughout different layers of code requiring time consuming updates if the application under test is modified. * Well defined flows allows the user to have a common means for navigating and controlling interactions with the application under test. This takes all logic out of test classes and yields in higher more modular code re-use. * When an application requiring testing has the elements and flows implemented less code savy resources can easily add new test cases once trained on how to access the flows and elements. * When ever a link or button is clicked a screen shot is taken * Results are available under site/results directory in html format. Report includes the rdoc on a per test class method along with any screen shots taken. Example report: https://cyberconnect.biz/opensource/demo_results.html * Transparent remote Unix command execution leading to well defined interfaces for common task. For example, one may have a class defined specifically for RemoteUnixNetwork. This class would have methods such as, assign_ip, ifup, ifdown, etc. This class then would be able to perform these task on any remote Unix machine. * Executes the same on Windows or Linux/Unix environments. Developers have the freedom to develop on the platform of choice. * Mechanize extension: Allows the user to define a web application's page elements in a YAML format and provide navigation paths accessing the YAML structure to interact with the web application. Users can also perform direct http.post or any other mechanize functionality when defining state-full interfaces to hit a web application without going through a browser.

Modules and Mixins for extending ActiveRecord models for content management systems

Qer is an easy command-line todo list.

Interface to QPID, the Queriable Patient Inference Dossier system.

QRTools is a library for decoding QR Codes. It relies on libdecodeqr for decoding.

A quantity class containing "value" and "unit" which provides: * Unit conversion like the units command. * Operation between quantities with different units, like "km" and "mile", * with automatic unit conversion.

A collection of shortcuts and helpers for leveraging a request's env in Rails, such as including a browser-specific stylesheet if one exists or putting a short version of the user agent in the CSS classes of the body tag. This eliminates the need for most hacks or conditional comments since you can now get browser-specific with your CSS rules (ex. body.ie6 div { ... })

Daemon Kit aims to simplify creating Ruby daemons by providing a sound application skeleton (through a generator), task specific generators (jabber bot, etc) and robust environment management code. Using simple built-in generators it is easy to created evented and non-evented daemons that perform a multitude of different tasks. Supported generators: * XMPP bot (non-evented) * AMQP consumer (evented) * Nanite agent * Cron-style daemon * ruote remote participants

The only comprehensive Ruby interface to Quickbooks. THIS IS A DEMO VERSION. Visit behindlogic.com for the full version, which works with all versions of QuickBooks.

quick_cert allows you to quickly and easily create SSL certificates. It uses a simple configuration file to generate self-signed client and server certificates.

Command line utility for serving the current directory over HTTP.

control QuickTime Player on Mac.

== Install sudo gem install quietbacktrace == Usage Quiet Backtrace works by adding new attributes to Test::Unit::TestCase. By default, their values are: self.quiet_backtrace = true self.backtrace_silencers = [:test_unit, :gem_root, :e1] self.backtrace_filters = [:method_name]

Super-quick image resizing using the ImageMagick command line tools

A simple but secure password storage solution using git and crypt

RestfulQuery provides a simple interface in front of a complex parser to parse specially formatted query hashes into complex SQL queries. It includes ActiveRecord and Sequel extensions.