agson/lib/agson/combinators.js

Querying and manipulating JSON graphs

(function() {
  var Just, Nothing, fromNullable, fromValidation, fromValidator, identity, lens, lensListAsString, lensMapAsString, product, sum, where, _ref;

  _ref = require('data.maybe'), Just = _ref.Just, Nothing = _ref.Nothing, fromNullable = _ref.fromNullable, fromValidation = _ref.fromValidation;

  lens = require('./Lens').of;

  identity = require('./lenses').identity;

  where = function(predm) {
    return lens("where(" + (predm.toString()) + ")", function(ma) {
      return {
        modify: function(f) {
          if (!predm(ma)) {
            return ma;
          } else {
            return f(ma);
          }
        },
        get: function() {
          if (!predm(ma)) {
            return Nothing();
          } else {
            return ma;
          }
        }
      };
    });
  };

  lensListAsString = function(list) {
    var abl;
    return ((function() {
      var _i, _len, _results;
      _results = [];
      for (_i = 0, _len = list.length; _i < _len; _i++) {
        abl = list[_i];
        _results.push(abl.toString());
      }
      return _results;
    })()).join(',');
  };

  lensMapAsString = function(object) {
    var abl, key;
    return ((function() {
      var _results;
      _results = [];
      for (key in object) {
        abl = object[key];
        _results.push("" + key + ":" + (abl.toString()));
      }
      return _results;
    })()).join(',');
  };

  product = (function() {
    return {
      tuple: function(list) {
        return lens("product.tuple[" + (lensListAsString(list)) + "]", function(ma) {
          return {
            get: function() {
              var abl, tuple, _i, _len;
              tuple = Just([]);
              for (_i = 0, _len = list.length; _i < _len; _i++) {
                abl = list[_i];
                tuple = tuple.chain(function(t) {
                  return abl.runM(ma).get().chain(function(b) {
                    t.push(b);
                    return Just(t);
                  });
                });
              }
              return tuple;
            },
            modify: function(f) {
              return f(this.get()).chain(function(tuple) {
                var abl, result, _i, _len;
                result = ma;
                for (_i = 0, _len = list.length; _i < _len; _i++) {
                  abl = list[_i];
                  result = result.chain(function() {
                    var mb;
                    mb = fromNullable(tuple.shift());
                    return abl.runM(result).modify(function() {
                      return mb;
                    });
                  });
                }
                return result;
              });
            }
          };
        });
      },
      dict: function(object) {
        return lens("product.dict{" + (lensMapAsString(object)) + "}", function(ma) {
          return {
            get: function() {
              var abl, dict, key;
              dict = Just({});
              for (key in object) {
                abl = object[key];
                dict = dict.chain(function(d) {
                  return abl.runM(ma).get().chain(function(b) {
                    d[key] = b;
                    return Just(d);
                  });
                });
              }
              return dict;
            },
            modify: function(f) {
              return f(this.get()).chain(function(dict) {
                var abl, key, result;
                result = ma;
                for (key in object) {
                  abl = object[key];
                  result = result.chain(function() {
                    var mb;
                    mb = fromNullable(dict[key]);
                    return abl.runM(result).modify(function() {
                      return mb;
                    });
                  });
                }
                return result;
              });
            }
          };
        });
      }
    };
  })();

  fromValidator = function(validator) {
    return lens("validate", function(ma) {
      return {
        get: function() {
          return ma.chain(function(a) {
            return fromValidation(validator(a));
          });
        },
        modify: function(f) {
          return ma.chain(function(a) {
            var validb;
            validb = fromValidation(validator(a));
            if (validb.isJust) {
              return f(validb);
            } else {
              return ma;
            }
          });
        }
      };
    });
  };

  sum = (function() {
    var withTag;
    withTag = function(tag, value) {
      var tagged;
      tagged = {};
      tagged[tag] = value;
      return Just(tagged);
    };
    return {
      tagged: function(tagsToLenses) {
        return lens("sum.tagged(" + (lensMapAsString(tagsToLenses)) + ")", function(ma) {
          return {
            get: function() {
              var abl, mb, result, tag;
              result = Nothing();
              for (tag in tagsToLenses) {
                abl = tagsToLenses[tag];
                mb = abl.runM(ma).get();
                if (mb.isJust) {
                  result = withTag(tag, mb.get());
                  break;
                }
              }
              return result;
            },
            modify: function(f) {
              var abl, result, tag, tagged;
              result = Nothing();
              for (tag in tagsToLenses) {
                abl = tagsToLenses[tag];
                tagged = abl.runM(ma).get();
                if (tagged.isJust) {
                  result = f(withTag(tag, tagged.get()));
                  break;
                }
              }
              return result;
            }
          };
        });
      }
    };
  })();

  module.exports = {
    where: where,
    product: product,
    fromValidator: fromValidator,
    sum: sum
  };

}).call(this);