0.0
# XQuery
[![Join the chat at https://gitter.im/JelF/xquery](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/JelF/xquery?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![Build Status](https://travis-ci.org/JelF/xquery.svg?branch=master)](https://travis-ci.org/JelF/xquery)
[![Code Climate](https://codeclimate.com/github/JelF/xquery/badges/gpa.svg)](https://codeclimate.com/github/JelF/xquery)
[![Test Coverage](https://codeclimate.com/github/JelF/xquery/badges/coverage.svg)](https://codeclimate.com/github/JelF/xquery/coverage)
[![Issue Count](https://codeclimate.com/github/JelF/xquery/badges/issue_count.svg)](https://codeclimate.com/github/JelF/xquery)
XQuery is designed to replace boring method call chains and allow to easier
convert it in a builder classes
## Usage of `XQuery` function
`XQuery` is a shortcat to `XQuery::Generic.with`
```
r = XQuery(''.html_safe) do |q|
# similar to tap
q << 'bla bla bla'
q << 'bla bla bla'
# using truncate
q.truncate(15)
# real content (q.send(:query)) mutated
q << '!'
end
r # => "bla bla blab...!"
```
## Usage of `XQuery::Abstract`
I designed this gem to help me with `ActiveRecord` Queries, so i inherited
`XQuery::Abstract` and used it's powers. It provides the following features
### `wrap_method` and `wrap_methods`
when you call each of this methods they became automatically wrapped
(`XQuery::Abstract` basically wraps all methods query `#respond_to?`)
It means, that there are instance methods with same name defined and will
change a `#query` to their call result.
```
self.query = query.foo(x)
# is basically the same as
foo(x)
# when `wrap_method :foo` called
```
You can also specify new name using `wrap_method :foo, as: :bar` syntax
### `q` object
`q` is a proxy object which holds all of wrapped methods,
but not methods you defined inside your class.
E.g. i have defined `wrap_method(:foo)`, but also delegated `#foo` to some
another object. If i call `q.foo`, i will get wrapped method.
Note, that if you redefine `#__foo` method, q.foo will call it instead of
normal work.
You can add additional methods to `q` using something like `alias_on_q :foo`.
I used it with `kaminary` and it was useful
```
def page=(x)
apply { |query| query.page(x) }
end
alias_on_q :page=
def page
query.current_page
end
alias_on_q :page
```
### `query_superclass`
You should specify `query_superclass` class_attribute to inherit
`XQuery::Abstract`. Whenever `query.is_a?(query_superclass)` evaluate to false,
you will get `XQuery::QuerySuperclassChanged` exception.
It can save you much time when your class misconfigured.
E.g. you are using `select!` and it returns `nil`, because why not?
### `#apply` method
`#apply` does exact what it source tells
```
# yields query inside block
# @param block [#to_proc]
# @return [XQuery::Abstract] self
def apply(&block)
self.query = block.call(query)
self
end
```
It is usefull to merge different queries.
### `with` class method
You can get XQuery functionality even you have not defined a specific class
(You are still have to inherit XQuery::Abstract to use it)
You can see it in this document when i described `XQuery` function.
Note, that it yields a class instance, not `q` object.
It accepts any arguments, they will be passed to a constructor (except block)
### `execute` method
Preferred way to call public instance methods.
Resulting query would be returned
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.0
swagger_coverage programmatically compares Swagger API routes to existing routes from the source code and reports the difference(s)
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.01
For some reason, there's no adapter for a gem in SimpleCov, an excellent, simple Ruby 1.9 coverage tool. So this one defines one in about 8 lines of code.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.0
For some reason, there's no profile for a gem in SimpleCov, an excellent, simple Ruby 1.9 coverage tool. So this one defines one in about 8 lines of code.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
0.04
A tool to find what specs examples cover a specific line of code
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.0
This gem will check if a coverage file meets the expected level. If it doesn't it will exit with a exit code of 1. This can be used in tools such as Jenkins to check if the coverage meets the expected level.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
0.01
Gtk Webkit bindings for ruby. Partial coverage sufficient to embed a webview in a Ruby-GNOME2 application.
Also initial/experimental support for allowing ruby code to be called by javascript & executing javascript
from ruby.
e.g
require 'gtk2'
require 'webkit'
v = WebKit::WebView.new
v.main_frame.setup_ruby
puts v.main_frame.exec_js("ruby_eval('RUBY_DESCRIPTION')")
puts v.main_frame.exec_js("document.root.innerHTML")
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.0
Lookout-Rake
Lookout-Rake provides Rake┬╣ tasks for testing using Lookout.
┬╣ See http://rake.rubyforge.org/
§ Installation
Install Lookout-Rake with
% gem install lookout-rake
§ Usage
Include the following code in your ‹Rakefile›:
require 'lookout-rake-3.0'
Lookout::Rake::Tasks::Test.new
If the ‹:default› task hasn’t been defined it’ll be set to depend on the
‹:test› task. The ‹:check› task will also depend on the ‹:test› task.
There’s also a ‹:test:coverage› task that gets defined that uses the
coverage library that comes with Ruby 1.9 to check the test coverage when
the tests are run.
You can hook up your test task to use your Inventory┬╣:
load File.expand_path('../lib/library-X.0/version.rb', __FILE__)
Lookout::Rake::Tasks::Test.new :inventory => Library::Version
Also, if you use the tasks that come with Inventory-Rake┬▓, the test task
will hook into the inventory you tell them to use automatically, that is,
the following will do:
load File.expand_path('../lib/library-X.0/version.rb', __FILE__)
Inventory::Rake::Tasks.define Library::Version
Lookout::Rake::Tasks::Test.new
For further usage information, see the {API documentation}┬│.
┬╣ Inventory: http://disu.se/software/inventory/
┬▓ Inventory-Rake: http://disu.se/software/inventory-rake/
┬│ API: http://disu.se/software/lookout-rake/api/Lookout/Rake/Tasks/Test/
§ Integration
To use Lookout together with Vim¹, place ‹contrib/rakelookout.vim› in
‹~/.vim/compiler› and add
compiler rakelookout
to ‹~/.vim/after/ftplugin/ruby.vim›. Executing ‹:make› from inside Vim
will now run your tests and an errors and failures can be visited with
‹:cnext›. Execute ‹:help quickfix› for additional information.
Another useful addition to your ‹~/.vim/after/ftplugin/ruby.vim› file may
be
nnoremap <buffer> <silent> <Leader>M <Esc>:call <SID>run_test()<CR>
let b:undo_ftplugin .= ' | nunmap <buffer> <Leader>M'
function! s:run_test()
let test = expand('%')
let line = 'LINE=' . line('.')
if test =~ '^lib/'
let test = substitute(test, '^lib/', 'test/', '')
let line = ""
endif
execute 'make' 'TEST=' . shellescape(test) line
endfunction
Now, pressing ‹<Leader>M› will either run all tests for a given class, if
the implementation file is active, or run the test at or just before the
cursor, if the test file is active. This is useful if youΓÇÖre currently
receiving a lot of errors and/or failures and want to focus on those
associated with a specific class or on a specific test.
┬╣ Find out more about Vim at http://www.vim.org/
§ Financing
Currently, most of my time is spent at my day job and in my rather busy
private life. Please motivate me to spend time on this piece of software
by donating some of your money to this project. Yeah, I realize that
requesting money to develop software is a bit, well, capitalistic of me.
But please realize that I live in a capitalistic society and I need money
to have other people give me the things that I need to continue living
under the rules of said society. So, if you feel that this piece of
software has helped you out enough to warrant a reward, please PayPal a
donation to now@disu.se┬╣. Thanks! Your support wonΓÇÖt go unnoticed!
┬╣ Send a donation:
https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=now%40disu%2ese&item_name=Nikolai%20Weibull%20Software%20Services
§ Reporting Bugs
Please report any bugs that you encounter to the {issue tracker}┬╣.
┬╣ See https://github.com/now/lookout-rake/issues
§ Authors
Nikolai Weibull wrote the code, the tests, the manual pages, and this
README.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.04
= Mcrypt - libmcrypt bindings for Ruby
Mcrypt provides Ruby-language bindings for libmcrypt(3), a
symmetric cryptography library. {Libmcrypt}[http://mcrypt.sourceforge.net/]
supports lots of different ciphers and encryption modes.
== You will need
* A working Ruby installation (>= 1.8.6 or 1.9)
* A working libmcrypt installation (2.5.x or 2.6.x, tested with 2.5.8)
* A sane build environment
== Installation
Install the gem:
gem install ruby-mcrypt --test -- --with-mcrypt-dir=/path/to/mcrypt/prefix
If you're installing on Ubuntu:
sudo apt-get install mcrypt libmcrypt-dev
gem install ruby-mcrypt
If you want to run the longer test suite, do this instead:
MCRYPT_TEST_BRUTE=1 \
gem install ruby-mcrypt --test -- --with-mcrypt-dir=/path/to/mcrypt/prefix
Put this in your code:
require 'rubygems'
require 'mcrypt'
Or in Rails' environment.rb:
gem "ruby-mcrypt", :lib => "mcrypt"
== Usage
crypto = Mcrypt.new(:twofish, :cbc, MY_KEY, MY_IV, :pkcs)
# encryption and decryption in one step
ciphertext = crypto.encrypt(plaintext)
plaintext = crypto.decrypt(ciphertext)
# encrypt in smaller steps
while chunk = $stdin.read(4096)
$stdout << crypto.encrypt_more(chunk)
end
$stdout << crypto.encrypt_finish
# or decrypt:
while chunk = $stdin.read(4096)
$stdout << crypto.decrypt_more(chunk)
end
$stdout << crypto.decrypt_finish
== Known Issues
* Test coverage is lacking.
If you find any bugs, please let the author know.
== Wish List
* IO-like behavior, e.g. crypto.open($stdin) { |stream| ... }
== Author
* Philip Garrett <philgarr at gmail.com>
== Copyright and License
Copyright (c) 2009-2013 Philip Garrett.
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:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity
0.04
The RTF library provides a pure Ruby set of functionality that can be used to
programmatically create RTF documents. The main aim in developing this library
is to ease the complexity involved in assembling RTF documents although some
consideration has also been given to generating documents that are easier to
manually interpret too.
This library does not include functionality for parsing RTF documents. Nor does
the library claim to provide extensive coverage of the RTF specification. The
library was developed mostly with reference to the RTF Pocket Guide by Sean M.
Burke and some reference to the RTF specification itself. The introduction to
the RTF Pocket Guide states that the book covers version 1.7 of the RTF
specification so I guess, as this was the primary source, that this is the
version that the library covers too. Finally, no consideration was given to
making the functionality within the library thread safe.
In creating this library I set out to make it reasonably easy to create RTF
documents in code. Having said that I'm certain that it is possible to generate
invalid RTF documents with this library.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
Activity