cordova-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Brian LeRoux...@brian.io>
Subject Re: adding platforms to npm for dependency sanity
Date Tue, 03 Jun 2014 23:16:43 GMT
…and use package.json to achieve a frictionless env swap on a per project
basis, eventually making the CLI a thin shell that calls into node_modules
ala Grunt, Gulp, etc.


On Tue, Jun 3, 2014 at 4:07 PM, tommy-carlos williams <tommy@devgeeks.org>
wrote:

> You can’t have version x of a plugin for iOS and version y of that same
> plugin for Android, so multiple platform versions seems like a complexity
> for complexity’s sake.
>
> It’s true that different apps need to support different platform versions,
> but I would suspect that the greatest majority of those would want the same
> version of iOS and Android in app x.
>
>
>
> On 4 June 2014 at 9:04:42, Brian LeRoux (b@brian.io) wrote:
>
> That is the thing: you do not EVER want to have disparate versions of
> platforms. Plugins negate this potential fantasy.
>
> You want version locked deps. You want to use package.json to do that b/c
> that is what the runtime we use has standardized itself on.
>
>
> On Tue, Jun 3, 2014 at 1:12 PM, Terence M. Bandoian <terence@tmbsw.com>
> wrote:
>
> > A typical use case might be:
> >
> > -project1
> > -project1-ios
> > -project1-android
> > -project1-windows
> > ...
> > -projectN
> > -projectN-ios
> > -projectN-android
> > -projectN-windows
> >
> > with a different platform version for each sub-project.
> >
> > Would CLI be installed globally? Locally for each sub-project? Would a
> > project-platform have to be re-built if a plugin were added?
> >
> > -Terence
> >
> >
> > On 6/3/2014 1:47 PM, Michal Mocny wrote:
> >
> >> Okay, so I think that implies:
> >>
> >> (a) CLI versions tied to very specific platform versions ==> to switch
> >> platform versions you must switching CLI versions ==> switching one
> >> platform version switches all platform versions.
> >> - Andrew pointed out this is currently the case, and is a problem that
> >> leads to users not updating CLI as often as they otherwise would
> >> - I think this basically implies platforms cannot be independently
> >> versioned (sure the semver numbers may differ, but for all practical
> >> purposes, you would use platforms from the same release date, based on
> CLI
> >> version).
> >>
> >> (b) Require apps to depend on specific CLI version, assuming you mean
> with
> >> a local package.json:
> >> - Now all cordova projects must be node projects, which they currently
> are
> >> not.
> >> - Currently the cordova-cli creates apps, so we have a globally
> installed
> >> bootstrapping cordova-cli, and a locally installed specific version
> >> cordova-cli, a-la grunt/gulp. (this idea was thrown around before).
> >> - Quite a dramatic change for cordova workflow, surely larger than the
> >> current proposal.
> >> - Or we drop cordova-cli entirely and just publish grunt/gulp plugins to
> >> "add cordova" to your existing web app. Thats an even more radical
> >> departure and significant work.
> >>
> >> -Michal
> >>
> >>
> >> On Tue, Jun 3, 2014 at 1:58 PM, Brian LeRoux <b@brian.io> wrote:
> >>
> >> No, at least not how I'd see it done.
> >>>
> >>> 1.) Updating is important. Staying current: encouraged.
> >>> 2.) I'd make my App depend on a specific CLI version. I'd call into
> that
> >>> using npm scripts.
> >>>
> >>>
> >>>
> >>>
> >>> On Tue, Jun 3, 2014 at 10:48 AM, Michal Mocny <mmocny@chromium.org>
> >>> wrote:
> >>>
> >>> Thinking it through, if cordova platforms are deps of the CLI, to
> >>>>
> >>> install a
> >>>
> >>>> specific version you wouldn't just do:
> >>>>
> >>>>> npm install -g cordova-ios@3.4.1
> >>>>>
> >>>> you would actually need to:
> >>>>
> >>>>> cd $(npm config get prefix)/lib/node_modules/cordova
> >>>>> npm install --save cordova-ios@3.4.1
> >>>>>
> >>>> ..and then remember to do that again whenever you `npm update -g`
> >>>> ..and its harder to have multiple platform versions for different
> >>>>
> >>> projects
> >>>
> >>>> (questionable if this is useful for devs outside of cordova
> >>>> contributors,
> >>>> but may be useful at last test upgrades when we ship new platform
> >>>> versions).
> >>>>
> >>>> -Michal
> >>>>
> >>>>
> >>>> On Tue, Jun 3, 2014 at 1:28 PM, Brian LeRoux <b@brian.io> wrote:
> >>>>
> >>>> NIH: not invented here
> >>>>>
> >>>>>
> >>>>>
> >>>>> On Tue, Jun 3, 2014 at 10:17 AM, Andrew Grieve <agrieve@chromium.org
> >
> >>>>> wrote:
> >>>>>
> >>>>> On Tue, Jun 3, 2014 at 12:19 PM, Brian LeRoux <b@brian.io> wrote:
> >>>>>>
> >>>>>> Actually that was >0 LOC which is a fine argument if you ask me.
> >>>>>>>
> >>>>>> And
> >>>
> >>>> we
> >>>>
> >>>>> both know there is much more to it than just that. lazy_load…for
> >>>>>>>
> >>>>>> example.
> >>>>>
> >>>>>>
> >>>>>> If you're concerned about code, there is a tonne of much
> >>>>>>
> >>>>> lower-hanging
> >>>
> >>>> fruit.
> >>>>>>
> >>>>>>
> >>>>>> Bundling platforms is bundling a dep that we require to operate. We
> >>>>>>>
> >>>>>> do
> >>>>
> >>>>> not
> >>>>>>
> >>>>>>> require plugins to operate. You cannot build a project without
> >>>>>>>
> >>>>>> having a
> >>>>
> >>>>> platform and, indeed, you probably want more than one.
> >>>>>>>
> >>>>>>> I don't require blackberry to create an iOS project. But I do
> >>>>>> require
> >>>>>>
> >>>>> some
> >>>>>
> >>>>>> plugins. We use "npm cache add" to download plugins, I don't see how
> >>>>>> platforms would not work just as easily.
> >>>>>>
> >>>>>>
> >>>>>> Agree that we need discreet versioning: hence why I'm advocating we
> >>>>>>>
> >>>>>> use
> >>>>
> >>>>> well understood, maintained, and effectively standard system for
> >>>>>>>
> >>>>>> doing
> >>>>
> >>>>> this. We do not need NIH dependencies that is what package.json is
> >>>>>>>
> >>>>>> for!
> >>>>
> >>>>> I don't know what NIH dependencies are. Googling suggests you're
> >>>>>>
> >>>>> talking
> >>>>
> >>>>> about drugs...
> >>>>>>
> >>>>>> We *are* using npm for downloading, we're just not making the user
> >>>>>>
> >>>>> type
> >>>
> >>>> it
> >>>>>
> >>>>>> directly.
> >>>>>>
> >>>>>> Mark's approach also avoids the "what-if" cases where what's in your
> >>>>>> node_modules might not match what's in your platforms/
> >>>>>>
> >>>>>> Does what Mark has implemented not address a use-case of yours? Or
> >>>>>>
> >>>>> are
> >>>
> >>>> we
> >>>>
> >>>>> going back & forth over personal preference?
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>>>
> >>>>>>>
> >>>>>>> On Tue, Jun 3, 2014 at 9:07 AM, Andrew Grieve <
> >>>>>>>
> >>>>>> agrieve@chromium.org>
> >>>
> >>>> wrote:
> >>>>>>>
> >>>>>>> On Tue, Jun 3, 2014 at 11:34 AM, Brian LeRoux <b@brian.io>
> >>>>>>>>
> >>>>>>> wrote:
> >>>
> >>>> Andrew, you misunderstand. I am talking about bundling
> >>>>>>>>>
> >>>>>>>> platforms
> >>>
> >>>> directly
> >>>>>>>
> >>>>>>>> as dependencies of the CLI.
> >>>>>>>>>
> >>>>>>>>> A trivial example:
> >>>>>>>>>
> >>>>>>>>> CLI
> >>>>>>>>> '-ios
> >>>>>>>>>
> >>>>>>>>> Wherein, CLI declares the precise version of the platform it
> >>>>>>>>>
> >>>>>>>> uses.
> >>>>
> >>>>> We
> >>>>>
> >>>>>> could
> >>>>>>>>
> >>>>>>>>> wildcard. I don't know that we want or need to do that.
> >>>>>>>>>
> >>>>>>>>> It would have identical semantics to today except the download
> >>>>>>>>>
> >>>>>>>> penalty
> >>>>>>
> >>>>>>> happens up front. (We can remove lazy_load logic. We don't have
> >>>>>>>>>
> >>>>>>>> to
> >>>>
> >>>>> maintain
> >>>>>>>>
> >>>>>>>>> our own dependency manifests and caches. LESS code: good
> >>>>>>>>>
> >>>>>>>> thing.)
> >>>
> >>>> Let me paste the code for doing our own caching for you:
> >>>>>>>>
> >>>>>>>> cordova_npm: function lazy_load_npm(platform) {
> >>>>>>>> if (!(platform in platforms)) {
> >>>>>>>> return Q.reject(new Error('Cordova library "' +
> >>>>>>>>
> >>>>>>> platform
> >>>>
> >>>>> +
> >>>>>
> >>>>>> '"
> >>>>>>
> >>>>>>> not recognized.'));
> >>>>>>>> }
> >>>>>>>> var pkg = 'cordova-' + platform + '@' +
> >>>>>>>> platforms[platform].version;
> >>>>>>>> return Q.nfcall( npm.load, {cache:
> >>>>>>>>
> >>>>>>> path.join(util.libDirectory,
> >>>>>
> >>>>>> 'npm_cache') })
> >>>>>>>> .then(function() {
> >>>>>>>> return Q.ninvoke(npm.commands, 'cache', ['add',
> >>>>>>>>
> >>>>>>> pkg]);
> >>>
> >>>> }).then(function(info) {
> >>>>>>>> var pkgDir = path.resolve(npm.cache, info.name,
> >>>>>>>>
> >>>>>>> info.version,
> >>>>>>>
> >>>>>>>> 'package');
> >>>>>>>> return pkgDir;
> >>>>>>>> });
> >>>>>>>> },
> >>>>>>>>
> >>>>>>>> There's really no "amount of code" argument here.
> >>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> Adding platforms at a specific version would mean having a
> >>>>>>>>>
> >>>>>>>> specific
> >>>>
> >>>>> version
> >>>>>>>>
> >>>>>>>>> of the CLI. Yes: this is way better! Explicit dependencies is
> >>>>>>>>>
> >>>>>>>> the
> >>>
> >>>> best
> >>>>>>
> >>>>>>> way
> >>>>>>>>
> >>>>>>>>> to work w/ the small modules thing.
> >>>>>>>>>
> >>>>>>>>> Bundling platforms with CLI would be like bundling all of the
> >>>>>>>>
> >>>>>>> plugins
> >>>>
> >>>>> with
> >>>>>>>
> >>>>>>>> CLI, or like bundling every npm module with npm.
> >>>>>>>>
> >>>>>>>> Devs need to be able to try out platforms at different versions.
> >>>>>>>>
> >>>>>>> We
> >>>
> >>>> should
> >>>>>>>
> >>>>>>>> not do anything that keeps users clinging to old versions of CLI
> >>>>>>>>
> >>>>>>> (e.g.
> >>>>>
> >>>>>> they
> >>>>>>>
> >>>>>>>> do this now because they don't want to update to new platforms)
> >>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> On Mon, Jun 2, 2014 at 7:34 PM, Michal Mocny <
> >>>>>>>>>
> >>>>>>>> mmocny@chromium.org>
> >>>>
> >>>>> wrote:
> >>>>>>>>
> >>>>>>>>> On Mon, Jun 2, 2014 at 10:14 PM, Andrew Grieve <
> >>>>>>>>>>
> >>>>>>>>> agrieve@chromium.org
> >>>>>>
> >>>>>>> wrote:
> >>>>>>>>>>
> >>>>>>>>>> Here's both flows as I understand them:
> >>>>>>>>>>>
> >>>>>>>>>>> Direct NPM flow:
> >>>>>>>>>>> # Downloads platform source into node_modules
> >>>>>>>>>>> npm install cordova-ios@3.4.0 --save
> >>>>>>>>>>> # Runs the create script and installs plugins to create
> >>>>>>>>>>>
> >>>>>>>>>> platforms/ios
> >>>>>>>
> >>>>>>>> cordova platform add ios --path=node_modules/cordova-ios
> >>>>>>>>>>>
> >>>>>>>>>>> To be fair, I think with Brian's suggestion, platform add FOO
> >>>>>>>>>>
> >>>>>>>>> would
> >>>>>
> >>>>>> by
> >>>>>>>
> >>>>>>>> default look in node_modules so you wouldn't be explicit
> >>>>>>>>>>
> >>>>>>>>> about
> >>>
> >>>> it,
> >>>>>
> >>>>>> and
> >>>>>>>
> >>>>>>>> also
> >>>>>>>>>
> >>>>>>>>>> the default cordova project package.json would depend on all
> >>>>>>>>>>
> >>>>>>>>> the
> >>>>
> >>>>> latest
> >>>>>>>
> >>>>>>>> versions of each platform, so the flows would actually be:
> >>>>>>>>>>
> >>>>>>>>>>> cordova create Foo && cd Foo
> >>>>>>>>>>> npm install
> >>>>>>>>>>> npm install cordova-ios@3.4 --save
> >>>>>>>>>>> cordova platform add android
> >>>>>>>>>>> cordova platform add ios
> >>>>>>>>>>> # crazy idea? use npm post-install hooks to auto-run
> >>>>>>>>>>>
> >>>>>>>>>> create/upgrade
> >>>>>>
> >>>>>>> so
> >>>>>>>>
> >>>>>>>>> you usually don't need above two lines?
> >>>>>>>>>>
> >>>>>>>>>> Compared to:
> >>>>>>>>>>
> >>>>>>>>>>> cordova create Foo && cd Foo
> >>>>>>>>>>> cordova platform add android
> >>>>>>>>>>> cordova platform add ios@3.4
> >>>>>>>>>>>
> >>>>>>>>>> I think #2 is enough better that its not worth changing.
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Cordova-to-npm flow (as Mark's implemented):
> >>>>>>>>>>> # Runs "npm cache add cordova-ios", then runs create script
> >>>>>>>>>>>
> >>>>>>>>>> from
> >>>>>
> >>>>>> ~/cache/cordova-ios/bin/create
> >>>>>>>>>>> cordova platform add ios@3.4.0
> >>>>>>>>>>>
> >>>>>>>>>>> - In both flows: we use npm to do all of the heavy lifting
> >>>>>>>>>>> - In both flows: the npm module is cached in your home
> >>>>>>>>>>>
> >>>>>>>>>> directory
> >>>>>
> >>>>>> - In both flows?: we store the plugins & platforms
> >>>>>>>>>>>
> >>>>>>>>>> explicitly
> >>>
> >>>> within
> >>>>>>>
> >>>>>>>> config.xml (Gorkem's added this)
> >>>>>>>>>>> - In flow #1, we have a package.json & a node_modules, in
> >>>>>>>>>>>
> >>>>>>>>>> #2
> >>>
> >>>> we
> >>>>
> >>>>> don't.
> >>>>>>>>
> >>>>>>>>> Why put the onus on the user to fetch the platform source
> >>>>>>>>>>>
> >>>>>>>>>> when
> >>>>
> >>>>> it's
> >>>>>>
> >>>>>>> as
> >>>>>>>>
> >>>>>>>>> easy
> >>>>>>>>>>
> >>>>>>>>>>> as running "npm cache add" under-the-hood?
> >>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> In regards to the idea of using require() on platform
> >>>>>>>>>>>
> >>>>>>>>>> scripts
> >>>
> >>>> instead
> >>>>>>>
> >>>>>>>> of
> >>>>>>>>>
> >>>>>>>>>> subshelling: I think this is tangental to the debate of how
> >>>>>>>>>>>
> >>>>>>>>>> to
> >>>>
> >>>>> fetch
> >>>>>>>
> >>>>>>>> the
> >>>>>>>>>
> >>>>>>>>>> platform.
> >>>>>>>>>>> In regards to using "npm install" directly when using the
> >>>>>>>>>>>
> >>>>>>>>>> plugman
> >>>>>
> >>>>>> workflow:
> >>>>>>>>>>
> >>>>>>>>>>> Sounds good to me.
> >>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> On Mon, Jun 2, 2014 at 6:05 PM, Brian LeRoux <b@brian.io>
> >>>>>>>>>>>
> >>>>>>>>>> wrote:
> >>>>>
> >>>>>> Eventually, yes. (Sort of how Grunt works now.)
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> On Mon, Jun 2, 2014 at 5:52 PM, Terence M. Bandoian <
> >>>>>>>>>>>>
> >>>>>>>>>>> terence@tmbsw.com
> >>>>>>>>>
> >>>>>>>>>> wrote:
> >>>>>>>>>>>>
> >>>>>>>>>>>> Can multiple versions of a platform be installed
> >>>>>>>>>>>>>
> >>>>>>>>>>>> side-by-side?
> >>>>>>
> >>>>>>> -Terence
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> On 6/2/2014 3:04 PM, Michal Mocny wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> >From original email: "Ideal future CLI uses platforms
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> just
> >>>>>
> >>>>>> like
> >>>>>>>
> >>>>>>>> other
> >>>>>>>>>>
> >>>>>>>>>>> deps.
> >>>>>>>>>>>>>> We lose lazy loading but network and disk is cheap so
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> it
> >>>
> >>>> wasn't
> >>>>>>>
> >>>>>>>> really
> >>>>>>>>>>
> >>>>>>>>>>> important anyhow."
> >>>>>>>>>>>>>> Made me think Brian is proposing adding platforms to
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> cli
> >>>
> >>>> package.json
> >>>>>>>>>>
> >>>>>>>>>>> dependencies, and you would have a single global
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> install
> >>>
> >>>> cordova-platforms.
> >>>>>>>>>>>>>> Then you can override the version with an explicit
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> install
> >>>>>
> >>>>>> as
> >>>>>>>
> >>>>>>>> he
> >>>>>>>>
> >>>>>>>>> mentions
> >>>>>>>>>>>>>> "npm i cordova-ios@3.5.0".
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Personally, I think that workflow could work, and has
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> a
> >>>
> >>>> few
> >>>>>
> >>>>>> benefits,
> >>>>>>>>>>
> >>>>>>>>>>> but
> >>>>>>>>>>>>
> >>>>>>>>>>>>> I'm not sure that option compares well to the
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> alternative
> >>>>
> >>>>> of
> >>>>>
> >>>>>> just
> >>>>>>>>
> >>>>>>>>> lazy
> >>>>>>>>>>
> >>>>>>>>>>> loading using npm cache add as Mark has already
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> implemented
> >>>>>
> >>>>>> an
> >>>>>>
> >>>>>>> experiment
> >>>>>>>>>>>>
> >>>>>>>>>>>>> (anyone interested in this topic should take a look at
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> that
> >>>>>
> >>>>>> patch).
> >>>>>>>>>
> >>>>>>>>>> The steps Brian & Ian outline about how to package
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> platforms
> >>>>>
> >>>>>> for
> >>>>>>>
> >>>>>>>> release
> >>>>>>>>>>>
> >>>>>>>>>>>> to
> >>>>>>>>>>>>>> npm are possibly an improvement over the old-style
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> platform-centric
> >>>>>>>>>
> >>>>>>>>>> workflow. Instead of downloading a tarball and
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> running
> >>>
> >>>> a
> >>>>
> >>>>> create
> >>>>>>>
> >>>>>>>> script,
> >>>>>>>>>>>
> >>>>>>>>>>>> you npm install and run a create() function, and that
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> can
> >>>>
> >>>>> more
> >>>>>>
> >>>>>>> easily
> >>>>>>>>>>
> >>>>>>>>>>> be
> >>>>>>>>>>>
> >>>>>>>>>>>> bundled into other build scripts/boilerplate. For CLI
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> workflow,
> >>>>>>>
> >>>>>>>> not
> >>>>>>>>>
> >>>>>>>>>> sure
> >>>>>>>>>>>>
> >>>>>>>>>>>>> that there is any real difference (as Jesse says).
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> One
> >>>
> >>>> note,
> >>>>>>
> >>>>>>> though:
> >>>>>>>>>>
> >>>>>>>>>>> cordova-* platforms are templates for projects, so
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> the
> >>>
> >>>> package.json
> >>>>>>>>>>
> >>>>>>>>>>> of
> >>>>>>>>>>>
> >>>>>>>>>>>> the
> >>>>>>>>>>>>>> npm package itself shouldn't end up inside projects
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> that
> >>>
> >>>> are
> >>>>>
> >>>>>> created
> >>>>>>>>>
> >>>>>>>>>> with
> >>>>>>>>>>>>
> >>>>>>>>>>>>> it. I think.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> -Michal
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> On Mon, Jun 2, 2014 at 3:42 PM, Ian Clelland <
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> iclelland@chromium.org>
> >>>>>>>>>>
> >>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> There seems to be some confusion -- I think people
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>> are
> >>>
> >>>> talking
> >>>>>>>
> >>>>>>>> about
> >>>>>>>>>>
> >>>>>>>>>>> different things here, but perhaps it's just me ;)
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> I thought that Brian's original suggestion was about
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> being
> >>>>>
> >>>>>> able
> >>>>>>>
> >>>>>>>> to
> >>>>>>>>>
> >>>>>>>>>> host
> >>>>>>>>>>>
> >>>>>>>>>>>> Cordova platforms directly on NPM. That's why each
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> one
> >>>
> >>>> would
> >>>>>>
> >>>>>>> require
> >>>>>>>>>>
> >>>>>>>>>>> a
> >>>>>>>>>>>
> >>>>>>>>>>>> package.json. (which would probably end up in
> >>>>>>>>>>>>>>> <project>/platforms/<platform> in a project, but
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> that's
> >>>
> >>>> not
> >>>>>
> >>>>>> the
> >>>>>>>
> >>>>>>>> point
> >>>>>>>>>>
> >>>>>>>>>>> of
> >>>>>>>>>>>>
> >>>>>>>>>>>>> it).
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> As an NPM project, we then would have the opportunity
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> (though
> >>>>>>
> >>>>>>> not
> >>>>>>>>
> >>>>>>>>> the
> >>>>>>>>>>
> >>>>>>>>>>> obligation) to make all of the supporting scripts for
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> each
> >>>>>
> >>>>>> platform
> >>>>>>>>>
> >>>>>>>>>> (create, build, run, etc) part of the node module,
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> for
> >>>
> >>>> a
> >>>>
> >>>>> uniform
> >>>>>>>>
> >>>>>>>>> interface
> >>>>>>>>>>>>>>> that doesn't require going through the command line.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> It's not about making platforms into CLI dependencies
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> (any
> >>>>>
> >>>>>> more
> >>>>>>>
> >>>>>>>> than
> >>>>>>>>>>
> >>>>>>>>>>> plugins are CLI dependencies right now), or about
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> making
> >>>>
> >>>>> a
> >>>>>
> >>>>>> cordova-based
> >>>>>>>>>>>>
> >>>>>>>>>>>>> project into a node package.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> If that's right, then I support that -- I'd like the
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> platforms
> >>>>>>>
> >>>>>>>> to
> >>>>>>>>
> >>>>>>>>> be
> >>>>>>>>>>
> >>>>>>>>>>> installable through npm, and to be versioned
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> separately,
> >>>>
> >>>>> installable
> >>>>>>>>>>
> >>>>>>>>>>> separately, and scriptable without having to spawn
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> subshells.
> >>>>>>
> >>>>>>> And if I have it completely wrong, then let me know
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> --
> >>>
> >>>> I'll
> >>>>>
> >>>>>> just
> >>>>>>>>
> >>>>>>>>> go
> >>>>>>>>>
> >>>>>>>>>> back
> >>>>>>>>>>>>
> >>>>>>>>>>>>> to
> >>>>>>>>>>>>>>> fixing File bugs ;)
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On Mon, Jun 2, 2014 at 3:29 PM, Andrew Grieve <
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> agrieve@chromium.org>
> >>>>>>>>>>
> >>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Not sure what your question is.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On Mon, Jun 2, 2014 at 2:03 PM, Brian LeRoux <
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> b@brian.io>
> >>>>>
> >>>>>> wrote:
> >>>>>>>>>
> >>>>>>>>>> *ahem
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> On Wed, May 28, 2014 at 11:20 AM, Brian LeRoux <
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> b@brian.io
> >>>>>>
> >>>>>>> wrote:
> >>>>>>>>>>
> >>>>>>>>>>> npm i cordova-ios@3.5.0
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Right?
> >>>>>>>>>>>>>>>>>> On May 27, 2014 11:06 PM, "Andrew Grieve" <
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> agrieve@chromium.org
> >>>>>>>>>
> >>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>> Lazy loading is what will give us the ability to
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> support
> >>>>>
> >>>>>> multiple
> >>>>>>>>>
> >>>>>>>>>> versions
> >>>>>>>>>>>>>>>>>> of platforms.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> If we don't support users choosing the version of
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> the
> >>>>
> >>>>> platform
> >>>>>>>>>
> >>>>>>>>>> they
> >>>>>>>>>>>
> >>>>>>>>>>>> want,
> >>>>>>>>>>>>>>>>>> then they will resist updating their version of
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> CLI
> >>>
> >>>> (like
> >>>>>>
> >>>>>>> they
> >>>>>>>>
> >>>>>>>>> do
> >>>>>>>>>>
> >>>>>>>>>>> right
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> now).
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> I'm very keen to allow users to chose their
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> platform
> >>>>
> >>>>> versions,
> >>>>>>>>>
> >>>>>>>>>> just
> >>>>>>>>>>>
> >>>>>>>>>>>> as
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> they
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> are able to choose their plugin versions.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> On Tue, May 27, 2014 at 5:57 PM, Mark Koudritsky
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> <
> >>>
> >>>> kamrik@google.com
> >>>>>>>>>>>>
> >>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> +1
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Steve published (some of?) the platforms on npm
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> as
> >>>
> >>>> part
> >>>>>>
> >>>>>>> of
> >>>>>>>
> >>>>>>>> the
> >>>>>>>>>
> >>>>>>>>>> latest
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> release.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> https://www.npmjs.org/package/cordova-android
> >>>>>>>>>>>>>>>>>>>> https://www.npmjs.org/package/cordova-ios
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> CLI already require()s npm for downloading
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> plugins
> >>>
> >>>> from
> >>>>>>
> >>>>>>> the
> >>>>>>>>
> >>>>>>>>> registry.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Extending this to platforms is on my todo list for
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> this\next
> >>>>>>>
> >>>>>>>> week.
> >>>>>>>>>>
> >>>>>>>>>>> The "lazy" part of the loading was about
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> caching,
> >>>
> >>>> so
> >>>>
> >>>>> we
> >>>>>>
> >>>>>>> don't
> >>>>>>>>>
> >>>>>>>>>> lose
> >>>>>>>>>>>
> >>>>>>>>>>>> it
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> since
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> npm does its own caching.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> On Tue, May 27, 2014 at 5:42 PM, Parashuram
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Narasimhan
> >>>>>
> >>>>>> (MS
> >>>>>>>
> >>>>>>>> OPEN
> >>>>>>>>>>
> >>>>>>>>>>> TECH)
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> <
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> panarasi@microsoft.com> wrote:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> +1. This will also be a step towards releasing
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> platforms
> >>>>>>>
> >>>>>>>> independently.
> >>>>>>>>>>>>>>>>>>>> Will the CLI have a semver like dependency on
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
>
>

Mime
  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message