1/*
2 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package jdk.nashorn.tools.jjs;
27
28import java.io.IOException;
29import java.util.ArrayList;
30import java.util.Arrays;
31import java.util.Collections;
32import java.util.List;
33import java.util.WeakHashMap;
34import java.util.regex.Pattern;
35import java.util.stream.Collectors;
36import jdk.nashorn.internal.runtime.Context;
37import jdk.nashorn.internal.runtime.JSType;
38import jdk.nashorn.internal.runtime.NativeJavaPackage;
39import jdk.nashorn.internal.runtime.PropertyMap;
40import jdk.nashorn.internal.runtime.ScriptObject;
41import jdk.nashorn.internal.runtime.ScriptRuntime;
42import jdk.nashorn.internal.objects.NativeJava;
43
44/*
45 * A helper class to get properties of a given object for source code completion.
46 */
47final class PropertiesHelper {
48    // Java package properties helper, may be null
49    private PackagesHelper pkgsHelper;
50    // cached properties list
51    private final WeakHashMap<Object, List<String>> propsCache = new WeakHashMap<>();
52
53    /**
54     * Construct a new PropertiesHelper.
55     *
56     * @param context the current nashorn Context
57     */
58    PropertiesHelper(final Context context) {
59        try {
60            this.pkgsHelper = new PackagesHelper(context);
61        } catch (final IOException exp) {
62            if (Main.DEBUG) {
63                exp.printStackTrace();
64            }
65            this.pkgsHelper = null;
66        }
67    }
68
69    void close() throws Exception {
70        propsCache.clear();
71        pkgsHelper.close();
72    }
73
74    /**
75     * returns the list of properties of the given object.
76     *
77     * @param obj object whose property list is returned
78     * @return the list of properties of the given object
79     */
80    List<String> getProperties(final Object obj) {
81        assert obj != null && obj != ScriptRuntime.UNDEFINED;
82
83        // wrap JS primitives as objects before gettting properties
84        if (JSType.isPrimitive(obj)) {
85            return getProperties(JSType.toScriptObject(obj));
86        }
87
88        // Handle Java package prefix case first. Should do it before checking
89        // for its super class ScriptObject!
90        if (obj instanceof NativeJavaPackage) {
91            if (pkgsHelper != null) {
92                return pkgsHelper.getPackageProperties(((NativeJavaPackage)obj).getName());
93            } else {
94                return Collections.<String>emptyList();
95            }
96        }
97
98        // script object - all inherited and non-enumerable, non-index properties
99        if (obj instanceof ScriptObject) {
100            final ScriptObject sobj = (ScriptObject)obj;
101            final PropertyMap pmap = sobj.getMap();
102            if (propsCache.containsKey(pmap)) {
103                return propsCache.get(pmap);
104            }
105            final String[] keys = sobj.getAllKeys();
106            List<String> props = Arrays.asList(keys);
107            props = props.stream()
108                         .filter(s -> Character.isJavaIdentifierStart(s.charAt(0)))
109                         .collect(Collectors.toList());
110            Collections.sort(props);
111            // cache properties against the PropertyMap
112            propsCache.put(pmap, props);
113            return props;
114        }
115
116        // java class case - don't refer to StaticClass directly
117        if (NativeJava.isType(ScriptRuntime.UNDEFINED, obj)) {
118            if (propsCache.containsKey(obj)) {
119                return propsCache.get(obj);
120            }
121            final List<String> props = NativeJava.getProperties(obj);
122            Collections.sort(props);
123            // cache properties against the StaticClass representing the class
124            propsCache.put(obj, props);
125            return props;
126        }
127
128        // any other Java object
129        final Class<?> clazz = obj.getClass();
130        if (propsCache.containsKey(clazz)) {
131            return propsCache.get(clazz);
132        }
133
134        final List<String> props = NativeJava.getProperties(obj);
135        Collections.sort(props);
136        // cache properties against the Class object
137        propsCache.put(clazz, props);
138        return props;
139    }
140
141    // This method creates a regex Pattern to use to do CamelCase
142    // matching. The pattern is derived from user supplied string
143    // containing one or more upper case characters in it.
144    private static Pattern makeCamelCasePattern(final String str) {
145        assert !str.isEmpty();
146
147        final char[] chars = str.toCharArray();
148        final StringBuilder buf = new StringBuilder();
149        boolean seenUpperCase = false;
150
151        // Skip first char for case check. Even if it is upper case,
152        // we do not want to put lower case matching pattern before
153        // the first letter!
154        buf.append(chars[0]);
155
156        for (int idx = 1; idx < chars.length; idx++) {
157            final char ch = chars[idx];
158            if (ch >= 'A' && ch <= 'Z') {
159                seenUpperCase = true;
160                buf.append("[^A-Z]*");
161            }
162            buf.append(ch);
163        }
164
165        if (seenUpperCase) {
166            // match anything at the end!
167            buf.append(".*");
168            try {
169                return Pattern.compile(buf.toString());
170            } catch (Exception exp) {
171            }
172        }
173
174        return null;
175    }
176
177    /**
178     * Returns the list of properties of the given object that start with the given prefix.
179     *
180     * @param obj object whose property list is returned
181     * @param prefix property prefix to be matched
182     * @return the list of properties of the given object
183     */
184    List<String> getProperties(final Object obj, final String prefix) {
185        assert prefix != null && !prefix.isEmpty();
186        List<String> allProps = getProperties(obj);
187        List<String> props = allProps.stream()
188                   .filter(s -> s.startsWith(prefix))
189                   .collect(Collectors.toList());
190
191        // If no match, try CamelCase completion..
192        if (props.isEmpty()) {
193            final Pattern pat = makeCamelCasePattern(prefix);
194            if (pat != null) {
195                return allProps.stream()
196                    .filter(s -> pat.matcher(s).matches())
197                    .collect(Collectors.toList());
198            }
199        }
200
201        return props;
202    }
203}
204