Results for check-source-formatting

Germinate is a tool for writing about code. With Germinate, the source code IS the article. For example, given the following source code: # #!/usr/bin/env ruby # :BRACKET_CODE: <pre>, </pre> # :PROCESS: ruby, "ruby %f" # :SAMPLE: hello def hello(who) puts "Hello, #{who}" end hello("World") # :TEXT: # Check out my amazing program! Here's the hello method: # :INSERT: @hello:/def/../end/ # And here's the output: # :INSERT: @hello|ruby When we run the <tt>germ format</tt> command the following output is generated: Check out my amazing program! Here's the hello method: <pre> def hello(who) puts "Hello, #{who}" end </pre> And here's the output: <pre> Hello, World </pre> To get a better idea of how this works, please take a look at link:examples/basic.rb, or run: germ generate > basic.rb To generate an example article to play with. Germinate is particularly useful for writing articles, such as blog posts, which contain code excerpts. Instead of forcing you to keep a source code file and an article document in sync throughout the editing process, the Germinate motto is "The source code IS the article". Specially marked comment sections in your code file become the article text. Wherever you need to reference the source code in the article, use insertion directives to tell Germinate what parts of the code to excerpt. An advanced selector syntax enables you to be very specific about which lines of code you want to insert. If you also want to show the output of your code, Germinate has you covered. Special "process" directives enable you to define arbitrary commands which can be run on your code. The output of the command then becomes the excerpt text. You can define an arbitrary number of processes and have different excerpts showing the same code as processed by different commands. You can even string processes together into pipelines. Development of Germinate is graciously sponsored by Devver, purveyor of fine cloud-based services to busy Ruby developers. If you like this tool please check them out at http://devver.net.

Germinate is a tool for writing about code. With Germinate, the source code IS the article. For example, given the following source code: # #!/usr/bin/env ruby # :BRACKET_CODE: <pre>, </pre> # :PROCESS: ruby, "ruby %f" # :SAMPLE: hello def hello(who) puts "Hello, #{who}" end hello("World") # :TEXT: # Check out my amazing program! Here's the hello method: # :INSERT: @hello:/def/../end/ # And here's the output: # :INSERT: @hello|ruby When we run the <tt>germ format</tt> command the following output is generated: Check out my amazing program! Here's the hello method: <pre> def hello(who) puts "Hello, #{who}" end </pre> And here's the output: <pre> Hello, World </pre> To get a better idea of how this works, please take a look at link:examples/basic.rb, or run: germ generate > basic.rb To generate an example article to play with. Germinate is particularly useful for writing articles, such as blog posts, which contain code excerpts. Instead of forcing you to keep a source code file and an article document in sync throughout the editing process, the Germinate motto is "The source code IS the article". Specially marked comment sections in your code file become the article text. Wherever you need to reference the source code in the article, use insertion directives to tell Germinate what parts of the code to excerpt. An advanced selector syntax enables you to be very specific about which lines of code you want to insert. If you also want to show the output of your code, Germinate has you covered. Special "process" directives enable you to define arbitrary commands which can be run on your code. The output of the command then becomes the excerpt text. You can define an arbitrary number of processes and have different excerpts showing the same code as processed by different commands. You can even string processes together into pipelines. Development of Germinate is graciously sponsored by Devver, purveyor of fine cloud-based services to busy Ruby developers. If you like this tool please check them out at http://devver.net.

= Biological Extensions to the InterMine Webservice Client Library This library is a set of extensions to the InterMine Webservices client, providing access for data in biological formats. It directly extends the InterMine classes, providing extra methods to the Query class. == Example Get all sequences for proteins on "h", "r", "eve", "bib" and "zen": require "rubygems" require "intermine/service" require "intermine/bio" s = Service.new("www.flymine.org/query") puts s.query("Gene").select("proteins").where(:symbol => %w{h r eve bib zen}).fasta Process the locations of these genes one at a time: s.query.select("Gene").where(:symbol => %w{h r eve bib zen}).bed do |line| process line end == Who is this for? InterMine data warehouses are typically constructed to hold Biological data, and as this library facilitates programmatic access to these data, this install is primarily aimed at bioinformaticians. In particular, users of the following services may find it especially useful: * FlyMine (http://www.flymine.org/query) * YeastMine (http://yeastmine.yeastgenome.org/yeastmine) * RatMine (http://ratmine.mcw.edu/ratmine) * modMine (http://intermine.modencode.org/release-23) * metabolicMine (http://www.metabolicmine.org/beta) These extensions are aimed at bioinformaticians looking to integrate these sources of data into other workflows. For details on constructing queries, see the intermine documentation. == Support Support is available on our development mailing list: dev@intermine.org == License This code is Open Source under the LGPL. Source code for all InterMine code can be checked out from svn://subversion.flymine.org/flymine

= Webservice Client Library for InterMine Data-Warehouses This library provides an interface to the InterMine webservices API. It makes construction and execution of queries more straightforward, safe and convenient, and allows for results to be used directly in Ruby code. As well as traditional row based access, the library provides an object-orientated record result format (similar to ActiveRecords), and allows for fast, memory efficient iteration of result sets. == Example Get all protein domains associated with a set of genes and print their names: require "intermine/service" Service.new("www.flymine.org/query"). new_query("Pathway") select(:name). where("genes.symbol" => ["zen", "hox", "h", "bib"]). each_row { |row| puts row[:name]} == Who is this for? InterMine data warehouses are typically constructed to hold Biological data, and as this library facilitates programmatic access to these data, this install is primarily aimed at bioinformaticians. In particular, users of the following services may find it especially useful: * FlyMine (http://www.flymine.org/query) * YeastMine (http://yeastmine.yeastgenome.org/yeastmine) * RatMine (http://ratmine.mcw.edu/ratmine) * modMine (http://intermine.modencode.org/release-23) * metabolicMine (http://www.metabolicmine.org/beta) == How to use this library: We have tried to construct an interface to this library that does not require you to learn an entirely new set of concepts. As such, as well as the underlying methods that are common to all libraries, there is an additional set of aliases and sugar methods that emulate the DSL style of SQL: === SQL style service = Service.new("www.flymine.org/query") service.model. table("Gene"). select("*", "pathways.*"). where(:symbol => "zen"). order_by(:symbol). outerjoin(:pathways). each_row do |r| puts r end === Common InterMine interface service = Service.new("www.flymine.org/query") query = service.new_query("Gene") query.add_views("*", "pathways.*") query.add_constraint("symbol", "=", "zen") query.add_sort_order(:symbol) query.add_join(:pathways) query.each_row do |r| puts r end For more details, see the accompanying documentation and the unit tests for interface examples. Further documentation is available at www.intermine.org. == Support Support is available on our development mailing list: dev@intermine.org == License This code is Open Source under the LGPL. Source code for this gem can be checked out from https://github.com/intermine/intermine-ws-ruby

== PintosCheck -- Auto Pintos Checker to Save the Day == == Functionalities == The functionality of this simple script is to download pintos homework assignments from the mail inbox and then run through all the desired tests and finally generate reports in plain text or html formats, all automatically. == Requirements For Running PintosCheck == Since all the scripts are written in ruby, PintosCheck require ruby installed on the system. I use ruby 1.8.7 for development, but ruby 1.9.* versions are expected to function as well. However, ruby 1.8.6 and lower versions are not supported. For information of downloading and installing ruby, see http://www.ruby-lang.org/en/downloads/. In addition to ruby itself, RubyGems 1.3.* is also required because it hosts the installation source for this project and almost all other ruby projects as well. To download or update RubyGems, please go to http://gemcutter.org/pages/download for more information. == Installation == Once you have all the requirements on your system, it's really easy to install PintosCheck. In the UNIX shell or Windows command line environment, type the following command(sudo if needed): gem install pintoscheck --include-dependencies Go grab a cup of coffee, and PintosCheck will automatically download and install itself onto the system. To check the installation, type 'ptschk --version', and if something like 'PintosCheck 0.1.0' pops up then you're green to go! == Finally, how do I check my students' pintos homework? == This project ships with a 'ptschk' command tool. This tool needs a task configuration file to actually do everything. The configuration file is in YAML format, which is basically a recursive key-value pair representation. If you're using PintosCheck for the first time, there's a very nice command line option to generate the skeleton for you. Just run 'ptschk init my_first_task.config' and a file named 'my_first_task.config' will be generated for you. Inside this file there is a set of the minimal options for the task to run properly, and you just have to fill in what you need. After you set up your configuration file, run 'ptschk run my_first_task.config' and the tasks will kick off immediately, and after a while the report will be generated. A detailed configuration options for advanced task setup will be available in production release of this project.

Diff and patch tables

Chef-Berksfile-Env ================== A Chef plugin which allows you to lock down your Chef Environment's cookbook versions with a Berksfile. This is effectively the same as doing `berks apply ...` but via `knife environment from file ...`. View the [Change Log](https://github.com/bbaugher/chef-berksfile-env/blob/master/CHANGELOG.md) to see what has changed. Installation ------------ /opt/chef/embedded/bin/gem install chef-berksfile-env Usage ----- In your chef repo create a Berksfile next to your Chef environment file like this, chef-repo/environments/[ENV_NAME]/Berksfile This is the default location that will used by the plugin. We have to put the Berksfile in its own directory since [multiple Berksfiles can't exist in the same directory](https://github.com/berkshelf/berkshelf/issues/1247). The berksfile should include any cookbooks that your nodes or roles explicitly mention for that environment, source "https://supermarket.getchef.com" cookbook "java" cookbook "yum", "~> 2.0" ... Next we need to generate our Berksfile's lock file, berks install Your environment file must by in `.rb` format and look like this, require 'chef-berksfile-env' # The name must be defined first so we can use it to find the Berksfile name "my_env" # Load Berksfile locked dependencies as my environment's cookbook version contraints load_berksfile ... Now our environment will use the locked versions of the cookbooks and transitive dependencies generated by our Berksfile. Upgrading to the latest dependecies is now as simple as, berks install Our Berksfile also provides an easy way to ensure all the cookbooks and their versions that our environment requires are uploaded to our chef-server, berks upload How the Plugin Finds the Berksfile ---------------------------------- If you are curious how the plugin knows to find the Berksfile in `chef-repo/environments/[ENV]/Berksfile`, you want to put your Berksfile somewhere else or you have run into this error `Expected Berksfile at [/path/../Berksfile] but does not exist`, this section will explain how this works and ways to tweak the path or fix your error. `load_berksfile` has an optional argument which represents the path to your Berksfile. This path can be pseduo relative (explained in a moment) or absolute. By default the value is `environments/[ENV_NAME]/Berksfile`. By pseduo relative I mean that its a relative path but the plugin will check to see if the directory we are executing from partially matches our relative path. So if we are running knife from `/home/chef-repo/environments` and our relative path is `chef-repo/environments/dev/Berksfile` the plugin will see that the relative path is partially included in our execution directory and will attempt to merge the two to come up with `/home/chef-repo/environments/dev/Berksfile`. If we can't make any match at all we attempt to guess the path by just joining the relative path with our execution directory. So why do we do this? Well the only way to use this plugin is if your environment is in Ruby format. Chef's `knife from file ...` uses Ruby's `instance_eval` in order to do this. This means the code on Chef's end effectively looks like this, env.instance_eval(IO.read(env_ruby_file)) which means that any context about the location of the environment file is lost. So we have no great way to discern the location of our environment Ruby file, so instead we guess.

# HebCal Determines the date of Passover for a Gregorian year. Also includes boolean functions to check whether a date is a Jewish holiday, Fast Day or Rosh Chodesh. Supported languages: Javascript Ruby ## Installation as a Ruby gem Add this line to your application's Gemfile: gem 'hebcal' And then execute: $ bundle Or install it yourself as: $ gem install hebcal ## General notes 1. 3- and 4-digit years are supported, so the domain of valid years is 100-9999. For years before the Gregorian transition (1582), the transition is ignored and the proleptic Gregorian calendar is used. ## Ruby Version ### To Run Unit Tests $ rake test ### To Use #### Calculating the date of Passover 1. At the top of the file where the class is defined, declare `require `hebcal`` 1. In the class, declare `include HebCal::Passover` 1. `WhenIsPesach(yyyy)` returns a Ruby Time object representing midnight on the first day of passover, where `yyyy` is the Gregorian year Note that the date returned is the first day of Pesach, not the day on which Pesach begins at sunset. #### Finding out if a date is a holiday 1. At the top of the file where the class is defined, declare `require `hebcal`` 1. In the desired class, declare `include HebCal::Holidays` 1. `IsPesach(d)` returns true iff d is a Ruby Time object representing a date during Pesach. Note that the day on which Pesach begins at sunset returns false. 1. The following functions work in a similar way to `IsPesach()`: 1. `IsShavuot()`, `IsRoshHashanah()`, `IsYomKippur()`, `IsSukkot()` 1. `IsRegel()`: `IsPesach() || IsShavuot || IsSukkot()` 1. `IsMoed()`: Hol HaMoed Pesach or Hol HaMoed Sukkot 1. `IsYomTov()`: `IsPesach() || IsShavuot() || IsRoshHashanah() || IsSukkot()) && !IsMoed()` Note that IsYomTov(yk) == false, where yk is the date of Yom Kippur. 1. `IsPurim()`, `IsHanuka()` 1. `Is10Tevet()`, `IsTaanitEster()`, `Is17Tamuz()`, `Is9Av()`, `IsFastOfGedalia()` 1. `IsTaanit()`: `Is10Tevet() || IsTaanitEster() || Is17Tamuz() || Is9Av() || IsFastOfGedalia()` 1. `IsRoshChodesh()` ## Javascript Version ### To Run Unit Tests 1. Open index.html in a browser. You should see a lot of green text saying that tests passed. If not, javascript may not be enabled in your browser. Scroll down to the bottom and verify that the summary says all tests passed. ### To Use 1. Include the javascript source file in your HTML page 1. If using Ruby On Rails, you can declare `//= require hebcal` at the top of a javascript or coffeescript file 1. To include the script explicitly in an html file, `<script src="app/assets/javascripts/hebcal/passover.js" type="text/javascript"></script>` 1. All date formats are YYYY-mm-dd, where month is index from 1 (i.e. 1 == January, not the usual javascript index of 0 == January!) and YYYY is the Gregorian year. 1. $.whenIsPesach(yyyy) returns a date in the above format, where yyyy is the Gregorian year. Note that the date returned is the first day of Pesach, not the day on which Pesach begins at sunset. 1. $.isPesach(d) returns true iff d is a date during Pesach, in the above format. Note that the day on which Pesach begins at sunset returns false. 1. The following functions work in a similar way to $.isPesach(): 1. $.isShavuot(), $.isRoshHashanah(), $.isYomKippur(), $.isSukkot(); 1. $.isRegel(): $.isPesach() || $.isShavuot() || $.isSukkot(); 1. $.isMoed(): Hol HaMoed Pesach or Hol HaMoed Sukkot; 1. $.isYomTov(): ($.isPesach() || $.isSukkot() || $.isShavuot() || $.isRoshHashanah()) && !$.isMoed(); Note that isYomTov(yk) == false, where yk is the date of Yom Kippur. 1. `$.isPurim()`, `$.isHanuka()` 1. `$.isRoshChodesh()` 1. `$.is10Tevet()`, `$.isTaanitEster()`, `$.is17Tamuz()`, `$.is9Av()`, `$.isFastOfGedalia()` 1. `$.isTaanit()`: `$.is10Tevet() || $.isTaanitEster() || $.is17Tamuz() || $.is9Av() || $.isFastOfGedalia()`

Diff and patch tables

# SshSig - SSH signature verification in pure ruby SshSig is a Ruby gem which can be used to verify signatures signed created by `ssh-keygen`. This capability was [first added](https://github.com/openssh/openssh-portable/commit/2a9c9f7272c1e8665155118fe6536bebdafb6166) in OpenSSH 8.0 allows SSH keys to be used for GPG-like signing capabilities, [including signing git commits](https://github.com/git/git/pull/1041). ## Installation Add this line to your application's Gemfile: ```ruby gem 'ssh_sig' ``` And then execute: $ bundle install Or install it yourself as: $ gem install ssh_sig ## Usage Version 1 of [the SSH signature format](https://github.com/openssh/openssh-portable/blob/b7ffbb17e37f59249c31f1ff59d6c5d80888f689/PROTOCOL.sshsig) supports `ed25519` and `rsa` keys. It is recommended that you use `ed25519` over `rsa` where possible (`ssh-keygen -t ed25519`). In order to verify a signature you need: 1. The public key of the sender 1. The signature file 1. The message to be verified. ```ruby require 'ssh_sig' armored_pubkey = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAILXPkJPI4TMFWZP4xRBQjNeizUG99KuZCt9G23rX48kz" blob = ::SshSig::Blob.from_armor( <<~EOF -----BEGIN SSH SIGNATURE----- U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgtc+Qk8jhMwVZk/jFEFCM16LNQb 30q5kK30bbetfjyTMAAAAEZmlsZQAAAAAAAAAGc2hhNTEyAAAAUwAAAAtzc2gtZWQyNTUx OQAAAECJITeYJIlEeydsCTh1DkfdhlDJFBa73ojfWe0MbrIzoJKd9THd9WeQrhygSRGsNG cU/stk3/919nykg67yG2gN -----END SSH SIGNATURE----- EOF ) message = "This message was definitely sent by Brian Williams" valid = ::SshSig::Verifier .from_armored_pubkey(armored_pubkey) .verify(blob, message) if valid puts 'Signature is valid' else puts 'Signature is not valid' end ``` Signatures can be created using `ssh-keygen -Y sign -n file -f ~/.ssh/ed_25519 message.txt` and will be outputted in `message.txt.sig`. Public keys can be found in a variety of places, including: - Your `~/.ssh/id_<alg>.pub` file - `authorized_keys` files on servers - `https://gitlab.com/<username>.keys` - `https://github.com/<username>.keys` The `SshSig::Verifier#from_gitlab` and `SshSig::Verifier#from_github` methods are provided to automatically load public keys from the respective `<username>.keys` urls. ```ruby require 'ssh_sig' blob = ::SshSig::Blob.from_armor( <<~EOF -----BEGIN SSH SIGNATURE----- U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgtc+Qk8jhMwVZk/jFEFCM16LNQb 30q5kK30bbetfjyTMAAAAEZmlsZQAAAAAAAAAGc2hhNTEyAAAAUwAAAAtzc2gtZWQyNTUx OQAAAECJITeYJIlEeydsCTh1DkfdhlDJFBa73ojfWe0MbrIzoJKd9THd9WeQrhygSRGsNG cU/stk3/919nykg67yG2gN -----END SSH SIGNATURE----- EOF ) message = 'This message was definitely sent by Brian Williams' valid = ::SshSig::Verifier .from_gitlab('bwill') .verify(blob, message) if valid puts 'Signature is valid' else puts 'Signature is not valid' end ``` ## Is it safe to re-purpose SSH keys for signing? Yes. The [SSH signature protocol](https://github.com/openssh/openssh-portable/blob/d575cf44895104e0fcb0629920fb645207218129/PROTOCOL.sshsig) is designed to be resistant to cross-protocol attacks, where signatures created for one purpose (i.e. signing a git commit), may be re-used for another purpose (i.e. authenticating to a server). It does this using the magic pre-amble (to differentiate between messages signed by `ssh-keygen` and messages used for SSH authentication) and namespaces (to differentiate between messages signed by `ssh-keygen` but used for different purposes). This causes identical messages to produce different signatures for each different protocol. ## Development After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ssh_sig. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/ssh_sig/blob/main/CODE_OF_CONDUCT.md). ## License The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

No description provided.