cordova-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Michal Mocny <mmo...@chromium.org>
Subject Re: adding platforms to npm for dependency sanity
Date Tue, 03 Jun 2014 23:26:02 GMT
I don't see how that can be true.


On Tue, Jun 3, 2014 at 7:23 PM, Brian LeRoux <b@brian.io> wrote:

> You know how we do it today? Just like that.
>
>
> On Tue, Jun 3, 2014 at 4:20 PM, Michal Mocny <mmocny@chromium.org> wrote:
>
>> Brian/Tommy, may you please write out the complete set of CLI commands
>> you envision for:
>> (a) create a new project and add 2 platforms
>> (b) upgrade an existing project to a specific version
>>
>> I worry the current package.json proposal is more complex than we realize.
>>
>> -Michal
>>
>>
>> On Tue, Jun 3, 2014 at 7:17 PM, tommy-carlos williams <tommy@devgeeks.org
>> > wrote:
>>
>>> +1
>>>
>>>
>>> On 4 June 2014 at 9:17:09, Brian LeRoux (b@brian.io) wrote:
>>>
>>> …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