🌐 Proxy toolkit: parse, check, fetch from services
Offers getProxyForUrl to get the proxy URL for a URL, respecting the *_PROXY (e.g. HTTP_PROXY) and NO_PROXY environment variables.
Determine address of proxied request
HTTP proxying for the masses
TypeScript definitions for http-proxy
ES5 shim for ES6 (ECMAScript 6) Reflect and Proxy objects
The one-liner node.js proxy middleware for connect, express, next.js and more
The Chrome DevTools Protocol JSON
Fully featured SOCKS proxy client supporting SOCKSv4, SOCKSv4a, and SOCKSv5. Includes Bind and Associate functionality.
An HTTP(s) proxy `http.Agent` implementation for HTTP
Maps proxy protocols to `http.Agent` implementations
Turn a function into an `http.Agent` instance
An HTTP(s) proxy `http.Agent` implementation for HTTPS
A SOCKS proxy `http.Agent` implementation for HTTP and HTTPS
http proxy middleware for express
an identity object using ES6 proxies
TypeScript definitions for express-http-proxy
A PAC file proxy `http.Agent` implementation for HTTP
A powerful web-proxy used as a core for the TestCafe testing framework (https://github.com/DevExpress/testcafe).
TypeScript definitions for proxy-from-env
Datadog API Node.JS Client
Mocks Server plugin providing proxy variant handler
Global HTTP/HTTPS proxy configurable using environment variables.
WebDriver Proxy for testing rich clients. It block certain calls until Angular is done updating the page under test.
Connection proxy for ActiveRecord for single master / multiple slave database deployments
Connection proxy for ActiveRecord for master / replica setups.
ActiveRecord connection proxy for master/slave connections
Connection proxy for ActiveRecord for single master / multiple slave database deployments
Connection proxy for ActiveRecord for single master / multiple slave database deployments
Connection proxy for ActiveRecord for single master / multiple slave database deployments
Proxy release, copy of master branch on 7-21-2011. Sunspot is a library providing a powerful, all-ruby API for the Solr search engine. Sunspot manages the configuration of persistent Ruby classes for search and indexing and exposes Solr's most powerful features through a collection of DSLs. Complex search operations can be performed without hand-writing any boolean queries or building Solr parameters by hand.
Proxy release, copy of master branch on 7-21-2011. Sunspot::Rails is an extension to the Sunspot library for Solr search. Sunspot::Rails adds integration between Sunspot and ActiveRecord, including defining search and indexing related methods on ActiveRecord models themselves, running a Sunspot-compatible Solr instance for development and test environments, and automatically commit Solr index changes at the end of each Rails request.
# XQuery [](https://gitter.im/JelF/xquery?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [](https://travis-ci.org/JelF/xquery) [](https://codeclimate.com/github/JelF/xquery) [](https://codeclimate.com/github/JelF/xquery/coverage) [](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
No description provided.
No description provided.
No description provided.
No description provided.