Rework of dependency and requirements

spec/integration/init_spec.cr

@@ -11,7 +11,7 @@ describe "init" do
       File.exists?(File.join(application_path, Shards::SPEC_FILENAME)).should be_true
       spec = Shards::Spec.from_file(shard_path)
       spec.name.should eq("integration")
-      spec.version.should eq("0.1.0")
+      spec.version.should eq(version "0.1.0")
     end
   end
 

spec/integration/spec_helper.cr

@@ -7,6 +7,7 @@ require "../../src/lock"
 require "../../src/spec"
 require "../support/factories"
 require "../support/cli"
+require "../support/requirement"
 
 Spec.before_suite do
   run "rm -rf #{tmp_path}/*"
@@ -144,7 +145,7 @@ def assert_locked(name, version = nil, file = __FILE__, line = __LINE__, *, git
 
   if lock && version
     expected_version = git ? "#{version}+git.commit.#{git}" : version
-    assert expected_version == lock.version, "expected #{name} dependency to have been locked at version #{version}", file, line
+    assert expected_version == lock.requirement.as(Shards::Version).value, "expected #{name} dependency to have been locked at version #{version}", file, line
   end
 end
 

spec/support/cli.cr

@@ -34,7 +34,7 @@ def to_shard_yaml(metadata)
             case version
             when String
               yml << "    git: " << git_url(name).inspect << '\n'
-              yml << "    version: " << version.inspect << '\n'
+              yml << "    version: " << version.inspect << '\n' unless version == "*"
               # when Hash
               #  version.each do |k, v|
               #    yml << "    " << k << ": " << v.inspect << '\n'

spec/support/requirement.cr

@@ -0,0 +1,19 @@
+def branch(name)
+  Shards::GitBranchRef.new(name)
+end
+
+def commit(sha1)
+  Shards::GitCommitRef.new(sha1)
+end
+
+def version(version)
+  Shards::Version.new(version)
+end
+
+def versions(versions)
+  versions.map { |v| version(v) }
+end
+
+def version_req(pattern)
+  Shards::VersionReq.new(pattern)
+end

spec/unit/dependency_spec.cr

@@ -2,34 +2,85 @@ require "./spec_helper"
 
 module Shards
   describe Dependency do
-    it "version" do
-      dependency = Dependency.new("app")
-      dependency.version?.should be_nil
-
-      dependency = Dependency.new("app")
-      dependency.version = "<= 1.0.0"
-      dependency.version?.should eq("<= 1.0.0")
-      dependency.version.should eq("<= 1.0.0")
-
-      dependency = Dependency.new("app")
-      dependency.version = "<= 2.0.0"
-      dependency.version?.should eq("<= 2.0.0")
-      dependency.version.should eq("<= 2.0.0")
-    end
-
-    it "version with tags" do
-      dependency = Dependency.new("app")
-      dependency.tag = "fix/something"
-      dependency.version.should eq("*")
-
-      dependency = Dependency.new("app")
-      dependency.tag = "1.2.3"
-      dependency.version.should eq("*")
-
-      # version tag is considered a version:
-      dependency = Dependency.new("app")
-      dependency.tag = "v1.2.3-pre1"
-      dependency.version.should eq("1.2.3-pre1")
+    it "parse for path" do
+      parse_dependency({foo: {path: "/foo"}}) do |dep|
+        dep.name.should eq("foo")
+        dep.resolver.is_a?(PathResolver).should be_true
+        dep.resolver.source.should eq("/foo")
+        dep.requirement.should eq(Any)
+      end
+    end
+
+    it "parse for git" do
+      parse_dependency({foo: {git: "/foo"}}) do |dep|
+        dep.name.should eq("foo")
+        dep.resolver.is_a?(GitResolver).should be_true
+        dep.resolver.source.should eq("/foo")
+        dep.requirement.should eq(Any)
+      end
+    end
+
+    it "parse for git with version requirement" do
+      parse_dependency({foo: {git: "/foo", version: "~> 1.2"}}) do |dep|
+        dep.name.should eq("foo")
+        dep.resolver.is_a?(GitResolver).should be_true
+        dep.resolver.source.should eq("/foo")
+        dep.requirement.should eq(VersionReq.new("~> 1.2"))
+      end
+    end
+
+    it "parse for git with branch requirement" do
+      parse_dependency({foo: {git: "/foo", branch: "test"}}) do |dep|
+        dep.name.should eq("foo")
+        dep.resolver.is_a?(GitResolver).should be_true
+        dep.resolver.source.should eq("/foo")
+        dep.requirement.should eq(GitBranchRef.new("test"))
+      end
+    end
+
+    it "parse for git with tag requirement" do
+      parse_dependency({foo: {git: "/foo", tag: "test"}}) do |dep|
+        dep.name.should eq("foo")
+        dep.resolver.is_a?(GitResolver).should be_true
+        dep.resolver.source.should eq("/foo")
+        dep.requirement.should eq(GitTagRef.new("test"))
+      end
+    end
+
+    it "parse for git with commit requirement" do
+      parse_dependency({foo: {git: "/foo", commit: "7e2e840"}}) do |dep|
+        dep.name.should eq("foo")
+        dep.resolver.is_a?(GitResolver).should be_true
+        dep.resolver.source.should eq("/foo")
+        dep.requirement.should eq(GitCommitRef.new("7e2e840"))
+      end
+    end
+
+    it "parse for github" do
+      parse_dependency({foo: {github: "foo/bar"}}) do |dep|
+        dep.name.should eq("foo")
+        dep.resolver.is_a?(GitResolver).should be_true
+        dep.resolver.source.should eq("https://github.com/foo/bar.git")
+      end
+    end
+
+    it "allow extra arguments" do
+      parse_dependency({foo: {path: "/foo", branch: "master"}}) do |dep|
+        dep.name.should eq("foo")
+        dep.resolver.is_a?(PathResolver).should be_true
+        dep.requirement.should eq(Any)
+      end
+    end
+  end
+end
+
+private def parse_dependency(dep)
+  pull = YAML::PullParser.new(dep.to_yaml)
+  pull.read_stream do
+    pull.read_document do
+      pull.read_mapping do
+        yield Shards::Dependency.from_yaml(pull)
+      end
     end
   end
 end

spec/unit/git_resolver_spec.cr

@@ -1,11 +1,16 @@
 require "./spec_helper"
 
 private def resolver(name)
-  dependency = Shards::Dependency.new(name, git: git_url(name))
-  Shards::GitResolver.new(dependency)
+  Shards::GitResolver.new(name, git_url(name))
 end
 
 module Shards
+  # Allow overriding `source` for the specs
+  class GitResolver
+    def source=(@source)
+    end
+  end
+
   describe GitResolver do
     before_each do
       create_git_repository "empty"
@@ -26,59 +31,64 @@ module Shards
 
     it "available releases" do
       resolver("empty").available_releases.should be_empty
-      resolver("library").available_releases.should eq(["0.0.1", "0.1.0", "0.1.1", "0.1.2", "0.2.0"])
+      resolver("library").available_releases.should eq(versions ["0.0.1", "0.1.0", "0.1.1", "0.1.2", "0.2.0"])
     end
 
     it "latest version for ref" do
-      resolver("empty").latest_version_for_ref("master").should be_nil
+      resolver("empty").latest_version_for_ref(branch "master").should be_nil
       resolver("empty").latest_version_for_ref(nil).should be_nil
-      resolver("unreleased").latest_version_for_ref("master").should eq("0.1.0+git.commit.#{git_commits(:unreleased)[0]}")
-      resolver("unreleased").latest_version_for_ref("branch").should eq("0.1.0+git.commit.#{git_commits(:unreleased, "branch")[0]}")
-      resolver("unreleased").latest_version_for_ref(nil).should eq("0.1.0+git.commit.#{git_commits(:unreleased)[0]}")
-      resolver("library").latest_version_for_ref("master").should eq("0.2.0+git.commit.#{git_commits(:library)[0]}")
-      resolver("library").latest_version_for_ref(nil).should eq("0.2.0+git.commit.#{git_commits(:library)[0]}")
-      resolver("library").latest_version_for_ref("foo").should be_nil
+      resolver("unreleased").latest_version_for_ref(branch "master").should eq(version "0.1.0+git.commit.#{git_commits(:unreleased)[0]}")
+      resolver("unreleased").latest_version_for_ref(branch "branch").should eq(version "0.1.0+git.commit.#{git_commits(:unreleased, "branch")[0]}")
+      resolver("unreleased").latest_version_for_ref(nil).should eq(version "0.1.0+git.commit.#{git_commits(:unreleased)[0]}")
+      resolver("library").latest_version_for_ref(branch "master").should eq(version "0.2.0+git.commit.#{git_commits(:library)[0]}")
+      resolver("library").latest_version_for_ref(nil).should eq(version "0.2.0+git.commit.#{git_commits(:library)[0]}")
+      resolver("library").latest_version_for_ref(branch "foo").should be_nil
     end
 
     it "versions for" do
-      resolver("empty").versions_for(Dependency.new("empty")).should be_empty
-      resolver("library").versions_for(Dependency.new("library")).should eq(["0.0.1", "0.1.0", "0.1.1", "0.1.2", "0.2.0"])
-      resolver("library").versions_for(Dependency.new("library", version: "~> 0.1.0")).should eq(["0.1.0", "0.1.1", "0.1.2"])
-      resolver("library").versions_for(Dependency.new("library", branch: "master")).should eq(["0.2.0+git.commit.#{git_commits(:library)[0]}"])
-      resolver("unreleased").versions_for(Dependency.new("unreleased", branch: "master")).should eq(["0.1.0+git.commit.#{git_commits(:unreleased)[0]}"])
-      resolver("unreleased").versions_for(Dependency.new("unreleased")).should eq(["0.1.0+git.commit.#{git_commits(:unreleased)[0]}"])
+      resolver("empty").versions_for(Any).should be_empty
+      resolver("library").versions_for(Any).should eq(versions ["0.0.1", "0.1.0", "0.1.1", "0.1.2", "0.2.0"])
+      resolver("library").versions_for(VersionReq.new "~> 0.1.0").should eq(versions ["0.1.0", "0.1.1", "0.1.2"])
+      resolver("library").versions_for(branch "master").should eq(versions ["0.2.0+git.commit.#{git_commits(:library)[0]}"])
+      resolver("unreleased").versions_for(branch "master").should eq(versions ["0.1.0+git.commit.#{git_commits(:unreleased)[0]}"])
+      resolver("unreleased").versions_for(Any).should eq(versions ["0.1.0+git.commit.#{git_commits(:unreleased)[0]}"])
     end
 
     it "read spec for release" do
-      spec = resolver("library").spec("0.1.1")
-      spec.original_version.should eq("0.1.1")
-      spec.version.should eq("0.1.1")
+      spec = resolver("library").spec(version "0.1.1")
+      spec.original_version.should eq(version "0.1.1")
+      spec.version.should eq(version "0.1.1")
     end
 
     it "read spec for commit" do
-      version = "0.2.0+git.commit.#{git_commits(:library)[0]}"
+      version = version("0.2.0+git.commit.#{git_commits(:library)[0]}")
       spec = resolver("library").spec(version)
-      spec.original_version.should eq("0.2.0")
+      spec.original_version.should eq(version "0.2.0")
       spec.version.should eq(version)
     end
 
     it "install" do
       library = resolver("library")
 
-      library.install("0.1.2")
+      library.install(version "0.1.2")
       File.exists?(install_path("library", "src/library.cr")).should be_true
       File.exists?(install_path("library", "shard.yml")).should be_true
-      library.installed_spec.not_nil!.version.should eq("0.1.2")
-      # File.exists?(install_path("library", "LICENSE")).should be_true
+      library.installed_spec.not_nil!.version.should eq(version "0.1.2")
 
-      library.install("0.2.0")
-      library.installed_spec.not_nil!.version.should eq("0.2.0")
+      library.install(version "0.2.0")
+      library.installed_spec.not_nil!.version.should eq(version "0.2.0")
+    end
+
+    it "install commit" do
+      library = resolver("library")
+      version = version "0.2.0+git.commit.#{git_commits(:library)[0]}"
+      library.install(version)
+      library.installed_spec.not_nil!.version.should eq(version)
     end
 
     it "origin changed" do
-      dependency = Dependency.new("library", git: git_url("library"))
-      library = GitResolver.new(dependency)
-      library.install("0.1.2")
+      library = GitResolver.new("library", git_url("library"))
+      library.install(version "0.1.2")
 
       # Change the origin in the cache repo to https://github.com/foo/bar
       Dir.cd(library.local_path) do
@@ -99,7 +109,7 @@ module Shards
       ]
 
       same_origins.each do |origin|
-        dependency.git = origin
+        library.source = origin
         library.origin_changed?.should be_false
       end
 
@@ -115,15 +125,14 @@ module Shards
       ]
 
       changed_origins.each do |origin|
-        dependency.git = origin
+        library.source = origin
         library.origin_changed?.should be_true
       end
     end
 
-    pending "install refs" do
-      # TODO: install commit (whatever the version)
-      # TODO: install branch (whatever the version)
-      # TODO: install tag (whatever the version)
+    it "renders report version" do
+      resolver("library").report_version(version "1.2.3").should eq("1.2.3")
+      resolver("library").report_version(version "1.2.3+git.commit.654875c9dbfa8d72fba70d65fd548d51ffb85aff").should eq("1.2.3 at 654875c")
     end
   end
 end

spec/unit/lock_spec.cr

@@ -18,14 +18,12 @@ module Shards
       shards.size.should eq(2)
 
       shards[0].name.should eq("repo")
-      shards[0].path.should be_nil
-      shards[0].git.should eq("https://github.com/user/repo.git")
-      shards[0].version.should eq("1.2.3")
+      shards[0].resolver.should eq(GitResolver.new("repo", "https://github.com/user/repo.git"))
+      shards[0].requirement.should eq(version "1.2.3")
 
       shards[1].name.should eq("example")
-      shards[1].path.should be_nil
-      shards[1].git.should eq("https://example.com/example-crystal.git")
-      shards[1].refs.should eq("0d246ee6c52d4e758651b8669a303f04be9a2a96")
+      shards[1].resolver.should eq(GitResolver.new("example", "https://example.com/example-crystal.git"))
+      shards[1].requirement.should eq(commit "0d246ee6c52d4e758651b8669a303f04be9a2a96")
     end
 
     it "raises on unknown version" do