{"_id":"potato","_rev":"44-cc44fcde0f555a45c159ac688be166d4","name":"potato","description":"Potato : A composition-friendly Microframework =================================================","dist-tags":{"latest":"0.1.1"},"versions":{"0.0.1":{"name":"potato","description":"","version":"0.0.1","author":{"name":"Paul Masurel","email":"paul.masurel@gmail.com"},"engines":["node >= 0.4.0"],"licenses":[{"type":"MIT","url":"http://github.com/jashkenas/coffee-script/raw/master/LICENSE"}],"repository":{"type":"hg","url":"https://bitbucket.org/poulejapon/formidable.coffee"},"main":"./lib/potato","directories":{"lib":"./lib"},"dependencies":{},"devDependencies":{},"_id":"potato@0.0.1","_engineSupported":true,"_npmVersion":"1.0.6","_nodeVersion":"v0.4.8","_defaultsLoaded":true,"dist":{"shasum":"c2363691726962f77ed64d79be2b0102e2226cb3","tarball":"https://registry.npmjs.org/potato/-/potato-0.0.1.tgz","integrity":"sha512-N3AKhPkcrWvo5WsjV3Q/6V5Vyfh3y9A1hytYCDrUbSClYDN6t+unWpQ1qJAZTW4MaeWN7sHsPudvSsenJXXrTw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDhrASlhmPtyue6hFuAOQxutLRN1NHxmEGdLoB21kgDxgIgPoOtMQ4kX4DaHaMmPd9smSwn6mdupmR9yHXRBuzgX1s="}]},"scripts":{},"maintainers":[{"name":"poulejapon","email":"paul.masurel@gmail.com"}]},"0.0.5":{"name":"potato","description":"","version":"0.0.5","author":{"name":"Paul Masurel","email":"paul.masurel@gmail.com"},"private":false,"engines":["node >= 0.4.0"],"licenses":[{"type":"MIT","url":"https://raw.github.com/poulejapon/potato/master/LICENSE"}],"repository":{"type":"git","url":"git://github.com/poulejapon/potato.git"},"dependencies":{"hogan":">= 1.0.0"},"devDependencies":{"jasmine-node":"1.0.20","browserify":"1.10.14","coffee-script":"1.3.3","uglify-js":"1.2.6","markitup":"0.0.4","less":"1.3.0","readymade":"0.0.4"},"main":"./src/potato","directories":{"src":"./src"},"scripts":{"test":"jasmine-node --coffee ."},"_npmUser":{"name":"poulejapon","email":"paul.masurel@gmail.com"},"_id":"potato@0.0.5","optionalDependencies":{},"_engineSupported":true,"_npmVersion":"1.1.21","_nodeVersion":"v0.6.18","_defaultsLoaded":true,"dist":{"shasum":"fc62da797e4852d10add3c191d8f02bc92d12982","tarball":"https://registry.npmjs.org/potato/-/potato-0.0.5.tgz","integrity":"sha512-9bYLQTV7DG4OSNgVahOyxXWkQ+DLmMdd0oz1KdAI4tsW087uiKMCQTVM7n1ENlgtUbN/8I5UcAOpyT4/9RocVQ==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDJmmSPJlAClIQh0tXgsfOvW8GTG3gxWA6pVBxfM1xh6QIgakuWPxWRYjZfuktgQJqxUZCLmHSsX9jbkL/ck0dcMkw="}]},"readme":"Potato : A composition-friendly Microframework\n=================================================\n\n[![Build Status](https://secure.travis-ci.org/poulejapon/potato.png)](http://travis-ci.org/poulejapon/potato.png])\n\nPotato is a CoffeeScript micro-framework focused\non composition. It relies on its own object model, whose syntax might recall that of an ORM.\n\n\nObject composition\n-------------------------------------------------\n\nTo declare a model for a user profile, you would typically declare it as a composition of the information of name, age and address. Address itself will be the composition of a street/city/zipcode/state/country.\n\n```coffeescript\nO = require 'potato'\n\nAddress = O.Potato\n    components:\n        street:  O.String\n        city:    O.String\n        zipcode: O.String\n\nProfile = O.Potato\n    components:\n        name:    O.String\n        address: Address\n        age:     O.Int\n```\n\nYou may notice that this syntax also allows to inline the definition of a very simple composed object that is very unlikely to be reused. For instance :\n\n\n\n```coffeescript\nO = require 'potato'\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age: O.Int\n        address: Address\n```\n\n\n\nThough this style is not really recommended for such a definition, this syntax comes very handful with the\ndeep-overriding feature described below.\n\n```coffeescript\nO = require 'potato'.\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age:  O.Int\n        address: Address\n```\n\n\nInheritance, and deep-overriding.\n--------------------------------------------------\n \n The children components of your potatoes may themselves have components and your potatoes might rapidly look like small tree-like structures of components. You might still want to extend it, and override a piece of functionality located slightly deeper than in the very first layer of this tree.\n\nPotato makes it possible for you to inherit from an object, and extend or override pretty much anything, wherever in this tree ; be that a component, a method, or a static property of a component.\n\nFor instance, my address potato was assuming that my users were french. For international users I'll need\nto at least add a state and a country mention.\n\n```coffeescript\n# ...\n# here we added two new components\n# to our Address object.\n\nInternationalAddress = Address\n    components:\n        state:   O.String\n        country: O.String\n```\n\n\nString (as well as all Literal types) has a static property called default that describes the default value\nthat should be produced on instantiation.\n\nLet's say we actually wanted to have \"USA\", \"NY\", \"New York City\" as the default values for the country and the state components. We could have written :\n\n```coffeescript\n# ...\nInternationalAddress = Address\n    components:\n        city:    O.String\n            default: \"New York City\"\n        state:   O.String\n            default: \"NY\"\n        country: O.String\n            default: \"USA\"\n```\n\n\n\nStatic properties, methods, literals\n--------------------------------------------------\n\nYour object may have static members. These are pretty like static members in C++ or python etc. They are accessible from the Potato itself, but not from its instances.\n\nThe most obvious one is \"make\" which makes it possible to instantiate a potato.\n\n```coffeescript\n#\n# This should make an address with : \n# all our default values.\n#\naddress = InternationalAddress.make()\n```\n\n\nYou may define more static members using the \n\"static\" section prefix. For instance, Potato's Models have a JSON deserialization function which looks pretty much like this. \n    \n```coffeescript\nModel = O.Potato\n    static:\n        fromJSON: (json)->\n            @make JSON.parse json\n```\n\nOn the other hands methods are made to be called from \nobjects.\nA model also have a toJSON method, which looks like :\n\n```coffeescript\nModel = O.Potato\n    methods:\n        toJSON: ->\n            JSON.stringify @toData()\n```\n\nAs an helper, a static function is actually also magically created, taking the object to which it should be bound to as a first argument.\n\nSomeone in fond of functional programming may write things such as \n    \n```coffeescript\nmap Model.toJSON, someListOfModels\n```\n\nas an alternative to\n    \n```coffeescript\nmodel.toJSON() for model in someListOfModels\n```\n\n\n\n\nKnowing your components is a cool thing.\n--------------------------------------------------\n\nYour objects are aware of their components and their types and that is a great things.\n\nValidation\nSerialization\nGeneric forms","maintainers":[{"name":"poulejapon","email":"paul.masurel@gmail.com"}]},"0.0.6":{"name":"potato","description":"","version":"0.0.6","author":{"name":"Paul Masurel","email":"paul.masurel@gmail.com"},"private":false,"engines":["node >= 0.4.0"],"licenses":[{"type":"MIT","url":"https://raw.github.com/poulejapon/potato/master/LICENSE"}],"repository":{"type":"git","url":"git://github.com/poulejapon/potato.git"},"dependencies":{"hogan":">= 1.0.0"},"devDependencies":{"jasmine-node":"1.0.20","browserify":"1.10.14","coffee-script":"1.3.3","uglify-js":"1.2.6","markitup":"0.0.4","less":"1.3.0","readymade":"0.0.4"},"main":"./src/potato","directories":{"src":"./src"},"scripts":{"test":"jasmine-node --coffee ."},"_npmUser":{"name":"poulejapon","email":"paul.masurel@gmail.com"},"_id":"potato@0.0.6","optionalDependencies":{},"_engineSupported":true,"_npmVersion":"1.1.21","_nodeVersion":"v0.6.18","_defaultsLoaded":true,"dist":{"shasum":"6cf209fa6831f4f51bd00f89c333497925e086d1","tarball":"https://registry.npmjs.org/potato/-/potato-0.0.6.tgz","integrity":"sha512-ZBH1TgdPDfK6wny7BtQmJW5hFzMIRZsfQeqC2YgNNGhP/1HQsa4u8FQqSgc+S5sl/DSrx5091OsG2qvFRll+Dw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQCymjxghgttuYxTxFZ0jms1f0wJCEd8ASxVWLk7UcQxTgIgZlGWSflJdkJ4YBmnJNxs5aaBcSZkNCo7F9fxCipWmtQ="}]},"readme":"Potato : A composition-friendly Microframework\n=================================================\n\n[![Build Status](https://secure.travis-ci.org/poulejapon/potato.png)](http://travis-ci.org/poulejapon/potato.png])\n\nPotato is a CoffeeScript micro-framework focused\non composition. It relies on its own object model, whose syntax might recall that of an ORM.\n\n\nObject composition\n-------------------------------------------------\n\nTo declare a model for a user profile, you would typically declare it as a composition of the information of name, age and address. Address itself will be the composition of a street/city/zipcode/state/country.\n\n```coffeescript\nO = require 'potato'\n\nAddress = O.Potato\n    components:\n        street:  O.String\n        city:    O.String\n        zipcode: O.String\n\nProfile = O.Potato\n    components:\n        name:    O.String\n        address: Address\n        age:     O.Int\n```\n\nYou may notice that this syntax also allows to inline the definition of a very simple composed object that is very unlikely to be reused. For instance :\n\n\n\n```coffeescript\nO = require 'potato'\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age: O.Int\n        address: Address\n```\n\n\n\nThough this style is not really recommended for such a definition, this syntax comes very handful with the\ndeep-overriding feature described below.\n\n```coffeescript\nO = require 'potato'.\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age:  O.Int\n        address: Address\n```\n\n\nInheritance, and deep-overriding.\n--------------------------------------------------\n \n The children components of your potatoes may themselves have components and your potatoes might rapidly look like small tree-like structures of components. You might still want to extend it, and override a piece of functionality located slightly deeper than in the very first layer of this tree.\n\nPotato makes it possible for you to inherit from an object, and extend or override pretty much anything, wherever in this tree ; be that a component, a method, or a static property of a component.\n\nFor instance, my address potato was assuming that my users were french. For international users I'll need\nto at least add a state and a country mention.\n\n```coffeescript\n# ...\n# here we added two new components\n# to our Address object.\n\nInternationalAddress = Address\n    components:\n        state:   O.String\n        country: O.String\n```\n\n\nString (as well as all Literal types) has a static property called default that describes the default value\nthat should be produced on instantiation.\n\nLet's say we actually wanted to have \"USA\", \"NY\", \"New York City\" as the default values for the country and the state components. We could have written :\n\n```coffeescript\n# ...\nInternationalAddress = Address\n    components:\n        city:    O.String\n            default: \"New York City\"\n        state:   O.String\n            default: \"NY\"\n        country: O.String\n            default: \"USA\"\n```\n\n\n\nStatic properties, methods, literals\n--------------------------------------------------\n\nYour object may have static members. These are pretty like static members in C++ or python etc. They are accessible from the Potato itself, but not from its instances.\n\nThe most obvious one is \"make\" which makes it possible to instantiate a potato.\n\n```coffeescript\n#\n# This should make an address with : \n# all our default values.\n#\naddress = InternationalAddress.make()\n```\n\n\nYou may define more static members using the \n\"static\" section prefix. For instance, Potato's Models have a JSON deserialization function which looks pretty much like this. \n    \n```coffeescript\nModel = O.Potato\n    static:\n        fromJSON: (json)->\n            @make JSON.parse json\n```\n\nOn the other hands methods are made to be called from \nobjects.\nA model also have a toJSON method, which looks like :\n\n```coffeescript\nModel = O.Potato\n    methods:\n        toJSON: ->\n            JSON.stringify @toData()\n```\n\nAs an helper, a static function is actually also magically created, taking the object to which it should be bound to as a first argument.\n\nSomeone in fond of functional programming may write things such as \n    \n```coffeescript\nmap Model.toJSON, someListOfModels\n```\n\nas an alternative to\n    \n```coffeescript\nmodel.toJSON() for model in someListOfModels\n```\n\n\n\n\nKnowing your components is a cool thing.\n--------------------------------------------------\n\nYour objects are aware of their components and their types and that is a great things.\n\nValidation\nSerialization\nGeneric forms","maintainers":[{"name":"poulejapon","email":"paul.masurel@gmail.com"}]},"0.0.7":{"name":"potato","description":"","version":"0.0.7","author":{"name":"Paul Masurel","email":"paul.masurel@gmail.com"},"private":false,"engines":["node >= 0.4.0"],"licenses":[{"type":"MIT","url":"https://raw.github.com/poulejapon/potato/master/LICENSE"}],"repository":{"type":"git","url":"git://github.com/poulejapon/potato.git"},"dependencies":{"hogan":">= 1.0.0"},"devDependencies":{"jasmine-node":"1.0.20","browserify":"1.10.14","coffee-script":"1.3.3","uglify-js":"1.2.6","markitup":"0.0.4","less":"1.3.0","readymade":"0.0.4"},"main":"./src/potato","directories":{"src":"./src"},"scripts":{"test":"jasmine-node --coffee ."},"_npmUser":{"name":"poulejapon","email":"paul.masurel@gmail.com"},"_id":"potato@0.0.7","optionalDependencies":{},"_engineSupported":true,"_npmVersion":"1.1.21","_nodeVersion":"v0.6.18","_defaultsLoaded":true,"dist":{"shasum":"494a0889c5c2d1f464c6ee0ad9bda0ba9798073b","tarball":"https://registry.npmjs.org/potato/-/potato-0.0.7.tgz","integrity":"sha512-ZMpKXB4VIeBd5QZ4Foy1DCAtq8ATS6fjsIQo783cX9mF8dpZcpiYZFjVgn8jLrFzezTk2eTXZG+QPOJ7ZT/ILw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQD2LemBcevyRa3LsB755WlP505hGECMme7lUJEtqcj3wQIhAPtwfENGq0qrvAA58RvifAzh+I4ie+sh0aw6mEKwSt/g"}]},"readme":"Potato : A composition-friendly Microframework\n=================================================\n\n[![Build Status](https://secure.travis-ci.org/poulejapon/potato.png)](http://travis-ci.org/poulejapon/potato.png])\n\nPotato is a CoffeeScript micro-framework focused\non composition. It relies on its own object model, whose syntax might recall that of an ORM.\n\n\nObject composition\n-------------------------------------------------\n\nTo declare a model for a user profile, you would typically declare it as a composition of the information of name, age and address. Address itself will be the composition of a street/city/zipcode/state/country.\n\n```coffeescript\nO = require 'potato'\n\nAddress = O.Potato\n    components:\n        street:  O.String\n        city:    O.String\n        zipcode: O.String\n\nProfile = O.Potato\n    components:\n        name:    O.String\n        address: Address\n        age:     O.Int\n```\n\nYou may notice that this syntax also allows to inline the definition of a very simple composed object that is very unlikely to be reused. For instance :\n\n\n\n```coffeescript\nO = require 'potato'\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age: O.Int\n        address: Address\n```\n\n\n\nThough this style is not really recommended for such a definition, this syntax comes very handful with the\ndeep-overriding feature described below.\n\n```coffeescript\nO = require 'potato'.\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age:  O.Int\n        address: Address\n```\n\n\nInheritance, and deep-overriding.\n--------------------------------------------------\n \n The children components of your potatoes may themselves have components and your potatoes might rapidly look like small tree-like structures of components. You might still want to extend it, and override a piece of functionality located slightly deeper than in the very first layer of this tree.\n\nPotato makes it possible for you to inherit from an object, and extend or override pretty much anything, wherever in this tree ; be that a component, a method, or a static property of a component.\n\nFor instance, my address potato was assuming that my users were french. For international users I'll need\nto at least add a state and a country mention.\n\n```coffeescript\n# ...\n# here we added two new components\n# to our Address object.\n\nInternationalAddress = Address\n    components:\n        state:   O.String\n        country: O.String\n```\n\n\nString (as well as all Literal types) has a static property called default that describes the default value\nthat should be produced on instantiation.\n\nLet's say we actually wanted to have \"USA\", \"NY\", \"New York City\" as the default values for the country and the state components. We could have written :\n\n```coffeescript\n# ...\nInternationalAddress = Address\n    components:\n        city:    O.String\n            default: \"New York City\"\n        state:   O.String\n            default: \"NY\"\n        country: O.String\n            default: \"USA\"\n```\n\n\n\nStatic properties, methods, literals\n--------------------------------------------------\n\nYour object may have static members. These are pretty like static members in C++ or python etc. They are accessible from the Potato itself, but not from its instances.\n\nThe most obvious one is \"make\" which makes it possible to instantiate a potato.\n\n```coffeescript\n#\n# This should make an address with : \n# all our default values.\n#\naddress = InternationalAddress.make()\n```\n\n\nYou may define more static members using the \n\"static\" section prefix. For instance, Potato's Models have a JSON deserialization function which looks pretty much like this. \n    \n```coffeescript\nModel = O.Potato\n    static:\n        fromJSON: (json)->\n            @make JSON.parse json\n```\n\nOn the other hands methods are made to be called from \nobjects.\nA model also have a toJSON method, which looks like :\n\n```coffeescript\nModel = O.Potato\n    methods:\n        toJSON: ->\n            JSON.stringify @toData()\n```\n\nAs an helper, a static function is actually also magically created, taking the object to which it should be bound to as a first argument.\n\nSomeone in fond of functional programming may write things such as \n    \n```coffeescript\nmap Model.toJSON, someListOfModels\n```\n\nas an alternative to\n    \n```coffeescript\nmodel.toJSON() for model in someListOfModels\n```\n\n\n\n\nKnowing your components is a cool thing.\n--------------------------------------------------\n\nYour objects are aware of their components and their types and that is a great things.\n\nValidation\nSerialization\nGeneric forms","maintainers":[{"name":"poulejapon","email":"paul.masurel@gmail.com"}]},"0.0.3":{"name":"potato","description":"Potato : A composition-friendly Microframework =================================================","version":"0.0.3","author":{"name":"Paul Masurel","email":"paul.masurel@gmail.com"},"private":false,"engines":["node >= 0.4.0"],"licenses":[{"type":"MIT","url":"https://raw.github.com/poulejapon/potato/master/LICENSE"}],"repository":{"type":"git","url":"https://github.com/poulejapon/potato"},"dependencies":{"hogan.js":">= 2.0.0"},"devDependencies":{"jasmine-node":"1.0.20","browserify":"1.10.14","coffee-script":"1.3.3","uglify-js":"1.2.6","markitup":"0.0.4","less":"1.3.0","readymade":"0.2.4"},"main":"./src/potato","directories":{"src":"./src"},"scripts":{"test":"jasmine-node --coffee ."},"readme":"Potato : A composition-friendly Microframework\n=================================================\n\n[![Build Status](https://secure.travis-ci.org/poulejapon/potato.png)](http://travis-ci.org/poulejapon/potato.png])\n\nPotato is a CoffeeScript micro-framework focused\non composition. It relies on its own object model, whose syntax might recall that of an ORM.\n\n\nObject composition\n-------------------------------------------------\n\nTo declare a model for a user profile, you would typically declare it as a composition of the information of name, age and address. Address itself will be the composition of a street/city/zipcode/state/country.\n\n```coffeescript\nO = require 'potato'\n\nAddress = O.Potato\n    components:\n        street:  O.String\n        city:    O.String\n        zipcode: O.String\n\nProfile = O.Potato\n    components:\n        name:    O.String\n        address: Address\n        age:     O.Int\n```\n\nYou may notice that this syntax also allows to inline the definition of a very simple composed object that is very unlikely to be reused. For instance :\n\n\n\n```coffeescript\nO = require 'potato'\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age: O.Int\n        address: Address\n```\n\n\n\nThough this style is not really recommended for such a definition, this syntax comes very handful with the\ndeep-overriding feature described below.\n\n```coffeescript\nO = require 'potato'.\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age:  O.Int\n        address: Address\n```\n\n\nInheritance, and deep-overriding.\n--------------------------------------------------\n \n The children components of your potatoes may themselves have components and your potatoes might rapidly look like small tree-like structures of components. You might still want to extend it, and override a piece of functionality located slightly deeper than in the very first layer of this tree.\n\nPotato makes it possible for you to inherit from an object, and extend or override pretty much anything, wherever in this tree ; be that a component, a method, or a static property of a component.\n\nFor instance, my address potato was assuming that my users were french. For international users I'll need\nto at least add a state and a country mention.\n\n```coffeescript\n# ...\n# here we added two new components\n# to our Address object.\n\nInternationalAddress = Address\n    components:\n        state:   O.String\n        country: O.String\n```\n\n\nString (as well as all Literal types) has a static property called default that describes the default value\nthat should be produced on instantiation.\n\nLet's say we actually wanted to have \"USA\", \"NY\", \"New York City\" as the default values for the country and the state components. We could have written :\n\n```coffeescript\n# ...\nInternationalAddress = Address\n    components:\n        city:    O.String\n            default: \"New York City\"\n        state:   O.String\n            default: \"NY\"\n        country: O.String\n            default: \"USA\"\n```\n\n\n\nStatic properties, methods, literals\n--------------------------------------------------\n\nYour object may have static members. These are pretty like static members in C++ or python etc. They are accessible from the Potato itself, but not from its instances.\n\nThe most obvious one is \"make\" which makes it possible to instantiate a potato.\n\n```coffeescript\n#\n# This should make an address with : \n# all our default values.\n#\naddress = InternationalAddress.make()\n```\n\n\nYou may define more static members using the \n\"static\" section prefix. For instance, Potato's Models have a JSON deserialization function which looks pretty much like this. \n    \n```coffeescript\nModel = O.Potato\n    static:\n        fromJSON: (json)->\n            @make JSON.parse json\n```\n\nOn the other hands methods are made to be called from \nobjects.\nA model also have a toJSON method, which looks like :\n\n```coffeescript\nModel = O.Potato\n    methods:\n        toJSON: ->\n            JSON.stringify @toData()\n```\n\nAs an helper, a static function is actually also magically created, taking the object to which it should be bound to as a first argument.\n\nSomeone in fond of functional programming may write things such as \n    \n```coffeescript\nmap Model.toJSON, someListOfModels\n```\n\nas an alternative to\n    \n```coffeescript\nmodel.toJSON() for model in someListOfModels\n```\n\n\n\n\nKnowing your components is a cool thing.\n--------------------------------------------------\n\nYour objects are aware of their components and their types and that is a great things.\n\nValidation\nSerialization\nGeneric forms","readmeFilename":"README.md","_id":"potato@0.0.3","dist":{"shasum":"42605734ff5e3833833dbe0748a19074718f2c24","tarball":"https://registry.npmjs.org/potato/-/potato-0.0.3.tgz","integrity":"sha512-1+etIbzZnx8x76LfJ41CVQh+oS3xvAAKpvL7nHILB1XR3xarHBFmNy7RoC6d1NtMssdkiQOtnXXvavgtbnI8kA==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCICW2n31jJOBn0MjNhnVusenvFdVYwBF4kpjxqU6dJ2UoAiAdPQ3pqlxiQpHIGI5ypEI0+7VAMKiwSV4Mwn6Yl3vpyA=="}]},"_npmVersion":"1.1.69","_npmUser":{"name":"poulejapon","email":"paul.masurel@gmail.com"},"maintainers":[{"name":"poulejapon","email":"paul.masurel@gmail.com"}]},"0.0.8":{"name":"potato","description":"Potato : A composition-friendly Microframework =================================================","version":"0.0.8","author":{"name":"Paul Masurel","email":"paul.masurel@gmail.com"},"private":false,"engines":["node >= 0.4.0"],"licenses":[{"type":"MIT","url":"https://raw.github.com/poulejapon/potato/master/LICENSE"}],"repository":{"type":"git","url":"https://github.com/poulejapon/potato"},"dependencies":{"hogan.js":">= 2.0.0"},"devDependencies":{"jasmine-node":"1.0.20","browserify":"1.10.14","coffee-script":"1.3.3","uglify-js":"1.2.6","markitup":"0.0.4","less":"1.3.0","readymade":"0.2.4"},"main":"./src/potato","directories":{"src":"./src"},"scripts":{"test":"jasmine-node --coffee ."},"readme":"Potato : A composition-friendly Microframework\n=================================================\n\n[![Build Status](https://secure.travis-ci.org/poulejapon/potato.png)](http://travis-ci.org/poulejapon/potato.png])\n\nPotato is a CoffeeScript micro-framework focused\non composition. It relies on its own object model, whose syntax might recall that of an ORM.\n\n\nObject composition\n-------------------------------------------------\n\nTo declare a model for a user profile, you would typically declare it as a composition of the information of name, age and address. Address itself will be the composition of a street/city/zipcode/state/country.\n\n```coffeescript\nO = require 'potato'\n\nAddress = O.Potato\n    components:\n        street:  O.String\n        city:    O.String\n        zipcode: O.String\n\nProfile = O.Potato\n    components:\n        name:    O.String\n        address: Address\n        age:     O.Int\n```\n\nYou may notice that this syntax also allows to inline the definition of a very simple composed object that is very unlikely to be reused. For instance :\n\n\n\n```coffeescript\nO = require 'potato'\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age: O.Int\n        address: Address\n```\n\n\n\nThough this style is not really recommended for such a definition, this syntax comes very handful with the\ndeep-overriding feature described below.\n\n```coffeescript\nO = require 'potato'.\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age:  O.Int\n        address: Address\n```\n\n\nInheritance, and deep-overriding.\n--------------------------------------------------\n \n The children components of your potatoes may themselves have components and your potatoes might rapidly look like small tree-like structures of components. You might still want to extend it, and override a piece of functionality located slightly deeper than in the very first layer of this tree.\n\nPotato makes it possible for you to inherit from an object, and extend or override pretty much anything, wherever in this tree ; be that a component, a method, or a static property of a component.\n\nFor instance, my address potato was assuming that my users were french. For international users I'll need\nto at least add a state and a country mention.\n\n```coffeescript\n# ...\n# here we added two new components\n# to our Address object.\n\nInternationalAddress = Address\n    components:\n        state:   O.String\n        country: O.String\n```\n\n\nString (as well as all Literal types) has a static property called default that describes the default value\nthat should be produced on instantiation.\n\nLet's say we actually wanted to have \"USA\", \"NY\", \"New York City\" as the default values for the country and the state components. We could have written :\n\n```coffeescript\n# ...\nInternationalAddress = Address\n    components:\n        city:    O.String\n            default: \"New York City\"\n        state:   O.String\n            default: \"NY\"\n        country: O.String\n            default: \"USA\"\n```\n\n\n\nStatic properties, methods, literals\n--------------------------------------------------\n\nYour object may have static members. These are pretty like static members in C++ or python etc. They are accessible from the Potato itself, but not from its instances.\n\nThe most obvious one is \"make\" which makes it possible to instantiate a potato.\n\n```coffeescript\n#\n# This should make an address with : \n# all our default values.\n#\naddress = InternationalAddress.make()\n```\n\n\nYou may define more static members using the \n\"static\" section prefix. For instance, Potato's Models have a JSON deserialization function which looks pretty much like this. \n    \n```coffeescript\nModel = O.Potato\n    static:\n        fromJSON: (json)->\n            @make JSON.parse json\n```\n\nOn the other hands methods are made to be called from \nobjects.\nA model also have a toJSON method, which looks like :\n\n```coffeescript\nModel = O.Potato\n    methods:\n        toJSON: ->\n            JSON.stringify @toData()\n```\n\nAs an helper, a static function is actually also magically created, taking the object to which it should be bound to as a first argument.\n\nSomeone in fond of functional programming may write things such as \n    \n```coffeescript\nmap Model.toJSON, someListOfModels\n```\n\nas an alternative to\n    \n```coffeescript\nmodel.toJSON() for model in someListOfModels\n```\n\n\n\n\nKnowing your components is a cool thing.\n--------------------------------------------------\n\nYour objects are aware of their components and their types and that is a great things.\n\nValidation\nSerialization\nGeneric forms","readmeFilename":"README.md","_id":"potato@0.0.8","dist":{"shasum":"9192e6a639aa9dabf2e2f92331bc86bb607b72cb","tarball":"https://registry.npmjs.org/potato/-/potato-0.0.8.tgz","integrity":"sha512-qaY+hT8+fwQ9BZiLR601p2RnkDPOSc4xNOi9KDSzuEQY5gcs1shZAY10gRqZi8IAj7uvtWRHKvOHgRzpHW4kvw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEYCIQDCagTsnJscbj9//AI3IDWwj0xnddliNEgaprwKiHI3JwIhAMtddnKyd/aooS0DXOw6ubEfqLjBnmnErYB9YXvO3Mc/"}]},"_npmVersion":"1.1.69","_npmUser":{"name":"poulejapon","email":"paul.masurel@gmail.com"},"maintainers":[{"name":"poulejapon","email":"paul.masurel@gmail.com"}]},"0.0.9":{"name":"potato","description":"Potato : A composition-friendly Microframework =================================================","version":"0.0.9","author":{"name":"Paul Masurel","email":"paul.masurel@gmail.com"},"private":false,"engines":["node >= 0.4.0"],"licenses":[{"type":"MIT","url":"https://raw.github.com/poulejapon/potato/master/LICENSE"}],"repository":{"type":"git","url":"https://github.com/poulejapon/potato"},"dependencies":{"hogan.js":">= 2.0.0"},"devDependencies":{"jasmine-node":"1.0.20","browserify":"1.10.14","coffee-script":"1.3.3","uglify-js":"1.2.6","markitup":"0.0.4","less":"1.3.0","readymade":"0.2.4"},"main":"./src/potato","directories":{"src":"./src"},"scripts":{"test":"jasmine-node --coffee ."},"readme":"Potato : A composition-friendly Microframework\n=================================================\n\n[![Build Status](https://secure.travis-ci.org/poulejapon/potato.png)](http://travis-ci.org/poulejapon/potato.png])\n\nPotato is a CoffeeScript micro-framework focused\non composition. It relies on its own object model, whose syntax might recall that of an ORM.\n\n\nObject composition\n-------------------------------------------------\n\nTo declare a model for a user profile, you would typically declare it as a composition of the information of name, age and address. Address itself will be the composition of a street/city/zipcode/state/country.\n\n```coffeescript\nO = require 'potato'\n\nAddress = O.Potato\n    components:\n        street:  O.String\n        city:    O.String\n        zipcode: O.String\n\nProfile = O.Potato\n    components:\n        name:    O.String\n        address: Address\n        age:     O.Int\n```\n\nYou may notice that this syntax also allows to inline the definition of a very simple composed object that is very unlikely to be reused. For instance :\n\n\n\n```coffeescript\nO = require 'potato'\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age: O.Int\n        address: Address\n```\n\n\n\nThough this style is not really recommended for such a definition, this syntax comes very handful with the\ndeep-overriding feature described below.\n\n```coffeescript\nO = require 'potato'.\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age:  O.Int\n        address: Address\n```\n\n\nInheritance, and deep-overriding.\n--------------------------------------------------\n \n The children components of your potatoes may themselves have components and your potatoes might rapidly look like small tree-like structures of components. You might still want to extend it, and override a piece of functionality located slightly deeper than in the very first layer of this tree.\n\nPotato makes it possible for you to inherit from an object, and extend or override pretty much anything, wherever in this tree ; be that a component, a method, or a static property of a component.\n\nFor instance, my address potato was assuming that my users were french. For international users I'll need\nto at least add a state and a country mention.\n\n```coffeescript\n# ...\n# here we added two new components\n# to our Address object.\n\nInternationalAddress = Address\n    components:\n        state:   O.String\n        country: O.String\n```\n\n\nString (as well as all Literal types) has a static property called default that describes the default value\nthat should be produced on instantiation.\n\nLet's say we actually wanted to have \"USA\", \"NY\", \"New York City\" as the default values for the country and the state components. We could have written :\n\n```coffeescript\n# ...\nInternationalAddress = Address\n    components:\n        city:    O.String\n            default: \"New York City\"\n        state:   O.String\n            default: \"NY\"\n        country: O.String\n            default: \"USA\"\n```\n\n\n\nStatic properties, methods, literals\n--------------------------------------------------\n\nYour object may have static members. These are pretty like static members in C++ or python etc. They are accessible from the Potato itself, but not from its instances.\n\nThe most obvious one is \"make\" which makes it possible to instantiate a potato.\n\n```coffeescript\n#\n# This should make an address with : \n# all our default values.\n#\naddress = InternationalAddress.make()\n```\n\n\nYou may define more static members using the \n\"static\" section prefix. For instance, Potato's Models have a JSON deserialization function which looks pretty much like this. \n    \n```coffeescript\nModel = O.Potato\n    static:\n        fromJSON: (json)->\n            @make JSON.parse json\n```\n\nOn the other hands methods are made to be called from \nobjects.\nA model also have a toJSON method, which looks like :\n\n```coffeescript\nModel = O.Potato\n    methods:\n        toJSON: ->\n            JSON.stringify @toData()\n```\n\nAs an helper, a static function is actually also magically created, taking the object to which it should be bound to as a first argument.\n\nSomeone in fond of functional programming may write things such as \n    \n```coffeescript\nmap Model.toJSON, someListOfModels\n```\n\nas an alternative to\n    \n```coffeescript\nmodel.toJSON() for model in someListOfModels\n```\n\n\n\n\nKnowing your components is a cool thing.\n--------------------------------------------------\n\nYour objects are aware of their components and their types and that is a great things.\n\nValidation\nSerialization\nGeneric forms","readmeFilename":"README.md","_id":"potato@0.0.9","dist":{"shasum":"9c42dad0bb80c61eac0018ed00f124f5018de345","tarball":"https://registry.npmjs.org/potato/-/potato-0.0.9.tgz","integrity":"sha512-kx2mq24fzmb2QynJNbQWvOoc03DOL8pPaMZqctUFrPcZk0VQUFU+C50p+2+5Q0eoDJVCJaISF69AKSacm60OGw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEQCIC11NUWqknVrSW9gymWlkijdUE0NSwGKaMtfyzj7ahlvAiBX3+b7it4ePL2cDW2Fv8iDqHGKRnkRY4rQ37dQbTqGhA=="}]},"_npmVersion":"1.1.69","_npmUser":{"name":"poulejapon","email":"paul.masurel@gmail.com"},"maintainers":[{"name":"poulejapon","email":"paul.masurel@gmail.com"}]},"0.1.0":{"name":"potato","description":"Potato : A composition-friendly Microframework =================================================","version":"0.1.0","author":{"name":"Paul Masurel","email":"paul.masurel@gmail.com"},"private":false,"engines":["node >= 0.4.0"],"licenses":[{"type":"MIT","url":"https://raw.github.com/poulejapon/potato/master/LICENSE"}],"repository":{"type":"git","url":"https://github.com/poulejapon/potato"},"dependencies":{"hogan.js":">= 2.0.0"},"devDependencies":{"jasmine-node":"1.0.20","browserify":"1.10.14","coffee-script":"1.4.0","uglify-js":"1.2.6","markitup":"0.0.4","less":"1.3.0","readymade":"0.2.4","jsdom":"0.3.4","jquery":"1.8.3"},"main":"./src/potato","directories":{"src":"./src"},"scripts":{"test":"jasmine-node --coffee ."},"readme":"Potato : A composition-friendly Microframework\n=================================================\n\n[![Build Status](https://secure.travis-ci.org/poulejapon/potato.png)](http://travis-ci.org/poulejapon/potato.png])\n\nPotato is a CoffeeScript micro-framework focused\non composition. It relies on its own object model, whose syntax might recall that of an ORM.\n\n\nObject composition\n-------------------------------------------------\n\nTo declare a model for a user profile, you would typically declare it as a composition of the information of name, age and address. Address itself will be the composition of a street/city/zipcode/state/country.\n\n```coffeescript\nO = require 'potato'\n\nAddress = O.Potato\n    components:\n        street:  O.String\n        city:    O.String\n        zipcode: O.String\n\nProfile = O.Potato\n    components:\n        name:    O.String\n        address: Address\n        age:     O.Int\n```\n\nYou may notice that this syntax also allows to inline the definition of a very simple composed object that is very unlikely to be reused. For instance :\n\n\n\n```coffeescript\nO = require 'potato'\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age: O.Int\n        address: Address\n```\n\n\n\nThough this style is not really recommended for such a definition, this syntax comes very handful with the\ndeep-overriding feature described below.\n\n```coffeescript\nO = require 'potato'.\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age:  O.Int\n        address: Address\n```\n\n\nInheritance, and deep-overriding.\n--------------------------------------------------\n \n The children components of your potatoes may themselves have components and your potatoes might rapidly look like small tree-like structures of components. You might still want to extend it, and override a piece of functionality located slightly deeper than in the very first layer of this tree.\n\nPotato makes it possible for you to inherit from an object, and extend or override pretty much anything, wherever in this tree ; be that a component, a method, or a static property of a component.\n\nFor instance, my address potato was assuming that my users were french. For international users I'll need\nto at least add a state and a country mention.\n\n```coffeescript\n# ...\n# here we added two new components\n# to our Address object.\n\nInternationalAddress = Address\n    components:\n        state:   O.String\n        country: O.String\n```\n\n\nString (as well as all Literal types) has a static property called default that describes the default value\nthat should be produced on instantiation.\n\nLet's say we actually wanted to have \"USA\", \"NY\", \"New York City\" as the default values for the country and the state components. We could have written :\n\n```coffeescript\n# ...\nInternationalAddress = Address\n    components:\n        city:    O.String\n            default: \"New York City\"\n        state:   O.String\n            default: \"NY\"\n        country: O.String\n            default: \"USA\"\n```\n\n\n\nStatic properties, methods, literals\n--------------------------------------------------\n\nYour object may have static members. These are pretty like static members in C++ or python etc. They are accessible from the Potato itself, but not from its instances.\n\nThe most obvious one is \"make\" which makes it possible to instantiate a potato.\n\n```coffeescript\n#\n# This should make an address with : \n# all our default values.\n#\naddress = InternationalAddress.make()\n```\n\n\nYou may define more static members using the \n\"static\" section prefix. For instance, Potato's Models have a JSON deserialization function which looks pretty much like this. \n    \n```coffeescript\nModel = O.Potato\n    static:\n        fromJSON: (json)->\n            @make JSON.parse json\n```\n\nOn the other hands methods are made to be called from \nobjects.\nA model also have a toJSON method, which looks like :\n\n```coffeescript\nModel = O.Potato\n    methods:\n        toJSON: ->\n            JSON.stringify @toData()\n```\n\nAs an helper, a static function is actually also magically created, taking the object to which it should be bound to as a first argument.\n\nSomeone in fond of functional programming may write things such as \n    \n```coffeescript\nmap Model.toJSON, someListOfModels\n```\n\nas an alternative to\n    \n```coffeescript\nmodel.toJSON() for model in someListOfModels\n```\n\n\n\n\nKnowing your components is a cool thing.\n--------------------------------------------------\n\nYour objects are aware of their components and their types and that is a great things.\n\nValidation\nSerialization\nGeneric forms","readmeFilename":"README.md","_id":"potato@0.1.0","dist":{"shasum":"1c63c0ab9142362f58c12a1fc28ee41e5ced3be6","tarball":"https://registry.npmjs.org/potato/-/potato-0.1.0.tgz","integrity":"sha512-EpsOq4XZVp5n6mJqgsxPOrV07kkgsdL2zCW06gzkX73X+jgkegQSNlBZnXlqfnjBZrrjUp6x2MJaYUvKSbyo0w==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDcylIuJZE6SJ6uSrjMpBaIY0gYkA8vTJi2VZhVGcWAnwIgEusKj4URvYJxNUAEtBQE+BzO2hTggd63tcPWd3VOm2c="}]},"_npmVersion":"1.1.65","_npmUser":{"name":"poulejapon","email":"paul.masurel@gmail.com"},"maintainers":[{"name":"poulejapon","email":"paul.masurel@gmail.com"}]},"0.1.1":{"name":"potato","description":"Potato : A composition-friendly Microframework =================================================","version":"0.1.1","author":{"name":"Paul Masurel","email":"paul.masurel@gmail.com"},"private":false,"engines":["node >= 0.4.0"],"licenses":[{"type":"MIT","url":"https://raw.github.com/poulejapon/potato/master/LICENSE"}],"repository":{"type":"git","url":"https://github.com/poulejapon/potato"},"dependencies":{"hogan.js":">= 2.0.0"},"devDependencies":{"jasmine-node":"1.0.20","browserify":"1.10.14","coffee-script":"1.4.0","uglify-js":"1.2.6","markitup":"0.0.4","less":"1.3.0","readymade":"0.2.4","jsdom":"0.3.4","jquery":"1.8.3"},"main":"./src/potato","directories":{"src":"./src"},"scripts":{"test":"jasmine-node --coffee ."},"readme":"Potato : A composition-friendly Microframework\n=================================================\n\n[![Build Status](https://secure.travis-ci.org/poulejapon/potato.png)](http://travis-ci.org/poulejapon/potato.png])\n\nPotato is a CoffeeScript micro-framework focused\non composition. It relies on its own object model, whose syntax might recall that of an ORM.\n\n\nObject composition\n-------------------------------------------------\n\nTo declare a model for a user profile, you would typically declare it as a composition of the information of name, age and address. Address itself will be the composition of a street/city/zipcode/state/country.\n\n```coffeescript\nO = require 'potato'\n\nAddress = O.Potato\n    components:\n        street:  O.String\n        city:    O.String\n        zipcode: O.String\n\nProfile = O.Potato\n    components:\n        name:    O.String\n        address: Address\n        age:     O.Int\n```\n\nYou may notice that this syntax also allows to inline the definition of a very simple composed object that is very unlikely to be reused. For instance :\n\n\n\n```coffeescript\nO = require 'potato'\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age: O.Int\n        address: Address\n```\n\n\n\nThough this style is not really recommended for such a definition, this syntax comes very handful with the\ndeep-overriding feature described below.\n\n```coffeescript\nO = require 'potato'.\n\nUserInformation = O.Potato\n    components:\n        name: O.Potato\n            components:\n                first_name: O.String\n                last_name:  O.String\n        age:  O.Int\n        address: Address\n```\n\n\nInheritance, and deep-overriding.\n--------------------------------------------------\n \n The children components of your potatoes may themselves have components and your potatoes might rapidly look like small tree-like structures of components. You might still want to extend it, and override a piece of functionality located slightly deeper than in the very first layer of this tree.\n\nPotato makes it possible for you to inherit from an object, and extend or override pretty much anything, wherever in this tree ; be that a component, a method, or a static property of a component.\n\nFor instance, my address potato was assuming that my users were french. For international users I'll need\nto at least add a state and a country mention.\n\n```coffeescript\n# ...\n# here we added two new components\n# to our Address object.\n\nInternationalAddress = Address\n    components:\n        state:   O.String\n        country: O.String\n```\n\n\nString (as well as all Literal types) has a static property called default that describes the default value\nthat should be produced on instantiation.\n\nLet's say we actually wanted to have \"USA\", \"NY\", \"New York City\" as the default values for the country and the state components. We could have written :\n\n```coffeescript\n# ...\nInternationalAddress = Address\n    components:\n        city:    O.String\n            default: \"New York City\"\n        state:   O.String\n            default: \"NY\"\n        country: O.String\n            default: \"USA\"\n```\n\n\n\nStatic properties, methods, literals\n--------------------------------------------------\n\nYour object may have static members. These are pretty like static members in C++ or python etc. They are accessible from the Potato itself, but not from its instances.\n\nThe most obvious one is \"make\" which makes it possible to instantiate a potato.\n\n```coffeescript\n#\n# This should make an address with : \n# all our default values.\n#\naddress = InternationalAddress.make()\n```\n\n\nYou may define more static members using the \n\"static\" section prefix. For instance, Potato's Models have a JSON deserialization function which looks pretty much like this. \n    \n```coffeescript\nModel = O.Potato\n    static:\n        fromJSON: (json)->\n            @make JSON.parse json\n```\n\nOn the other hands methods are made to be called from \nobjects.\nA model also have a toJSON method, which looks like :\n\n```coffeescript\nModel = O.Potato\n    methods:\n        toJSON: ->\n            JSON.stringify @toData()\n```\n\nAs an helper, a static function is actually also magically created, taking the object to which it should be bound to as a first argument.\n\nSomeone in fond of functional programming may write things such as \n    \n```coffeescript\nmap Model.toJSON, someListOfModels\n```\n\nas an alternative to\n    \n```coffeescript\nmodel.toJSON() for model in someListOfModels\n```\n\n\n\n\nKnowing your components is a cool thing.\n--------------------------------------------------\n\nYour objects are aware of their components and their types and that is a great things.\n\nValidation\nSerialization\nGeneric forms","readmeFilename":"README.md","_id":"potato@0.1.1","dist":{"shasum":"ed6178f90898508f3dc3bc54e280f192441c4c74","tarball":"https://registry.npmjs.org/potato/-/potato-0.1.1.tgz","integrity":"sha512-JKl34po6FY1jk0ASC4iS3nTA+wpt9Nx/Uq8/dYJDPJNS5+SFK1dZuyjFzYHNkxw+eYejbECk7Pi35CzihUxfxw==","signatures":[{"keyid":"SHA256:jl3bwswu80PjjokCgh0o2w5c2U4LhQAE57gj9cz1kzA","sig":"MEUCIQDf2SazD3M4H48DBFU1LGjWkG+0hPQMkUd396hYI+eYmgIgdXRzhEcihxmjm0QSTZvo6GjNQWoCcC+3r0tBvMr4zzY="}]},"_npmVersion":"1.1.69","_npmUser":{"name":"poulejapon","email":"paul.masurel@gmail.com"},"maintainers":[{"name":"poulejapon","email":"paul.masurel@gmail.com"}]}},"maintainers":[{"name":"poulejapon","email":"paul.masurel@gmail.com"}],"time":{"modified":"2022-06-24T11:51:50.159Z","created":"2011-09-04T18:53:46.875Z","0.0.1":"2011-09-04T18:53:47.648Z","0.0.3":"2012-12-21T11:48:58.204Z","0.0.4":"2012-07-02T21:55:51.644Z","0.0.5":"2012-07-03T21:30:19.766Z","0.0.6":"2012-07-03T21:38:44.884Z","0.0.7":"2012-07-03T22:47:24.269Z","0.0.8":"2012-12-21T11:49:45.460Z","0.0.9":"2012-12-21T17:55:31.798Z","0.1.0":"2013-01-15T22:46:13.653Z","0.1.1":"2013-01-31T18:10:45.156Z"},"author":{"name":"Paul Masurel","email":"paul.masurel@gmail.com"},"repository":{"type":"git","url":"https://github.com/poulejapon/potato"}}