move Ox.getset and Ox.makeObject to Object.js

source/Ox/js/Object.js

@@ -14,6 +14,68 @@ Ox.extend = function(obj) {
     return obj;
 };
 
+/*@
+Ox.getset <f> Generic getter and setter function
+    See examples for details.
+    # Usage --------------------------------------------------------------------
+    Ox.getset(options, args=[])                              -> <o> all options
+    Ox.getset(options, args=[key])                           -> <*> options[key]
+    Ox.getset(options, args=[key, value], callback, that)    -> <f|o> context
+        sets options[key] to value and calls fn(key, value)
+        if the key/value pair was added or modified
+    Ox.getset(options, args=[{key: value}], callback, that)  -> <f|o> that
+        sets multiple options and calls fn(key, value)
+        for every key/value pair that was added or modified
+    # Arguments ----------------------------------------------------------------
+    options  <obj> Options object (key/value pairs)
+    args     <arr> The arguments "array" of the caller function
+    callback <fun> Callback function 
+        The callback is called for every key/value pair that was added or
+        modified.
+        key      <s> Key
+        value    <*> Value
+    that  <obj> The this object of the caller function (for chaining)
+    # Examples -----------------------------------------------------------------
+    <script>
+        Ox.test.object = new function() {
+            var options = {},
+                setOption = function(key, value) {
+                    // handle added or modified options
+                },
+                that = this;
+            that.options = function() {
+                return Ox.getset(options, arguments, setOption, that);
+            };
+            return that;
+        };
+    </script>
+    > Ox.test.object.options("key", "val").options("key")
+    "val"
+    > Ox.test.object.options({foo: "foo", bar: "bar"}).options()
+    {"key": "val", "foo": "foo", "bar": "bar"}
+@*/
+Ox.getset = function(object, args, callback, that) {
+    var object_ = Ox.clone(object), ret;
+    if (args.length == 0) {
+        // []
+        ret = object_;
+    } else if (args.length == 1 && !Ox.isObject(args[0])) {
+        // [key]
+        ret = Ox.clone(object[args[0]]);
+    } else {
+        // [key, val] or [{key: val, ...}]
+        args = Ox.makeObject(args);
+        object = Ox.extend(object, args);
+        Ox.forEach(args, function(value, key) {
+            if (!object_ || !Ox.isEqual(object_[key], value)) {
+                callback && callback(key, value);
+            }
+        });
+        ret = that;                            
+    }
+    return ret;
+};
+
 Ox.hasOwn = function(obj, val) {
     return Object.prototype.hasOwnProperty.call(obj, val)
 };
@@ -28,12 +90,37 @@ Ox.keyOf = function(obj, val) {
     Ox.forEach(obj, function(v, k) {
         if (v === val) {
             key = k;
-            Ox.Break()();
+            Ox.Break();
         }
     });
     return key;
 };
 
+/*@
+Ox.makeObject <f> Takes an array and returns an object
+    <code>Ox.makeObject</code> is a helper for functions with two alternative
+    signatures like <code>('key', 'val')</code> and <code>({key: 'val'})</code>.
+    > (function() { return Ox.makeObject(arguments); }({foo: 1, bar: 2}))
+    {foo: 1, bar: 2}
+    > (function() { return Ox.makeObject(arguments); }('foo', 1))
+    {foo: 1}
+    > (function() { return Ox.makeObject(arguments); }('foo'))
+    {foo: void 0}
+    > (function() { return Ox.makeObject(arguments); }())
+    {}
+@*/
+Ox.makeObject = function(array) {
+    var ret = {};
+    if (Ox.isObject(array[0])) {
+        // ({foo: 'bar'})
+        ret = array[0];
+    } else if (array.length) {
+        // ('foo', 'bar')
+        ret[array[0]] = array[1];
+    }
+    return ret;
+};
+
 /*@
 Ox.methods <f> Returns a sorted list of all method names of an object
     > Ox.methods({a: [], b: false, f: function() {}, n: 0, o: {}, s: ''})