Import-Package: com.googlecode.javaewah;version="[0.7.9,0.8.0)",
org.eclipse.jgit.api;version="[3.7.0,3.8.0)",
org.eclipse.jgit.api.errors;version="[3.7.0,3.8.0)",
+ org.eclipse.jgit.attributes;version="[3.7.0,3.8.0)",
org.eclipse.jgit.awtui;version="[3.7.0,3.8.0)",
org.eclipse.jgit.blame;version="[3.7.0,3.8.0)",
org.eclipse.jgit.console;version="[3.7.0,3.8.0)",
--- /dev/null
+/*
+ * Copyright (C) 2014, Obeo.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.eclipse.jgit.attributes;
+
+import static org.eclipse.jgit.attributes.Attribute.State.SET;
+import static org.eclipse.jgit.attributes.Attribute.State.UNSET;
+import static org.junit.Assert.assertEquals;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.After;
+import org.junit.Test;
+
+/**
+ * Test {@link AttributesNode}
+ */
+public class AttributeNodeTest {
+
+ private static final Attribute A_SET_ATTR = new Attribute("A", SET);
+
+ private static final Attribute A_UNSET_ATTR = new Attribute("A", UNSET);
+
+ private static final Attribute B_SET_ATTR = new Attribute("B", SET);
+
+ private static final Attribute B_UNSET_ATTR = new Attribute("B", UNSET);
+
+ private static final Attribute C_VALUE_ATTR = new Attribute("C", "value");
+
+ private static final Attribute C_VALUE2_ATTR = new Attribute("C", "value2");
+
+ private InputStream is;
+
+ @After
+ public void after() throws IOException {
+ if (is != null)
+ is.close();
+ }
+
+ @Test
+ public void testBasic() throws IOException {
+ String attributeFileContent = "*.type1 A -B C=value\n"
+ + "*.type2 -A B C=value2";
+
+ is = new ByteArrayInputStream(attributeFileContent.getBytes());
+ AttributesNode node = new AttributesNode();
+ node.parse(is);
+ assertAttribute("file.type1", node,
+ asSet(A_SET_ATTR, B_UNSET_ATTR, C_VALUE_ATTR));
+ assertAttribute("file.type2", node,
+ asSet(A_UNSET_ATTR, B_SET_ATTR, C_VALUE2_ATTR));
+ }
+
+ @Test
+ public void testNegativePattern() throws IOException {
+ String attributeFileContent = "!*.type1 A -B C=value\n"
+ + "!*.type2 -A B C=value2";
+
+ is = new ByteArrayInputStream(attributeFileContent.getBytes());
+ AttributesNode node = new AttributesNode();
+ node.parse(is);
+ assertAttribute("file.type1", node, Collections.<Attribute> emptySet());
+ assertAttribute("file.type2", node, Collections.<Attribute> emptySet());
+ }
+
+ @Test
+ public void testEmptyNegativeAttributeKey() throws IOException {
+ String attributeFileContent = "*.type1 - \n" //
+ + "*.type2 - -A";
+ is = new ByteArrayInputStream(attributeFileContent.getBytes());
+ AttributesNode node = new AttributesNode();
+ node.parse(is);
+ assertAttribute("file.type1", node, Collections.<Attribute> emptySet());
+ assertAttribute("file.type2", node, asSet(A_UNSET_ATTR));
+ }
+
+ @Test
+ public void testEmptyValueKey() throws IOException {
+ String attributeFileContent = "*.type1 = \n" //
+ + "*.type2 =value\n"//
+ + "*.type3 attr=\n";
+ is = new ByteArrayInputStream(attributeFileContent.getBytes());
+ AttributesNode node = new AttributesNode();
+ node.parse(is);
+ assertAttribute("file.type1", node, Collections.<Attribute> emptySet());
+ assertAttribute("file.type2", node, Collections.<Attribute> emptySet());
+ assertAttribute("file.type3", node, asSet(new Attribute("attr", "")));
+ }
+
+ @Test
+ public void testEmptyLine() throws IOException {
+ String attributeFileContent = "*.type1 A -B C=value\n" //
+ + "\n" //
+ + " \n" //
+ + "*.type2 -A B C=value2";
+
+ is = new ByteArrayInputStream(attributeFileContent.getBytes());
+ AttributesNode node = new AttributesNode();
+ node.parse(is);
+ assertAttribute("file.type1", node,
+ asSet(A_SET_ATTR, B_UNSET_ATTR, C_VALUE_ATTR));
+ assertAttribute("file.type2", node,
+ asSet(A_UNSET_ATTR, B_SET_ATTR, C_VALUE2_ATTR));
+ }
+
+ @Test
+ public void testTabSeparator() throws IOException {
+ String attributeFileContent = "*.type1 \tA -B\tC=value\n"
+ + "*.type2\t -A\tB C=value2\n" //
+ + "*.type3 \t\t B\n" //
+ + "*.type3\t-A";//
+
+ is = new ByteArrayInputStream(attributeFileContent.getBytes());
+ AttributesNode node = new AttributesNode();
+ node.parse(is);
+ assertAttribute("file.type1", node,
+ asSet(A_SET_ATTR, B_UNSET_ATTR, C_VALUE_ATTR));
+ assertAttribute("file.type2", node,
+ asSet(A_UNSET_ATTR, B_SET_ATTR, C_VALUE2_ATTR));
+ assertAttribute("file.type3", node, asSet(A_UNSET_ATTR, B_SET_ATTR));
+ }
+
+ private void assertAttribute(String path, AttributesNode node,
+ Set<Attribute> attrs) {
+ HashMap<String, Attribute> attributes = new HashMap<String, Attribute>();
+ node.getAttributes(path, false, attributes);
+ assertEquals(attrs, new HashSet<Attribute>(attributes.values()));
+ }
+
+ static Set<Attribute> asSet(Attribute... attrs) {
+ Set<Attribute> result = new HashSet<Attribute>();
+ for (Attribute attr : attrs)
+ result.add(attr);
+ return result;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (C) 2010, Marc Strapetz <marc.strapetz@syntevo.com>
+ * Copyright (C) 2013, Gunnar Wagenknecht
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.eclipse.jgit.attributes;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.eclipse.jgit.attributes.Attribute.State;
+import org.junit.Test;
+
+/**
+ * Tests {@link Attribute}
+ */
+public class AttributeTest {
+
+ @Test
+ public void testBasic() {
+ Attribute a = new Attribute("delta", State.SET);
+ assertEquals(a.getKey(), "delta");
+ assertEquals(a.getState(), State.SET);
+ assertNull(a.getValue());
+ assertEquals(a.toString(), "delta");
+
+ a = new Attribute("delta", State.UNSET);
+ assertEquals(a.getKey(), "delta");
+ assertEquals(a.getState(), State.UNSET);
+ assertNull(a.getValue());
+ assertEquals(a.toString(), "-delta");
+
+ a = new Attribute("delta", "value");
+ assertEquals(a.getKey(), "delta");
+ assertEquals(a.getState(), State.CUSTOM);
+ assertEquals(a.getValue(), "value");
+ assertEquals(a.toString(), "delta=value");
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2010, Red Hat Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.eclipse.jgit.attributes;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Tests git attributes pattern matches
+ * <p>
+ * Inspired by {@link org.eclipse.jgit.ignore.IgnoreMatcherTest}
+ * </p>
+ */
+public class AttributesMatcherTest {
+
+ @Test
+ public void testBasic() {
+ String pattern = "/test.stp";
+ assertMatched(pattern, "/test.stp");
+
+ pattern = "#/test.stp";
+ assertNotMatched(pattern, "/test.stp");
+ }
+
+ @Test
+ public void testFileNameWildcards() {
+ //Test basic * and ? for any pattern + any character
+ String pattern = "*.st?";
+ assertMatched(pattern, "/test.stp");
+ assertMatched(pattern, "/anothertest.stg");
+ assertMatched(pattern, "/anothertest.st0");
+ assertNotMatched(pattern, "/anothertest.sta1");
+ //Check that asterisk does not expand to "/"
+ assertNotMatched(pattern, "/another/test.sta1");
+
+ //Same as above, with a leading slash to ensure that doesn't cause problems
+ pattern = "/*.st?";
+ assertMatched(pattern, "/test.stp");
+ assertMatched(pattern, "/anothertest.stg");
+ assertMatched(pattern, "/anothertest.st0");
+ assertNotMatched(pattern, "/anothertest.sta1");
+ //Check that asterisk does not expand to "/"
+ assertNotMatched(pattern, "/another/test.sta1");
+
+ //Test for numbers
+ pattern = "*.sta[0-5]";
+ assertMatched(pattern, "/test.sta5");
+ assertMatched(pattern, "/test.sta4");
+ assertMatched(pattern, "/test.sta3");
+ assertMatched(pattern, "/test.sta2");
+ assertMatched(pattern, "/test.sta1");
+ assertMatched(pattern, "/test.sta0");
+ assertMatched(pattern, "/anothertest.sta2");
+ assertNotMatched(pattern, "test.stag");
+ assertNotMatched(pattern, "test.sta6");
+
+ //Test for letters
+ pattern = "/[tv]est.sta[a-d]";
+ assertMatched(pattern, "/test.staa");
+ assertMatched(pattern, "/test.stab");
+ assertMatched(pattern, "/test.stac");
+ assertMatched(pattern, "/test.stad");
+ assertMatched(pattern, "/vest.stac");
+ assertNotMatched(pattern, "test.stae");
+ assertNotMatched(pattern, "test.sta9");
+
+ //Test child directory/file is matched
+ pattern = "/src/ne?";
+ assertMatched(pattern, "/src/new/");
+ assertMatched(pattern, "/src/new");
+ assertMatched(pattern, "/src/new/a.c");
+ assertMatched(pattern, "/src/new/a/a.c");
+ assertNotMatched(pattern, "/src/new.c");
+
+ //Test name-only fnmatcher matches
+ pattern = "ne?";
+ assertMatched(pattern, "/src/new/");
+ assertMatched(pattern, "/src/new");
+ assertMatched(pattern, "/src/new/a.c");
+ assertMatched(pattern, "/src/new/a/a.c");
+ assertMatched(pattern, "/neb");
+ assertNotMatched(pattern, "/src/new.c");
+ }
+
+ @Test
+ public void testTargetWithoutLeadingSlash() {
+ //Test basic * and ? for any pattern + any character
+ String pattern = "/*.st?";
+ assertMatched(pattern, "test.stp");
+ assertMatched(pattern, "anothertest.stg");
+ assertMatched(pattern, "anothertest.st0");
+ assertNotMatched(pattern, "anothertest.sta1");
+ //Check that asterisk does not expand to ""
+ assertNotMatched(pattern, "another/test.sta1");
+
+ //Same as above, with a leading slash to ensure that doesn't cause problems
+ pattern = "/*.st?";
+ assertMatched(pattern, "test.stp");
+ assertMatched(pattern, "anothertest.stg");
+ assertMatched(pattern, "anothertest.st0");
+ assertNotMatched(pattern, "anothertest.sta1");
+ //Check that asterisk does not expand to ""
+ assertNotMatched(pattern, "another/test.sta1");
+
+ //Test for numbers
+ pattern = "/*.sta[0-5]";
+ assertMatched(pattern, "test.sta5");
+ assertMatched(pattern, "test.sta4");
+ assertMatched(pattern, "test.sta3");
+ assertMatched(pattern, "test.sta2");
+ assertMatched(pattern, "test.sta1");
+ assertMatched(pattern, "test.sta0");
+ assertMatched(pattern, "anothertest.sta2");
+ assertNotMatched(pattern, "test.stag");
+ assertNotMatched(pattern, "test.sta6");
+
+ //Test for letters
+ pattern = "/[tv]est.sta[a-d]";
+ assertMatched(pattern, "test.staa");
+ assertMatched(pattern, "test.stab");
+ assertMatched(pattern, "test.stac");
+ assertMatched(pattern, "test.stad");
+ assertMatched(pattern, "vest.stac");
+ assertNotMatched(pattern, "test.stae");
+ assertNotMatched(pattern, "test.sta9");
+
+ //Test child directory/file is matched
+ pattern = "/src/ne?";
+ assertMatched(pattern, "src/new/");
+ assertMatched(pattern, "src/new");
+ assertMatched(pattern, "src/new/a.c");
+ assertMatched(pattern, "src/new/a/a.c");
+ assertNotMatched(pattern, "src/new.c");
+
+ //Test name-only fnmatcher matches
+ pattern = "ne?";
+ assertMatched(pattern, "src/new/");
+ assertMatched(pattern, "src/new");
+ assertMatched(pattern, "src/new/a.c");
+ assertMatched(pattern, "src/new/a/a.c");
+ assertMatched(pattern, "neb");
+ assertNotMatched(pattern, "src/new.c");
+ }
+
+ @Test
+ public void testParentDirectoryGitAttributes() {
+ //Contains git attribute patterns such as might be seen in a parent directory
+
+ //Test for wildcards
+ String pattern = "/*/*.c";
+ assertMatched(pattern, "/file/a.c");
+ assertMatched(pattern, "/src/a.c");
+ assertNotMatched(pattern, "/src/new/a.c");
+
+ //Test child directory/file is matched
+ pattern = "/src/new";
+ assertMatched(pattern, "/src/new/");
+ assertMatched(pattern, "/src/new");
+ assertMatched(pattern, "/src/new/a.c");
+ assertMatched(pattern, "/src/new/a/a.c");
+ assertNotMatched(pattern, "/src/new.c");
+
+ //Test child directory is matched, slash after name
+ pattern = "/src/new/";
+ assertMatched(pattern, "/src/new/");
+ assertMatched(pattern, "/src/new/a.c");
+ assertMatched(pattern, "/src/new/a/a.c");
+ assertNotMatched(pattern, "/src/new");
+ assertNotMatched(pattern, "/src/new.c");
+
+ //Test directory is matched by name only
+ pattern = "b1";
+ assertMatched(pattern, "/src/new/a/b1/a.c");
+ assertNotMatched(pattern, "/src/new/a/b2/file.c");
+ assertNotMatched(pattern, "/src/new/a/bb1/file.c");
+ assertNotMatched(pattern, "/src/new/a/file.c");
+ }
+
+ @Test
+ public void testTrailingSlash() {
+ String pattern = "/src/";
+ assertMatched(pattern, "/src/");
+ assertMatched(pattern, "/src/new");
+ assertMatched(pattern, "/src/new/a.c");
+ assertMatched(pattern, "/src/a.c");
+ assertNotMatched(pattern, "/src");
+ assertNotMatched(pattern, "/srcA/");
+ }
+
+ @Test
+ public void testNameOnlyMatches() {
+ /*
+ * Name-only matches do not contain any path separators
+ */
+ //Test matches for file extension
+ String pattern = "*.stp";
+ assertMatched(pattern, "/test.stp");
+ assertMatched(pattern, "/src/test.stp");
+ assertNotMatched(pattern, "/test.stp1");
+ assertNotMatched(pattern, "/test.astp");
+
+ //Test matches for name-only, applies to file name or folder name
+ pattern = "src";
+ assertMatched(pattern, "/src");
+ assertMatched(pattern, "/src/");
+ assertMatched(pattern, "/src/a.c");
+ assertMatched(pattern, "/src/new/a.c");
+ assertMatched(pattern, "/new/src/a.c");
+ assertMatched(pattern, "/file/src");
+
+ //Test matches for name-only, applies only to folder names
+ pattern = "src/";
+ assertMatched(pattern, "/src/");
+ assertMatched(pattern, "/src/a.c");
+ assertMatched(pattern, "/src/new/a.c");
+ assertMatched(pattern, "/new/src/a.c");
+ assertNotMatched(pattern, "/src");
+ assertNotMatched(pattern, "/file/src");
+
+ //Test matches for name-only, applies to file name or folder name
+ //With a small wildcard
+ pattern = "?rc";
+ assertMatched(pattern, "/src/a.c");
+ assertMatched(pattern, "/src/new/a.c");
+ assertMatched(pattern, "/new/src/a.c");
+ assertMatched(pattern, "/file/src");
+ assertMatched(pattern, "/src/");
+
+ //Test matches for name-only, applies to file name or folder name
+ //With a small wildcard
+ pattern = "?r[a-c]";
+ assertMatched(pattern, "/src/a.c");
+ assertMatched(pattern, "/src/new/a.c");
+ assertMatched(pattern, "/new/src/a.c");
+ assertMatched(pattern, "/file/src");
+ assertMatched(pattern, "/src/");
+ assertMatched(pattern, "/srb/a.c");
+ assertMatched(pattern, "/grb/new/a.c");
+ assertMatched(pattern, "/new/crb/a.c");
+ assertMatched(pattern, "/file/3rb");
+ assertMatched(pattern, "/xrb/");
+ assertMatched(pattern, "/3ra/a.c");
+ assertMatched(pattern, "/5ra/new/a.c");
+ assertMatched(pattern, "/new/1ra/a.c");
+ assertMatched(pattern, "/file/dra");
+ assertMatched(pattern, "/era/");
+ assertNotMatched(pattern, "/crg");
+ assertNotMatched(pattern, "/cr3");
+ }
+
+ @Test
+ public void testGetters() {
+ AttributesRule r = new AttributesRule("/pattern/", "");
+ assertFalse(r.isNameOnly());
+ assertTrue(r.dirOnly());
+ assertNotNull(r.getAttributes());
+ assertTrue(r.getAttributes().isEmpty());
+ assertEquals(r.getPattern(), "/pattern");
+
+ r = new AttributesRule("/patter?/", "");
+ assertFalse(r.isNameOnly());
+ assertTrue(r.dirOnly());
+ assertNotNull(r.getAttributes());
+ assertTrue(r.getAttributes().isEmpty());
+ assertEquals(r.getPattern(), "/patter?");
+
+ r = new AttributesRule("patt*", "");
+ assertTrue(r.isNameOnly());
+ assertFalse(r.dirOnly());
+ assertNotNull(r.getAttributes());
+ assertTrue(r.getAttributes().isEmpty());
+ assertEquals(r.getPattern(), "patt*");
+
+ r = new AttributesRule("pattern", "attribute1");
+ assertTrue(r.isNameOnly());
+ assertFalse(r.dirOnly());
+ assertNotNull(r.getAttributes());
+ assertFalse(r.getAttributes().isEmpty());
+ assertEquals(r.getAttributes().size(), 1);
+ assertEquals(r.getPattern(), "pattern");
+
+ r = new AttributesRule("pattern", "attribute1 -attribute2");
+ assertTrue(r.isNameOnly());
+ assertFalse(r.dirOnly());
+ assertNotNull(r.getAttributes());
+ assertEquals(r.getAttributes().size(), 2);
+ assertEquals(r.getPattern(), "pattern");
+
+ r = new AttributesRule("pattern", "attribute1 \t-attribute2 \t");
+ assertTrue(r.isNameOnly());
+ assertFalse(r.dirOnly());
+ assertNotNull(r.getAttributes());
+ assertEquals(r.getAttributes().size(), 2);
+ assertEquals(r.getPattern(), "pattern");
+
+ r = new AttributesRule("pattern", "attribute1\t-attribute2\t");
+ assertTrue(r.isNameOnly());
+ assertFalse(r.dirOnly());
+ assertNotNull(r.getAttributes());
+ assertEquals(r.getAttributes().size(), 2);
+ assertEquals(r.getPattern(), "pattern");
+
+ r = new AttributesRule("pattern", "attribute1\t -attribute2\t ");
+ assertTrue(r.isNameOnly());
+ assertFalse(r.dirOnly());
+ assertNotNull(r.getAttributes());
+ assertEquals(r.getAttributes().size(), 2);
+ assertEquals(r.getPattern(), "pattern");
+
+ r = new AttributesRule("pattern",
+ "attribute1 -attribute2 attribute3=value ");
+ assertTrue(r.isNameOnly());
+ assertFalse(r.dirOnly());
+ assertNotNull(r.getAttributes());
+ assertEquals(r.getAttributes().size(), 3);
+ assertEquals(r.getPattern(), "pattern");
+ assertEquals(r.getAttributes().get(0).toString(), "attribute1");
+ assertEquals(r.getAttributes().get(1).toString(), "-attribute2");
+ assertEquals(r.getAttributes().get(2).toString(), "attribute3=value");
+ }
+
+ /**
+ * Check for a match. If target ends with "/", match will assume that the
+ * target is meant to be a directory.
+ *
+ * @param pattern
+ * Pattern as it would appear in a .gitattributes file
+ * @param target
+ * Target file path relative to repository's GIT_DIR
+ */
+ public void assertMatched(String pattern, String target) {
+ boolean value = match(pattern, target);
+ assertTrue("Expected a match for: " + pattern + " with: " + target,
+ value);
+ }
+
+ /**
+ * Check for a match. If target ends with "/", match will assume that the
+ * target is meant to be a directory.
+ *
+ * @param pattern
+ * Pattern as it would appear in a .gitattributes file
+ * @param target
+ * Target file path relative to repository's GIT_DIR
+ */
+ public void assertNotMatched(String pattern, String target) {
+ boolean value = match(pattern, target);
+ assertFalse("Expected no match for: " + pattern + " with: " + target,
+ value);
+ }
+
+ /**
+ * Check for a match. If target ends with "/", match will assume that the
+ * target is meant to be a directory.
+ *
+ * @param pattern
+ * Pattern as it would appear in a .gitattributes file
+ * @param target
+ * Target file path relative to repository's GIT_DIR
+ * @return Result of {@link AttributesRule#isMatch(String, boolean)}
+ */
+ private static boolean match(String pattern, String target) {
+ AttributesRule r = new AttributesRule(pattern, "");
+ //If speed of this test is ever an issue, we can use a presetRule field
+ //to avoid recompiling a pattern each time.
+ return r.isMatch(target, target.endsWith("/"));
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2010, Red Hat Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.eclipse.jgit.attributes;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.hasItem;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.attributes.Attribute.State;
+import org.eclipse.jgit.dircache.DirCacheIterator;
+import org.eclipse.jgit.junit.RepositoryTestCase;
+import org.eclipse.jgit.lib.FileMode;
+import org.eclipse.jgit.treewalk.TreeWalk;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Tests attributes node behavior on the the index.
+ */
+public class AttributesNodeDirCacheIteratorTest extends RepositoryTestCase {
+
+ private static final FileMode D = FileMode.TREE;
+
+ private static final FileMode F = FileMode.REGULAR_FILE;
+
+ private static Attribute EOL_LF = new Attribute("eol", "lf");
+
+ private static Attribute DELTA_UNSET = new Attribute("delta", State.UNSET);
+
+ private Git git;
+
+ private TreeWalk walk;
+
+ @Override
+ @Before
+ public void setUp() throws Exception {
+ super.setUp();
+ git = new Git(db);
+
+ }
+
+ @Test
+ public void testRules() throws Exception {
+ writeAttributesFile(".git/info/attributes", "windows* eol=crlf");
+
+ writeAttributesFile(".gitattributes", "*.txt eol=lf");
+ writeTrashFile("windows.file", "");
+ writeTrashFile("windows.txt", "");
+ writeTrashFile("readme.txt", "");
+
+ writeAttributesFile("src/config/.gitattributes", "*.txt -delta");
+ writeTrashFile("src/config/readme.txt", "");
+ writeTrashFile("src/config/windows.file", "");
+ writeTrashFile("src/config/windows.txt", "");
+
+ // Adds file to index
+ git.add().addFilepattern(".").call();
+
+ walk = beginWalk();
+
+ assertIteration(F, ".gitattributes");
+ assertIteration(F, "readme.txt", asList(EOL_LF));
+
+ assertIteration(D, "src");
+
+ assertIteration(D, "src/config");
+ assertIteration(F, "src/config/.gitattributes");
+ assertIteration(F, "src/config/readme.txt", asList(DELTA_UNSET));
+ assertIteration(F, "src/config/windows.file", null);
+ assertIteration(F, "src/config/windows.txt", asList(DELTA_UNSET));
+
+ assertIteration(F, "windows.file", null);
+ assertIteration(F, "windows.txt", asList(EOL_LF));
+
+ endWalk();
+ }
+
+ /**
+ * Checks that if there is no .gitattributes file in the repository
+ * everything still work fine.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void testNoAttributes() throws Exception {
+ writeTrashFile("l0.txt", "");
+ writeTrashFile("level1/l1.txt", "");
+ writeTrashFile("level1/level2/l2.txt", "");
+
+ // Adds file to index
+ git.add().addFilepattern(".").call();
+ walk = beginWalk();
+
+ assertIteration(F, "l0.txt");
+
+ assertIteration(D, "level1");
+ assertIteration(F, "level1/l1.txt");
+
+ assertIteration(D, "level1/level2");
+ assertIteration(F, "level1/level2/l2.txt");
+
+ endWalk();
+ }
+
+ /**
+ * Checks that empty .gitattribute files do not return incorrect value.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void testEmptyGitAttributeFile() throws Exception {
+ writeAttributesFile(".git/info/attributes", "");
+ writeTrashFile("l0.txt", "");
+ writeAttributesFile(".gitattributes", "");
+ writeTrashFile("level1/l1.txt", "");
+ writeTrashFile("level1/level2/l2.txt", "");
+
+ // Adds file to index
+ git.add().addFilepattern(".").call();
+ walk = beginWalk();
+
+ assertIteration(F, ".gitattributes");
+ assertIteration(F, "l0.txt");
+
+ assertIteration(D, "level1");
+ assertIteration(F, "level1/l1.txt");
+
+ assertIteration(D, "level1/level2");
+ assertIteration(F, "level1/level2/l2.txt");
+
+ endWalk();
+ }
+
+ @Test
+ public void testNoMatchingAttributes() throws Exception {
+ writeAttributesFile(".git/info/attributes", "*.java delta");
+ writeAttributesFile(".gitattributes", "*.java -delta");
+ writeAttributesFile("levelA/.gitattributes", "*.java eol=lf");
+ writeAttributesFile("levelB/.gitattributes", "*.txt eol=lf");
+
+ writeTrashFile("levelA/lA.txt", "");
+
+ // Adds file to index
+ git.add().addFilepattern(".").call();
+ walk = beginWalk();
+
+ assertIteration(F, ".gitattributes");
+
+ assertIteration(D, "levelA");
+ assertIteration(F, "levelA/.gitattributes");
+ assertIteration(F, "levelA/lA.txt");
+
+ assertIteration(D, "levelB");
+ assertIteration(F, "levelB/.gitattributes");
+
+ endWalk();
+ }
+
+ @Test
+ public void testIncorrectAttributeFileName() throws Exception {
+ writeAttributesFile("levelA/file.gitattributes", "*.txt -delta");
+ writeAttributesFile("gitattributes", "*.txt eol=lf");
+
+ writeTrashFile("l0.txt", "");
+ writeTrashFile("levelA/lA.txt", "");
+
+ // Adds file to index
+ git.add().addFilepattern(".").call();
+ walk = beginWalk();
+
+ assertIteration(F, "gitattributes");
+
+ assertIteration(F, "l0.txt");
+
+ assertIteration(D, "levelA");
+ assertIteration(F, "levelA/file.gitattributes");
+ assertIteration(F, "levelA/lA.txt");
+
+ endWalk();
+ }
+
+ private void assertIteration(FileMode type, String pathName)
+ throws IOException {
+ assertIteration(type, pathName, Collections.<Attribute> emptyList());
+ }
+
+ private void assertIteration(FileMode type, String pathName,
+ List<Attribute> nodeAttrs) throws IOException {
+ assertTrue("walk has entry", walk.next());
+ assertEquals(pathName, walk.getPathString());
+ assertEquals(type, walk.getFileMode(0));
+ DirCacheIterator itr = walk.getTree(0, DirCacheIterator.class);
+ assertNotNull("has tree", itr);
+
+ AttributesNode attributeNode = itr.getEntryAttributesNode(db
+ .newObjectReader());
+ assertAttributeNode(pathName, attributeNode, nodeAttrs);
+
+ if (D.equals(type))
+ walk.enterSubtree();
+
+ }
+
+ private void assertAttributeNode(String pathName,
+ AttributesNode attributeNode, List<Attribute> nodeAttrs) {
+ if (attributeNode == null)
+ assertTrue(nodeAttrs == null || nodeAttrs.isEmpty());
+ else {
+
+ Map<String, Attribute> entryAttributes = new LinkedHashMap<String, Attribute>();
+ attributeNode.getAttributes(pathName, false, entryAttributes);
+
+ if (nodeAttrs != null && !nodeAttrs.isEmpty()) {
+ for (Attribute attribute : nodeAttrs) {
+ assertThat(entryAttributes.values(), hasItem(attribute));
+ }
+ } else {
+ assertTrue(
+ "The entry "
+ + pathName
+ + " should not have any attributes. Instead, the following attributes are applied to this file "
+ + entryAttributes.toString(),
+ entryAttributes.isEmpty());
+ }
+ }
+ }
+
+ private void writeAttributesFile(String name, String... rules)
+ throws IOException {
+ StringBuilder data = new StringBuilder();
+ for (String line : rules)
+ data.append(line + "\n");
+ writeTrashFile(name, data.toString());
+ }
+
+ private TreeWalk beginWalk() throws Exception {
+ TreeWalk newWalk = new TreeWalk(db);
+ newWalk.addTree(new DirCacheIterator(db.readDirCache()));
+ return newWalk;
+ }
+
+ private void endWalk() throws IOException {
+ assertFalse("Not all files tested", walk.next());
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2014, Obeo.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.eclipse.jgit.attributes;
+
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.hasItem;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.jgit.attributes.Attribute.State;
+import org.eclipse.jgit.errors.CorruptObjectException;
+import org.eclipse.jgit.junit.JGitTestUtil;
+import org.eclipse.jgit.junit.RepositoryTestCase;
+import org.eclipse.jgit.lib.FileMode;
+import org.eclipse.jgit.treewalk.FileTreeIterator;
+import org.eclipse.jgit.treewalk.TreeWalk;
+import org.eclipse.jgit.treewalk.WorkingTreeIterator;
+import org.junit.Test;
+
+/**
+ * Tests attributes node behavior on the local filesystem.
+ */
+public class AttributesNodeWorkingTreeIteratorTest extends RepositoryTestCase {
+
+ private static final FileMode D = FileMode.TREE;
+
+ private static final FileMode F = FileMode.REGULAR_FILE;
+
+ private static Attribute EOL_CRLF = new Attribute("eol", "crlf");
+
+ private static Attribute EOL_LF = new Attribute("eol", "lf");
+
+ private static Attribute DELTA_UNSET = new Attribute("delta", State.UNSET);
+
+ private static Attribute CUSTOM_VALUE = new Attribute("custom", "value");
+
+ private TreeWalk walk;
+
+ @Test
+ public void testRules() throws Exception {
+
+ File customAttributeFile = File.createTempFile("tmp_",
+ "customAttributeFile", null);
+ customAttributeFile.deleteOnExit();
+
+ JGitTestUtil.write(customAttributeFile, "*.txt custom=value");
+ db.getConfig().setString("core", null, "attributesfile",
+ customAttributeFile.getAbsolutePath());
+ writeAttributesFile(".git/info/attributes", "windows* eol=crlf");
+
+ writeAttributesFile(".gitattributes", "*.txt eol=lf");
+ writeTrashFile("windows.file", "");
+ writeTrashFile("windows.txt", "");
+ writeTrashFile("global.txt", "");
+ writeTrashFile("readme.txt", "");
+
+ writeAttributesFile("src/config/.gitattributes", "*.txt -delta");
+ writeTrashFile("src/config/readme.txt", "");
+ writeTrashFile("src/config/windows.file", "");
+ writeTrashFile("src/config/windows.txt", "");
+
+ walk = beginWalk();
+
+ assertIteration(F, ".gitattributes");
+ assertIteration(F, "global.txt", asList(EOL_LF), null,
+ asList(CUSTOM_VALUE));
+ assertIteration(F, "readme.txt", asList(EOL_LF), null,
+ asList(CUSTOM_VALUE));
+
+ assertIteration(D, "src");
+
+ assertIteration(D, "src/config");
+ assertIteration(F, "src/config/.gitattributes");
+ assertIteration(F, "src/config/readme.txt", asList(DELTA_UNSET), null,
+ asList(CUSTOM_VALUE));
+ assertIteration(F, "src/config/windows.file", null, asList(EOL_CRLF),
+ null);
+ assertIteration(F, "src/config/windows.txt", asList(DELTA_UNSET),
+ asList(EOL_CRLF), asList(CUSTOM_VALUE));
+
+ assertIteration(F, "windows.file", null, asList(EOL_CRLF), null);
+ assertIteration(F, "windows.txt", asList(EOL_LF), asList(EOL_CRLF),
+ asList(CUSTOM_VALUE));
+
+ endWalk();
+ }
+
+ /**
+ * Checks that if there is no .gitattributes file in the repository
+ * everything still work fine.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void testNoAttributes() throws Exception {
+ writeTrashFile("l0.txt", "");
+ writeTrashFile("level1/l1.txt", "");
+ writeTrashFile("level1/level2/l2.txt", "");
+
+ walk = beginWalk();
+
+ assertIteration(F, "l0.txt");
+
+ assertIteration(D, "level1");
+ assertIteration(F, "level1/l1.txt");
+
+ assertIteration(D, "level1/level2");
+ assertIteration(F, "level1/level2/l2.txt");
+
+ endWalk();
+ }
+
+ /**
+ * Checks that empty .gitattribute files do not return incorrect value.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void testEmptyGitAttributeFile() throws Exception {
+ writeAttributesFile(".git/info/attributes", "");
+ writeTrashFile("l0.txt", "");
+ writeAttributesFile(".gitattributes", "");
+ writeTrashFile("level1/l1.txt", "");
+ writeTrashFile("level1/level2/l2.txt", "");
+
+ walk = beginWalk();
+
+ assertIteration(F, ".gitattributes");
+ assertIteration(F, "l0.txt");
+
+ assertIteration(D, "level1");
+ assertIteration(F, "level1/l1.txt");
+
+ assertIteration(D, "level1/level2");
+ assertIteration(F, "level1/level2/l2.txt");
+
+ endWalk();
+ }
+
+ @Test
+ public void testNoMatchingAttributes() throws Exception {
+ writeAttributesFile(".git/info/attributes", "*.java delta");
+ writeAttributesFile(".gitattributes", "*.java -delta");
+ writeAttributesFile("levelA/.gitattributes", "*.java eol=lf");
+ writeAttributesFile("levelB/.gitattributes", "*.txt eol=lf");
+
+ writeTrashFile("levelA/lA.txt", "");
+
+ walk = beginWalk();
+
+ assertIteration(F, ".gitattributes");
+
+ assertIteration(D, "levelA");
+ assertIteration(F, "levelA/.gitattributes");
+ assertIteration(F, "levelA/lA.txt");
+
+ assertIteration(D, "levelB");
+ assertIteration(F, "levelB/.gitattributes");
+
+ endWalk();
+ }
+
+ private void assertIteration(FileMode type, String pathName)
+ throws IOException {
+ assertIteration(type, pathName, Collections.<Attribute> emptyList(),
+ Collections.<Attribute> emptyList(),
+ Collections.<Attribute> emptyList());
+ }
+
+ private void assertIteration(FileMode type, String pathName,
+ List<Attribute> nodeAttrs, List<Attribute> infoAttrs,
+ List<Attribute> globalAttrs)
+ throws IOException {
+ assertTrue("walk has entry", walk.next());
+ assertEquals(pathName, walk.getPathString());
+ assertEquals(type, walk.getFileMode(0));
+ WorkingTreeIterator itr = walk.getTree(0, WorkingTreeIterator.class);
+ assertNotNull("has tree", itr);
+
+ AttributesNode attributeNode = itr.getEntryAttributesNode();
+ assertAttributeNode(pathName, attributeNode, nodeAttrs);
+ AttributesNode infoAttributeNode = itr.getInfoAttributesNode();
+ assertAttributeNode(pathName, infoAttributeNode, infoAttrs);
+ AttributesNode globalAttributeNode = itr.getGlobalAttributesNode();
+ assertAttributeNode(pathName, globalAttributeNode, globalAttrs);
+ if (D.equals(type))
+ walk.enterSubtree();
+
+ }
+
+ private void assertAttributeNode(String pathName,
+ AttributesNode attributeNode, List<Attribute> nodeAttrs) {
+ if (attributeNode == null)
+ assertTrue(nodeAttrs == null || nodeAttrs.isEmpty());
+ else {
+
+ Map<String, Attribute> entryAttributes = new LinkedHashMap<String, Attribute>();
+ attributeNode.getAttributes(pathName, false, entryAttributes);
+
+ if (nodeAttrs != null && !nodeAttrs.isEmpty()) {
+ for (Attribute attribute : nodeAttrs) {
+ assertThat(entryAttributes.values(), hasItem(attribute));
+ }
+ } else {
+ assertTrue(
+ "The entry "
+ + pathName
+ + " should not have any attributes. Instead, the following attributes are applied to this file "
+ + entryAttributes.toString(),
+ entryAttributes.isEmpty());
+ }
+ }
+ }
+
+ private void writeAttributesFile(String name, String... rules)
+ throws IOException {
+ StringBuilder data = new StringBuilder();
+ for (String line : rules)
+ data.append(line + "\n");
+ writeTrashFile(name, data.toString());
+ }
+
+ private TreeWalk beginWalk() throws CorruptObjectException {
+ TreeWalk newWalk = new TreeWalk(db);
+ newWalk.addTree(new FileTreeIterator(db));
+ return newWalk;
+ }
+
+ private void endWalk() throws IOException {
+ assertFalse("Not all files tested", walk.next());
+ }
+}
org.eclipse.jgit.lib,
org.eclipse.jgit.treewalk,
org.eclipse.jgit.blame,
+ org.eclipse.jgit.submodule,
org.eclipse.jgit.transport,
org.eclipse.jgit.merge",
org.eclipse.jgit.api.errors;version="3.7.0";
uses:="org.eclipse.jgit.lib,org.eclipse.jgit.errors",
+ org.eclipse.jgit.attributes;version="3.7.0",
org.eclipse.jgit.blame;version="3.7.0";
uses:="org.eclipse.jgit.lib,
org.eclipse.jgit.revwalk,
uses:="org.eclipse.jgit.lib,
org.eclipse.jgit.treewalk,
org.eclipse.jgit.util,
- org.eclipse.jgit.events",
+ org.eclipse.jgit.events,
+ org.eclipse.jgit.attributes",
org.eclipse.jgit.errors;version="3.7.0";
uses:="org.eclipse.jgit.lib,
org.eclipse.jgit.internal.storage.pack,
org.eclipse.jgit.fnmatch;version="3.7.0",
org.eclipse.jgit.gitrepo;version="3.7.0";
uses:="org.eclipse.jgit.api,
- org.eclipse.jgit.lib",
+ org.eclipse.jgit.lib,
+ org.eclipse.jgit.revwalk",
org.eclipse.jgit.gitrepo.internal;version="3.7.0";x-internal:=true,
org.eclipse.jgit.ignore;version="3.7.0",
org.eclipse.jgit.ignore.internal;version="3.7.0";x-friends:="org.eclipse.jgit.test",
org.eclipse.jgit.dircache,
org.eclipse.jgit.internal.storage.file,
org.eclipse.jgit.treewalk,
- org.eclipse.jgit.transport",
+ org.eclipse.jgit.transport,
+ org.eclipse.jgit.submodule",
org.eclipse.jgit.merge;version="3.7.0";
uses:="org.eclipse.jgit.lib,
org.eclipse.jgit.treewalk,
org.eclipse.jgit.revwalk,
org.eclipse.jgit.diff,
- org.eclipse.jgit.dircache",
+ org.eclipse.jgit.dircache,
+ org.eclipse.jgit.api",
org.eclipse.jgit.nls;version="3.7.0",
org.eclipse.jgit.notes;version="3.7.0";
uses:="org.eclipse.jgit.lib,
org.eclipse.jgit.patch;version="3.7.0";
uses:="org.eclipse.jgit.lib,org.eclipse.jgit.diff",
org.eclipse.jgit.revplot;version="3.7.0";
- uses:="org.eclipse.jgit.lib,org.eclipse.jgit.revwalk",
+ uses:="org.eclipse.jgit.lib,
+ org.eclipse.jgit.revwalk",
org.eclipse.jgit.revwalk;version="3.7.0";
uses:="org.eclipse.jgit.lib,
org.eclipse.jgit.treewalk,
org.eclipse.jgit.storage.pack;version="3.7.0";
uses:="org.eclipse.jgit.lib",
org.eclipse.jgit.submodule;version="3.7.0";
- uses:="org.eclipse.jgit.lib,org.eclipse.jgit.treewalk,org.eclipse.jgit.treewalk.filter",
+ uses:="org.eclipse.jgit.lib,
+ org.eclipse.jgit.treewalk.filter,
+ org.eclipse.jgit.treewalk",
org.eclipse.jgit.transport;version="3.7.0";
uses:="org.eclipse.jgit.transport.resolver,
org.eclipse.jgit.revwalk,
org.eclipse.jgit.transport.http;version="3.7.0";
uses:="javax.net.ssl",
org.eclipse.jgit.transport.resolver;version="3.7.0";
- uses:="org.eclipse.jgit.lib,org.eclipse.jgit.transport",
+ uses:="org.eclipse.jgit.lib,
+ org.eclipse.jgit.transport",
org.eclipse.jgit.treewalk;version="3.7.0";
uses:="org.eclipse.jgit.lib,
org.eclipse.jgit.revwalk,
+ org.eclipse.jgit.attributes,
org.eclipse.jgit.treewalk.filter,
org.eclipse.jgit.util,
org.eclipse.jgit.dircache",
org.eclipse.jgit.treewalk.filter;version="3.7.0";
uses:="org.eclipse.jgit.treewalk",
org.eclipse.jgit.util;version="3.7.0";
- uses:="org.eclipse.jgit.lib,org.eclipse.jgit.transport.http,org.eclipse.jgit.storage.file",
+ uses:="org.eclipse.jgit.lib,
+ org.eclipse.jgit.transport.http,
+ org.eclipse.jgit.storage.file,
+ org.ietf.jgss",
org.eclipse.jgit.util.io;version="3.7.0"
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: J2SE-1.5
--- /dev/null
+/*
+ * Copyright (C) 2010, Marc Strapetz <marc.strapetz@syntevo.com>
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.eclipse.jgit.attributes;
+
+/**
+ * Represents an attribute.
+ * <p>
+ * According to the man page, an attribute can have the following states:
+ * <ul>
+ * <li>Set - represented by {@link State#SET}</li>
+ * <li>Unset - represented by {@link State#UNSET}</li>
+ * <li>Set to a value - represented by {@link State#CUSTOM}</li>
+ * <li>Unspecified - <code>null</code> is used instead of an instance of this
+ * class</li>
+ * </ul>
+ * </p>
+ *
+ * @since 3.7
+ */
+public final class Attribute {
+
+ /**
+ * The attribute value state
+ */
+ public static enum State {
+ /** the attribute is set */
+ SET,
+
+ /** the attribute is unset */
+ UNSET,
+
+ /** the attribute is set to a custom value */
+ CUSTOM
+ }
+
+ private final String key;
+ private final State state;
+ private final String value;
+
+ /**
+ * Creates a new instance
+ *
+ * @param key
+ * the attribute key. Should not be <code>null</code>.
+ * @param state
+ * the attribute state. It should be either {@link State#SET} or
+ * {@link State#UNSET}. In order to create a custom value
+ * attribute prefer the use of {@link #Attribute(String, String)}
+ * constructor.
+ */
+ public Attribute(String key, State state) {
+ this(key, state, null);
+ }
+
+ private Attribute(String key, State state, String value) {
+ if (key == null)
+ throw new NullPointerException(
+ "The key of an attribute should not be null"); //$NON-NLS-1$
+ if (state == null)
+ throw new NullPointerException(
+ "The state of an attribute should not be null"); //$NON-NLS-1$
+
+ this.key = key;
+ this.state = state;
+ this.value = value;
+ }
+
+ /**
+ * Creates a new instance.
+ *
+ * @param key
+ * the attribute key. Should not be <code>null</code>.
+ * @param value
+ * the custom attribute value
+ */
+ public Attribute(String key, String value) {
+ this(key, State.CUSTOM, value);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (!(obj instanceof Attribute))
+ return false;
+ Attribute other = (Attribute) obj;
+ if (!key.equals(other.key))
+ return false;
+ if (state != other.state)
+ return false;
+ if (value == null) {
+ if (other.value != null)
+ return false;
+ } else if (!value.equals(other.value))
+ return false;
+ return true;
+ }
+
+ /**
+ * @return the attribute key (never returns <code>null</code>)
+ */
+ public String getKey() {
+ return key;
+ }
+
+ /**
+ * Returns the state.
+ *
+ * @return the state (never returns <code>null</code>)
+ */
+ public State getState() {
+ return state;
+ }
+
+ /**
+ * @return the attribute value (may be <code>null</code>)
+ */
+ public String getValue() {
+ return value;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + key.hashCode();
+ result = prime * result + state.hashCode();
+ result = prime * result + ((value == null) ? 0 : value.hashCode());
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ switch (state) {
+ case SET:
+ return key;
+ case UNSET:
+ return "-" + key; //$NON-NLS-1$
+ case CUSTOM:
+ default:
+ return key + "=" + value; //$NON-NLS-1$
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (C) 2010, Red Hat Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.eclipse.jgit.attributes;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+
+import org.eclipse.jgit.lib.Constants;
+
+/**
+ * Represents a bundle of attributes inherited from a base directory.
+ *
+ * This class is not thread safe, it maintains state about the last match.
+ *
+ * @since 3.7
+ */
+public class AttributesNode {
+ /** The rules that have been parsed into this node. */
+ private final List<AttributesRule> rules;
+
+ /** Create an empty ignore node with no rules. */
+ public AttributesNode() {
+ rules = new ArrayList<AttributesRule>();
+ }
+
+ /**
+ * Create an ignore node with given rules.
+ *
+ * @param rules
+ * list of rules.
+ **/
+ public AttributesNode(List<AttributesRule> rules) {
+ this.rules = rules;
+ }
+
+ /**
+ * Parse files according to gitattribute standards.
+ *
+ * @param in
+ * input stream holding the standard ignore format. The caller is
+ * responsible for closing the stream.
+ * @throws IOException
+ * Error thrown when reading an ignore file.
+ */
+ public void parse(InputStream in) throws IOException {
+ BufferedReader br = asReader(in);
+ String txt;
+ while ((txt = br.readLine()) != null) {
+ txt = txt.trim();
+ if (txt.length() > 0 && !txt.startsWith("#") /* Comments *///$NON-NLS-1$
+ && !txt.startsWith("!") /* Negative pattern forbidden for attributes */) { //$NON-NLS-1$
+ int patternEndSpace = txt.indexOf(' ');
+ int patternEndTab = txt.indexOf('\t');
+
+ final int patternEnd;
+ if (patternEndSpace == -1)
+ patternEnd = patternEndTab;
+ else if (patternEndTab == -1)
+ patternEnd = patternEndSpace;
+ else
+ patternEnd = Math.min(patternEndSpace, patternEndTab);
+
+ if (patternEnd > -1)
+ rules.add(new AttributesRule(txt.substring(0, patternEnd),
+ txt.substring(patternEnd + 1).trim()));
+ }
+ }
+ }
+
+ private static BufferedReader asReader(InputStream in) {
+ return new BufferedReader(new InputStreamReader(in, Constants.CHARSET));
+ }
+
+ /** @return list of all ignore rules held by this node. */
+ public List<AttributesRule> getRules() {
+ return Collections.unmodifiableList(rules);
+ }
+
+ /**
+ * Returns the matching attributes for an entry path.
+ *
+ * @param entryPath
+ * the path to test. The path must be relative to this attribute
+ * node's own repository path, and in repository path format
+ * (uses '/' and not '\').
+ * @param isDirectory
+ * true if the target item is a directory.
+ * @param attributes
+ * Map that will hold the attributes matching this entry path. If
+ * it is not empty, this method will NOT override any
+ * existing entry.
+ */
+ public void getAttributes(String entryPath, boolean isDirectory,
+ Map<String, Attribute> attributes) {
+ // Parse rules in the reverse order that they were read since the last
+ // entry should be used
+ ListIterator<AttributesRule> ruleIterator = rules.listIterator(rules
+ .size());
+ while (ruleIterator.hasPrevious()) {
+ AttributesRule rule = ruleIterator.previous();
+ if (rule.isMatch(entryPath, isDirectory)) {
+ ListIterator<Attribute> attributeIte = rule.getAttributes()
+ .listIterator(rule.getAttributes().size());
+ // Parses the attributes in the reverse order that they were
+ // read since the last entry should be used
+ while (attributeIte.hasPrevious()) {
+ Attribute attr = attributeIte.previous();
+ if (!attributes.containsKey(attr.getKey()))
+ attributes.put(attr.getKey(), attr);
+ }
+ }
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (C) 2010, Red Hat Inc.
+ * and other copyright owners as documented in the project's IP log.
+ *
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Distribution License v1.0 which
+ * accompanies this distribution, is reproduced below, and is
+ * available at http://www.eclipse.org/org/documents/edl-v10.php
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * - Neither the name of the Eclipse Foundation, Inc. nor the
+ * names of its contributors may be used to endorse or promote
+ * products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.eclipse.jgit.attributes;
+
+import static org.eclipse.jgit.ignore.internal.IMatcher.NO_MATCH;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.jgit.attributes.Attribute.State;
+import org.eclipse.jgit.errors.InvalidPatternException;
+import org.eclipse.jgit.ignore.FastIgnoreRule;
+import org.eclipse.jgit.ignore.internal.IMatcher;
+import org.eclipse.jgit.ignore.internal.PathMatcher;
+
+/**
+ * A single attributes rule corresponding to one line in a .gitattributes file.
+ *
+ * Inspiration from: {@link FastIgnoreRule}
+ *
+ * @since 3.7
+ */
+public class AttributesRule {
+
+ /**
+ * regular expression for splitting attributes - space, tab and \r (the C
+ * implementation oddly enough allows \r between attributes)
+ * */
+ private static final String ATTRIBUTES_SPLIT_REGEX = "[ \t\r]"; //$NON-NLS-1$
+
+ private static List<Attribute> parseAttributes(String attributesLine) {
+ // the C implementation oddly enough allows \r between attributes too.
+ ArrayList<Attribute> result = new ArrayList<Attribute>();
+ for (String attribute : attributesLine.split(ATTRIBUTES_SPLIT_REGEX)) {
+ attribute = attribute.trim();
+ if (attribute.length() == 0)
+ continue;
+
+ if (attribute.startsWith("-")) {//$NON-NLS-1$
+ if (attribute.length() > 1)
+ result.add(new Attribute(attribute.substring(1),
+ State.UNSET));
+ continue;
+ }
+
+ final int equalsIndex = attribute.indexOf("="); //$NON-NLS-1$
+ if (equalsIndex == -1)
+ result.add(new Attribute(attribute, State.SET));
+ else {
+ String attributeKey = attribute.substring(0, equalsIndex);
+ if (attributeKey.length() > 0) {
+ String attributeValue = attribute
+ .substring(equalsIndex + 1);
+ result.add(new Attribute(attributeKey, attributeValue));
+ }
+ }
+ }
+ return result;
+ }
+
+ private final String pattern;
+ private final List<Attribute> attributes;
+
+ private boolean nameOnly;
+ private boolean dirOnly;
+
+ private IMatcher matcher;
+
+ /**
+ * Create a new attribute rule with the given pattern. Assumes that the
+ * pattern is already trimmed.
+ *
+ * @param pattern
+ * Base pattern for the attributes rule. This pattern will be
+ * parsed to generate rule parameters. It can not be
+ * <code>null</code>.
+ * @param attributes
+ * the rule attributes. This string will be parsed to read the
+ * attributes.
+ */
+ public AttributesRule(String pattern, String attributes) {
+ this.attributes = parseAttributes(attributes);
+ nameOnly = false;
+ dirOnly = false;
+
+ if (pattern.endsWith("/")) { //$NON-NLS-1$
+ pattern = pattern.substring(0, pattern.length() - 1);
+ dirOnly = true;
+ }
+
+ boolean hasSlash = pattern.contains("/"); //$NON-NLS-1$
+
+ if (!hasSlash)
+ nameOnly = true;
+ else if (!pattern.startsWith("/")) { //$NON-NLS-1$
+ // Contains "/" but does not start with one
+ // Adding / to the start should not interfere with matching
+ pattern = "/" + pattern; //$NON-NLS-1$
+ }
+
+ try {
+ matcher = PathMatcher.createPathMatcher(pattern,
+ Character.valueOf(FastIgnoreRule.PATH_SEPARATOR), dirOnly);
+ } catch (InvalidPatternException e) {
+ matcher = NO_MATCH;
+ }
+
+ this.pattern = pattern;
+ }
+
+ /**
+ * @return True if the pattern should match directories only
+ */
+ public boolean dirOnly() {
+ return dirOnly;
+ }
+
+ /**
+ * Returns the attributes.
+ *
+ * @return an unmodifiable list of attributes (never returns
+ * <code>null</code>)
+ */
+ public List<Attribute> getAttributes() {
+ return Collections.unmodifiableList(attributes);
+ }
+
+ /**
+ * @return <code>true</code> if the pattern is just a file name and not a
+ * path
+ */
+ public boolean isNameOnly() {
+ return nameOnly;
+ }
+
+ /**
+ * @return The blob pattern to be used as a matcher (never returns
+ * <code>null</code>)
+ */
+ public String getPattern() {
+ return pattern;
+ }
+
+ /**
+ * Returns <code>true</code> if a match was made.
+ *
+ * @param relativeTarget
+ * Name pattern of the file, relative to the base directory of
+ * this rule
+ * @param isDirectory
+ * Whether the target file is a directory or not
+ * @return True if a match was made.
+ */
+ public boolean isMatch(String relativeTarget, boolean isDirectory) {
+ if (relativeTarget == null)
+ return false;
+ if (relativeTarget.length() == 0)
+ return false;
+ boolean match = matcher.matches(relativeTarget, isDirectory);
+ return match;
+ }
+}
\ No newline at end of file
--- /dev/null
+/**
+ * Support for reading .gitattributes.
+ */
+package org.eclipse.jgit.attributes;
package org.eclipse.jgit.dircache;
import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collections;
+import org.eclipse.jgit.attributes.AttributesNode;
+import org.eclipse.jgit.attributes.AttributesRule;
import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.FileMode;
+import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.ObjectLoader;
import org.eclipse.jgit.lib.ObjectReader;
import org.eclipse.jgit.treewalk.AbstractTreeIterator;
import org.eclipse.jgit.treewalk.EmptyTreeIterator;
+import org.eclipse.jgit.util.RawParseUtils;
/**
* Iterate a {@link DirCache} as part of a <code>TreeWalk</code>.
* @see org.eclipse.jgit.treewalk.TreeWalk
*/
public class DirCacheIterator extends AbstractTreeIterator {
+ /** Byte array holding ".gitattributes" string */
+ private static final byte[] DOT_GIT_ATTRIBUTES_BYTES = Constants.DOT_GIT_ATTRIBUTES
+ .getBytes();
+
/** The cache this iterator was created to walk. */
protected final DirCache cache;
/** The subtree containing {@link #currentEntry} if this is first entry. */
protected DirCacheTree currentSubtree;
+ /** Holds an {@link AttributesNode} for the current entry */
+ private AttributesNode attributesNode;
+
/**
* Create a new iterator for an already loaded DirCache instance.
* <p>
path = cep;
pathLen = cep.length;
currentSubtree = null;
+ // Checks if this entry is a .gitattributes file
+ if (RawParseUtils.match(path, pathOffset, DOT_GIT_ATTRIBUTES_BYTES) == path.length)
+ attributesNode = new LazyLoadingAttributesNode(
+ currentEntry.getObjectId());
}
/**
public DirCacheEntry getDirCacheEntry() {
return currentSubtree == null ? currentEntry : null;
}
+
+ /**
+ * Retrieves the {@link AttributesNode} for the current entry.
+ *
+ * @param reader
+ * {@link ObjectReader} used to parse the .gitattributes entry.
+ * @return {@link AttributesNode} for the current entry.
+ * @throws IOException
+ * @since 3.7
+ */
+ public AttributesNode getEntryAttributesNode(ObjectReader reader)
+ throws IOException {
+ if (attributesNode instanceof LazyLoadingAttributesNode)
+ attributesNode = ((LazyLoadingAttributesNode) attributesNode)
+ .load(reader);
+ return attributesNode;
+ }
+
+ /**
+ * {@link AttributesNode} implementation that provides lazy loading
+ * facilities.
+ */
+ private static class LazyLoadingAttributesNode extends AttributesNode {
+ final ObjectId objectId;
+
+ LazyLoadingAttributesNode(ObjectId objectId) {
+ super(Collections.<AttributesRule> emptyList());
+ this.objectId = objectId;
+
+ }
+
+ AttributesNode load(ObjectReader reader) throws IOException {
+ AttributesNode r = new AttributesNode();
+ ObjectLoader loader = reader.open(objectId);
+ if (loader != null) {
+ InputStream in = loader.openStream();
+ try {
+ r.parse(in);
+ } finally {
+ in.close();
+ }
+ }
+ return r.getRules().isEmpty() ? null : r;
+ }
+ }
+
}
package org.eclipse.jgit.ignore;
import static org.eclipse.jgit.ignore.internal.Strings.stripTrailing;
-
+import static org.eclipse.jgit.ignore.internal.IMatcher.NO_MATCH;
import org.eclipse.jgit.errors.InvalidPatternException;
import org.eclipse.jgit.ignore.internal.IMatcher;
import org.eclipse.jgit.ignore.internal.PathMatcher;
*/
public static final char PATH_SEPARATOR = '/';
- private static final NoResultMatcher NO_MATCH = new NoResultMatcher();
-
private final IMatcher matcher;
private final boolean inverse;
return false;
return matcher.equals(other.matcher);
}
-
- static final class NoResultMatcher implements IMatcher {
-
- public boolean matches(String path, boolean assumeDirectory) {
- return false;
- }
-
- public boolean matches(String segment, int startIncl, int endExcl,
- boolean assumeDirectory) {
- return false;
- }
- }
}
*/
public interface IMatcher {
+ /**
+ * Matcher that does not match any pattern.
+ */
+ public static final IMatcher NO_MATCH = new IMatcher() {
+ public boolean matches(String path, boolean assumeDirectory) {
+ return false;
+ }
+
+ public boolean matches(String segment, int startIncl, int endExcl,
+ boolean assumeDirectory) {
+ return false;
+ }
+ };
+
/**
* Matches entire given string
*
/** The "excludesfile" key */
public static final String CONFIG_KEY_EXCLUDESFILE = "excludesfile";
+ /**
+ * The "attributesfile" key
+ *
+ * @since 3.7
+ */
+ public static final String CONFIG_KEY_ATTRIBUTESFILE = "attributesfile";
+
/** The "filemode" key */
public static final String CONFIG_KEY_FILEMODE = "filemode";
/** A bare repository typically ends with this string */
public static final String DOT_GIT_EXT = ".git";
+ /**
+ * Name of the attributes file
+ *
+ * @since 3.7
+ */
+ public static final String DOT_GIT_ATTRIBUTES = ".gitattributes";
+
/** Name of the ignore file */
public static final String DOT_GIT_IGNORE = ".gitignore";
/*
+ * Copyright (C) 2013, Gunnar Wagenknecht
* Copyright (C) 2010, Chris Aniszczyk <caniszczyk@gmail.com>
* Copyright (C) 2009, Christian Halstrick <christian.halstrick@sap.com>
* Copyright (C) 2009, Google Inc.
private final String excludesfile;
+ private final String attributesfile;
+
/**
* Options for symlink handling
*
ConfigConstants.CONFIG_KEY_LOGALLREFUPDATES, true);
excludesfile = rc.getString(ConfigConstants.CONFIG_CORE_SECTION, null,
ConfigConstants.CONFIG_KEY_EXCLUDESFILE);
+ attributesfile = rc.getString(ConfigConstants.CONFIG_CORE_SECTION,
+ null, ConfigConstants.CONFIG_KEY_ATTRIBUTESFILE);
}
/**
public String getExcludesFile() {
return excludesfile;
}
+
+ /**
+ * @return path of attributesfile
+ * @since 3.7
+ */
+ public String getAttributesFile() {
+ return attributesfile;
+ }
}
import java.util.Comparator;
import org.eclipse.jgit.api.errors.JGitInternalException;
+import org.eclipse.jgit.attributes.AttributesNode;
+import org.eclipse.jgit.attributes.AttributesRule;
import org.eclipse.jgit.diff.RawText;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheEntry;
/** If there is a .gitignore file present, the parsed rules from it. */
private IgnoreNode ignoreNode;
+ /** If there is a .gitattributes file present, the parsed rules from it. */
+ private AttributesNode attributesNode;
+
/** Repository that is the root level being iterated over */
protected Repository repository;
/** The offset of the content id in {@link #idBuffer()} */
private int contentIdOffset;
+ /**
+ * Holds the {@link AttributesNode} that is stored in
+ * $GIT_DIR/info/attributes file.
+ */
+ private AttributesNode infoAttributeNode;
+
+ /**
+ * Holds the {@link AttributesNode} that is stored in global attribute file.
+ *
+ * @see CoreConfig#getAttributesFile()
+ */
+ private AttributesNode globalAttributeNode;
+
/**
* Create a new iterator with no parent.
*
protected WorkingTreeIterator(final WorkingTreeIterator p) {
super(p);
state = p.state;
+ infoAttributeNode = p.infoAttributeNode;
+ globalAttributeNode = p.globalAttributeNode;
}
/**
else
entry = null;
ignoreNode = new RootIgnoreNode(entry, repo);
+
+ infoAttributeNode = new InfoAttributesNode(repo);
+
+ globalAttributeNode = new GlobalAttributesNode(repo);
}
/**
return ignoreNode;
}
+ /**
+ * Retrieves the {@link AttributesNode} for the current entry.
+ *
+ * @return {@link AttributesNode} for the current entry.
+ * @throws IOException
+ * if an error is raised while parsing the .gitattributes file
+ * @since 3.7
+ */
+ public AttributesNode getEntryAttributesNode() throws IOException {
+ if (attributesNode instanceof PerDirectoryAttributesNode)
+ attributesNode = ((PerDirectoryAttributesNode) attributesNode)
+ .load();
+ return attributesNode;
+ }
+
+ /**
+ * Retrieves the {@link AttributesNode} that holds the information located
+ * in $GIT_DIR/info/attributes file.
+ *
+ * @return the {@link AttributesNode} that holds the information located in
+ * $GIT_DIR/info/attributes file.
+ * @throws IOException
+ * if an error is raised while parsing the attributes file
+ * @since 3.7
+ */
+ public AttributesNode getInfoAttributesNode() throws IOException {
+ if (infoAttributeNode instanceof InfoAttributesNode)
+ infoAttributeNode = ((InfoAttributesNode) infoAttributeNode).load();
+ return infoAttributeNode;
+ }
+
+ /**
+ * Retrieves the {@link AttributesNode} that holds the information located
+ * in system-wide file.
+ *
+ * @return the {@link AttributesNode} that holds the information located in
+ * system-wide file.
+ * @throws IOException
+ * IOException if an error is raised while parsing the
+ * attributes file
+ * @see CoreConfig#getAttributesFile()
+ * @since 3.7
+ */
+ public AttributesNode getGlobalAttributesNode() throws IOException {
+ if (globalAttributeNode instanceof GlobalAttributesNode)
+ globalAttributeNode = ((GlobalAttributesNode) globalAttributeNode)
+ .load();
+ return globalAttributeNode;
+ }
+
private static final Comparator<Entry> ENTRY_CMP = new Comparator<Entry>() {
public int compare(final Entry o1, final Entry o2) {
final byte[] a = o1.encodedName;
continue;
if (Constants.DOT_GIT_IGNORE.equals(name))
ignoreNode = new PerDirectoryIgnoreNode(e);
+ if (Constants.DOT_GIT_ATTRIBUTES.equals(name))
+ attributesNode = new PerDirectoryAttributesNode(e);
if (i != o)
entries[o] = e;
e.encodeName(nameEncoder);
}
}
+ /** Magic type indicating we know rules exist, but they aren't loaded. */
+ private static class PerDirectoryAttributesNode extends AttributesNode {
+ final Entry entry;
+
+ PerDirectoryAttributesNode(Entry entry) {
+ super(Collections.<AttributesRule> emptyList());
+ this.entry = entry;
+ }
+
+ AttributesNode load() throws IOException {
+ AttributesNode r = new AttributesNode();
+ InputStream in = entry.openInputStream();
+ try {
+ r.parse(in);
+ } finally {
+ in.close();
+ }
+ return r.getRules().isEmpty() ? null : r;
+ }
+ }
+
+ /**
+ * Attributes node loaded from global system-wide file.
+ */
+ private static class GlobalAttributesNode extends AttributesNode {
+ final Repository repository;
+
+ GlobalAttributesNode(Repository repository) {
+ this.repository = repository;
+ }
+
+ AttributesNode load() throws IOException {
+ AttributesNode r = new AttributesNode();
+
+ FS fs = repository.getFS();
+ String path = repository.getConfig().get(CoreConfig.KEY)
+ .getAttributesFile();
+ if (path != null) {
+ File attributesFile;
+ if (path.startsWith("~/")) //$NON-NLS-1$
+ attributesFile = fs.resolve(fs.userHome(),
+ path.substring(2));
+ else
+ attributesFile = fs.resolve(null, path);
+ loadRulesFromFile(r, attributesFile);
+ }
+ return r.getRules().isEmpty() ? null : r;
+ }
+ }
+
+ /** Magic type indicating there may be rules for the top level. */
+ private static class InfoAttributesNode extends AttributesNode {
+ final Repository repository;
+
+ InfoAttributesNode(Repository repository) {
+ this.repository = repository;
+ }
+
+ AttributesNode load() throws IOException {
+ AttributesNode r = new AttributesNode();
+
+ FS fs = repository.getFS();
+
+ File attributes = fs.resolve(repository.getDirectory(),
+ "info/attributes"); //$NON-NLS-1$
+ loadRulesFromFile(r, attributes);
+
+ return r.getRules().isEmpty() ? null : r;
+ }
+
+ }
+
+ private static void loadRulesFromFile(AttributesNode r, File attrs)
+ throws FileNotFoundException, IOException {
+ if (attrs.exists()) {
+ FileInputStream in = new FileInputStream(attrs);
+ try {
+ r.parse(in);
+ } finally {
+ in.close();
+ }
+ }
+ }
+
private static final class IteratorState {
/** Options used to process the working tree. */
final WorkingTreeOptions options;
projects / jgit.git / commitdiff