This is a Ruby port of the https://github.com/Operational-Transformation/ot.js Operational Transformation library.
At this time, only TextOperation has been ported.
Add this line to your application's Gemfile:
gem 'ot'And then execute:
$ bundle
Or install it yourself as:
$ gem install ot
retain(n)
Skip over a given number of charaters
insert(string)
Insert a string at the current position
delete(n)
Delete a string at the current position
noop?
Tests whether this operation has no effect.
to_a
Converts operation into an array value.
Note that this replaces the toJSON method in ot.js
self.from_a(ops)
Converts an array into an operation and validates it.
Note that this replaces the fromJSON method in ot.js
apply(str)
Apply an operation to a string, returning a new string. Throws an error if there's a mismatch between the input string and the operation.
invert(str)
Computes the inverse of an operation. The inverse of an operation is the operation that reverts the effects of the operation, e.g. when you have an operation 'insert("hello "); skip(6);' then the inverse is 'delete("hello "); skip(6);'. The inverse should be used for implementing undo.
compose(operation2)
Compose merges two consecutive operations into one operation, that preserves the changes of both. Or, in other words, for each input string S and a pair of consecutive operations A and B, apply(apply(S, A), B) = apply(S, compose(A, B)) must hold.
compose_with?(other)
When you use ctrl-z to undo your latest changes, you expect the program not to undo every single keystroke but to undo your last sentence you wrote at a stretch or the deletion you did by holding the backspace key down. This This can be implemented by composing operations on the undo stack. This method can help decide whether two operations should be composed. It returns true if the operations are consecutive insert operations or both operations delete text at the same position. You may want to include other factors like the time since the last change in your decision.
compose_with_inverted?(other)
Decides whether two operations should be composed with each other
if they were inverted, that is
shouldBeComposedWith(a, b) = shouldBeComposedWithInverted(b^{-1}, a^{-1}).
transform(operation1, operation2)
Transform takes two operations A and B that happened concurrently and
produces two operations A' and B' (in an array) such that
apply(apply(S, A), B') = apply(apply(S, B), A'). This function is the
heart of OT.
After checking out the repo, run bundle install to install dependencies. Then,
run rake rspec to run the tests. You can also run bin/console for an
interactive prompt that will allow you to experiment.
Bug reports and pull requests are welcome on GitHub at https://github.com/ball-hayden/ot.rb.
The gem is available as open source under the terms of the MIT License.