Generate a personalized Spotify Wrapped-style summary of your Amp Code usage
A tiny and fast text wrap library which takes ANSI escapes into account.
Wrapped version of http://www.strictly-software.com/htmlencode
TypeScript compiler wrapper for static analysis and code manipulation.
A plugin for CodeMirror to handle wrapped line indentation
A small collection of utilities for making functions somewhat resilient against errors.
SumSub WebSdk React
Components to provide and consume RTL or LTR direction in React
ESLint plugin to highlight code patterns in React applications which can lead to browser exceptions while the Google Translate browser extension is in use.
Wrap a function without changing its name and other properties
Enforce that all function components are wrapped in `React.memo`, and that all props and deps are wrapped in `useMemo`/`useCallback` so they don’t break memo.
A tiny, PEG-like system for building language grammars with regexes.
Block Drag & Drop Plugin for DraftJS
An elegant, accessible toggle component for React. Also a glorified checkbox.
Type declarations for the Telegram API
Make a function mimic another one
Clamping primitives for Vue.
mdast utility to generate a table of contents from a tree
consistent interface for
Arcjet local analysis engine
Tiny, dependency free promisify library.
Prevent display sleep and enable wake lock in any Android or iOS web browser
TypeScript SDK for interacting with the Stacks Wrapped smart contract
Run jscodeshift on Vue single file components
Ruby cli for wrapping UI mockups in a device frame. Supports iPhone 6 (black & white), more devices coming soon.
What is Nexter ? A misspelled tv show or a killer feature ? Almost : it wraps your model with an ordered scope and cuts out the next and previous record. It also works with associations & nested columns.
Thanks to Pat Allan & his regex-fu, Anthony Kolber (http://aestheticallyloyal.com/) for showing me Typogrify. Square Circle Triangle (http://sct.com.au/) because I mashed it together on a Friday afternoon at work :) == FEATURES/PROBLEMS: * Multiple adjacent caps are wrapped in <span class="caps"> (Gives you a handle on small caps) * Single and double quotes are wrapped in a class name matching their entity name in HTML * Ampersands wrapped in <span class="amp"> * Runs smarty pants (Which writes HTML entities so that you don't have to) * No more widows in your headlines * Extends the string class == USAGE:
# 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