rosette-core 1.0.1

data/spec/core/extractor/translation/translation_to_hash_spec.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe TranslationToHash do
+  describe '#to_h' do
+    let(:phrase) do
+      TestPhrase.new('key', 'meta key', 'file', 'commit id')
+    end
+
+    it 'returns a hash of the appropriate attributes' do
+      TestTranslation.new(translation: 'translation', locale: 'es', phrase: phrase) do |t|
+        expect(t.to_h).to eq({
+          translation: 'translation', locale: 'es',
+          phrase: {
+            key: 'key', meta_key: 'meta key',
+            file: 'file', commit_id: 'commit id'
+          }
+        })
+      end
+    end
+  end
+end

data/spec/core/git/diff_finder_spec.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+java_import 'org.eclipse.jgit.revwalk.RevWalk'
+java_import 'org.eclipse.jgit.lib.ObjectId'
+
+describe DiffFinder do
+  let(:repo_name) { 'double_commit' }
+  let(:fixture) { load_repo_fixture(repo_name) }
+  let(:repo) { Repo.from_path(fixture.repo_fixture.working_dir.join('.git').to_s) }
+  let(:rev_walk) { RevWalk.new(repo.jgit_repo) }
+  let(:diff_finder) { DiffFinder.new(repo.jgit_repo, rev_walk) }
+
+  let(:revs) do
+    fixture.each_commit.map do |fixture_commit|
+      rev_walk.parseCommit(ObjectId.fromString(fixture_commit.sha))
+    end
+  end
+
+  let(:first_file_contents) do
+    "I'm a little teapot\n" +
+    "The green albatross flitters in the moonlight\n"
+  end
+
+  let(:second_file_contents) do
+    "Chatanooga Choo Choo\n" +
+    "Diamonds are a girl's best friend.\n" +
+    "Cash for the merchandise; cash for the fancy goods.\n" +
+    "I'm in Spañish.\n"
+  end
+
+  describe '#diff' do
+    it 'returns the diff between the first two commits' do
+      commit_id = revs.first.getName
+
+      diff_finder.diff(revs.first, revs.last).tap do |diff|
+        expect(diff.size).to eq(1)
+        expect(diff[commit_id].first.getNewPath).to eq('second_file.txt')
+        expect(diff_finder.read_new_entry(diff[commit_id].first)).to(
+          eq(second_file_contents)
+        )
+      end
+    end
+  end
+
+  describe '#diff_with_parent' do
+    it 'returns the diff between the first two commits (just as a regular diff would do)' do
+      commit_id = revs.first.getName
+
+      diff_finder.diff_with_parents(revs.last).tap do |diff|
+        expect(diff.size).to eq(1)
+        expect(diff[revs.first.getName].first.getNewPath).to eq('second_file.txt')
+        expect(diff_finder.read_new_entry(diff[revs.first.getName].first)).to(
+          eq(second_file_contents)
+        )
+      end
+    end
+
+    it "returns the diff successfully if the rev doesn't have a parent" do
+      commit_id = revs.first.getName
+
+      diff_finder.diff_with_parents(revs.first).tap do |diff|
+        expect(diff.size).to eq(1)
+        expect(diff[commit_id].first.getNewPath).to eq('first_file.txt')
+        expect(diff_finder.read_new_entry(diff[commit_id].first)).to(
+          eq(first_file_contents)
+        )
+      end
+    end
+  end
+end

data/spec/core/git/ref_spec.rb

@@ -0,0 +1,118 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe Ref do
+  describe '.parse' do
+    it 'parses remotes' do
+      ref = Ref.parse('refs/remotes/origin/foobar')
+      expect(ref).to be_a(Remote)
+    end
+
+    it 'parses heads' do
+      ref = Ref.parse('refs/heads/foobar')
+      expect(ref).to be_a(Head)
+    end
+
+    it 'parses tags' do
+      ref = Ref.parse('refs/tags/foobar')
+      expect(ref).to be_a(Tag)
+    end
+  end
+end
+
+describe Remote do
+  describe '.create_from' do
+    it 'creates a new remote ref' do
+      remote = Remote.create_from(%w(remotes origin foobar))
+      expect(remote.remote).to eq('origin')
+      expect(remote.name).to eq('foobar')
+    end
+  end
+
+  context 'with a remote' do
+    let(:remote) { Remote.new('origin', 'foobar') }
+
+    describe '#type' do
+      it 'returns the correct type' do
+        expect(remote.type).to eq(:remote)
+      end
+    end
+
+    describe '#to_s' do
+      it 'constructs a string representation' do
+        expect(remote.to_s).to eq('refs/remotes/origin/foobar')
+      end
+    end
+
+    it 'responds correctly to query methods' do
+      expect(remote).to be_remote
+      expect(remote).to_not be_head
+      expect(remote).to_not be_tag
+    end
+  end
+end
+
+describe Head do
+  describe '.create_from' do
+    it 'creates a new head' do
+      head = Head.create_from(%w(heads foobar))
+      expect(head.name).to eq('foobar')
+    end
+  end
+
+  context 'with a head' do
+    let(:head) { Head.new('foobar') }
+
+    describe '#type' do
+      it 'returns the correct type' do
+        expect(head.type).to eq(:head)
+      end
+    end
+
+    describe '#to_s' do
+      it 'constructs a string representation' do
+        expect(head.to_s).to eq('refs/heads/foobar')
+      end
+    end
+
+    it 'responds correctly to query methods' do
+      expect(head).to be_head
+      expect(head).to_not be_remote
+      expect(head).to_not be_tag
+    end
+  end
+end
+
+describe Tag do
+  describe '.create_from' do
+    it 'creates a new tag' do
+      tag = Tag.create_from(%w(tags foobar))
+      expect(tag.name).to eq('foobar')
+    end
+  end
+
+  context 'with a tag' do
+    let(:tag) { Tag.new('foobar') }
+
+    describe '#type' do
+      it 'returns the correct type' do
+        expect(tag.type).to eq(:tag)
+      end
+    end
+
+    describe '#to_s' do
+      it 'constructs a string representation' do
+        expect(tag.to_s).to eq('refs/tags/foobar')
+      end
+    end
+
+    it 'responds correctly to query methods' do
+      expect(tag).to be_tag
+      expect(tag).to_not be_head
+      expect(tag).to_not be_remote
+    end
+  end
+end

data/spec/core/git/repo_spec.rb

@@ -0,0 +1,216 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+java_import 'org.eclipse.jgit.lib.ObjectId'
+
+describe Repo do
+  let(:repo_class) { Repo }
+
+  describe 'self.from_path' do
+    it 'returns a new repo at the given path' do
+      tmp_repo = TmpRepo.new
+      repo = repo_class.from_path(tmp_repo.working_dir.join('.git').to_s)
+      expect(repo.path).to eq(tmp_repo.working_dir.to_s)
+      tmp_repo.unlink
+    end
+  end
+
+  context 'with the double commit fixture' do
+    let(:repo_name) { 'double_commit' }
+    let(:fixture) { load_repo_fixture(repo_name) }
+    let(:repo) { repo_class.from_path(fixture.working_dir.join('.git').to_s) }
+    let(:commits) do
+      fixture.git('rev-list --all').split("\n").map do |sha|
+        repo.get_rev_commit(sha)
+      end.reverse
+    end
+
+    describe '#get_rev_commit' do
+      it 'returns a rev commit for a symbolic ref' do
+        commit = repo.get_rev_commit('HEAD')
+        expect(commit.getName).to eq(commits.last.getName)
+      end
+
+      it 'returns a rev commit for a sha' do
+        commit = repo.get_rev_commit(commits.last.getName)
+        expect(commit.getName).to eq(commits.last.getName)
+      end
+
+      it "falls back to remotes if the branch hasn't been checked out locally" do
+        branch_name = 'my_remote_branch'
+
+        remote_repo = TmpRepo.new.tap do |r|
+          r.create_branch(branch_name)
+          r.create_file('foo.txt') { |f| f.write('foo') }
+          r.add_all
+          r.commit('Initial commit')
+        end
+
+        fixture.repo.git("remote add origin file://#{remote_repo.working_dir}")
+        fixture.repo.git('fetch')
+
+        remote_commit_id = remote_repo.git('rev-parse HEAD').strip
+        commit = repo.get_rev_commit(branch_name)
+        expect(commit.getName).to eq(remote_commit_id)
+      end
+    end
+
+    describe '#diff' do
+      it 'returns the diff when a symbolic ref is involved' do
+        commit_id = commits.first.getName
+        repo.diff(commit_id, 'HEAD').tap do |diff|
+          expect(diff.size).to eq(1)
+          expect(diff[commit_id].first.getNewPath).to eq('second_file.txt')
+        end
+      end
+
+      it 'returns the diff between two shas' do
+        first_commit_id = commits.first.getName
+        second_commit_id = commits.last.getName
+        repo.diff(first_commit_id, second_commit_id).tap do |diff|
+          expect(diff.size).to eq(1)
+          expect(diff[first_commit_id].first.getNewPath).to eq('second_file.txt')
+        end
+      end
+    end
+
+    describe '#ref_diff_with_parents' do
+      it 'returns the correct diff' do
+        commit_id = commits.first.getName
+        repo.ref_diff_with_parents('HEAD').tap do |diff|
+          expect(diff.size).to eq(1)
+          expect(diff[commit_id].first.getNewPath).to eq('second_file.txt')
+        end
+      end
+    end
+
+    describe '#rev_diff_with_parents' do
+      it 'returns the correct diff' do
+        commit_id = commits.first.getName
+        repo.rev_diff_with_parents(repo.get_rev_commit('HEAD')).tap do |diff|
+          expect(diff.size).to eq(1)
+          expect(diff[commit_id].first.getNewPath).to eq('second_file.txt')
+        end
+      end
+    end
+
+    describe '#path' do
+      it 'returns the current working directory' do
+        expect(repo.path).to eq(fixture.working_dir.to_s)
+      end
+    end
+
+    describe '#read_object_bytes' do
+      it 'returns a byte array containing the object of the given id' do
+        object_id = ObjectId.fromString(fixture.git('hash-object first_file.txt').strip)
+        actual_bytes = repo.read_object_bytes(object_id)
+        expected_bytes = "I'm a little teapot\nThe green albatross flitters in the moonlight\n".bytes
+
+        expected_bytes.each_with_index do |expected_byte, index|
+          expect(actual_bytes[index]).to eq(expected_byte)
+        end
+      end
+    end
+
+    describe '#each_commit' do
+      it 'yields each commit or returns an enumerator' do
+        repo.each_commit.tap do |commit_enum|
+          expect(commit_enum).to be_a(Enumerator)
+          expect(commit_enum.map(&:getName)).to eq(commits.map(&:getName))
+        end
+      end
+    end
+
+    describe '#commit_count' do
+      it 'returns the total number of commits in the repo' do
+        expect(repo.commit_count).to eq(2)
+      end
+    end
+  end
+
+  context 'with the four commits fixture' do
+    let(:repo_name) { 'four_commits' }
+    let(:fixture) { load_repo_fixture(repo_name) }
+    let(:repo) { repo_class.from_path(fixture.working_dir.join('.git').to_s) }
+    let(:commits) do
+      fixture.git('rev-list --all').split("\n").map do |sha|
+        repo.get_rev_commit(sha)
+      end.reverse
+    end
+
+    describe '#each_commit_in_range' do
+      it 'yields only the commits in the given range' do
+        commit_args = [commits[2].getId.name, commits[0].getId.name]
+
+        found_commits = repo.each_commit_in_range(*commit_args).map do |c|
+          c.getId.name
+        end
+
+        expect(found_commits).to(
+          eq(commits[0..2].map { |c| c.getId.name }.reverse)
+        )
+      end
+    end
+  end
+
+  context 'with a merge commit fixture' do
+    let(:repo_name) { 'merge_commit' }
+    let(:fixture) { load_repo_fixture(repo_name) }
+    let(:repo) { repo_class.from_path(fixture.working_dir.join('.git').to_s) }
+    let(:commits) do
+      fixture.git('rev-list --all').split("\n").map do |sha|
+        repo.get_rev_commit(sha)
+      end
+    end
+
+    describe '#parents_of' do
+      it 'returns a single commit for a commit with a single parent' do
+        repo.parents_of(commits[1]).tap do |parents|
+          expect(parents.size).to eq(1)
+          expect(parents.first.getName).to eq(commits.last.getName)
+        end
+      end
+
+      it 'returns multiple parents when given a merge commit' do
+        repo.parents_of(commits.first).tap do |parents|
+          expect(parents.size).to eq(2)
+          parent_shas = parents.map(&:getName)
+          expect(parent_shas).to include(commits.last.getName)
+          expect(parent_shas).to include(commits[1].getName)
+        end
+      end
+    end
+
+    describe '#parent_ids_of' do
+      it 'returns a single sha for a commit with a single parent' do
+        repo.parent_ids_of(commits[1]).tap do |parent_ids|
+          expect(parent_ids).to eq([commits.last.getName])
+        end
+      end
+
+      it 'returns multiple parent shas when given a merge commit' do
+        repo.parent_ids_of(commits.first).tap do |parent_ids|
+          expect(parent_ids).to eq(commits[1..-1].reverse.map(&:getName))
+        end
+      end
+    end
+
+    describe '#commit_count' do
+      it 'returns the total number of commits in the repo' do
+        expect(repo.commit_count).to eq(3)
+      end
+    end
+
+    describe '#refs_containing' do
+      it 'returns the refs that contain the given commit' do
+        refs = repo.refs_containing(commits.last.getId.name)
+        expect(refs.map(&:getName)).to eq([
+          "HEAD", "refs/heads/master", "refs/heads/mybranch"
+        ])
+      end
+    end
+  end
+end

data/spec/core/path_matcher_factory_spec.rb

@@ -0,0 +1,139 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+include Rosette::Core
+
+describe PathMatcherFactory do
+  let(:factory) { PathMatcherFactory }
+
+  describe '#create_root' do
+    it 'returns an empty, generic node' do
+      # instance_of returns false for subclasses of Node
+      expect(factory.create_root).to be_instance_of(factory::Node)
+    end
+  end
+
+  let(:root) { factory.create_root }
+
+  describe 'operators' do
+    it 'supports the and binary operator' do
+      node = root.match_path('foo/bar').and(root.match_path('foo/baz'))
+      expect(node).to be_a(factory::BinaryNode)
+      expect(node).to be_a(factory::AndNode)
+
+      node.left.tap do |left|
+        expect(left).to be_a(factory::PathNode)
+        expect(left.path).to eq('foo/bar')
+      end
+
+      node.right.tap do |right|
+        expect(right).to be_a(factory::PathNode)
+        expect(right.path).to eq('foo/baz')
+      end
+    end
+
+    it 'supports the or binary operator' do
+      node = root.match_path('foo/bar').or(root.match_path('foo/baz'))
+      expect(node).to be_a(factory::BinaryNode)
+      expect(node).to be_a(factory::OrNode)
+
+      node.left.tap do |left|
+        expect(left).to be_a(factory::PathNode)
+        expect(left.path).to eq('foo/bar')
+      end
+
+      node.right.tap do |right|
+        expect(right).to be_a(factory::PathNode)
+        expect(right.path).to eq('foo/baz')
+      end
+    end
+
+    it 'supports the unary not operator' do
+      node = root.match_path('foo/bar').not
+      expect(node).to be_a(factory::UnaryNode)
+      expect(node).to be_a(factory::NotNode)
+
+      node.child.tap do |child|
+        expect(child).to be_a(factory::PathNode)
+        expect(child.path).to eq('foo/bar')
+      end
+    end
+  end
+end
+
+context 'nodes' do
+  let(:factory) { PathMatcherFactory }
+  let(:root) { factory.create_root }
+
+  describe PathMatcherFactory::AndNode do
+    describe '#matches?' do
+      it 'returns true if both paths match, false otherwise' do
+        node = root.match_path('foo/bar').and(root.match_path('foo/bar/baz'))
+        expect(node).to be_a(factory::AndNode)
+        expect(node.matches?('foo/bar/baz/goo')).to be_truthy
+        expect(node.matches?('foo/bar')).to be_falsy
+      end
+    end
+  end
+
+  describe PathMatcherFactory::OrNode do
+    describe '#matches?' do
+      it 'returns true if either path matches, false otherwise' do
+        node = root.match_path('foo').or(root.match_path('goo'))
+        expect(node).to be_a(factory::OrNode)
+        expect(node.matches?('foo')).to be_truthy
+        expect(node.matches?('foo/bar')).to be_truthy
+        expect(node.matches?('goo')).to be_truthy
+        expect(node.matches?('goo/boo')).to be_truthy
+        expect(node.matches?('ya/ya')).to be_falsy
+      end
+    end
+  end
+
+  describe PathMatcherFactory::NotNode do
+    describe '#matches?' do
+      it "returns true if the path doesn't match, false otherwise" do
+        node = root.match_path('foo').not
+        expect(node).to be_a(factory::NotNode)
+        expect(node.matches?('bar')).to be_truthy
+        expect(node.matches?('foo')).to be_falsy
+        expect(node.matches?('foo/bar')).to be_falsy
+      end
+    end
+  end
+
+  describe PathMatcherFactory::FileExtensionNode do
+    describe '#matches?' do
+      it 'returns true if the file extension matches, false otherwise' do
+        node = root.match_file_extension('.rb')
+        expect(node).to be_a(factory::FileExtensionNode)
+        expect(node.matches?('file.rb')).to be_truthy
+        expect(node.matches?('file.txt')).to be_falsy
+      end
+    end
+  end
+
+  describe PathMatcherFactory::PathNode do
+    describe '#matches?' do
+      it 'returns true if the path matches, false otherwise' do
+        node = root.match_path('foo/bar')
+        expect(node).to be_a(factory::PathNode)
+        expect(node.matches?('foo/bar')).to be_truthy
+        expect(node.matches?('foo/bar/baz')).to be_truthy
+        expect(node.matches?('foo')).to be_falsy
+      end
+    end
+  end
+
+  describe PathMatcherFactory::RegexNode do
+    describe '#matches?' do
+      it 'returns true if the path matches a regex, false otherwise' do
+        node = root.match_regex(/[a-z]{2}\.rb/)
+        expect(node).to be_a(factory::RegexNode)
+        expect(node.matches?('fi.rb')).to be_truthy
+        expect(node.matches?('fi.txt')).to be_falsy
+      end
+    end
+  end
+end