diff --git a/.gitignore b/.gitignore index e69de29..66bd6b3 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1 @@ +/guice-2.0-1219.tar.xz diff --git a/0001-aop-fix.patch b/0001-aop-fix.patch new file mode 100644 index 0000000..e7f1e95 --- /dev/null +++ b/0001-aop-fix.patch @@ -0,0 +1,42 @@ +From 7af563b4004f9b450a4cabb66bfb529a54437b7f Mon Sep 17 00:00:00 2001 +From: Stanislav Ochotnicky +Date: Thu, 7 Oct 2010 14:35:14 +0200 +Subject: [PATCH 1/3] aop-fix + +--- + .../google/inject/internal/ConstructionProxy.java | 3 +++ + .../internal/DefaultConstructionProxyFactory.java | 2 ++ + 2 files changed, 5 insertions(+), 0 deletions(-) + +diff --git a/src/com/google/inject/internal/ConstructionProxy.java b/src/com/google/inject/internal/ConstructionProxy.java +index 930d660..b63f6c8 100644 +--- a/src/com/google/inject/internal/ConstructionProxy.java ++++ b/src/com/google/inject/internal/ConstructionProxy.java +@@ -22,7 +22,10 @@ import java.lang.reflect.Constructor; + import java.lang.reflect.InvocationTargetException; + import java.lang.reflect.Method; + import java.util.List; ++ ++/*if[AOP]*/ + import org.aopalliance.intercept.MethodInterceptor; ++/*end[AOP]*/ + + /** + * Proxies calls to a {@link java.lang.reflect.Constructor} for a class +diff --git a/src/com/google/inject/internal/DefaultConstructionProxyFactory.java b/src/com/google/inject/internal/DefaultConstructionProxyFactory.java +index c654bbc..bad7ccd 100644 +--- a/src/com/google/inject/internal/DefaultConstructionProxyFactory.java ++++ b/src/com/google/inject/internal/DefaultConstructionProxyFactory.java +@@ -24,7 +24,9 @@ import java.lang.reflect.InvocationTargetException; + import java.lang.reflect.Method; + import java.lang.reflect.Modifier; + import java.util.List; ++/*if[AOP]*/ + import org.aopalliance.intercept.MethodInterceptor; ++/*end[AOP]*/ + + /** + * Produces construction proxies that invoke the class constructor. +-- +1.7.2.3 + diff --git a/0002-get-type-converter-binding.patch b/0002-get-type-converter-binding.patch new file mode 100644 index 0000000..45469f1 --- /dev/null +++ b/0002-get-type-converter-binding.patch @@ -0,0 +1,492 @@ +From 04db80a7bc5d783404caae072dc9708f59aaf0cf Mon Sep 17 00:00:00 2001 +From: Stanislav Ochotnicky +Date: Thu, 7 Oct 2010 14:41:14 +0200 +Subject: [PATCH 2/3] get type converter binding + +--- + src/com/google/inject/Injector.java | 10 ++++ + src/com/google/inject/internal/Errors.java | 19 ++++--- + .../google/inject/internal/InheritingState.java | 15 +++--- + src/com/google/inject/internal/InjectorImpl.java | 31 ++++++++--- + .../inject/internal/InternalInjectorCreator.java | 4 ++ + .../inject/internal/MatcherAndConverter.java | 56 -------------------- + src/com/google/inject/internal/State.java | 15 +++--- + .../internal/TypeConverterBindingProcessor.java | 6 +- + .../inject/spi/ConvertedConstantBinding.java | 7 ++- + .../google/inject/spi/TypeConverterBinding.java | 7 ++- + test/com/google/inject/TypeConversionTest.java | 10 ++++ + 11 files changed, 87 insertions(+), 93 deletions(-) + delete mode 100644 src/com/google/inject/internal/MatcherAndConverter.java + +diff --git a/src/com/google/inject/Injector.java b/src/com/google/inject/Injector.java +index 64b584e..eff67ad 100644 +--- a/src/com/google/inject/Injector.java ++++ b/src/com/google/inject/Injector.java +@@ -20,6 +20,8 @@ import java.lang.annotation.Annotation; + import java.util.List; + import java.util.Map; + ++import com.google.inject.spi.TypeConverterBinding; ++ + /** + * Builds the graphs of objects that make up your application. The injector tracks the dependencies + * for each type and uses bindings to inject them. This is the core of Guice, although you rarely +@@ -247,4 +249,12 @@ public interface Injector { + * @since 3.0 + */ + Map, Scope> getScopeBindings(); ++ ++ /** ++ * Returns a list containing all type converter bindings in the injector. The returned list ++ * is immutable. ++ * ++ *

This method is part of the Guice SPI and is intended for use by tools and extensions. ++ */ ++ List getTypeConverterBindings(); + } +diff --git a/src/com/google/inject/internal/Errors.java b/src/com/google/inject/internal/Errors.java +index 84fd96e..5baaa27 100644 +--- a/src/com/google/inject/internal/Errors.java ++++ b/src/com/google/inject/internal/Errors.java +@@ -33,6 +33,7 @@ import com.google.inject.spi.Dependency; + import com.google.inject.spi.InjectionListener; + import com.google.inject.spi.InjectionPoint; + import com.google.inject.spi.Message; ++import com.google.inject.spi.TypeConverterBinding; + import com.google.inject.spi.TypeListenerBinding; + import java.io.PrintWriter; + import java.io.Serializable; +@@ -51,7 +52,7 @@ import java.util.List; + + /** + * A collection of error messages. If this type is passed as a method parameter, the method is +- * considered to have executed succesfully only if new errors were not added to this collection. ++ * considered to have executed successfully only if new errors were not added to this collection. + * + *

Errors can be chained to provide additional context. To add context, call {@link #withSource} + * to create a new Errors instance that contains additional context. All messages added to the +@@ -135,30 +136,30 @@ public final class Errors implements Serializable { + } + + public Errors converterReturnedNull(String stringValue, Object source, +- TypeLiteral type, MatcherAndConverter matchingConverter) { ++ TypeLiteral type, TypeConverterBinding typeConverterBinding) { + return addMessage("Received null converting '%s' (bound at %s) to %s%n" + + " using %s.", +- stringValue, convert(source), type, matchingConverter); ++ stringValue, convert(source), type, typeConverterBinding); + } + + public Errors conversionTypeError(String stringValue, Object source, TypeLiteral type, +- MatcherAndConverter matchingConverter, Object converted) { ++ TypeConverterBinding typeConverterBinding, Object converted) { + return addMessage("Type mismatch converting '%s' (bound at %s) to %s%n" + + " using %s.%n" + + " Converter returned %s.", +- stringValue, convert(source), type, matchingConverter, converted); ++ stringValue, convert(source), type, typeConverterBinding, converted); + } + + public Errors conversionError(String stringValue, Object source, +- TypeLiteral type, MatcherAndConverter matchingConverter, RuntimeException cause) { ++ TypeLiteral type, TypeConverterBinding typeConverterBinding, RuntimeException cause) { + return errorInUserCode(cause, "Error converting '%s' (bound at %s) to %s%n" + + " using %s.%n" + + " Reason: %s", +- stringValue, convert(source), type, matchingConverter, cause); ++ stringValue, convert(source), type, typeConverterBinding, cause); + } + + public Errors ambiguousTypeConversion(String stringValue, Object source, TypeLiteral type, +- MatcherAndConverter a, MatcherAndConverter b) { ++ TypeConverterBinding a, TypeConverterBinding b) { + return addMessage("Multiple converters can convert '%s' (bound at %s) to %s:%n" + + " %s and%n" + + " %s.%n" +@@ -604,7 +605,7 @@ public final class Errors implements Serializable { + } + + boolean appliesTo(Object o) { +- return type.isAssignableFrom(o.getClass()); ++ return o != null && type.isAssignableFrom(o.getClass()); + } + + String convert(Object o) { +diff --git a/src/com/google/inject/internal/InheritingState.java b/src/com/google/inject/internal/InheritingState.java +index 4050b1e..288d875 100644 +--- a/src/com/google/inject/internal/InheritingState.java ++++ b/src/com/google/inject/internal/InheritingState.java +@@ -24,6 +24,7 @@ import com.google.inject.internal.util.ImmutableList; + import com.google.inject.internal.util.Lists; + import com.google.inject.internal.util.Maps; + import static com.google.inject.internal.util.Preconditions.checkNotNull; ++import com.google.inject.spi.TypeConverterBinding; + import com.google.inject.spi.TypeListenerBinding; + import java.lang.annotation.Annotation; + import java.util.ArrayList; +@@ -43,7 +44,7 @@ final class InheritingState implements State { + private final Map, Binding> explicitBindings + = Collections.unmodifiableMap(explicitBindingsMutable); + private final Map, Scope> scopes = Maps.newHashMap(); +- private final List converters = Lists.newArrayList(); ++ private final List converters = Lists.newArrayList(); + /*if[AOP]*/ + private final List methodAspects = Lists.newArrayList(); + /*end[AOP]*/ +@@ -83,19 +84,19 @@ final class InheritingState implements State { + scopes.put(annotationType, scope); + } + +- public Iterable getConvertersThisLevel() { ++ public List getConvertersThisLevel() { + return converters; + } + +- public void addConverter(MatcherAndConverter matcherAndConverter) { +- converters.add(matcherAndConverter); ++ public void addConverter(TypeConverterBinding typeConverterBinding) { ++ converters.add(typeConverterBinding); + } + +- public MatcherAndConverter getConverter( ++ public TypeConverterBinding getConverter( + String stringValue, TypeLiteral type, Errors errors, Object source) { +- MatcherAndConverter matchingConverter = null; ++ TypeConverterBinding matchingConverter = null; + for (State s = this; s != State.NONE; s = s.parent()) { +- for (MatcherAndConverter converter : s.getConvertersThisLevel()) { ++ for (TypeConverterBinding converter : s.getConvertersThisLevel()) { + if (converter.getTypeMatcher().matches(type)) { + if (matchingConverter != null) { + errors.ambiguousTypeConversion(stringValue, source, type, matchingConverter, converter); +diff --git a/src/com/google/inject/internal/InjectorImpl.java b/src/com/google/inject/internal/InjectorImpl.java +index ab8e281..73ad4d3 100644 +--- a/src/com/google/inject/internal/InjectorImpl.java ++++ b/src/com/google/inject/internal/InjectorImpl.java +@@ -45,6 +45,7 @@ import com.google.inject.spi.Dependency; + import com.google.inject.spi.HasDependencies; + import com.google.inject.spi.InjectionPoint; + import com.google.inject.spi.ProviderBinding; ++import com.google.inject.spi.TypeConverterBinding; + import com.google.inject.util.Providers; + import java.lang.annotation.Annotation; + import java.lang.reflect.GenericArrayType; +@@ -376,9 +377,9 @@ final class InjectorImpl implements Injector, Lookups { + + // Find a matching type converter. + TypeLiteral type = key.getTypeLiteral(); +- MatcherAndConverter matchingConverter = state.getConverter(stringValue, type, errors, source); ++ TypeConverterBinding typeConverterBinding = state.getConverter(stringValue, type, errors, source); + +- if (matchingConverter == null) { ++ if (typeConverterBinding == null) { + // No converter can handle the given type. + return null; + } +@@ -386,23 +387,24 @@ final class InjectorImpl implements Injector, Lookups { + // Try to convert the string. A failed conversion results in an error. + try { + @SuppressWarnings("unchecked") // This cast is safe because we double check below. +- T converted = (T) matchingConverter.getTypeConverter().convert(stringValue, type); ++ T converted = (T) typeConverterBinding.getTypeConverter().convert(stringValue, type); + + if (converted == null) { +- throw errors.converterReturnedNull(stringValue, source, type, matchingConverter) ++ throw errors.converterReturnedNull(stringValue, source, type, typeConverterBinding) + .toException(); + } + + if (!type.getRawType().isInstance(converted)) { +- throw errors.conversionTypeError(stringValue, source, type, matchingConverter, converted) ++ throw errors.conversionTypeError(stringValue, source, type, typeConverterBinding, converted) + .toException(); + } + +- return new ConvertedConstantBindingImpl(this, key, converted, stringBinding); ++ return new ConvertedConstantBindingImpl(this, key, converted, stringBinding, ++ typeConverterBinding); + } catch (ErrorsException e) { + throw e; + } catch (RuntimeException e) { +- throw errors.conversionError(stringValue, source, type, matchingConverter, e) ++ throw errors.conversionError(stringValue, source, type, typeConverterBinding, e) + .toException(); + } + } +@@ -412,14 +414,17 @@ final class InjectorImpl implements Injector, Lookups { + final T value; + final Provider provider; + final Binding originalBinding; ++ final TypeConverterBinding typeConverterBinding; + + ConvertedConstantBindingImpl( +- InjectorImpl injector, Key key, T value, Binding originalBinding) { ++ InjectorImpl injector, Key key, T value, Binding originalBinding, ++ TypeConverterBinding typeConverterBinding) { + super(injector, key, originalBinding.getSource(), + new ConstantFactory(Initializables.of(value)), Scoping.UNSCOPED); + this.value = value; + provider = Providers.of(value); + this.originalBinding = originalBinding; ++ this.typeConverterBinding = typeConverterBinding; + } + + @Override public Provider getProvider() { +@@ -434,6 +439,10 @@ final class InjectorImpl implements Injector, Lookups { + return value; + } + ++ public TypeConverterBinding getTypeConverterBinding() { ++ return typeConverterBinding; ++ } ++ + public Key getSourceKey() { + return originalBinding.getKey(); + } +@@ -828,7 +837,11 @@ final class InjectorImpl implements Injector, Lookups { + } + + public Map, Scope> getScopeBindings() { +- return state.getScopes(); ++ return Collections.unmodifiableMap(state.getScopes()); ++ } ++ ++ public List getTypeConverterBindings() { ++ return Collections.unmodifiableList(state.getConvertersThisLevel()); + } + + private static class BindingsMultimap { +diff --git a/src/com/google/inject/internal/InternalInjectorCreator.java b/src/com/google/inject/internal/InternalInjectorCreator.java +index 44f0065..5c6d9e0 100644 +--- a/src/com/google/inject/internal/InternalInjectorCreator.java ++++ b/src/com/google/inject/internal/InternalInjectorCreator.java +@@ -25,6 +25,7 @@ import com.google.inject.Provider; + import com.google.inject.Scope; + import com.google.inject.Stage; + import com.google.inject.TypeLiteral; ++import com.google.inject.spi.TypeConverterBinding; + import com.google.inject.internal.util.ImmutableSet; + import com.google.inject.internal.util.Iterables; + import com.google.inject.internal.util.Stopwatch; +@@ -287,6 +288,9 @@ public final class InternalInjectorCreator { + public Map, Scope> getScopeBindings() { + return delegateInjector.getScopeBindings(); + } ++ public List getTypeConverterBindings() { ++ return delegateInjector.getTypeConverterBindings(); ++ } + public Provider getProvider(Key key) { + throw new UnsupportedOperationException( + "Injector.getProvider(Key) is not supported in Stage.TOOL"); +diff --git a/src/com/google/inject/internal/MatcherAndConverter.java b/src/com/google/inject/internal/MatcherAndConverter.java +deleted file mode 100644 +index b618b3f..0000000 +--- a/src/com/google/inject/internal/MatcherAndConverter.java ++++ /dev/null +@@ -1,56 +0,0 @@ +-/* +- * Copyright (C) 2007 Google Inc. +- * +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- */ +- +-package com.google.inject.internal; +- +-import com.google.inject.TypeLiteral; +-import static com.google.inject.internal.util.Preconditions.checkNotNull; +-import com.google.inject.matcher.Matcher; +-import com.google.inject.spi.TypeConverter; +- +-/** +- * @author crazybob@google.com (Bob Lee) +- */ +-final class MatcherAndConverter { +- +- private final Matcher> typeMatcher; +- private final TypeConverter typeConverter; +- private final Object source; +- +- public MatcherAndConverter(Matcher> typeMatcher, +- TypeConverter typeConverter, Object source) { +- this.typeMatcher = checkNotNull(typeMatcher, "type matcher"); +- this.typeConverter = checkNotNull(typeConverter, "converter"); +- this.source = source; +- } +- +- public TypeConverter getTypeConverter() { +- return typeConverter; +- } +- +- public Matcher> getTypeMatcher() { +- return typeMatcher; +- } +- +- public Object getSource() { +- return source; +- } +- +- @Override public String toString() { +- return typeConverter + " which matches " + typeMatcher +- + " (bound at " + source + ")"; +- } +-} +diff --git a/src/com/google/inject/internal/State.java b/src/com/google/inject/internal/State.java +index 4bf8025..743092b 100644 +--- a/src/com/google/inject/internal/State.java ++++ b/src/com/google/inject/internal/State.java +@@ -20,6 +20,7 @@ import com.google.inject.Binding; + import com.google.inject.Key; + import com.google.inject.Scope; + import com.google.inject.TypeLiteral; ++import com.google.inject.spi.TypeConverterBinding; + import com.google.inject.internal.util.ImmutableList; + import com.google.inject.internal.util.ImmutableMap; + import com.google.inject.internal.util.ImmutableSet; +@@ -61,17 +62,17 @@ interface State { + throw new UnsupportedOperationException(); + } + +- public void addConverter(MatcherAndConverter matcherAndConverter) { ++ public void addConverter(TypeConverterBinding typeConverterBinding) { + throw new UnsupportedOperationException(); + } + +- public MatcherAndConverter getConverter(String stringValue, TypeLiteral type, Errors errors, ++ public TypeConverterBinding getConverter(String stringValue, TypeLiteral type, Errors errors, + Object source) { + throw new UnsupportedOperationException(); + } + +- public Iterable getConvertersThisLevel() { +- return ImmutableSet.of(); ++ public List getConvertersThisLevel() { ++ return ImmutableList.of(); + } + + /*if[AOP]*/ +@@ -123,14 +124,14 @@ interface State { + + void putAnnotation(Class annotationType, Scope scope); + +- void addConverter(MatcherAndConverter matcherAndConverter); ++ void addConverter(TypeConverterBinding typeConverterBinding); + + /** Returns the matching converter for {@code type}, or null if none match. */ +- MatcherAndConverter getConverter( ++ TypeConverterBinding getConverter( + String stringValue, TypeLiteral type, Errors errors, Object source); + + /** Returns all converters at this level only. */ +- Iterable getConvertersThisLevel(); ++ List getConvertersThisLevel(); + + /*if[AOP]*/ + void addMethodAspect(MethodAspect methodAspect); +diff --git a/src/com/google/inject/internal/TypeConverterBindingProcessor.java b/src/com/google/inject/internal/TypeConverterBindingProcessor.java +index 1f10349..ceb0657 100644 +--- a/src/com/google/inject/internal/TypeConverterBindingProcessor.java ++++ b/src/com/google/inject/internal/TypeConverterBindingProcessor.java +@@ -161,12 +161,12 @@ final class TypeConverterBindingProcessor extends AbstractProcessor { + private void internalConvertToTypes(Matcher> typeMatcher, + TypeConverter converter) { + injector.state.addConverter( +- new MatcherAndConverter(typeMatcher, converter, SourceProvider.UNKNOWN_SOURCE)); ++ new TypeConverterBinding(SourceProvider.UNKNOWN_SOURCE, typeMatcher, converter)); + } + + @Override public Boolean visit(TypeConverterBinding command) { +- injector.state.addConverter(new MatcherAndConverter( +- command.getTypeMatcher(), command.getTypeConverter(), command.getSource())); ++ injector.state.addConverter(new TypeConverterBinding( ++ command.getSource(), command.getTypeMatcher(), command.getTypeConverter())); + return true; + } + } +diff --git a/src/com/google/inject/spi/ConvertedConstantBinding.java b/src/com/google/inject/spi/ConvertedConstantBinding.java +index 6c78acb..285ca30 100644 +--- a/src/com/google/inject/spi/ConvertedConstantBinding.java ++++ b/src/com/google/inject/spi/ConvertedConstantBinding.java +@@ -35,6 +35,11 @@ public interface ConvertedConstantBinding extends Binding, HasDependencies + T getValue(); + + /** ++ * Returns the type converter binding used to convert the constant. ++ */ ++ TypeConverterBinding getTypeConverterBinding(); ++ ++ /** + * Returns the key for the source binding. That binding can e retrieved from an injector using + * {@link com.google.inject.Injector#getBinding(Key) Injector.getBinding(key)}. + */ +@@ -44,4 +49,4 @@ public interface ConvertedConstantBinding extends Binding, HasDependencies + * Returns a singleton set containing only the converted key. + */ + Set> getDependencies(); +-} +\ No newline at end of file ++} +diff --git a/src/com/google/inject/spi/TypeConverterBinding.java b/src/com/google/inject/spi/TypeConverterBinding.java +index 74f7c73..9564715 100644 +--- a/src/com/google/inject/spi/TypeConverterBinding.java ++++ b/src/com/google/inject/spi/TypeConverterBinding.java +@@ -36,7 +36,7 @@ public final class TypeConverterBinding implements Element { + private final Matcher> typeMatcher; + private final TypeConverter typeConverter; + +- TypeConverterBinding(Object source, Matcher> typeMatcher, ++ public TypeConverterBinding(Object source, Matcher> typeMatcher, + TypeConverter typeConverter) { + this.source = checkNotNull(source, "source"); + this.typeMatcher = checkNotNull(typeMatcher, "typeMatcher"); +@@ -62,4 +62,9 @@ public final class TypeConverterBinding implements Element { + public void applyTo(Binder binder) { + binder.withSource(getSource()).convertToTypes(typeMatcher, typeConverter); + } ++ ++ @Override public String toString() { ++ return typeConverter + " which matches " + typeMatcher ++ + " (bound at " + source + ")"; ++ } + } +diff --git a/test/com/google/inject/TypeConversionTest.java b/test/com/google/inject/TypeConversionTest.java +index ead3c99..3d57d31 100644 +--- a/test/com/google/inject/TypeConversionTest.java ++++ b/test/com/google/inject/TypeConversionTest.java +@@ -19,7 +19,9 @@ package com.google.inject; + import static com.google.inject.Asserts.assertContains; + import com.google.inject.internal.util.Iterables; + import com.google.inject.matcher.Matchers; ++import com.google.inject.spi.ConvertedConstantBinding; + import com.google.inject.spi.TypeConverter; ++import com.google.inject.spi.TypeConverterBinding; + import java.lang.annotation.Retention; + import static java.lang.annotation.RetentionPolicy.RUNTIME; + import java.util.Date; +@@ -209,6 +211,14 @@ public class TypeConversionTest extends TestCase { + }); + + assertSame(result, injector.getInstance(DateHolder.class).date); ++ ++ Binding binding = injector.getBinding(Key.get(Date.class, NumericValue.class)); ++ assertTrue(binding instanceof ConvertedConstantBinding); ++ ++ TypeConverterBinding converterBinding = ((ConvertedConstantBinding)binding).getTypeConverterBinding(); ++ assertEquals("CustomConverter", converterBinding.getTypeConverter().toString()); ++ ++ assertTrue(injector.getTypeConverterBindings().contains(converterBinding)); + } + + public void testInvalidCustomValue() throws CreationException { +-- +1.7.2.3 + diff --git a/0003-aopaliance.patch b/0003-aopaliance.patch new file mode 100644 index 0000000..36183c9 --- /dev/null +++ b/0003-aopaliance.patch @@ -0,0 +1,41 @@ +From cb1aa0aaf482bccfb732f4e304103a138c749e28 Mon Sep 17 00:00:00 2001 +From: Stanislav Ochotnicky +Date: Thu, 7 Oct 2010 14:50:39 +0200 +Subject: [PATCH 3/3] aopaliance + +--- + pom.xml | 12 ++---------- + 1 files changed, 2 insertions(+), 10 deletions(-) + +diff --git a/pom.xml b/pom.xml +index 79326a3..2be2a10 100644 +--- a/pom.xml ++++ b/pom.xml +@@ -2,22 +2,14 @@ + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> + 4.0.0 +- +- com.google.inject +- guice-parent +- 3.0-SNAPSHOT +- guice-parent/pom.xml +- ++ com.google.inject ++ 3.0-SNAPSHOT + guice + jar + Google Guice: Core + + + +- +- aopalliance +- aopalliance +- + + +-- +1.7.2.3 + diff --git a/google-guice.spec b/google-guice.spec new file mode 100644 index 0000000..bb1ca1d --- /dev/null +++ b/google-guice.spec @@ -0,0 +1,181 @@ +%global short_name guice +%global revision 1219 + +Name: google-%{short_name} +Version: 2.0 +Release: 2.1219svn%{?dist} +Summary: Lightweight dependency injection framework + + +Group: Development/Tools +License: ASL 2.0 +URL: http://code.google.com/p/%{name} + +# svn export -r1219 http://google-guice.googlecode.com/svn/trunk/ guice-2.0-1219 +# tar caf guice-2.0-1219.tar.xz guice-2.0-1219 +Source0: %{short_name}-%{version}-%{revision}.tar.xz + +# TODO upstream +Patch0: 0001-aop-fix.patch +# see http://code.google.com/p/google-guice/issues/detail?id=436 +# needed for sisu-inject (and maven-3) +Patch1: 0002-get-type-converter-binding.patch +# remove aopalliacne dep from pom and parent pom +Patch2: 0003-aopaliance.patch + +BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) + +BuildArch: noarch + +BuildRequires: ant +BuildRequires: jarjar => 1.0 +BuildRequires: cglib +BuildRequires: aqute-bndlib +BuildRequires: objectweb-asm +BuildRequires: junit +BuildRequires: atinject + +Requires: java >= 1:1.6.0 +Requires(post): jpackage-utils +Requires(postun): jpackage-utils + +%description +Put simply, Guice alleviates the need for factories and the use of new +in your Java code. Think of Guice's @Inject as the new new. You will +still need to write factories in some cases, but your code will not +depend directly on them. Your code will be easier to change, unit test +and reuse in other contexts. + +Guice embraces Java's type safe nature, especially when it comes to +features introduced in Java 5 such as generics and annotations. You +might think of Guice as filling in missing features for core +Java. Ideally, the language itself would provide most of the same +features, but until such a language comes along, we have Guice. + +Guice helps you design better APIs, and the Guice API itself sets a +good example. Guice is not a kitchen sink. We justify each feature +with at least three use cases. When in doubt, we leave it out. We +build general functionality which enables you to extend Guice rather +than adding every feature to the core framework. + +%package javadoc +Summary: API documentation for %{name} +Group: Documentation +Requires: jpackage-utils + +%description javadoc +%{summary}. + +%prep +%setup -q -n %{short_name}-%{version}-%{revision} +%patch0 -p1 +%patch1 -p1 +%patch2 -p1 + +# remove bundled libraries +find . -name '*.class' -delete +find . -name '*.bar' -delete +# we'll repack munge.jar so don't delete it just yet +find . -name '*.jar' -not -name 'munge.jar' -delete + +# re-create symlinks +pushd lib/build +build-jar-repository -s -p . aqute-bndlib cglib \ + jarjar junit objectweb-asm \ + +mv aqute-bndlib*.jar bnd-0.0.384.jar +mv cglib*.jar cglib-2.2.1-snapshot.jar +mv jarjar*.jar jarjar-1.0rc8.jar +mv objectweb-asmasm-all.jar asm-3.1.jar + +popd +ln -sf `build-classpath atinject` lib/javax.inject.jar + +# there is munge.jar defining ant task it's a mixture of files, but +# there are sources in jar so we re-compile the jar to verify it +# builds +mkdir munge-repack +unzip lib/build/munge.jar -d munge-repack +rm lib/build/munge.jar + +pushd munge-repack +rm *.class +javac -cp `build-classpath ant junit` *.java +zip -r ../lib/build/munge.jar . +popd + +rm -rf munge-repack +#end munge.jar repack + +%build +# create no-aop build environment +ant no_aop + +pushd build/no_aop/ +# javadoc fails without this directory +mkdir -p servlet/lib/build + +ant -Dversion=%{version} jar javadoc +popd + +%install +rm -rf $RPM_BUILD_ROOT + +install -d -m 0755 $RPM_BUILD_ROOT%{_javadir} +pushd build/no_aop +install -pm 644 build/dist/%{short_name}-%{version}.jar $RPM_BUILD_ROOT%{_javadir}/%{name}-%{version}.jar +(cd $RPM_BUILD_ROOT%{_javadir} && for jar in *-%{version}*; do ln -sf ${jar} `echo $jar| sed "s|google-||g"`; done) +(cd $RPM_BUILD_ROOT%{_javadir} && for jar in *-%{version}*; do ln -sf ${jar} `echo $jar| sed "s|-%{version}||g"`; done) + +install -d -m 755 $RPM_BUILD_ROOT%{_mavenpomdir} +install -pm 644 %{short_name}-parent/pom.xml $RPM_BUILD_ROOT/%{_mavenpomdir}/JPP-%{short_name}-parent.pom + +install -pm 644 pom.xml $RPM_BUILD_ROOT/%{_mavenpomdir}/JPP-%{name}.pom +%add_to_maven_depmap com.google.inject %{short_name} %{version} JPP %{name} +# provide sisu group/artifact (should be just mavenized google-guice +# with +%add_to_maven_depmap org.sonatype.sisu sisu-%{short_name} %{version} JPP %{name} + + +# javadoc +install -d -m 0755 $RPM_BUILD_ROOT%{_javadocdir}/%{name}-%{version} +cp -pr build/javadoc/* %{buildroot}%{_javadocdir}/%{name}-%{version}/ +ln -s %{name}-%{version} %{buildroot}%{_javadocdir}/%{name} + + + +%clean +rm -rf $RPM_BUILD_ROOT + +%post +%update_maven_depmap + +%postun +%update_maven_depmap + + +%files +%defattr(-,root,root,-) +%doc COPYING +%{_javadir}/*.jar +%{_mavenpomdir}/* +%{_mavendepmapfragdir}/* + + +%files javadoc +%defattr(-,root,root,-) +%doc COPYING +%doc %{_javadocdir}/%{name}* + + + +%changelog +* Wed Oct 13 2010 Stanislav Ochotnicky - 2.0-2.1219svn +- Moved munge repacking to prep +- Added -Dversion to change generated manifest version +- Removed http part of URL + +* Thu Oct 7 2010 Stanislav Ochotnicky - 2.0-1.1219svn +- Initial version of the package + + diff --git a/sources b/sources index e69de29..dd6bba4 100644 --- a/sources +++ b/sources @@ -0,0 +1 @@ +8c63986768946922fcb7647b4bd5c9c9 guice-2.0-1219.tar.xz