cordova-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Carlos Santana <csantan...@gmail.com>
Subject Re: adding platforms to npm for dependency sanity
Date Wed, 04 Jun 2014 15:10:56 GMT
I think regardless how much sugar we use to make it easy, I think the under
the hood foundation/architecture should be something like:

LocalProject/www/
LocalProject/config.xml
LocalProject/package.json
LocalProject/node_module/.bin/cordova

config.xml (manages the cordova app)
package.json (manages the cordova project)

pacakge.json (will specify all dependencies and npm will take care of
fulfill them)
{
cordova: ">3.6",
cordova-ios: "3.6.1",
cordova-android: "3.6.2",
cordova-plugin-device: "*",
cordova-plugin-file: "^0.2.4"
}
npm install will take care of making everything available locally.

I know that we don't have plugins in npm, but something to think about, in
terms of just a secondary repository to download the files and caching.

a global @cordova-cli, can be available like grunt-cli, to look first in
local directory (i.e. findup)

like someone mentioned npm installs hooks can run the "cordova platform add"

this way minimal set of files can be put a dev repo, and reproduce by
another developer very easy both getting same resulting project.

git clone https://github.com/myuser/cordovapp && cd cordovapp && npm
install && cordova run android



On Tue, Jun 3, 2014 at 6:35 PM, Terence M. Bandoian <terence@tmbsw.com>
wrote:

> I still consider myself a relative newcomer to Cordova but, from a
> development standpoint, it would be easiest for me if I could manage each
> platform of a project independently - including plugins.  Creating a
> parallel project to make sure that the plugins and Cordova base don't
> change for one platform while I work on another isn't ideal but it isn't
> completely unmanageable either.  It just makes the workflow a little more
> complex.
>
> -Terence
>
>
>
> On 6/3/2014 7:12 PM, Michal Mocny wrote:
>
>> We don't do platform-plugin version matching *at all* today.  Everyone
>> uses
>> the latest plugins and any platform version they want, and its been
>> "fine".
>>   So using different platform versions isn't as hard as you guys are
>> making
>> it out to be.
>>
>> Still, I've already said its not necessarily a complexity that needs to be
>> addressed in a world where you can create multiple projects and use
>> --link-to or whatever, so long as your platforms aren't installed
>> globally.
>>
>>
>> Anyway, thanks for posting your instructions Brian/Tommy.  As I mentioned
>> it would be, thats a different workflow than we have now.  I'm going to
>> sleep on it before I comment, but it certainly isn't just like "You know
>> how we do it today".
>>
>> -Michal
>>
>>
>> On Tue, Jun 3, 2014 at 7:59 PM, tommy-carlos williams <tommy@devgeeks.org
>> >
>> wrote:
>>
>>  I don’t think you really can forget about plugins for a second.
>>>
>>> In my personal opinion, the entire ./platforms folder should be a build
>>> artefact. If you want to freeze iOS, then use a branch or a new clone of
>>> the project.
>>>
>>> It’s not that I can think of no scenarios where supporting multiple
>>> platform versions would be needed, it’s just that I think it’s needlessly
>>> complex vs using a dev workflow to solve those problems.
>>>
>>> I already version cordova within a project… I have a local version of
>>> cordova installed into ./node_modules for each project and use Grunt to
>>> call ./node_modules/.bin/cordova rather than the global cordova cli.
>>>
>>> On 4 June 2014 at 9:46:29, Terence M. Bandoian (terence@tmbsw.com)
>>> wrote:
>>>
>>> Forgetting about plugins for a second, what if:
>>>
>>> - I complete a project for iOS
>>> - six months later the client decides to port to Android and:
>>> - I want the latest fixes for Android
>>> - I want to keep the iOS version frozen for the time being
>>>
>>> I would expect releases for each platform to be on different schedules.
>>>
>>> -Terence
>>>
>>>
>>> On 6/3/2014 6:17 PM, Michal Mocny wrote:
>>>
>>>> Most plugins will work across a wide range of platform versions, so
>>>> often
>>>> it would work to have disparate platform versions even with plugins.
>>>> However, I do concede that in general this isn't a complexity we focus
>>>>
>>> on.
>>>
>>>> Interested in your thoughts about the other points.
>>>>
>>>> -Michal
>>>>
>>>>
>>>> On Tue, Jun 3, 2014 at 7: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
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>
>>>
>


-- 
Carlos Santana
<csantana23@gmail.com>

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