Research
Security News
Malicious npm Packages Inject SSH Backdoors via Typosquatted Libraries
Socket’s threat research team has detected six malicious npm packages typosquatting popular libraries to insert SSH backdoors.
custom-ability
Advanced tools
make custom ability more easy. generate the ability which can be added to any class directly.
generate the ability which can be added to any class directly. It makes custom ability more easy.
Sometimes, we still feel that the class is a liitle big, and too many features in it. We just need some of the features(methods) inside. So as a class developer can consider these functions to extract, as a kind of ability to the user.
suppose we wanna add the RefCount ability to any class directly.
the RefCount ability will add the following members to your class.
and you should implement the destroy
method which will be called
by release
/free
.
release()
/free()
: Decrements reference count for this instance.
If it is becoming less than 0, the object would be (self) destroyed.addRef()
: Increments the reference count for this instance
and returns the new reference count.Note: The same name of the methods will be replaced via the ability. These old methods will be lost. So, you must confirm whether there are the same methods in your class before you apply the new ability.
customAbility = require 'custom-ability'
class RefCountable
# define the instance methods here:
release: ->
result = --@RefCount
@destroy() unless result >= 0
result
free: @::release
addRef: ->
if not isUndefined @RefCount
++@RefCount
else
@RefCount = 1
# the class methods if any:
@someClassMethod: ->
module.exports = customAbility RefCountable, 'addRef'
do not forget to add the "ability"
keyword to your package.json which means
the ability power with it.
// package.json
"keywords": [
"ability",
...
],
do not forget to add the "ability.js"
file on your package root folder too.
now user use this ability like this:
refable = require 'ref-object/ability'
class MyClass
refable MyClass
destroy: ->console.log 'destroy'
my = new MyClass
my.addRef()
my.free() # nothing
my.free() # print the 'destroy' here.
More complicated example, you can see the events-ex/src/eventable.coffee.
In order to make certain ability to work, you need to modify some methods of the class. this time we need the "additional abilities" now. eg, the event-able ability to AbstractObject. We need to send a notification event when the state of the object changes. So the event-able of AbstractObject should be:
eventable = require 'events-ex/eventable'
eventableOptions = require './eventable-options'
module.exports = (aClass, aOptions)->
eventable aClass, eventableOptions(aOptions)
# eventable-options.coffee
module.exports = (aOptions)->
aOptions = {} unless aOptions
aOptions.methods = {} unless aOptions.methods
extend aOptions.methods,
# override methods:
setObjectState: (value, emitted = true)->
self= @self
@super.call(self, value)
self.emit value, self if emitted
return
...
return aOptions
# more detail on [AbstractObject/src/eventable-options.coffee](https://github.com/snowyu/abstract-object)
the original eventable('events-ex/eventable')
is no useful for AbstractObject.
but we wanna the original eventable('events-ex/eventable')
knows the changes
and use it automatically.
eventable = require 'events-ex/eventable'
class MyClass
inherits MyClass, AbstractObject
eventable MyClass
you just do this on the AbstractObject:
AbstractObject = require('./lib/abstract-object')
AbstractObject.$abilities =
# "Eventable" is the AbilityClass name
Eventable: require('./lib/eventable-options')
module.exports = AbstractObject
just one function:
var customAbility = require('custom-ability')
arguments
AbilityClass
is a function(aClass, aOptions)
to return the real Ability Class
if true. defaults to false.return
the custom ability function has two arguments: function(class[, options])
class
: the class to be injected the ability.options
(object): optional options
include
(array|string): only these emitter methods will be added to the classexclude
(array|string): theses emitter methods would not be added to the class
coreMethod
could not be excluded. It's always added to the class.methods
(object): injected/hooked methods to the class
this.super()
to call the original method.this.self
is the original this
object.classMethods
(object): hooked class methods to the class, it's the same as the methods
.replacedMethods
(array): the method name in the array will be replaced the original
method directly.super
method. you can exclude it with normal name if it's not a core method.customAbility = require 'custom-ability'
class PropertyManagerAbility
constructor: ->@initialize.call @, arguments[gOptPos]
# the non-enumerable property and beginning with '$' will
# be injected to `initialize` method
defineProperty @::, '$initialize', ->
options = arugments[gOptPos]
options?={}
that = @
if @super and @self
inherited = @super
that = @self
inherited.apply(that, arugments)
that._initialize options if isFunction that._initialize
that.defineProperties(options.attributes)
that.assign(options)
module.exports = customAbility PropertyManagerAbility, 'assign'
: additional abilities usage changed
Put the '$abilities'(object) property on your prototype of class if need to modify the class before apply ability.
$abilities
object key is the AbilityClass NameAbstractObject = require('./lib/abstract-object')
AbstractObject.$abilities = {
# "Eventable" is the AbilityClass name
# the value is modified ability function.
Eventable: require('./lib/eventable-options')
}
module.exports = AbstractObject
the eventable-options.coffee file:
# eventable-options.coffee
module.exports = (aOptions)->
aOptions = {} unless aOptions
aOptions.methods = {} unless aOptions.methods
extend aOptions.methods,
# override methods:
setObjectState: (value, emitted = true)->
self= @self
@super.call(self, value)
self.emit value, self if emitted
return
...
return aOptions
# more detail on [AbstractObject/src/eventable-options.coffee](https://github.com/snowyu/abstract-object)
the AbstractObject's 'eventable' function:
eventable = require 'events-ex/eventable'
eventableOptions = require './eventable-options'
module.exports = (aClass, aOptions)->
eventable aClass, eventableOptions(aOptions)
ability = require('custom-ability/require')
class MyClass
#get the stateable ability from AbstractObject for MyClass
ability 'abstract-object', MyClass
$abilities
object key is the AbilityClass NameAbstractObject = require('./lib/abstract-object')
AbstractObject.$abilities = {
# "Eventable" is the AbilityClass name
# the value is modified ability function.
Eventable: require('./eventable')
}
module.exports = AbstractObject
the AbstractObject's 'eventable' function:
eventable = require 'events-ex/eventable'
module.exports = (aClass)->
eventable aClass, methods:
# override methods:
# we need to emit event when object state changes.
setObjectState: (value, emitted = true)->
self= @self
@super.call(self, value)
self.emit value, self if emitted
return
...
# more detail on [AbstractObject/src/eventable](https://github.com/snowyu/abstract-object)
FAQs
make custom ability more easy. generate the ability which can be added to any class directly.
We found that custom-ability demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Security News
Socket’s threat research team has detected six malicious npm packages typosquatting popular libraries to insert SSH backdoors.
Security News
MITRE's 2024 CWE Top 25 highlights critical software vulnerabilities like XSS, SQL Injection, and CSRF, reflecting shifts due to a refined ranking methodology.
Security News
In this segment of the Risky Business podcast, Feross Aboukhadijeh and Patrick Gray discuss the challenges of tracking malware discovered in open source softare.