https://github.com/ramadis/unmiss
🔍 Ruby's method_missing implementation in modern javascript
https://github.com/ramadis/unmiss
javascript metaprogramming method-missing ruby
Last synced: about 1 year ago
JSON representation
🔍 Ruby's method_missing implementation in modern javascript
- Host: GitHub
- URL: https://github.com/ramadis/unmiss
- Owner: ramadis
- License: mit
- Created: 2017-09-01T06:23:44.000Z (over 8 years ago)
- Default Branch: master
- Last Pushed: 2021-11-11T23:33:22.000Z (over 4 years ago)
- Last Synced: 2024-08-11T09:24:10.133Z (over 1 year ago)
- Topics: javascript, metaprogramming, method-missing, ruby
- Language: JavaScript
- Homepage:
- Size: 213 KB
- Stars: 27
- Watchers: 4
- Forks: 2
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Unmiss 🔍
**Unmiss** is a Ruby's `method_missing` implementation you can use in your javascript classes. Basically, it is a method that is called when no matching method is found. It gives you a way to intercept unanswerable messages and handle them gracefully. Learn more about `method_missing` [here](http://rubylearning.com/satishtalim/ruby_method_missing.html).
[](https://travis-ci.org/ramadis/unmiss)
## Requirements
**Unmiss** uses ES6 `Proxies` to simulate `method_missing`, so it will run on node versions >= v6.4.0. It also supports [most modern browsers](https://caniuse.com/proxy).
## Installation
```bash
npm install --save unmiss
```
## Usage and Examples
There are multiple ways to use **Unmiss**: Using class inheritance, by calling a high order function, using [decorators](https://github.com/tc39/proposal-decorators), or wrapping an existing instance. Whichever way you prefer, add to your class a `methodMissing` method to generate an awesome safety net method.
Using a high order function:
```js
import { withMethodMissing } from 'unmiss'
class Example {
methodMissing(name, ...args) {
console.log(`Method ${name} was called with arguments: ${args.join(' ')}`);
}
}
const instance = new withMethodMissing(Example);
instance.what('is', 'this');
> Method what was called with arguments: is this
```
Using a modern javascript decorator:
```js
import { withMethodMissing } from 'unmiss'
@withMethodMissing
class Example {
methodMissing(name, ...args) {
console.log(`Method ${name} was called with arguments: ${args.join(' ')}`);
}
}
const instance = new Example();
instance.what('is', 'this');
> Method what was called with arguments: is this
```
Using ES6 classical inheritance:
```js
import { MethodMissingClass } from 'unmiss'
class Example extends MethodMissingClass {
methodMissing(name, ...args) {
console.log(`Method ${name} was called with arguments: ${args.join(' ')}`);
}
}
const instance = new Example();
instance.what('is', 'this');
> Method what was called with arguments: is this
```
**ALERT:** If you choose to use the inheritance way, take into account that if you want to use a `constructor` in your class, you will have to call `super()` first.
Wrapping an existing instance of a class:
```js
import { addMethodMissing } from 'unmiss'
class Example {
methodMissing(name, ...args) {
console.log(`Method ${name} was called with arguments: ${args.join(' ')}`);
}
}
const instance = addMethodMissing(new Example());
instance.what('is', 'this');
> Method what was called with arguments: is this
```
## Contributing
Feel free to submit any issues and PRs you want. To run the project first install its dependencies:
```sh
npm install
```
Then build it and test it:
```sh
npm run build && npm run test
```