Add --frozen and --without_development flags

Author: straight-shoota

docs/shards.adoc

@@ -58,7 +58,7 @@ Exit status:
 *init*::
 Initializes a default _shard.yml_ in the current folder.
 
-*install*::
+*install* [--frozen] [--without-development] [--production]::
 Resolves and installs dependencies into the _lib_ folder. If not already
 present, generates a _shard.lock_ file from resolved dependencies, locking
 version numbers or Git commits.
@@ -67,6 +67,12 @@ Reads and enforces locked versions and commits if a _shard.lock_ file is
 present. The *install* command may fail if a locked version doesn't match
 a requirement, but may succeed if a new dependency was added, as long as it
 doesn't generate a conflict, thus generating a new _shard.lock_ file.
++
+--
+--frozen:: Strictly installs locked versions from _shard.lock_. Fails if _shard.lock_ is missing.
+--without-development:: Does not install development dependencies.
+--production:: same as _--frozen_ and _--without-development_
+--
 
 *list* [--tree]::
 Lists the installed dependencies and their versions.
@@ -121,12 +127,6 @@ after a command.
 --ignore-crystal-version::
   Do not enforce crystal version restrictions on shards.
 
---production::
-  Runs in release mode. Development dependencies won’t
-  be installed and only locked dependencies will be installed. Commands
-  will fail if dependencies in _shard.yml_ and _shard.lock_ are out of
-  sync (used by *install*, *update*, *check* and *list* commands).
-
 -q, --quiet::
   Decreases the log verbosity, printing only warnings and errors.
 

man/shards.1

@@ -2,12 +2,12 @@
 .\"     Title: shards
 .\"    Author: [see the "AUTHOR(S)" section]
 .\" Generator: Asciidoctor 2.0.12
-.\"      Date: 2021-01-30
+.\"      Date: 2021-02-02
 .\"    Manual: Shards Manual
 .\"    Source: shards 0.13.0
 .\"  Language: English
 .\"
-.TH "SHARDS" "1" "2021-01-30" "shards 0.13.0" "Shards Manual"
+.TH "SHARDS" "1" "2021-02-02" "shards 0.13.0" "Shards Manual"
 .ie \n(.g .ds Aq \(aq
 .el       .ds Aq '
 .ss \n[.ss] 0
@@ -92,7 +92,7 @@ Dependencies are not satisfied.
 Initializes a default \fIshard.yml\fP in the current folder.
 .RE
 .sp
-\fBinstall\fP
+\fBinstall\fP [\-\-frozen] [\-\-without\-development] [\-\-production]
 .RS 4
 Resolves and installs dependencies into the \fIlib\fP folder. If not already
 present, generates a \fIshard.lock\fP file from resolved dependencies, locking
@@ -102,6 +102,21 @@ Reads and enforces locked versions and commits if a \fIshard.lock\fP file is
 present. The \fBinstall\fP command may fail if a locked version doesn\(cqt match
 a requirement, but may succeed if a new dependency was added, as long as it
 doesn\(cqt generate a conflict, thus generating a new \fIshard.lock\fP file.
+.sp
+\-\-frozen
+.RS 4
+Strictly installs locked versions from \fIshard.lock\fP. Fails if \fIshard.lock\fP is missing.
+.RE
+.sp
+\-\-without\-development
+.RS 4
+Does not install development dependencies.
+.RE
+.sp
+\-\-production
+.RS 4
+same as \fI\-\-frozen\fP and \fI\-\-without\-development\fP
+.RE
 .RE
 .sp
 \fBlist\fP [\-\-tree]
@@ -178,14 +193,6 @@ Don\(cqt update remote repositories, use the local cache only.
 Do not enforce crystal version restrictions on shards.
 .RE
 .sp
-\-\-production
-.RS 4
-Runs in release mode. Development dependencies won’t
-be installed and only locked dependencies will be installed. Commands
-will fail if dependencies in \fIshard.yml\fP and \fIshard.lock\fP are out of
-sync (used by \fBinstall\fP, \fBupdate\fP, \fBcheck\fP and \fBlist\fP commands).
-.RE
-.sp
 \-q, \-\-quiet
 .RS 4
 Decreases the log verbosity, printing only warnings and errors.

spec/integration/install_spec.cr

@@ -398,143 +398,181 @@ describe "install" do
     end
   end
 
-  describe "with --production" do
-    it "fails if shard.lock and shard.yml has different sources" do
-      # The sources will not match, so the .lock is not valid regarding the specs
-      metadata = {dependencies: {awesome: {git: git_url(:forked_awesome)}}}
-      lock = {awesome: "0.1.0", d: "0.1.0"}
+  ["frozen", "production"].each do |flag|
+    describe "with --#{flag}" do
+      it "fails if shard.lock and shard.yml has different sources" do
+        # The sources will not match, so the .lock is not valid regarding the specs
+        metadata = {dependencies: {awesome: {git: git_url(:forked_awesome)}}}
+        lock = {awesome: "0.1.0", d: "0.1.0"}
+
+        with_shard(metadata, lock) do
+          assert_locked "awesome", "0.1.0", source: {git: git_url(:awesome)}
+
+          ex = expect_raises(FailedCommand) { run "shards install --#{flag} --no-color" }
+          ex.stdout.should contain("Outdated shard.lock (awesome source changed)")
+          ex.stderr.should be_empty
+        end
+      end
 
-      with_shard(metadata, lock) do
-        assert_locked "awesome", "0.1.0", source: {git: git_url(:awesome)}
+      it "fails if shard.lock is missing" do
+        metadata = {dependencies: {web: "*"}}
 
-        ex = expect_raises(FailedCommand) { run "shards install --production --no-color" }
-        ex.stdout.should contain("Outdated shard.lock (awesome source changed)")
-        ex.stderr.should be_empty
+        with_shard(metadata) do
+          ex = expect_raises(FailedCommand) { run "shards install --#{flag} --no-color" }
+          ex.stdout.should contain("Missing shard.lock")
+          ex.stderr.should be_empty
+        end
       end
-    end
 
-    it "fails if shard.lock and shard.yml has different sources with incompatible versions." do
-      # User should use update command in this scenario
-      # forked_awesome does not have a 0.3.0
-      # awesome has 0.3.0
-      metadata = {dependencies: {awesome: {git: git_url(:forked_awesome)}}}
-      lock = {awesome: "0.3.0"}
+      it "fails if shard.lock and shard.yml has different sources with incompatible versions." do
+        # User should use update command in this scenario
+        # forked_awesome does not have a 0.3.0
+        # awesome has 0.3.0
+        metadata = {dependencies: {awesome: {git: git_url(:forked_awesome)}}}
+        lock = {awesome: "0.3.0"}
 
-      with_shard(metadata, lock) do
-        assert_locked "awesome", "0.3.0", source: {git: git_url(:awesome)}
+        with_shard(metadata, lock) do
+          assert_locked "awesome", "0.3.0", source: {git: git_url(:awesome)}
 
-        ex = expect_raises(FailedCommand) { run "shards install --production --no-color" }
-        ex.stdout.should contain("Maybe a commit, branch or file doesn't exist?")
-        ex.stderr.should be_empty
+          ex = expect_raises(FailedCommand) { run "shards install --#{flag} --no-color" }
+          ex.stdout.should contain("Maybe a commit, branch or file doesn't exist?")
+          ex.stderr.should be_empty
+        end
       end
-    end
 
-    it "fails to install when dependency requirement changed" do
-      metadata = {dependencies: {web: "2.0.0"}}
-      lock = {web: "1.0.0"}
+      it "fails to install when dependency requirement changed" do
+        metadata = {dependencies: {web: "2.0.0"}}
+        lock = {web: "1.0.0"}
+
+        with_shard(metadata, lock) do
+          ex = expect_raises(FailedCommand) { run "shards install --no-color --#{flag}" }
+          ex.stdout.should contain("Outdated shard.lock")
+          ex.stderr.should be_empty
+          refute_installed "web"
+        end
+        end
+
+      it "fails to install when dependency requirement (commit) changed" do
+        metadata = {dependencies: {inprogress: {git: git_url(:inprogress), commit: git_commits(:inprogress)[1]}}}
+        lock = {inprogress: "0.1.0+git.commit.#{git_commits(:inprogress).first}"}
+
+        with_shard(metadata, lock) do
+          ex = expect_raises(FailedCommand) { run "shards install --no-color --#{flag}" }
+          ex.stdout.should contain("Outdated shard.lock")
+          refute_installed "inprogress"
+        end
+      end
 
-      with_shard(metadata, lock) do
-        ex = expect_raises(FailedCommand) { run "shards install --no-color --production" }
-        ex.stdout.should contain("Outdated shard.lock")
-        ex.stderr.should be_empty
-        refute_installed "web"
+      it "doesn't install new dependencies" do
+        metadata = {
+          dependencies: {
+            web: "~> 1.0.0",
+            orm: "*",
+          },
+        }
+        lock = {web: "1.0.0"}
+
+        with_shard(metadata, lock) do
+          ex = expect_raises(FailedCommand) { run "shards install --#{flag} --no-color" }
+          ex.stdout.should contain("Outdated shard.lock")
+          ex.stderr.should be_empty
+        end
       end
-    end
 
-    it "fails to install when dependency requirement (commit) changed" do
-      metadata = {dependencies: {inprogress: {git: git_url(:inprogress), commit: git_commits(:inprogress)[1]}}}
-      lock = {inprogress: "0.1.0+git.commit.#{git_commits(:inprogress).first}"}
+      it "install" do
+        metadata = {dependencies: {web: "*"}}
+        lock = {web: "1.0.0"}
 
-      with_shard(metadata, lock) do
-        ex = expect_raises(FailedCommand) { run "shards install --no-color --production" }
-        ex.stdout.should contain("Outdated shard.lock")
-        refute_installed "inprogress"
+        with_shard(metadata, lock) do
+          run "shards install --#{flag}"
+          assert_installed "web", "1.0.0"
+        end
       end
-    end
 
-    it "doesn't install new dependencies" do
-      metadata = {
-        dependencies: {
-          web: "~> 1.0.0",
-          orm: "*",
-        },
-      }
-      lock = {web: "1.0.0"}
+      it "install with locked commit" do
+        metadata = {dependencies: {web: "*"}}
+        web_version = "2.1.0+git.commit.#{git_commits(:web).first}"
+        lock = {web: web_version}
 
-      with_shard(metadata, lock) do
-        ex = expect_raises(FailedCommand) { run "shards install --production --no-color" }
-        ex.stdout.should contain("Outdated shard.lock")
-        ex.stderr.should be_empty
+        with_shard(metadata, lock) do
+          run "shards install --#{flag}"
+          assert_installed "web", "2.1.0", git: git_commits(:web).first
+        end
       end
-    end
 
-    it "install" do
-      metadata = {dependencies: {web: "*"}}
-      lock = {web: "1.0.0"}
+      it "install with locked commit by a previous shards version" do
+        metadata = {dependencies: {web: "*"}}
 
-      with_shard(metadata, lock) do
-        run "shards install --production"
-        assert_installed "web", "1.0.0"
+        with_shard(metadata) do
+          File.write "shard.lock", {version: "1.0", shards: {web: {git: git_url(:web), commit: git_commits(:web).first}}}
+          run "shards install --#{flag}"
+          assert_installed "web", "2.1.0", git: git_commits(:web).first
+        end
       end
-    end
 
-    it "install with locked commit" do
-      metadata = {dependencies: {web: "*"}}
-      web_version = "2.1.0+git.commit.#{git_commits(:web).first}"
-      lock = {web: web_version}
+      it "fails if lock is not up to date with override in main dependency" do
+        metadata = {dependencies: {
+          awesome: "*",
+        }}
+        lock = {awesome: "0.1.0", d: "0.1.0"}
+        override = {dependencies: {
+          awesome: {git: git_url(:forked_awesome), branch: "feature/super"},
+        }}
+        expected_commit = git_commits(:forked_awesome).first
+
+        with_shard(metadata, lock, override) do
+          ex = expect_raises(FailedCommand) { run "shards install --no-color --#{flag}" }
+          ex.stdout.should contain("Outdated shard.lock")
+          ex.stderr.should be_empty
+          refute_installed "awesome"
+        end
+      end
 
-      with_shard(metadata, lock) do
-        run "shards install --production"
-        assert_installed "web", "2.1.0", git: git_commits(:web).first
+      it "fails if lock is not up to date with override in nested dependency" do
+        metadata = {dependencies: {
+          intermediate: "*",
+        }}
+        lock = {intermediate: "0.1.0", awesome: "0.1.0", d: "0.1.0"}
+        override = {dependencies: {
+          awesome: {git: git_url(:forked_awesome), branch: "feature/super"},
+        }}
+        expected_commit = git_commits(:forked_awesome).first
+
+        with_shard(metadata, lock, override) do
+          ex = expect_raises(FailedCommand) { run "shards install --no-color --#{flag}" }
+          ex.stdout.should contain("Outdated shard.lock")
+          ex.stderr.should be_empty
+          refute_installed "awesome"
+        end
       end
     end
+  end
 
-    it "install with locked commit by a previous shards version" do
-      metadata = {dependencies: {web: "*"}}
+  describe "with --without-development" do
+    it "doesn't install development dependencies" do
+      metadata = {
+        dependencies:             {web: "*", orm: "*"},
+        development_dependencies: {mock: "*"},
+      }
 
       with_shard(metadata) do
-        File.write "shard.lock", {version: "1.0", shards: {web: {git: git_url(:web), commit: git_commits(:web).first}}}
-        run "shards install --production"
-        assert_installed "web", "2.1.0", git: git_commits(:web).first
-      end
-    end
+        File.exists?(File.join(application_path, "shard.lock")).should be_false
+        run "shards install --without-development"
 
-    it "fails if lock is not up to date with override in main dependency" do
-      metadata = {dependencies: {
-        awesome: "*",
-      }}
-      lock = {awesome: "0.1.0", d: "0.1.0"}
-      override = {dependencies: {
-        awesome: {git: git_url(:forked_awesome), branch: "feature/super"},
-      }}
-      expected_commit = git_commits(:forked_awesome).first
-
-      with_shard(metadata, lock, override) do
-        ex = expect_raises(FailedCommand) { run "shards install --no-color --production" }
-        ex.stdout.should contain("Outdated shard.lock")
-        ex.stderr.should be_empty
-        refute_installed "awesome"
-      end
-    end
+        # it installed dependencies (recursively)
+        assert_installed "web"
+        assert_installed "orm"
 
-    it "fails if lock is not up to date with override in nested dependency" do
-      metadata = {dependencies: {
-        intermediate: "*",
-      }}
-      lock = {intermediate: "0.1.0", awesome: "0.1.0", d: "0.1.0"}
-      override = {dependencies: {
-        awesome: {git: git_url(:forked_awesome), branch: "feature/super"},
-      }}
-      expected_commit = git_commits(:forked_awesome).first
+        # it didn't install development dependencies
+        refute_installed "mock"
+        refute_installed "minitest"
 
-      with_shard(metadata, lock, override) do
-        ex = expect_raises(FailedCommand) { run "shards install --no-color --production" }
-        ex.stdout.should contain("Outdated shard.lock")
-        ex.stderr.should be_empty
-        refute_installed "awesome"
+        File.exists?(File.join(application_path, "shard.lock")).should be_true
       end
     end
+  end
 
+  describe "with --production" do
     it "doesn't install development dependencies" do
       metadata = {
         dependencies:             {web: "*", orm: "*"},