B
benny
Benny is happy to announce his first published piece of software:
"FaceToFace" available as gem.
Dear list,
I hope this is useful for someone and I am curious what you think about it.
The code itself is no big deal and always open for improvements (as my
english is).
= Overview
FaceToFace aims to standardize the conversion and messaging
between classes and objects.
You may think of it as syntactic sugar and as duck-typing taken to
the next level (imagine two ducks face to face, none of them being a real
duck).
Up to now we had to remember each method that converts to a
certain class, e.g. 'to_i' converts to Integer, 'to_s' converts to String
etc.
With FaceToFace you only have to remember one method and
you need to know the class to convert to, e.g.
5.to(String ) #=> "5"
"6".to( Integer ) #=> 6
That way you could double-ducktype, i.e. you may not care
about the class of any object you convert to or from, e.g.
def double_duck_me( duck1, duck2 )
duck1.to( duck2.class_name )
end
Instead of using to() you could also use from() to access the result of a
conversion, e.g.
Array.from( "test" ) #=> ["test"]
String.from( 4 ) #=> "4"
Furthermore you can pass objects instead of classes as well
5.to( "" ) #=> "5"
"6".from( 4 ) #=> "4"
This allows you to pass messages between objects and modify them completely
or partially, e.g.
class MyClass
attr_accessor :message, :data
end
class YourClass
attr_accessor :message, :data
end
MyClass.register_from( YourClass ) do |my, your|
my.message = your.data
my
end
my = MyClass.new
my.data = "my Data"
your = YourClass.new
your.data = "your Data"
my.from( your )
#=> #<MyClass:0x806c56c @data="my Data", @message="your Data">
== Benefits
+ Unfied way to define Object / Class conversions
+ Ability to seperate the code of conversion methods from the classes
itself for continuous optimization/version-replacement
+ "blind" conversion to/from foreign classes
+ indirect conversion via slots in the future
+ you don't have to invent new methods each time you need to define a
conversion
- maybe performance
- a little more effort to define the conversion methods
== Future
In the near future there will be a Slot class that is meant to be an
Interface to most of the core types/classes.
If two classes have a conversion method to/from the same Slot, it will be
possible to convert them into each other via this Slot. This should
sometimes eliminate the need of direct or multiple conversion.
== Installation
gem install FaceToFace --remote
== Example of usage
require 'rubygems'
require_gem 'FaceToFace'
# not needed but recommended (registers to_a, to_s and the like)
require 'basic_registration'
# registration of the conversion methods of self defined classes, e.g.
MyClass.register_from( YourClass ) do |my, your|
my.message = your.data
my.message
end
MyClass.register_to( YourClass ) do |my, your|
your.message = my.data
your.message
end
# You may overwrite singleton methods for objects and classes
class MyClass
def initialize(data)
@data = data
end
def MyClass.from(obj, via=nil)
FaceToFace::Registry.from( (self.new(obj.message) ), obj, via )
end
end
your.message = "your Message"
MyClass.from( your )
#=> #<MyClass:0x810d8d8 @data="your Message", @message="your Data">
----------------------------------------
Project Website: http://rubyforge.org/projects/facetoface
Contact: (e-mail address removed)
benny
---------------------------------------------------------------------------------------------------
Don't crash when a filter changes the subject of a message which results
in the attempt to remove it from the tree of subject threading messages
failing and the detached child looking for a new parent finding the old
parent as the new parent, which in turn results in the child being deleted
with the old (and new) parent, which is not a good idea, since it is
still referenced.
(Till Adams commit on kdepim/kmail/kmheaders.cpp in HEAD, 6. Jan. 2005)
"FaceToFace" available as gem.
Dear list,
I hope this is useful for someone and I am curious what you think about it.
The code itself is no big deal and always open for improvements (as my
english is).
= Overview
FaceToFace aims to standardize the conversion and messaging
between classes and objects.
You may think of it as syntactic sugar and as duck-typing taken to
the next level (imagine two ducks face to face, none of them being a real
duck).
Up to now we had to remember each method that converts to a
certain class, e.g. 'to_i' converts to Integer, 'to_s' converts to String
etc.
With FaceToFace you only have to remember one method and
you need to know the class to convert to, e.g.
5.to(String ) #=> "5"
"6".to( Integer ) #=> 6
That way you could double-ducktype, i.e. you may not care
about the class of any object you convert to or from, e.g.
def double_duck_me( duck1, duck2 )
duck1.to( duck2.class_name )
end
Instead of using to() you could also use from() to access the result of a
conversion, e.g.
Array.from( "test" ) #=> ["test"]
String.from( 4 ) #=> "4"
Furthermore you can pass objects instead of classes as well
5.to( "" ) #=> "5"
"6".from( 4 ) #=> "4"
This allows you to pass messages between objects and modify them completely
or partially, e.g.
class MyClass
attr_accessor :message, :data
end
class YourClass
attr_accessor :message, :data
end
MyClass.register_from( YourClass ) do |my, your|
my.message = your.data
my
end
my = MyClass.new
my.data = "my Data"
your = YourClass.new
your.data = "your Data"
my.from( your )
#=> #<MyClass:0x806c56c @data="my Data", @message="your Data">
== Benefits
+ Unfied way to define Object / Class conversions
+ Ability to seperate the code of conversion methods from the classes
itself for continuous optimization/version-replacement
+ "blind" conversion to/from foreign classes
+ indirect conversion via slots in the future
+ you don't have to invent new methods each time you need to define a
conversion
- maybe performance
- a little more effort to define the conversion methods
== Future
In the near future there will be a Slot class that is meant to be an
Interface to most of the core types/classes.
If two classes have a conversion method to/from the same Slot, it will be
possible to convert them into each other via this Slot. This should
sometimes eliminate the need of direct or multiple conversion.
== Installation
gem install FaceToFace --remote
== Example of usage
require 'rubygems'
require_gem 'FaceToFace'
# not needed but recommended (registers to_a, to_s and the like)
require 'basic_registration'
# registration of the conversion methods of self defined classes, e.g.
MyClass.register_from( YourClass ) do |my, your|
my.message = your.data
my.message
end
MyClass.register_to( YourClass ) do |my, your|
your.message = my.data
your.message
end
# You may overwrite singleton methods for objects and classes
class MyClass
def initialize(data)
@data = data
end
def MyClass.from(obj, via=nil)
FaceToFace::Registry.from( (self.new(obj.message) ), obj, via )
end
end
your.message = "your Message"
MyClass.from( your )
#=> #<MyClass:0x810d8d8 @data="your Message", @message="your Data">
----------------------------------------
Project Website: http://rubyforge.org/projects/facetoface
Contact: (e-mail address removed)
benny
---------------------------------------------------------------------------------------------------
Don't crash when a filter changes the subject of a message which results
in the attempt to remove it from the tree of subject threading messages
failing and the detached child looking for a new parent finding the old
parent as the new parent, which in turn results in the child being deleted
with the old (and new) parent, which is not a good idea, since it is
still referenced.
(Till Adams commit on kdepim/kmail/kmheaders.cpp in HEAD, 6. Jan. 2005)
