Attachment #64115 for bug #138846

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 138846
Collapse All | Expand All

Lines 39-45 Link Here

(-)a/o.n.core/test/unit/src/org/netbeans/core/filesystems/ArchiveURLMapperTest.java (-1 / +1 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.core.filesystems;	42	package org.netbeans.core.startup.layers;
43		43
44	import java.io.File;	44	import java.io.File;
45	import java.io.FileOutputStream;	45	import java.io.FileOutputStream;




 * made subject to such option by the copyright holder.
 */

package org.netbeans.core.startup.layers;

import java.io.BufferedReader;
import java.io.File;

import java.net.URL;
import java.net.URLConnection;
import java.util.StringTokenizer;
import org.netbeans.core.startup.layers.NbinstURLMapper;
import org.netbeans.core.startup.layers.NbinstURLStreamHandlerFactory;
import org.netbeans.junit.MockServices;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.masterfs.MasterURLMapper;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.URLMapper;

        super (testName);
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        
        MockServices.setServices(
                TestInstalledFileLocator.class,
                NbinstURLStreamHandlerFactory.class,
                NbinstURLMapper.class);
                MasterURLMapper.class);

        org.netbeans.core.startup.Main.initializeURLFactory ();
        

Lines 118-124 Link Here

(-)a/core.ui/nbproject/project.xml (-1 / +1 lines)
118	<build-prerequisite/>	118	<build-prerequisite/>
119	<compile-dependency/>	119	<compile-dependency/>
120	<run-dependency>	120	<run-dependency>
121	<specification-version>7.7</specification-version>	121	<implementation-version/>
122	</run-dependency>	122	</run-dependency>
123	</dependency>	123	</dependency>
124	<dependency>	124	<dependency>

Lines 50-65 Link Here

(-)a/core.ui/src/org/netbeans/core/ui/options/filetypes/FileAssociationsModel.java (-15 / +25 lines)
50	import java.util.TreeSet;	50	import java.util.TreeSet;
51	import java.util.logging.Level;	51	import java.util.logging.Level;
52	import java.util.logging.Logger;	52	import java.util.logging.Logger;
53	import org.netbeans.core.LoaderPoolNode;	53	import org.netbeans.modules.openide.filesystems.declmime.MIMEResolverImpl;
		54	import org.openide.filesystems.FileChangeAdapter;
		55	import org.openide.filesystems.FileChangeListener;
		56	import org.openide.filesystems.FileEvent;
54	import org.openide.filesystems.FileObject;	57	import org.openide.filesystems.FileObject;
		58	import org.openide.filesystems.FileRenameEvent;
55	import org.openide.filesystems.FileSystem;	59	import org.openide.filesystems.FileSystem;
56	import org.openide.filesystems.FileUtil;	60	import org.openide.filesystems.FileUtil;
57	import org.openide.filesystems.MIMEResolver;
58	import org.openide.filesystems.Repository;	61	import org.openide.filesystems.Repository;
59	import org.openide.loaders.DataLoader;	62	import org.openide.loaders.DataLoader;
60	import org.openide.util.Lookup;
61	import org.openide.util.LookupEvent;
62	import org.openide.util.LookupListener;
63	import org.openide.util.lookup.Lookups;	63	import org.openide.util.lookup.Lookups;
64	import org.openide.xml.XMLUtil;	64	import org.openide.xml.XMLUtil;
65	import org.w3c.dom.Document;	65	import org.w3c.dom.Document;
Lines 87-99 Link Here
87	/** Maps MIME type to MimeItem object which holds display name. */	87	/** Maps MIME type to MimeItem object which holds display name. */
88	private HashMap<String, MimeItem> mimeToItem = new HashMap<String, MimeItem>();	88	private HashMap<String, MimeItem> mimeToItem = new HashMap<String, MimeItem>();
89	private boolean initialized = false;	89	private boolean initialized = false;
90	private LookupListener lookupListener = new LookupListenerImpl();	90	private final FileChangeListener mimeResolversListener = new FileChangeAdapter() {
		91	public @Override void fileDeleted(FileEvent fe) {
		92	initialized = false;
		93	}
		94	public @Override void fileRenamed(FileRenameEvent fe) {
		95	initialized = false;
		96	}
		97	public @Override void fileDataCreated(FileEvent fe) {
		98	initialized = false;
		99	}
		100	public @Override void fileChanged(FileEvent fe) {
		101	initialized = false;
		102	}
		103	};
91	private FileObject userDefinedResolverFO;	104	private FileObject userDefinedResolverFO;
92		105
93	/** Creates new model. */	106	/** Creates new model. */
94	FileAssociationsModel() {	107	FileAssociationsModel() {
95	Lookup lookup = Lookups.forPath(MIME_RESOLVERS_PATH);	108	FileObject resolvers = Repository.getDefault().getDefaultFileSystem().findResource(MIME_RESOLVERS_PATH);
96	lookup.lookupResult(MIMEResolver.class).addLookupListener(lookupListener);	109	if (resolvers != null) {
		110	resolvers.addFileChangeListener(FileUtil.weakFileChangeListener(mimeResolversListener, resolvers));
		111	}
97	}	112	}
98		113
99	/** Returns true if model includes given extension. */	114	/** Returns true if model includes given extension. */
Lines 303-309 Link Here
303	if (userDefined) {	318	if (userDefined) {
304	userDefinedResolverFO = mimeResolverFO;	319	userDefinedResolverFO = mimeResolverFO;
305	}	320	}
306	ArrayList<String[]> extAndMimePairs = LoaderPoolNode.getExtensionsAndMIMETypes(mimeResolverFO);	321	assert mimeResolverFO.getPath().startsWith("Services/MIMEResolver"); //NOI18N
		322	ArrayList<String[]> extAndMimePairs = MIMEResolverImpl.getExtensionsAndMIMETypes(mimeResolverFO);
307	Iterator<String[]> iter = extAndMimePairs.iterator();	323	Iterator<String[]> iter = extAndMimePairs.iterator();
308	while (iter.hasNext()) {	324	while (iter.hasNext()) {
309	String[] pair = iter.next();	325	String[] pair = iter.next();
Lines 328-339 Link Here
328	}	344	}
329	LOGGER.fine("extensionToMimeSystem=" + extensionToMimeSystem); //NOI18N	345	LOGGER.fine("extensionToMimeSystem=" + extensionToMimeSystem); //NOI18N
330	LOGGER.fine("extensionToMimeUser=" + extensionToMimeUser); //NOI18N	346	LOGGER.fine("extensionToMimeUser=" + extensionToMimeUser); //NOI18N
331	}
332
333	private class LookupListenerImpl implements LookupListener {
334	public void resultChanged(LookupEvent ev) {
335	initialized = false;
336	}
337	}	347	}
338		348
339	/** To store MIME type and its loader display name. It is used in combo box. */	349	/** To store MIME type and its loader display name. It is used in combo box. */

Lines 45-52 Link Here

(-)a/o.n.core/src/org/netbeans/core/Bundle.properties (-2 lines)
45	This module provides the central infrastructure \	45	This module provides the central infrastructure \
46	that lets NetBeans-based applications run. \	46	that lets NetBeans-based applications run. \
47	It cannot be disabled.	47	It cannot be disabled.
48
49	Services/MIMEResolver=File Types
50		48
51	#DataSystem	49	#DataSystem
52	dataSystemName=All Files	50	dataSystemName=All Files




import javax.swing.Action;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.core.filesystems.MIMEResolverImpl;
import org.netbeans.core.startup.ManifestSection;
import org.openide.actions.MoveDownAction;
import org.openide.actions.MoveUpAction;

import org.openide.util.LookupEvent;
import org.openide.util.LookupListener;
import org.openide.util.NbBundle;
import org.openide.util.NotImplementedException;
import org.openide.util.RequestProcessor;
import org.openide.util.TopologicalSortException;
import org.openide.util.Utilities;

    }
    private static NbLoaderPool nbLoaderPool = null;

    /** Returns list of extension and MIME type pairs for given MIMEResolver
     * FileObject. The list can contain duplicates and also [null, MIME] pairs.
     * @param fo MIMEResolver FileObject
     * @return list of extension and MIME type pairs. The list can contain 
     * duplicates and also [null, MIME] pairs.
     * @since 3.9
     */
    public static ArrayList<String[]> getExtensionsAndMIMETypes(FileObject fo) {
        return MIMEResolverImpl.getExtensionsAndMIMETypes(fo);
    }

    /***** Inner classes **************/

    /** Node representing one loader in Loader Pool */




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * Contributor(s):
 *
 * The Original Software is NetBeans. The Initial Developer of the Original
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
 * Microsystems, Inc. All Rights Reserved.
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 */

package org.netbeans.core.filesystems;

import java.io.*;
import java.util.*;

import org.xml.sax.*;
import org.xml.sax.helpers.*;

import org.openide.cookies.InstanceCookie;
import org.openide.loaders.*;
import org.openide.filesystems.*;
import org.openide.util.*;
import org.openide.util.lookup.*;
import org.openide.xml.*;
import org.openide.*;

/**
 * Default implementation providing Environment for XMLDataObject according to its
 * public ID.
 *
 * <p>
 * Subclass instance of this must be registered as <tt>FileEntityResolver</tt>
 * dictates and must implement <tt>Environment.Provider</tt> interface.
 *
 * <p>
 * It forever caches provided environment!
 *
 * @see     org.netbeans.core.xml.FileEntityResolver
 * @author  Petr Kuzel
 * @version 
 */
class XMLEnvironmentProvider extends SharedClassObject {

    private static final long serialVersionUID = 18947L;
    
    private static transient Map<FileObject, Lookup> envs = new HashMap<FileObject, Lookup>(11); // 11 expected number of modules using this
    
    // Environment.Provider ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    
    /** Returns a lookup that represents environment.
     * @return the lookup
     */
    public final Lookup getEnvironment(DataObject obj){
        
        // the obj check is done by core FileEntityResolver that calls us
        
        // we want to create just one instance per FileObject

        FileObject file = obj.getPrimaryFile();
        Lookup lookup = envs.get(file);
        if (lookup == null) {
            lookup = createLookup(obj);
            envs.put(file, lookup);
        }
        return lookup;
        
    }
    
    /**
     * It is called exactly once per DataObject.
     *
     * @return content of assigned Lookup
     */
    protected InstanceContent createInstanceContent(DataObject obj) {
        return new InstanceContent();
    }
    
    /**
     * It is called exactly once per DataObject.
     *
     * @return Lookup containing <tt>createInstanceContent()</tt>
     */
    protected Lookup createLookup(DataObject obj) {
        InstanceContent ic = createInstanceContent(obj);
        Lookup lookup = new AbstractLookup(ic);
        if (lookup.lookup(InstanceCookie.class) == null) {
            Exceptions.printStackTrace(new IllegalStateException());  // instance cookie required
        }
        return lookup;
    }
            
}




            </file>
        </folder>
    
        <folder name="MIMEResolver">
            <attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.core.Bundle" />
            <attr name="SystemFileSystem.icon" urlvalue="nbresloc:/org/netbeans/core/resources/mime.gif" />        
            <attr name="helpID" stringvalue="org.netbeans.core.filesystems.MIMEResolverImpl"/>
        </folder>

        <folder name="Hidden">
            <attr name="hidden" boolvalue="true" />
            <file name="HtmlBrowserFactoryEditorForGeneralOptionsPanel.instance">

                </file>

                <!-- Declarative MIME resolver -->
                <file name="DTD_MIME_Resolver_1_0" url="nbres:/org/netbeans/modules/openide/filesystems/declmime/resolver.dtd">
                    <attr name="hint.originalPublicID" stringvalue="-//NetBeans//DTD MIME Resolver 1.0//EN"/>
                </file>

                <file name="DTD_MIME_Resolver_XML_Rules_1_0" url="nbres:/org/netbeans/modules/openide/filesystems/declmime/xml-rules.dtd">
                    <attr name="hint.originalPublicID" stringvalue="-//NetBeans//DTD MIME Resolver XML Rules 1.0//EN"/>
                </file>            


                    <attr name="instanceClass" stringvalue="org.openide.loaders.XMLDataObject$Processor"/>
                    <attr name="instanceCreate" newvalue="org.netbeans.core.xml.EntityCatalogImpl$RegistrationProcessor" />
                </file>

                <!-- Environment.Provider for declarative MIME resolver XML documents. -->
                <file name="DTD_MIME_Resolver_1_0.instance">
                    <attr name="instanceClass" stringvalue="org.openide.loaders.Environment$Provider"/>
                    <attr name="instanceCreate" newvalue="org.netbeans.core.filesystems.MIMEResolverImpl"/>
                </file>
            </folder>
        </folder>
    </folder>




 * made subject to such option by the copyright holder.
 */

package org.netbeans.core;

import java.io.IOException;
import java.io.OutputStream;

import java.util.jar.Attributes;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.core.LoaderPoolNode;
import org.netbeans.core.startup.ManifestSection;
import org.openide.ErrorManager;
import org.openide.filesystems.FileObject;

 *
 * @author Jaroslav Tulach
 */
public class LoaderPoolNodeResolverChangeTest extends org.netbeans.core.LoggingTestCaseHid 
implements LookupListener, ChangeListener {
    private FileObject fo;
    private Lenka loader;

    private int poolChange;
    private static ErrorManager err;
    
    public LoaderPoolNodeResolverChangeTest(String testName) {
        super(testName);
    }


Lines 1-5 Link Here

(-)a/openide.filesystems/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.openide.filesystems	2	OpenIDE-Module: org.openide.filesystems
3	OpenIDE-Module-Specification-Version: 7.10	3	OpenIDE-Module-Implementation-Version: 1
4	OpenIDE-Module-Localizing-Bundle: org/openide/filesystems/Bundle.properties	4	OpenIDE-Module-Localizing-Bundle: org/openide/filesystems/Bundle.properties
5		5

Lines 43-45 Link Here

(-)a/openide.filesystems/nbproject/project.properties (+1 lines)
43	javadoc.main.page=org/openide/filesystems/doc-files/api.html	43	javadoc.main.page=org/openide/filesystems/doc-files/api.html
44	javadoc.arch=${basedir}/arch.xml	44	javadoc.arch=${basedir}/arch.xml
45	javadoc.apichanges=${basedir}/apichanges.xml	45	javadoc.apichanges=${basedir}/apichanges.xml
		46	spec.version.base=7.10.0

Lines 39-45 Link Here

(-)a/o.n.core/src/org/netbeans/core/filesystems/DefaultParser.java (-1 / +1 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.core.filesystems;	42	package org.netbeans.modules.openide.filesystems.declmime;
43		43
44	import java.io.*;	44	import java.io.*;
45	import java.util.logging.Level;	45	import java.util.logging.Level;

Lines 39-45 Link Here

(-)a/o.n.core/src/org/netbeans/core/filesystems/FileObjectFilter.java (-1 / +1 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.core.filesystems;	42	package org.netbeans.modules.openide.filesystems.declmime;
43		43
44	import org.openide.filesystems.*;	44	import org.openide.filesystems.*;
45		45

Lines 39-45 Link Here

(-)a/o.n.core/src/org/netbeans/core/filesystems/MIMEComponent.java (-1 / +1 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.core.filesystems;	42	package org.netbeans.modules.openide.filesystems.declmime;
43		43
44	import org.xml.sax.ContentHandler;	44	import org.xml.sax.ContentHandler;
45		45




 * made subject to such option by the copyright holder.
 */

package org.netbeans.modules.openide.filesystems.declmime;

import java.io.FileNotFoundException;
import java.io.IOException;

import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openide.cookies.InstanceCookie;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.MIMEResolver;
import org.openide.loaders.DataObject;
import org.openide.loaders.Environment;
import org.openide.util.Utilities;
import org.openide.util.lookup.InstanceContent;
import org.openide.xml.XMLUtil;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;

 * MIMEResolver implementation driven by an XML document instance
 * following PUBLIC "-//NetBeans//DTD MIME Resolver 1.0//EN".
 *
 * <p>
 * 1. It provides Environment for XMLDataObjects with above public ID.
 * <p>
 * 2. Provided environment returns (InstanceCookie) Impl instance.
 * <p>
 * 3. [Instance]Lookup return that Impl instance.
 * <p>
 * 4. MIMEResolver's findMIMEType() parses description file and applies checks on passed files.
 * <p>
 * <b>Note:</b> It is public to be accessible by XML layer.
 *
 * @author  Petr Kuzel
 */
public final class MIMEResolverImpl extends MIMEResolver {

    private static final long serialVersionUID = 18975L;
    

    private static final boolean CASE_INSENSITIVE =
        Utilities.isWindows() || Utilities.getOperatingSystem() == Utilities.OS_VMS;
    
    // DefaultEnvironmentProvider~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    
    protected InstanceContent createInstanceContent(DataObject obj) {
        FileObject fo = obj.getPrimaryFile();
        InstanceContent ic = new InstanceContent();
        ic.add(new Impl(fo));
        return ic;
    }
    
    /** Returns list of extension and MIME type pairs for given MIMEResolver
     * FileObject. The list can contain duplicates and also [null, MIME] pairs.
     * @param fo MIMEResolver FileObject
     * @return list of extension and MIME type pairs. The list can contain 
     * duplicates and also [null, MIME] pairs.
     */
    public static ArrayList<String[]> getExtensionsAndMIMETypes(FileObject fo) {
        assert fo.getPath().startsWith("Services/MIMEResolver");  //NOI18N
        ArrayList<String[]> result = new ArrayList<String[]>();
        MIMEResolverImpl impl = new MIMEResolverImpl(fo);
        impl.parseDesc();
        FileElement[] elements = impl.smell;
        if(elements != null) {

        return result;
    }
    
    // This file object describes rules that drive ths instance
    private final FileObject data;

    // Resolvers in reverse order
    private FileElement[] smell = null;
    // The cookie return itself i.e. MIMEResolver to be searchable by Lookup.
    //
    static class Impl extends MIMEResolver implements InstanceCookie {
        // This file object describes rules that drive ths instance
        private final FileObject data;

    private short state = DescParser.INIT;

    public MIMEResolverImpl(FileObject obj) {
        if (ERR.isLoggable(Level.FINE)) {
            ERR.fine("MIMEResolverImpl.<init>(" + obj + ")");  // NOI18N
        Impl(FileObject obj) {
            if (ERR.isLoggable(Level.FINE)) ERR.fine("MIMEResolverImpl.Impl.<init>(" + obj + ")");  // NOI18N
            data = obj;
        }
        data = obj;
    }
         * Resolves FileObject and returns recognized MIME type
         * @param fo is FileObject which should be resolved
         * @return  recognized MIME type or null if not recognized
         */
        public String findMIMEType(FileObject fo) {

    /**
     * Resolves FileObject and returns recognized MIME type
     * @param fo is FileObject which should be resolved
     * @return  recognized MIME type or null if not recognized
     */
    public String findMIMEType(FileObject fo) {

        synchronized (this) {  // lazy init

            if (state == DescParser.INIT) {
                state = parseDesc();
                if (state == DescParser.ERROR) {                    
                    return null;
                }                
            }

            if (state == DescParser.ERROR) {
                return null;
            for (int i = smell.length-1; i>=0; i--) {
                String s = smell[i].resolve(fo);
                if (s != null) {
                    if (ERR.isLoggable(Level.FINE)) ERR.fine("MIMEResolverImpl.findMIMEType(" + fo + ")=" + s);  // NOI18N
                    return s;
                }
            }
            
            return null;
        }

        // smell is filled in reverse order

        for (int i = smell.length - 1; i >= 0; i--) {
            String s = smell[i].resolve(fo);
            if (s != null) {
                if (ERR.isLoggable(Level.FINE)) {
                    ERR.fine("MIMEResolverImpl.findMIMEType(" + fo + ")=" + s);  // NOI18N
                if (parser.state == DescParser.ERROR) {
                    ERR.fine("MIMEResolverImpl.Impl parsing error!");
                } else {
                    StringBuffer buf = new StringBuffer();
                    buf.append("Parse: ");
                    for (int i = 0; i<smell.length; i++)
                        buf.append('\n').append(smell[i]);
                    ERR.fine(buf.toString());
                }
                return s;
            }
            return parser.state;
        }
        
        // InstanceCookie ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        public Object instanceCreate() {
            return this;
        }    

        public Class instanceClass() {
            return this.getClass();
        }    

        public String instanceName() {
            return this.getClass().getName();
        }

        return null;
        public String toString() {
            return "MIMEResolverImpl.Impl[" + data + ", " + smell + "]";  // NOI18N
        }

        
    }

    // description document is parsed in the same thread
    private short parseDesc() {
        smell = new FileElement[0];
        DescParser parser = new DescParser(data);
        parser.parse();
        smell = (parser.template != null) ? parser.template : smell;
        if (ERR.isLoggable(Level.FINE)) {
            if (parser.state == DescParser.ERROR) {
                ERR.fine("MIMEResolverImpl parsing error!");
            } else {
                StringBuffer buf = new StringBuffer();
                buf.append("Parse: ");
                for (int i = 0; i < smell.length; i++) {
                    buf.append('\n').append(smell[i]);
                }
                ERR.fine(buf.toString());
            }
        }
        return parser.state;
    }

    /** For debug purposes. */
    public String toString() {
        return "MIMEResolverImpl[" + data + ", " + smell + "]";  // NOI18N
    }

    // XML -> memory representation ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    /**

Lines 39-45 Link Here

(-)a/o.n.core/src/org/netbeans/core/filesystems/Util.java (-1 / +1 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.core.filesystems;	42	package org.netbeans.modules.openide.filesystems.declmime;
43		43
44	import org.openide.util.Utilities;	44	import org.openide.util.Utilities;
45		45

Lines 39-45 Link Here

(-)a/o.n.core/src/org/netbeans/core/filesystems/XMLMIMEComponent.java (-2 / +2 lines)
39	* made subject to such option by the copyright holder.	39	* made subject to such option by the copyright holder.
40	*/	40	*/
41		41
42	package org.netbeans.core.filesystems;	42	package org.netbeans.modules.openide.filesystems.declmime;
43		43
44	import java.lang.ref.WeakReference;	44	import java.lang.ref.WeakReference;
45	import java.util.logging.Level;	45	import java.util.logging.Level;
Lines 337-343 Link Here
337		337
338	// it may be caused by wrong user XML documents, notify only in debug mode	338	// it may be caused by wrong user XML documents, notify only in debug mode
339	// also see #16484 if the error message makes no sense	339	// also see #16484 if the error message makes no sense
340	Logger emgr = Logger.getLogger("org.netbeans.core.filesystems.XMLMIMEComponent"); // NOI18N	340	Logger emgr = Logger.getLogger(XMLMIMEComponent.class.getName());
341	if (emgr.isLoggable(Level.FINE)) {	341	if (emgr.isLoggable(Level.FINE)) {
342	emgr.fine("[while parsing " + fo + "] " + exception.getSystemId() + ":" + exception.getLineNumber() + ":" + exception.getColumnNumber() + ": " + exception.getMessage()); // NOI18N	342	emgr.fine("[while parsing " + fo + "] " + exception.getSystemId() + ":" + exception.getLineNumber() + ":" + exception.getColumnNumber() + ": " + exception.getMessage()); // NOI18N
343	}	343	}

Lines 47-56 Link Here

(-)a/openide.filesystems/src/org/openide/filesystems/MIMESupport.java (-2 / +18 lines)
47	import java.io.OutputStream;	47	import java.io.OutputStream;
48	import java.lang.ref.Reference;	48	import java.lang.ref.Reference;
49	import java.lang.ref.WeakReference;	49	import java.lang.ref.WeakReference;
		50	import java.util.ArrayList;
		51	import java.util.Arrays;
50	import java.util.Enumeration;	52	import java.util.Enumeration;
51	import java.util.HashSet;	53	import java.util.HashSet;
		54	import java.util.List;
52	import java.util.Set;	55	import java.util.Set;
53	import java.util.logging.Logger;	56	import java.util.logging.Logger;
		57	import org.netbeans.modules.openide.filesystems.declmime.MIMEResolverImpl;
54	import org.openide.util.Lookup;	58	import org.openide.util.Lookup;
55	import org.openide.util.LookupEvent;	59	import org.openide.util.LookupEvent;
56	import org.openide.util.LookupListener;	60	import org.openide.util.LookupListener;
Lines 194-201 Link Here
194	}	198	}
195		199
196	ERR.fine("Computing resolvers"); // NOI18N	200	ERR.fine("Computing resolvers"); // NOI18N
197		201
198	MIMEResolver[] toRet = result.allInstances().toArray(new MIMEResolver[0]);	202	List<MIMEResolver> all = new ArrayList<MIMEResolver>(result.allInstances());
		203
		204	FileObject declarativeFolder = Repository.getDefault().getDefaultFileSystem().findResource("Services/MIMEResolver"); // NOI18N
		205	if (declarativeFolder != null) {
		206	for (FileObject f : Ordering.getOrder(Arrays.asList(declarativeFolder.getChildren()), true)) {
		207	if (f.hasExt("xml")) { // NOI18N
		208	// For now, just assume it has the right DTD. Could check this if desired.
		209	all.add(new MIMEResolverImpl(f));
		210	}
		211	}
		212	}
		213
		214	MIMEResolver[] toRet = all.toArray(new MIMEResolver[all.size()]);
199		215
200	ERR.fine("Resolvers computed"); // NOI18N	216	ERR.fine("Resolvers computed"); // NOI18N
201		217




 * made subject to such option by the copyright holder.
 */

package org.netbeans.modules.openide.filesystems.declmime;

import java.io.*;
import java.util.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import org.netbeans.junit.NbTestCase;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileSystem;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.MIMEResolver;
import org.openide.filesystems.XMLFileSystem;

public class MIMEResolverImplTest extends NbTestCase {
    List<MIMEResolver> resolvers;

    }
    
    @SuppressWarnings("deprecation")
    @Override
    protected void setUp() throws Exception {
/*
        URL u = getClass().getProtectionDomain().getCodeSource().getLocation();
        u = new URL(u, "org/netbeans/core/filesystems/code-fs.xml");
*/
        URL u = this.getClass().getResource ("code-fs.xml");        
        FileSystem fs = new XMLFileSystem(u);
        

            resolvers.add(createResolver(fos[i]));
        }
        
/*
        u = getClass().getProtectionDomain().getCodeSource().getLocation();
        u = new URL(u, "org/netbeans/core/filesystems/data-fs.xml");
*/
        u = this.getClass().getResource ("data-fs.xml");                
        fs = new XMLFileSystem(u);
        

        FileUtil.setMIMEType("txt2", "text/plain; charset=us-ascii");        
    }
    
    public static void main(java.lang.String[] args) {
        junit.textui.TestRunner.run(suite());
    }
    
    public static NbTest suite() {
        NbTestSuite suite = new NbTestSuite(MIMEResolverImplTest.class);
        
        return suite;
    }
    
    
    private static MIMEResolver createResolver(FileObject fo) throws Exception {
        if (fo == null) throw new NullPointerException();
        return new MIMEResolverImpl(fo);
    }

    private String resolve(FileObject fo) {
        for (MIMEResolver r : resolvers) {
        while (it.hasNext()) {
            MIMEResolver r = (MIMEResolver) it.next();
            String s = r.findMIMEType(fo);
            if (s != null) return s;
        }
        return null;
    }
    
    public void testMultithreading() throws Exception {
        
        Object tl1 = new Object();
        Object tl2 = new Object();


    private class TestThread extends Thread {
        
        final Object lock;
        String fail;
        
        private TestThread(Object lock) {
            this.lock = lock;
        }
        
        @Override
        public void run() {
            String s;
            FileObject fo = null;

    public void testIllegalXMLEncoding() {
        assertEquals("illegal-encoding.xml recognized as a XML file", "text/x-springconfig+xml", resolve(root.getFileObject("illegal-encoding", "xml")));
    }

}




import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.lang.ref.WeakReference;
import java.util.Date;
import java.util.Enumeration;

        }
    }
    
    public void testDeclarativeMIMEResolvers() throws Exception {
        FileObject resolver = FileUtil.createData(Repository.getDefault().getDefaultFileSystem().getRoot(), "Services/MIMEResolver/r.xml");
        OutputStream os = resolver.getOutputStream();
        PrintStream ps = new PrintStream(os);
        ps.println("<!DOCTYPE MIME-resolver PUBLIC '-//NetBeans//DTD MIME Resolver 1.0//EN' 'http://www.netbeans.org/dtds/mime-resolver-1_0.dtd'>");
        ps.println("<MIME-resolver>");
        ps.println(" <file>");
        ps.println("  <ext name='foo'/>");
        ps.println("  <resolver mime='text/x-foo'/>");
        ps.println(" </file>");
        ps.println("</MIME-resolver>");
        os.close();
        FileObject foo = FileUtil.createMemoryFileSystem().getRoot().createData("x.foo");
        assertEquals("text/x-foo", foo.getMIMEType());
    }

    public static class TestLookup extends ProxyLookup {
        public TestLookup() {
            super();

Return to bug 138846

Lines 64-70 Link Here

(-)a/o.n.core/src/org/netbeans/core/LoaderPoolNode.java (-12 / +1 lines)
64	import javax.swing.Action;	64	import javax.swing.Action;
65	import javax.swing.event.ChangeEvent;	65	import javax.swing.event.ChangeEvent;
66	import javax.swing.event.ChangeListener;	66	import javax.swing.event.ChangeListener;
67	import org.netbeans.core.filesystems.MIMEResolverImpl;
68	import org.netbeans.core.startup.ManifestSection;	67	import org.netbeans.core.startup.ManifestSection;
69	import org.openide.actions.MoveDownAction;	68	import org.openide.actions.MoveDownAction;
70	import org.openide.actions.MoveUpAction;	69	import org.openide.actions.MoveUpAction;
Lines 90-95 Link Here
90	import org.openide.util.LookupEvent;	89	import org.openide.util.LookupEvent;
91	import org.openide.util.LookupListener;	90	import org.openide.util.LookupListener;
92	import org.openide.util.NbBundle;	91	import org.openide.util.NbBundle;
		92	import org.openide.util.NotImplementedException;
93	import org.openide.util.RequestProcessor;	93	import org.openide.util.RequestProcessor;
94	import org.openide.util.TopologicalSortException;	94	import org.openide.util.TopologicalSortException;
95	import org.openide.util.Utilities;	95	import org.openide.util.Utilities;
Lines 739-755 Link Here
739	}	739	}
740	private static NbLoaderPool nbLoaderPool = null;	740	private static NbLoaderPool nbLoaderPool = null;
741		741
742	/** Returns list of extension and MIME type pairs for given MIMEResolver
743	* FileObject. The list can contain duplicates and also [null, MIME] pairs.
744	* @param fo MIMEResolver FileObject
745	* @return list of extension and MIME type pairs. The list can contain
746	* duplicates and also [null, MIME] pairs.
747	* @since 3.9
748	*/
749	public static ArrayList<String[]> getExtensionsAndMIMETypes(FileObject fo) {
750	return MIMEResolverImpl.getExtensionsAndMIMETypes(fo);
751	}
752
753	/*** Inner classes ************/	742	/*** Inner classes ************/
754		743
755	/** Node representing one loader in Loader Pool */	744	/** Node representing one loader in Loader Pool */

Lines 1-123 Link Here

(-)a/o.n.core/src/org/netbeans/core/filesystems/XMLEnvironmentProvider.java (-123 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
5	*
6	* The contents of this file are subject to the terms of either the GNU
7	* General Public License Version 2 only ("GPL") or the Common
8	* Development and Distribution License("CDDL") (collectively, the
9	* "License"). You may not use this file except in compliance with the
10	* License. You can obtain a copy of the License at
11	* http://www.netbeans.org/cddl-gplv2.html
12	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
13	* specific language governing permissions and limitations under the
14	* License. When distributing the software, include this License Header
15	* Notice in each file and include the License file at
16	* nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
17	* particular file as subject to the "Classpath" exception as provided
18	* by Sun in the GPL Version 2 section of the License file that
19	* accompanied this code. If applicable, add the following below the
20	* License Header, with the fields enclosed by brackets [] replaced by
21	* your own identifying information:
22	* "Portions Copyrighted [year] [name of copyright owner]"
23	*
24	* Contributor(s):
25	*
26	* The Original Software is NetBeans. The Initial Developer of the Original
27	* Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
28	* Microsystems, Inc. All Rights Reserved.
29	*
30	* If you wish your version of this file to be governed by only the CDDL
31	* or only the GPL Version 2, indicate your decision by adding
32	* "[Contributor] elects to include this software in this distribution
33	* under the [CDDL or GPL Version 2] license." If you do not indicate a
34	* single choice of license, a recipient has the option to distribute
35	* your version of this file under either the CDDL, the GPL Version 2 or
36	* to extend the choice of license to its licensees as provided above.
37	* However, if you add GPL Version 2 code and therefore, elected the GPL
38	* Version 2 license, then the option applies only if the new code is
39	* made subject to such option by the copyright holder.
40	*/
41
42	package org.netbeans.core.filesystems;
43
44	import java.io.*;
45	import java.util.*;
46
47	import org.xml.sax.*;
48	import org.xml.sax.helpers.*;
49
50	import org.openide.cookies.InstanceCookie;
51	import org.openide.loaders.*;
52	import org.openide.filesystems.*;
53	import org.openide.util.*;
54	import org.openide.util.lookup.*;
55	import org.openide.xml.*;
56	import org.openide.*;
57
58	/**
59	* Default implementation providing Environment for XMLDataObject according to its
60	* public ID.
61	*
62	* <p>
63	* Subclass instance of this must be registered as <tt>FileEntityResolver</tt>
64	* dictates and must implement <tt>Environment.Provider</tt> interface.
65	*
66	* <p>
67	* It forever caches provided environment!
68	*
69	* @see org.netbeans.core.xml.FileEntityResolver
70	* @author Petr Kuzel
71	* @version
72	*/
73	class XMLEnvironmentProvider extends SharedClassObject {
74
75	private static final long serialVersionUID = 18947L;
76
77	private static transient Map<FileObject, Lookup> envs = new HashMap<FileObject, Lookup>(11); // 11 expected number of modules using this
78
79	// Environment.Provider ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
80
81	/** Returns a lookup that represents environment.
82	* @return the lookup
83	*/
84	public final Lookup getEnvironment(DataObject obj){
85
86	// the obj check is done by core FileEntityResolver that calls us
87
88	// we want to create just one instance per FileObject
89
90	FileObject file = obj.getPrimaryFile();
91	Lookup lookup = envs.get(file);
92	if (lookup == null) {
93	lookup = createLookup(obj);
94	envs.put(file, lookup);
95	}
96	return lookup;
97
98	}
99
100	/**
101	* It is called exactly once per DataObject.
102	*
103	* @return content of assigned Lookup
104	*/
105	protected InstanceContent createInstanceContent(DataObject obj) {
106	return new InstanceContent();
107	}
108
109	/**
110	* It is called exactly once per DataObject.
111	*
112	* @return Lookup containing <tt>createInstanceContent()</tt>
113	*/
114	protected Lookup createLookup(DataObject obj) {
115	InstanceContent ic = createInstanceContent(obj);
116	Lookup lookup = new AbstractLookup(ic);
117	if (lookup.lookup(InstanceCookie.class) == null) {
118	Exceptions.printStackTrace(new IllegalStateException()); // instance cookie required
119	}
120	return lookup;
121	}
122
123	}

Lines 53-64 Link Here

(-)a/o.n.core/src/org/netbeans/core/resources/mf-layer.xml (-14 / +2 lines)
53	</file>	53	</file>
54	</folder>	54	</folder>
55		55
56	<folder name="MIMEResolver">
57	<attr name="SystemFileSystem.localizingBundle" stringvalue="org.netbeans.core.Bundle" />
58	<attr name="SystemFileSystem.icon" urlvalue="nbresloc:/org/netbeans/core/resources/mime.gif" />
59	<attr name="helpID" stringvalue="org.netbeans.core.filesystems.MIMEResolverImpl"/>
60	</folder>
61
62	<folder name="Hidden">	56	<folder name="Hidden">
63	<attr name="hidden" boolvalue="true" />	57	<attr name="hidden" boolvalue="true" />
64	<file name="HtmlBrowserFactoryEditorForGeneralOptionsPanel.instance">	58	<file name="HtmlBrowserFactoryEditorForGeneralOptionsPanel.instance">
Lines 109-119 Link Here
109	</file>	103	</file>
110		104
111	<!-- Declarative MIME resolver -->	105	<!-- Declarative MIME resolver -->
112	<file name="DTD_MIME_Resolver_1_0" url="nbres:/org/netbeans/core/filesystems/resolver.dtd">	106	<file name="DTD_MIME_Resolver_1_0" url="nbres:/org/netbeans/modules/openide/filesystems/declmime/resolver.dtd">
113	<attr name="hint.originalPublicID" stringvalue="-//NetBeans//DTD MIME Resolver 1.0//EN"/>	107	<attr name="hint.originalPublicID" stringvalue="-//NetBeans//DTD MIME Resolver 1.0//EN"/>
114	</file>	108	</file>
115		109
116	<file name="DTD_MIME_Resolver_XML_Rules_1_0" url="nbres:/org/netbeans/core/filesystems/xml-rules.dtd">	110	<file name="DTD_MIME_Resolver_XML_Rules_1_0" url="nbres:/org/netbeans/modules/openide/filesystems/declmime/xml-rules.dtd">
117	<attr name="hint.originalPublicID" stringvalue="-//NetBeans//DTD MIME Resolver XML Rules 1.0//EN"/>	111	<attr name="hint.originalPublicID" stringvalue="-//NetBeans//DTD MIME Resolver XML Rules 1.0//EN"/>
118	</file>	112	</file>
119		113
Lines 129-140 Link Here
129	<attr name="instanceClass" stringvalue="org.openide.loaders.XMLDataObject$Processor"/>	123	<attr name="instanceClass" stringvalue="org.openide.loaders.XMLDataObject$Processor"/>
130	<attr name="instanceCreate" newvalue="org.netbeans.core.xml.EntityCatalogImpl$RegistrationProcessor" />	124	<attr name="instanceCreate" newvalue="org.netbeans.core.xml.EntityCatalogImpl$RegistrationProcessor" />
131	</file>	125	</file>
132
133	<!-- Environment.Provider for declarative MIME resolver XML documents. -->
134	<file name="DTD_MIME_Resolver_1_0.instance">
135	<attr name="instanceClass" stringvalue="org.openide.loaders.Environment$Provider"/>
136	<attr name="instanceCreate" newvalue="org.netbeans.core.filesystems.MIMEResolverImpl"/>
137	</file>
138	</folder>	126	</folder>
139	</folder>	127	</folder>
140	</folder>	128	</folder>

Lines 45-50 Link Here

(-)a/openide.filesystems/test/unit/src/org/openide/filesystems/MIMESupportTest.java (+17 lines)
45	import java.io.IOException;	45	import java.io.IOException;
46	import java.io.InputStream;	46	import java.io.InputStream;
47	import java.io.OutputStream;	47	import java.io.OutputStream;
		48	import java.io.PrintStream;
48	import java.lang.ref.WeakReference;	49	import java.lang.ref.WeakReference;
49	import java.util.Date;	50	import java.util.Date;
50	import java.util.Enumeration;	51	import java.util.Enumeration;
Lines 196-201 Link Here
196	}	197	}
197	}	198	}
198		199
		200	public void testDeclarativeMIMEResolvers() throws Exception {
		201	FileObject resolver = FileUtil.createData(Repository.getDefault().getDefaultFileSystem().getRoot(), "Services/MIMEResolver/r.xml");
		202	OutputStream os = resolver.getOutputStream();
		203	PrintStream ps = new PrintStream(os);
		204	ps.println("<!DOCTYPE MIME-resolver PUBLIC '-//NetBeans//DTD MIME Resolver 1.0//EN' 'http://www.netbeans.org/dtds/mime-resolver-1_0.dtd'>");
		205	ps.println("<MIME-resolver>");
		206	ps.println(" <file>");
		207	ps.println(" <ext name='foo'/>");
		208	ps.println(" <resolver mime='text/x-foo'/>");
		209	ps.println(" </file>");
		210	ps.println("</MIME-resolver>");
		211	os.close();
		212	FileObject foo = FileUtil.createMemoryFileSystem().getRoot().createData("x.foo");
		213	assertEquals("text/x-foo", foo.getMIMEType());
		214	}
		215
199	public static class TestLookup extends ProxyLookup {	216	public static class TestLookup extends ProxyLookup {
200	public TestLookup() {	217	public TestLookup() {
201	super();	218	super();