concurrent-ruby 0.7.0.rc1-x86-solaris-2.11 → 0.7.0.rc2-x86-solaris-2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f961593582c44b7f41e545c1203588da585ab96
-  data.tar.gz: 4b65af75c6c98497f90897c0fab976e7fcb0b5e7
+  metadata.gz: 2e851c255a67a6fc45285fa0945f7c15f6aa44cb
+  data.tar.gz: 8a560af27570c136596e05bfbb8b7a05831bc686
 SHA512:
-  metadata.gz: ca7a31c0accb5d0872f74205e58d80e59960fbb440688fe9d85f7840ee4d463bc2706262d6aa1779a36ffa7fcbf2caffc3b7308afe82bfc9152fa3c183712aa8
-  data.tar.gz: 0666007eed4a5d9d995a2d457f58d0c6ad399bc502bc85734613a679d2800662aa3621043b67b5c4f737b4964a660390ae18d2153e981ee7d4bcc21d11ca6782
+  metadata.gz: f15adb8bf748b1da9d61c604bfb6d9a207d1c074464c4bd4f136d1eda1189911805e93fac577f104b8113bb0d88cf5a91cbaa443585a38f52772e9199568c46d
+  data.tar.gz: 37de66b3c064dbe7e7ed2b7e6dcaf5a21689293eb3a70d88e47aa169c03700b16d6194ea9dec8f7806519c3065d9855713cf0d9def643bb12eccd1310440e76b

data/README.md

@@ -1,5 +1,5 @@
 # Concurrent Ruby
-[![Gem Version](https://badge.fury.io/rb/concurrent-ruby.png)](http://badge.fury.io/rb/concurrent-ruby) [![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby) [![Coverage Status](https://coveralls.io/repos/ruby-concurrency/concurrent-ruby/badge.png)](https://coveralls.io/r/ruby-concurrency/concurrent-ruby) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.png)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby) [![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.png)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby) [![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.png)](https://gemnasium.com/ruby-concurrency/concurrent-ruby) [![Gitter chat](https://badges.gitter.im/ruby-concurrency.png)](https://gitter.im/ruby-concurrency)
+[![Gem Version](https://badge.fury.io/rb/concurrent-ruby.png)](http://badge.fury.io/rb/concurrent-ruby) [![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby) [![Coverage Status](https://coveralls.io/repos/ruby-concurrency/concurrent-ruby/badge.png)](https://coveralls.io/r/ruby-concurrency/concurrent-ruby) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.png)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby) [![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.png)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby) [![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.png)](https://gemnasium.com/ruby-concurrency/concurrent-ruby) [![Gitter chat](https://badges.gitter.im/ruby-concurrency/concurrent-ruby.png)](https://gitter.im/ruby-concurrency/concurrent-ruby)
 
 <table>
   <tr>
@@ -54,7 +54,7 @@ _NOTE: There is an old gem from 2007 called "concurrent" that does not appear to
 ## Features & Documentation
 
 Please see the [Concurrent Ruby Wiki](https://github.com/ruby-concurrency/concurrent-ruby/wiki)
-or the [API documentation](http://ruby-concurrency.github.io/concurrent-ruby/frames.html))
+or the [API documentation](http://ruby-concurrency.github.io/concurrent-ruby/frames.html)
 for more information or join our [mailing list](http://groups.google.com/group/concurrent-ruby).
 
 There are many concurrency abstractions in this library. These abstractions can be broadly categorized
@@ -146,6 +146,7 @@ task.value #=> 25.96
 * [Chip Miller](https://github.com/chip-miller)
 * [Giuseppe Capizzi](https://github.com/gcapizzi)
 * [Jamie Hodge](https://github.com/jamiehodge)
+* [Justin Lambert](https://github.com/mastfish)
 * [Larry Lv](https://github.com/larrylv)
 * [Maxim Chechel](https://github.com/maximchick)
 * [Ravil Bayramgalin](https://github.com/brainopia)

data/ext/concurrent_ruby_ext/atomic_boolean.c

@@ -0,0 +1,48 @@
+#include <ruby.h>
+
+#include "atomic_boolean.h"
+#include "atomic_reference.h"
+#include "ruby_193_compatible.h"
+
+void atomic_boolean_mark(void *value) {
+  rb_gc_mark_maybe((VALUE) value);
+}
+
+VALUE atomic_boolean_allocate(VALUE klass) {
+  return rb_data_object_alloc(klass, (void *) Qfalse, atomic_boolean_mark, NULL);
+}
+
+VALUE method_atomic_boolean_initialize(int argc, VALUE* argv, VALUE self) {
+  VALUE value = Qfalse;
+  rb_check_arity(argc, 0, 1);
+  if (argc == 1) value = TRUTHY(argv[0]);
+  DATA_PTR(self) = (void *) value;
+  return(self);
+}
+
+VALUE method_atomic_boolean_value(VALUE self) {
+  return (VALUE) DATA_PTR(self);
+}
+
+VALUE method_atomic_boolean_value_set(VALUE self, VALUE value) {
+  VALUE new_value = TRUTHY(value);
+  DATA_PTR(self) = (void *) new_value;
+  return(new_value);
+}
+
+VALUE method_atomic_boolean_true_question(VALUE self) {
+  return(method_atomic_boolean_value(self));
+}
+
+VALUE method_atomic_boolean_false_question(VALUE self) {
+  VALUE current = method_atomic_boolean_value(self);
+  return(current == Qfalse ? Qtrue : Qfalse);
+}
+
+VALUE method_atomic_boolean_make_true(VALUE self) {
+  return(ir_compare_and_set(self, Qfalse, Qtrue));
+}
+
+VALUE method_atomic_boolean_make_false(VALUE self) {
+  return(ir_compare_and_set(self, Qtrue, Qfalse));
+}

data/ext/concurrent_ruby_ext/atomic_boolean.h

@@ -0,0 +1,16 @@
+#ifndef __ATOMIC_BOOLEAN_H__
+#define __ATOMIC_BOOLEAN_H__
+
+#define TRUTHY(value)(value == Qfalse || value == Qnil ? Qfalse : Qtrue)
+
+void atomic_boolean_mark(void*);
+VALUE atomic_boolean_allocate(VALUE);
+VALUE method_atomic_boolean_initialize(int, VALUE*, VALUE);
+VALUE method_atomic_boolean_value(VALUE);
+VALUE method_atomic_boolean_value_set(VALUE, VALUE);
+VALUE method_atomic_boolean_true_question(VALUE);
+VALUE method_atomic_boolean_false_question(VALUE);
+VALUE method_atomic_boolean_make_true(VALUE);
+VALUE method_atomic_boolean_make_false(VALUE);
+
+#endif

data/ext/concurrent_ruby_ext/atomic_fixnum.c

@@ -0,0 +1,50 @@
+#include <ruby.h>
+
+#include "atomic_fixnum.h"
+#include "atomic_reference.h"
+#include "ruby_193_compatible.h"
+
+void atomic_fixnum_mark(void *value) {
+  rb_gc_mark_maybe((VALUE) value);
+}
+
+VALUE atomic_fixnum_allocate(VALUE klass) {
+  return rb_data_object_alloc(klass, (void *) Qnil, atomic_fixnum_mark, NULL);
+}
+
+VALUE method_atomic_fixnum_initialize(int argc, VALUE* argv, VALUE self) {
+  VALUE value = LL2NUM(0);
+  rb_check_arity(argc, 0, 1);
+  if (argc == 1) {
+    Check_Type(argv[0], T_FIXNUM);
+    value = argv[0];
+  }
+  DATA_PTR(self) = (void *) value;
+  return(self);
+}
+
+VALUE method_atomic_fixnum_value(VALUE self) {
+  return (VALUE) DATA_PTR(self);
+}
+
+VALUE method_atomic_fixnum_value_set(VALUE self, VALUE value) {
+  Check_Type(value, T_FIXNUM);
+  DATA_PTR(self) = (void *) value;
+  return(value);
+}
+
+VALUE method_atomic_fixnum_increment(VALUE self) {
+  long long value = NUM2LL((VALUE) DATA_PTR(self));
+  return method_atomic_fixnum_value_set(self, LL2NUM(value + 1));
+}
+
+VALUE method_atomic_fixnum_decrement(VALUE self) {
+  long long value = NUM2LL((VALUE) DATA_PTR(self));
+  return method_atomic_fixnum_value_set(self, LL2NUM(value - 1));
+}
+
+VALUE method_atomic_fixnum_compare_and_set(VALUE self, VALUE rb_expect, VALUE rb_update) {
+  Check_Type(rb_expect, T_FIXNUM);
+  Check_Type(rb_update, T_FIXNUM);
+  return ir_compare_and_set(self, rb_expect, rb_update);
+}

data/ext/concurrent_ruby_ext/atomic_fixnum.h

@@ -0,0 +1,13 @@
+#ifndef __ATOMIC_FIXNUM_H__
+#define __ATOMIC_FIXNUM_H__
+
+void atomic_fixnum_mark(void*);
+VALUE atomic_fixnum_allocate(VALUE);
+VALUE method_atomic_fixnum_initialize(int, VALUE*, VALUE);
+VALUE method_atomic_fixnum_value(VALUE);
+VALUE method_atomic_fixnum_value_set(VALUE, VALUE);
+VALUE method_atomic_fixnum_increment(VALUE);
+VALUE method_atomic_fixnum_decrement(VALUE);
+VALUE method_atomic_fixnum_compare_and_set(VALUE, VALUE, VALUE);
+
+#endif

data/ext/concurrent_ruby_ext/atomic_reference.c

@@ -1,78 +1,78 @@
 #include <ruby.h>
-#if defined(__sun)
-#include <atomic.h>
-#endif
+/*#if defined(__sun)*/
+/*#include <atomic.h>*/
+/*#endif*/
 
-#ifdef HAVE_LIBKERN_OSATOMIC_H
-#include <libkern/OSAtomic.h>
-#endif
+/*#ifdef HAVE_LIBKERN_OSATOMIC_H*/
+/*#include <libkern/OSAtomic.h>*/
+/*#endif*/
 
 #include "atomic_reference.h"
 
 void ir_mark(void *value) {
-    rb_gc_mark_maybe((VALUE) value);
+  rb_gc_mark_maybe((VALUE) value);
 }
 
 VALUE ir_alloc(VALUE klass) {
-    return rb_data_object_alloc(klass, (void *) Qnil, ir_mark, NULL);
+  return rb_data_object_alloc(klass, (void *) Qnil, ir_mark, NULL);
 }
 
 VALUE ir_initialize(int argc, VALUE* argv, VALUE self) {
-    VALUE value = Qnil;
-    if (rb_scan_args(argc, argv, "01", &value) == 1) {
-	value = argv[0];
-    }
-    DATA_PTR(self) = (void *) value;
-    return Qnil;
+  VALUE value = Qnil;
+  if (rb_scan_args(argc, argv, "01", &value) == 1) {
+    value = argv[0];
+  }
+  DATA_PTR(self) = (void *) value;
+  return Qnil;
 }
 
 VALUE ir_get(VALUE self) {
-    return (VALUE) DATA_PTR(self);
+  return (VALUE) DATA_PTR(self);
 }
 
 VALUE ir_set(VALUE self, VALUE new_value) {
-    DATA_PTR(self) = (void *) new_value;
-    return new_value;
+  DATA_PTR(self) = (void *) new_value;
+  return new_value;
 }
 
 VALUE ir_get_and_set(VALUE self, VALUE new_value) {
-    VALUE old_value;
-    old_value = (VALUE) DATA_PTR(self);
-    DATA_PTR(self) = (void *) new_value;
-    return old_value;
+  VALUE old_value;
+  old_value = (VALUE) DATA_PTR(self);
+  DATA_PTR(self) = (void *) new_value;
+  return old_value;
 }
 
 VALUE ir_compare_and_set(volatile VALUE self, VALUE expect_value, VALUE new_value) {
 #if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
-    if (OSAtomicCompareAndSwap64(expect_value, new_value, &DATA_PTR(self))) {
-	return Qtrue;
-    }
+  if (OSAtomicCompareAndSwap64(expect_value, new_value, &DATA_PTR(self))) {
+    return Qtrue;
+  }
 #elif defined(__sun)
-/*  Assuming VALUE is uintptr_t */
-/*  Based on the definition of uintptr_t from /usr/include/sys/int_types.h */
+  /*  Assuming VALUE is uintptr_t */
+  /*  Based on the definition of uintptr_t from /usr/include/sys/int_types.h */
 #if defined(_LP64) || defined(_I32LPx)
-    /*  64-bit: uintptr_t === unsigned long */
-    if (atomic_cas_ulong((uintptr_t *) &DATA_PTR(self), expect_value, new_value)) {
-        return Qtrue;
-    }
+  /*  64-bit: uintptr_t === unsigned long */
+  if (atomic_cas_ulong((uintptr_t *) &DATA_PTR(self), expect_value, new_value)) {
+    return Qtrue;
+  }
 #else
-    /*  32-bit: uintptr_t === unsigned int */
-    if (atomic_cas_uint((uintptr_t *) &DATA_PTR(self), expect_value, new_value)) {
-        return Qtrue;
-    }
+  /*  32-bit: uintptr_t === unsigned int */
+  if (atomic_cas_uint((uintptr_t *) &DATA_PTR(self), expect_value, new_value)) {
+    return Qtrue;
+  }
 #endif
 #elif defined _MSC_VER && defined _M_AMD64
-    if (InterlockedCompareExchange64((LONGLONG*)&DATA_PTR(self), new_value, expect_value)) {
-	return Qtrue;
-    }
+  if (InterlockedCompareExchange64((LONGLONG*)&DATA_PTR(self), new_value, expect_value)) {
+    return Qtrue;
+  }
 #elif defined _MSC_VER && defined _M_IX86
-    if (InterlockedCompareExchange((LONG*)&DATA_PTR(self), new_value, expect_value)) {
-	return Qtrue;
-    }
+  if (InterlockedCompareExchange((LONG*)&DATA_PTR(self), new_value, expect_value)) {
+    return Qtrue;
+  }
 #else
-    if (__sync_bool_compare_and_swap(&DATA_PTR(self), expect_value, new_value)) {
-	return Qtrue;
-    }
+  if (__sync_bool_compare_and_swap(&DATA_PTR(self), expect_value, new_value)) {
+    return Qtrue;
+  }
 #endif
-    return Qfalse;
+  return Qfalse;
 }

data/ext/concurrent_ruby_ext/atomic_reference.h

@@ -1,6 +1,14 @@
 #ifndef __ATOMIC_REFERENCE_H__
 #define __ATOMIC_REFERENCE_H__
 
+#if defined(__sun)
+#include <atomic.h>
+#endif
+
+#ifdef HAVE_LIBKERN_OSATOMIC_H
+#include <libkern/OSAtomic.h>
+#endif
+
 void ir_mark(void*);
 VALUE ir_alloc(VALUE);
 VALUE ir_initialize(int, VALUE*, VALUE);

data/ext/concurrent_ruby_ext/rb_concurrent.c

@@ -1,11 +1,15 @@
 #include <ruby.h>
 
 #include "atomic_reference.h"
+#include "atomic_boolean.h"
+#include "atomic_fixnum.h"
 
 // module and class definitions
 
 static VALUE rb_mConcurrent;
 static VALUE rb_cAtomic;
+static VALUE rb_cAtomicBoolean;
+static VALUE rb_cAtomicFixnum;
 
 // Init_concurrent_ruby_ext
 
@@ -14,15 +18,40 @@ void Init_concurrent_ruby_ext() {
   // define modules and classes
   rb_mConcurrent = rb_define_module("Concurrent");
   rb_cAtomic = rb_define_class_under(rb_mConcurrent, "CAtomic", rb_cObject);
+  rb_cAtomicBoolean = rb_define_class_under(rb_mConcurrent, "CAtomicBoolean", rb_cObject);
+  rb_cAtomicFixnum = rb_define_class_under(rb_mConcurrent, "CAtomicFixnum", rb_cObject);
 
   // CAtomic
   rb_define_alloc_func(rb_cAtomic, ir_alloc);
   rb_define_method(rb_cAtomic, "initialize", ir_initialize, -1);
   rb_define_method(rb_cAtomic, "get", ir_get, 0);
-  rb_define_method(rb_cAtomic, "value", ir_get, 0);
   rb_define_method(rb_cAtomic, "set", ir_set, 1);
-  rb_define_method(rb_cAtomic, "value=", ir_set, 1);
   rb_define_method(rb_cAtomic, "get_and_set", ir_get_and_set, 1);
-  rb_define_method(rb_cAtomic, "swap", ir_get_and_set, 1);
   rb_define_method(rb_cAtomic, "_compare_and_set", ir_compare_and_set, 2);
+  rb_define_alias(rb_cAtomic, "value", "get");
+  rb_define_alias(rb_cAtomic, "value=", "set");
+  rb_define_alias(rb_cAtomic, "swap", "get_and_set");
+
+  // CAtomicBoolean
+  rb_define_alloc_func(rb_cAtomicBoolean, atomic_boolean_allocate);
+  rb_define_method(rb_cAtomicBoolean, "initialize", method_atomic_boolean_initialize, -1);
+  rb_define_method(rb_cAtomicBoolean, "value", method_atomic_boolean_value, 0);
+  rb_define_method(rb_cAtomicBoolean, "value=", method_atomic_boolean_value_set, 1);
+  rb_define_method(rb_cAtomicBoolean, "true?", method_atomic_boolean_true_question, 0);
+  rb_define_method(rb_cAtomicBoolean, "false?", method_atomic_boolean_false_question, 0);
+  rb_define_method(rb_cAtomicBoolean, "make_true", method_atomic_boolean_make_true, 0);
+  rb_define_method(rb_cAtomicBoolean, "make_false", method_atomic_boolean_make_false, 0);
+
+  // CAtomicFixnum
+  rb_define_const(rb_cAtomicFixnum, "MIN_VALUE", LL2NUM(LLONG_MIN));
+  rb_define_const(rb_cAtomicFixnum, "MAX_VALUE", LL2NUM(LLONG_MAX));
+  rb_define_alloc_func(rb_cAtomicFixnum, atomic_fixnum_allocate);
+  rb_define_method(rb_cAtomicFixnum, "initialize", method_atomic_fixnum_initialize, -1);
+  rb_define_method(rb_cAtomicFixnum, "value", method_atomic_fixnum_value, 0);
+  rb_define_method(rb_cAtomicFixnum, "value=", method_atomic_fixnum_value_set, 1);
+  rb_define_method(rb_cAtomicFixnum, "increment", method_atomic_fixnum_increment, 0);
+  rb_define_method(rb_cAtomicFixnum, "decrement", method_atomic_fixnum_decrement, 0);
+  rb_define_method(rb_cAtomicFixnum, "compare_and_set", method_atomic_fixnum_compare_and_set, 2);
+  rb_define_alias(rb_cAtomicFixnum, "up", "increment");
+  rb_define_alias(rb_cAtomicFixnum, "down", "decrement");
 }

data/ext/concurrent_ruby_ext/ruby_193_compatible.h

@@ -0,0 +1,28 @@
+#ifndef rb_check_arity
+
+// https://github.com/ruby/ruby/blob/ruby_2_0_0/include/ruby/intern.h
+// rb_check_arity was added in Ruby 2.0
+
+#define UNLIMITED_ARGUMENTS (-1)
+
+static inline void rb_error_arity(int argc, int min, int max)
+{
+  VALUE err_mess = 0;
+  if (min == max) {
+    err_mess = rb_sprintf("wrong number of arguments (%d for %d)", argc, min);
+  }
+  else if (max == UNLIMITED_ARGUMENTS) {
+    err_mess = rb_sprintf("wrong number of arguments (%d for %d+)", argc, min);
+  }
+  else {
+    err_mess = rb_sprintf("wrong number of arguments (%d for %d..%d)", argc, min, max);
+  }
+  rb_raise(rb_eTypeError, err_mess);
+}
+
+#define rb_check_arity(argc, min, max) do { \
+  if (((argc) < (min)) || ((argc) > (max) && (max) != UNLIMITED_ARGUMENTS)) \
+  rb_error_arity(argc, min, max); \
+} while(0)
+
+#endif

data/lib/concurrent.rb

@@ -8,8 +8,9 @@ require 'concurrent/collections'
 require 'concurrent/executors'
 require 'concurrent/utilities'
 
-require 'concurrent/actress'
+require 'concurrent/actor'
 require 'concurrent/atomic'
+require 'concurrent/lazy_register'
 require 'concurrent/agent'
 require 'concurrent/async'
 require 'concurrent/dataflow'

data/lib/concurrent/actor.rb

@@ -0,0 +1,104 @@
+require 'concurrent/configuration'
+require 'concurrent/executor/serialized_execution'
+require 'concurrent/ivar'
+require 'concurrent/logging'
+require 'concurrent/atomic/synchronization'
+
+module Concurrent
+  # TODO https://github.com/celluloid/celluloid/wiki/Supervision-Groups
+
+  # TODO doc
+  # - what happens if I try to supervise using a normal Context?
+
+
+  # {include:file:doc/actor/main.md}
+  module Actor
+
+    require 'concurrent/actor/type_check'
+    require 'concurrent/actor/errors'
+    require 'concurrent/actor/public_delegations'
+    require 'concurrent/actor/internal_delegations'
+    require 'concurrent/actor/envelope'
+    require 'concurrent/actor/reference'
+    require 'concurrent/actor/core'
+    require 'concurrent/actor/behaviour'
+    require 'concurrent/actor/context'
+
+    require 'concurrent/actor/default_dead_letter_handler'
+    require 'concurrent/actor/root'
+    require 'concurrent/actor/ad_hoc'
+
+    # @return [Reference, nil] current executing actor if any
+    def self.current
+      Thread.current[:__current_actor__]
+    end
+
+    @root = Delay.new do
+      Core.new(parent: nil, name: '/', class: Root, initialized: ivar = IVar.new).reference.tap do
+        ivar.no_error!
+      end
+    end
+
+    # A root actor, a default parent of all actors spawned outside an actor
+    def self.root
+      @root.value!
+    end
+
+    # Spawns a new actor.
+    #
+    # @example simple
+    #   Actor.spawn(AdHoc, :ping1) { -> message { message } }
+    #
+    # @example complex
+    #   Actor.spawn name:     :ping3,
+    #                 class:    AdHoc,
+    #                 args:     [1]
+    #                 executor: Concurrent.configuration.global_task_pool do |add|
+    #     lambda { |number| number + add }
+    #   end
+    #
+    # @param block for context_class instantiation
+    # @param args see {.spawn_optionify}
+    # @return [Reference] never the actual actor
+    def self.spawn(*args, &block)
+      experimental_acknowledged? or
+          warn '[EXPERIMENTAL] A full release of `Actor`, is expected in the 0.7.0 release.'
+
+      if Actor.current
+        Core.new(spawn_optionify(*args).merge(parent: Actor.current), &block).reference
+      else
+        root.ask([:spawn, spawn_optionify(*args), block]).value
+      end
+    end
+
+    # as {.spawn} but it'll raise when Actor not initialized properly
+    def self.spawn!(*args, &block)
+      spawn(spawn_optionify(*args).merge(initialized: ivar = IVar.new), &block).tap { ivar.no_error! }
+    end
+
+    # @overload spawn_optionify(context_class, name, *args)
+    #   @param [Context] context_class to be spawned
+    #   @param [String, Symbol] name of the instance, it's used to generate the {Core#path} of the actor
+    #   @param args for context_class instantiation
+    # @overload spawn_optionify(opts)
+    #   see {Core#initialize} opts
+    def self.spawn_optionify(*args)
+      if args.size == 1 && args.first.is_a?(Hash)
+        args.first
+      else
+        { class: args[0],
+          name:  args[1],
+          args:  args[2..-1] }
+      end
+    end
+
+    # call this to disable experimental warning
+    def self.i_know_it_is_experimental!
+      @experimental_acknowledged = true
+    end
+
+    def self.experimental_acknowledged?
+      !!@experimental_acknowledged
+    end
+  end
+end