diff --git a/src/main/java/jp/sf/fess/dic/DictionaryException.java b/src/main/java/jp/sf/fess/dic/DictionaryException.java new file mode 100644 index 000000000..9cd25e7e1 --- /dev/null +++ b/src/main/java/jp/sf/fess/dic/DictionaryException.java @@ -0,0 +1,17 @@ +package jp.sf.fess.dic; + +import jp.sf.fess.FessSystemException; + +public class DictionaryException extends FessSystemException { + + private static final long serialVersionUID = 1L; + + public DictionaryException(final String message, final Throwable cause) { + super(message, cause); + } + + public DictionaryException(final String message) { + super(message); + } + +} diff --git a/src/main/java/jp/sf/fess/dic/DictionaryFile.java b/src/main/java/jp/sf/fess/dic/DictionaryFile.java new file mode 100644 index 000000000..f9740b862 --- /dev/null +++ b/src/main/java/jp/sf/fess/dic/DictionaryFile.java @@ -0,0 +1,164 @@ +package jp.sf.fess.dic; + +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; + +public abstract class DictionaryFile { + public abstract String getName(); + + public abstract PagingList selectList(int offset, int size); + + public abstract void insert(DictionaryItem item); + + public abstract void update(DictionaryItem item); + + public abstract void delete(DictionaryItem item); + + public static class PagingList implements List { + private final List parent; + + protected int allRecordCount; + + protected int pageSize; + + protected int currentPageNumber; + + public PagingList(final List list, final int offset, final int size, + final int allRecordCount) { + this.parent = list; + this.allRecordCount = allRecordCount; + pageSize = size; + currentPageNumber = offset / size + 1; + } + + @Override + public int size() { + return parent.size(); + } + + @Override + public boolean isEmpty() { + return parent.isEmpty(); + } + + @Override + public boolean contains(final Object o) { + return parent.contains(o); + } + + @Override + public Iterator iterator() { + return parent.iterator(); + } + + @Override + public Object[] toArray() { + return parent.toArray(); + } + + @Override + public T[] toArray(final T[] a) { + return parent.toArray(a); + } + + @Override + public boolean add(final E e) { + return parent.add(e); + } + + @Override + public boolean remove(final Object o) { + return parent.remove(o); + } + + @Override + public boolean containsAll(final Collection c) { + return parent.containsAll(c); + } + + @Override + public boolean addAll(final Collection c) { + return parent.addAll(c); + } + + @Override + public boolean addAll(final int index, final Collection c) { + return parent.addAll(index, c); + } + + @Override + public boolean removeAll(final Collection c) { + return parent.retainAll(c); + } + + @Override + public boolean retainAll(final Collection c) { + return parent.retainAll(c); + } + + @Override + public void clear() { + parent.clear(); + } + + @Override + public E get(final int index) { + return parent.get(index); + } + + @Override + public E set(final int index, final E element) { + return parent.set(index, element); + } + + @Override + public void add(final int index, final E element) { + parent.add(index, element); + } + + @Override + public E remove(final int index) { + return parent.remove(index); + } + + @Override + public int indexOf(final Object o) { + return parent.indexOf(o); + } + + @Override + public int lastIndexOf(final Object o) { + return parent.lastIndexOf(o); + } + + @Override + public ListIterator listIterator() { + return parent.listIterator(); + } + + @Override + public ListIterator listIterator(final int index) { + return parent.listIterator(index); + } + + @Override + public List subList(final int fromIndex, final int toIndex) { + return parent.subList(fromIndex, toIndex); + } + + public int getAllRecordCount() { + return allRecordCount; + } + + public int getPageSize() { + return pageSize; + } + + public int getCurrentPageNumber() { + return currentPageNumber; + } + + } +} \ No newline at end of file diff --git a/src/main/java/jp/sf/fess/dic/DictionaryItem.java b/src/main/java/jp/sf/fess/dic/DictionaryItem.java new file mode 100644 index 000000000..09e3319aa --- /dev/null +++ b/src/main/java/jp/sf/fess/dic/DictionaryItem.java @@ -0,0 +1,5 @@ +package jp.sf.fess.dic; + +public abstract class DictionaryItem { + +} diff --git a/src/main/java/jp/sf/fess/dic/DictionaryLocator.java b/src/main/java/jp/sf/fess/dic/DictionaryLocator.java new file mode 100644 index 000000000..ad8e42a53 --- /dev/null +++ b/src/main/java/jp/sf/fess/dic/DictionaryLocator.java @@ -0,0 +1,41 @@ +package jp.sf.fess.dic; + +import java.io.File; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Map; + +import jp.sf.fess.util.ResourceUtil; + +import org.apache.commons.io.FileUtils; +import org.apache.commons.io.filefilter.AbstractFileFilter; + +public abstract class DictionaryLocator { + protected List searchPathList = new ArrayList(); + + public abstract Map find(); + + protected File[] findFiles(final String path, final String filenamePrefix, + final List excludedSet) { + final Collection files = FileUtils.listFiles(new File(path), + new AbstractFileFilter() { + @Override + public boolean accept(final File dir, final String name) { + return name.startsWith(filenamePrefix); + } + }, new AbstractFileFilter() { + @Override + public boolean accept(final File dir, final String name) { + return excludedSet == null + || !excludedSet.contains(name); + } + }); + + return files.toArray(new File[files.size()]); + } + + public void addSearchPath(final String path) { + searchPathList.add(ResourceUtil.resolve(path)); + } +} diff --git a/src/main/java/jp/sf/fess/dic/DictionaryManager.java b/src/main/java/jp/sf/fess/dic/DictionaryManager.java new file mode 100644 index 000000000..32574a16e --- /dev/null +++ b/src/main/java/jp/sf/fess/dic/DictionaryManager.java @@ -0,0 +1,98 @@ +package jp.sf.fess.dic; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; + +import jp.sf.fess.dic.synonym.SynonymFile; + +import org.seasar.extension.timer.TimeoutManager; +import org.seasar.extension.timer.TimeoutTarget; +import org.seasar.extension.timer.TimeoutTask; +import org.seasar.framework.container.annotation.tiger.DestroyMethod; +import org.seasar.framework.container.annotation.tiger.InitMethod; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class DictionaryManager { + private static final Logger logger = LoggerFactory + .getLogger(DictionaryManager.class); + + protected Map dicFileMap; + + public long keepAlive = 5 * 60 * 1000; // 5min + + public int watcherTimeout = 60; // 1min + + protected volatile long lifetime = 0; + + protected TimeoutTask watcherTargetTask; + + protected List locatorList = new ArrayList(); + + @InitMethod + public void init() { + // start + final WatcherTarget watcherTarget = new WatcherTarget(); + watcherTargetTask = TimeoutManager.getInstance().addTimeoutTarget( + watcherTarget, watcherTimeout, true); + } + + @DestroyMethod + public void destroy() { + if (watcherTargetTask != null && !watcherTargetTask.isStopped()) { + watcherTargetTask.stop(); + } + } + + public DictionaryFile[] getDictionaryFiles() { + final Map fileMap = getDictionaryFileMap(); + + final Collection values = fileMap.values(); + return values.toArray(new SynonymFile[values.size()]); + } + + public DictionaryFile getDictionaryFile(final String uri) { + final Map fileMap = getDictionaryFileMap(); + + return fileMap.get(uri); + } + + protected Map getDictionaryFileMap() { + synchronized (this) { + if (lifetime > System.currentTimeMillis() && dicFileMap != null) { + lifetime = System.currentTimeMillis() + keepAlive; + return dicFileMap; + } + + final Map newFileMap = new TreeMap(); + for (final DictionaryLocator locator : locatorList) { + newFileMap.putAll(locator.find()); + } + dicFileMap = newFileMap; + lifetime = System.currentTimeMillis() + keepAlive; + return dicFileMap; + } + } + + public void addLocator(final DictionaryLocator locator) { + locatorList.add(locator); + } + + protected class WatcherTarget implements TimeoutTarget { + @Override + public void expired() { + synchronized (DictionaryManager.this) { + if (lifetime <= System.currentTimeMillis() + && dicFileMap != null) { + if (logger.isDebugEnabled()) { + logger.debug("Cleaning synonym files: " + dicFileMap); + } + dicFileMap = null; + } + } + } + } +} diff --git a/src/main/java/jp/sf/fess/dic/synonym/SynonymFile.java b/src/main/java/jp/sf/fess/dic/synonym/SynonymFile.java new file mode 100644 index 000000000..223912cb8 --- /dev/null +++ b/src/main/java/jp/sf/fess/dic/synonym/SynonymFile.java @@ -0,0 +1,331 @@ +package jp.sf.fess.dic.synonym; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.OutputStreamWriter; +import java.io.Writer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import jp.sf.fess.Constants; +import jp.sf.fess.dic.DictionaryException; +import jp.sf.fess.dic.DictionaryFile; +import jp.sf.fess.dic.DictionaryItem; + +import org.apache.commons.io.FileUtils; +import org.apache.commons.io.IOUtils; + +public class SynonymFile extends DictionaryFile { + private final File file; + + List synonymItemList; + + public SynonymFile(final File file) { + this.file = file; + } + + @Override + public String getName() { + return file.getAbsolutePath(); + } + + @Override + public synchronized PagingList selectList(final int offset, + final int size) { + if (synonymItemList == null) { + reload(null); + } + + if (offset >= synonymItemList.size() || offset < 0) { + return new PagingList( + Collections. emptyList(), offset, size, + synonymItemList.size()); + } + + int toIndex = offset + size; + if (toIndex > synonymItemList.size()) { + toIndex = synonymItemList.size(); + } + + return new PagingList(synonymItemList.subList(offset, + toIndex), offset, size, synonymItemList.size()); + } + + @Override + public synchronized void insert(final DictionaryItem item) { + final SynonymItem synonymItem = (SynonymItem) item; + BufferedWriter bw = null; + try { + bw = new BufferedWriter(new OutputStreamWriter( + new FileOutputStream(file, true), Constants.UTF_8)); + bw.newLine(); + bw.write(synonymItem.toLineString()); + bw.flush(); + synonymItemList.add(new SynonymItem(synonymItemList.size() + 1, + synonymItem.getInputs(), synonymItem.getOutputs())); + } catch (final IOException e) { + throw new DictionaryException("Failed to write: " + item, e); + } finally { + IOUtils.closeQuietly(bw); + } + } + + @Override + public synchronized void update(final DictionaryItem item) { + reload(new SynonymUpdater(file, (SynonymItem) item)); + } + + @Override + public synchronized void delete(final DictionaryItem item) { + final SynonymItem synonymItem = (SynonymItem) item; + synonymItem.setNewInputs(new String[0]); + synonymItem.setNewOutputs(new String[0]); + reload(new SynonymUpdater(file, synonymItem)); + } + + protected void reload(final SynonymUpdater updater) { + final List itemList = new ArrayList(); + BufferedReader reader = null; + try { + reader = new BufferedReader(new InputStreamReader( + new FileInputStream(file), Constants.UTF_8)); + int id = 0; + String line = null; + while ((line = reader.readLine()) != null) { + if (line.length() == 0 || line.charAt(0) == '#') { + if (updater != null) { + updater.write(line); + } + continue; // ignore empty lines and comments + } + + String inputs[]; + String outputs[]; + + final List sides = split(line, "=>"); + if (sides.size() > 1) { // explicit mapping + if (sides.size() != 2) { + throw new DictionaryException( + "more than one explicit mapping specified on the same line"); + } + final List inputStrings = split(sides.get(0), ","); + inputs = new String[inputStrings.size()]; + for (int i = 0; i < inputs.length; i++) { + inputs[i] = unescape(inputStrings.get(i)).trim(); + } + + final List outputStrings = split(sides.get(1), ","); + outputs = new String[outputStrings.size()]; + for (int i = 0; i < outputs.length; i++) { + outputs[i] = unescape(outputStrings.get(i)).trim(); + } + + if (inputs.length > 0 && outputs.length > 0) { + id++; + final SynonymItem item = new SynonymItem(id, inputs, + outputs); + if (updater != null) { + final SynonymItem newItem = updater.write(item); + if (newItem != null) { + itemList.add(newItem); + } else { + id--; + } + } else { + itemList.add(item); + } + } + } else { + final List inputStrings = split(line, ","); + inputs = new String[inputStrings.size()]; + for (int i = 0; i < inputs.length; i++) { + inputs[i] = unescape(inputStrings.get(i)).trim(); + } + + if (inputs.length > 0) { + id++; + final SynonymItem item = new SynonymItem(id, inputs, + inputs); + if (updater != null) { + final SynonymItem newItem = updater.write(item); + if (newItem != null) { + itemList.add(newItem); + } else { + id--; + } + } else { + itemList.add(item); + } + } + } + } + if (updater != null) { + updater.commit(); + } + } catch (final IOException e) { + throw new DictionaryException("Failed to parse " + + file.getAbsolutePath(), e); + } finally { + IOUtils.closeQuietly(reader); + synonymItemList = itemList; + if (updater != null) { + updater.close(); + } + } + } + + private static List split(final String s, final String separator) { + final List list = new ArrayList(2); + StringBuilder sb = new StringBuilder(); + int pos = 0; + final int end = s.length(); + while (pos < end) { + if (s.startsWith(separator, pos)) { + if (sb.length() > 0) { + list.add(sb.toString()); + sb = new StringBuilder(); + } + pos += separator.length(); + continue; + } + + char ch = s.charAt(pos++); + if (ch == '\\') { + sb.append(ch); + if (pos >= end) { + break; // ERROR, or let it go? + } + ch = s.charAt(pos++); + } + + sb.append(ch); + } + + if (sb.length() > 0) { + list.add(sb.toString()); + } + + return list; + } + + private String unescape(final String s) { + if (s.indexOf("\\") >= 0) { + final StringBuilder sb = new StringBuilder(); + for (int i = 0; i < s.length(); i++) { + final char ch = s.charAt(i); + if (ch == '\\' && i < s.length() - 1) { + sb.append(s.charAt(++i)); + } else { + sb.append(ch); + } + } + return sb.toString(); + } + return s; + } + + protected static class SynonymUpdater { + + protected boolean isCommit = false; + + protected File oldFile; + + protected File newFile; + + protected Writer writer; + + protected SynonymItem item; + + protected SynonymUpdater(final File file, final SynonymItem newItem) { + try { + newFile = File.createTempFile("synonym", ".txt"); + writer = new BufferedWriter(new OutputStreamWriter( + new FileOutputStream(newFile), Constants.UTF_8)); + } catch (final IOException e) { + if (newFile != null) { + newFile.delete(); + } + throw new DictionaryException( + "Failed to write a synonym file.", e); + } + oldFile = file; + item = newItem; + } + + public SynonymItem write(final SynonymItem oldItem) { + try { + if (item.getId() == oldItem.getId() && item.isUpdated()) { + if (item.equals(oldItem)) { + try { + if (!item.isDeleted()) { + // update + writer.write(item.toLineString()); + writer.write(System.lineSeparator()); + return new SynonymItem(item.getId(), + item.getNewInputs(), + item.getNewOutputs()); + } else { + return null; + } + } finally { + item.setNewInputs(null); + item.setNewOutputs(null); + } + } else { + throw new DictionaryException( + "Synonym file was updated: old=" + oldItem + + " : new=" + item); + } + } else { + writer.write(oldItem.toLineString()); + writer.write(System.lineSeparator()); + return oldItem; + } + } catch (final IOException e) { + throw new DictionaryException("Failed to write: " + oldItem + + " -> " + item, e); + } + } + + public void write(final String line) { + try { + writer.write(line); + writer.write(System.lineSeparator()); + } catch (final IOException e) { + throw new DictionaryException("Failed to write: " + line, e); + } + } + + public void commit() { + isCommit = true; + } + + public void close() { + try { + writer.flush(); + } catch (final IOException e) { + // ignore + } + IOUtils.closeQuietly(writer); + + if (isCommit) { + try { + FileUtils.copyFile(newFile, oldFile); + newFile.delete(); + } catch (final IOException e) { + throw new DictionaryException("Failed to replace " + + oldFile.getAbsolutePath() + " with " + + newFile.getAbsolutePath(), e); + } + } else { + newFile.delete(); + } + } + } +} diff --git a/src/main/java/jp/sf/fess/synonym/SynonymItem.java b/src/main/java/jp/sf/fess/dic/synonym/SynonymItem.java similarity index 65% rename from src/main/java/jp/sf/fess/synonym/SynonymItem.java rename to src/main/java/jp/sf/fess/dic/synonym/SynonymItem.java index 927f2fd3b..f13e36c64 100644 --- a/src/main/java/jp/sf/fess/synonym/SynonymItem.java +++ b/src/main/java/jp/sf/fess/dic/synonym/SynonymItem.java @@ -1,8 +1,12 @@ -package jp.sf.fess.synonym; +package jp.sf.fess.dic.synonym; import java.util.Arrays; -public class SynonymItem { +import jp.sf.fess.dic.DictionaryItem; + +import org.apache.commons.lang3.StringUtils; + +public class SynonymItem extends DictionaryItem { private final String[] inputs; private final String[] outputs; @@ -56,6 +60,10 @@ public class SynonymItem { return newInputs != null && newOutputs != null; } + public boolean isDeleted() { + return isUpdated() && newInputs.length == 0; + } + public void sort() { if (inputs != null) { Arrays.sort(inputs); @@ -103,4 +111,30 @@ public class SynonymItem { return true; } + @Override + public String toString() { + return "SynonymItem [id=" + id + ", inputs=" + Arrays.toString(inputs) + + ", outputs=" + Arrays.toString(outputs) + ", newInputs=" + + Arrays.toString(newInputs) + ", newOutputs=" + + Arrays.toString(newOutputs) + "]"; + } + + public String toLineString() { + if (isUpdated()) { + if (Arrays.equals(newInputs, newOutputs)) { + return StringUtils.join(newInputs, ","); + } else { + return StringUtils.join(newInputs, ",") + "=>" + + StringUtils.join(newOutputs, ","); + } + } else { + if (Arrays.equals(inputs, outputs)) { + return StringUtils.join(inputs, ","); + } else { + return StringUtils.join(inputs, ",") + "=>" + + StringUtils.join(outputs, ","); + } + } + } + } diff --git a/src/main/java/jp/sf/fess/dic/synonym/SynonymLocator.java b/src/main/java/jp/sf/fess/dic/synonym/SynonymLocator.java new file mode 100644 index 000000000..ba63e5dd7 --- /dev/null +++ b/src/main/java/jp/sf/fess/dic/synonym/SynonymLocator.java @@ -0,0 +1,38 @@ +package jp.sf.fess.dic.synonym; + +import java.io.File; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import jp.sf.fess.dic.DictionaryFile; +import jp.sf.fess.dic.DictionaryLocator; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class SynonymLocator extends DictionaryLocator { + private static final Logger logger = LoggerFactory + .getLogger(SynonymLocator.class); + + public String synonymFilePrefix = "synonym"; + + public List excludedSynonymList; + + @Override + public Map find() { + final Map fileMap = new HashMap(); + for (final String path : searchPathList) { + final File[] files = findFiles(path, synonymFilePrefix, + excludedSynonymList); + for (final File file : files) { + if (logger.isInfoEnabled()) { + logger.info("Synonym File: " + file.getAbsolutePath()); + } + fileMap.put(file.getAbsolutePath(), new SynonymFile(file)); + } + } + return fileMap; + } + +} diff --git a/src/main/java/jp/sf/fess/synonym/SynonymException.java b/src/main/java/jp/sf/fess/synonym/SynonymException.java deleted file mode 100644 index b89c96529..000000000 --- a/src/main/java/jp/sf/fess/synonym/SynonymException.java +++ /dev/null @@ -1,13 +0,0 @@ -package jp.sf.fess.synonym; - -import jp.sf.fess.FessSystemException; - -public class SynonymException extends FessSystemException { - - private static final long serialVersionUID = 1L; - - public SynonymException(final String message, final Throwable cause) { - super(message, cause); - } - -} diff --git a/src/main/java/jp/sf/fess/synonym/SynonymFile.java b/src/main/java/jp/sf/fess/synonym/SynonymFile.java deleted file mode 100644 index 7864d1f1a..000000000 --- a/src/main/java/jp/sf/fess/synonym/SynonymFile.java +++ /dev/null @@ -1,144 +0,0 @@ -package jp.sf.fess.synonym; - -import java.io.BufferedReader; -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.io.InputStreamReader; -import java.util.ArrayList; -import java.util.List; - -import jp.sf.fess.Constants; - -import org.apache.commons.io.IOUtils; - -public class SynonymFile { - private final File file; - - final List synonymItemList = new ArrayList(); - - public SynonymFile(final File file) { - this.file = file; - } - - public void clear() { - synchronized (synonymItemList) { - synonymItemList.clear(); - } - } - - public void load() { - BufferedReader reader = null; - synchronized (synonymItemList) { - try { - reader = new BufferedReader(new InputStreamReader( - new FileInputStream(file), Constants.UTF_8)); - int id = 0; - String line = null; - while ((line = reader.readLine()) != null) { - if (line.length() == 0 || line.charAt(0) == '#') { - continue; // ignore empty lines and comments - } - - String inputs[]; - String outputs[]; - - final String sides[] = split(line, "=>"); - if (sides.length > 1) { // explicit mapping - if (sides.length != 2) { - throw new IllegalArgumentException( - "more than one explicit mapping specified on the same line"); - } - final String inputStrings[] = split(sides[0], ","); - inputs = new String[inputStrings.length]; - for (int i = 0; i < inputs.length; i++) { - inputs[i] = unescape(inputStrings[i]).trim(); - } - - final String outputStrings[] = split(sides[1], ","); - outputs = new String[outputStrings.length]; - for (int i = 0; i < outputs.length; i++) { - outputs[i] = unescape(outputStrings[i]).trim(); - } - - if (inputs.length > 0 && outputs.length > 0) { - final SynonymItem item = new SynonymItem(id, - inputs, inputs); - id++; - synonymItemList.add(item); - } - } else { - final String inputStrings[] = split(line, ","); - inputs = new String[inputStrings.length]; - for (int i = 0; i < inputs.length; i++) { - inputs[i] = unescape(inputStrings[i]).trim(); - } - - if (inputs.length > 0) { - final SynonymItem item = new SynonymItem(id, - inputs, inputs); - id++; - synonymItemList.add(item); - } - } - } - } catch (final IOException e) { - throw new SynonymException("Failed to parse " - + file.getAbsolutePath(), e); - } finally { - IOUtils.closeQuietly(reader); - } - } - } - - private static String[] split(final String s, final String separator) { - final List list = new ArrayList(2); - StringBuilder sb = new StringBuilder(); - int pos = 0; - final int end = s.length(); - while (pos < end) { - if (s.startsWith(separator, pos)) { - if (sb.length() > 0) { - list.add(sb.toString()); - sb = new StringBuilder(); - } - pos += separator.length(); - continue; - } - - char ch = s.charAt(pos++); - if (ch == '\\') { - sb.append(ch); - if (pos >= end) { - break; // ERROR, or let it go? - } - ch = s.charAt(pos++); - } - - sb.append(ch); - } - - if (sb.length() > 0) { - list.add(sb.toString()); - } - - return list.toArray(new String[list.size()]); - } - - private String unescape(final String s) { - if (s.indexOf("\\") >= 0) { - final StringBuilder sb = new StringBuilder(); - for (int i = 0; i < s.length(); i++) { - final char ch = s.charAt(i); - if (ch == '\\' && i < s.length() - 1) { - sb.append(s.charAt(++i)); - } else { - sb.append(ch); - } - } - return sb.toString(); - } - return s; - } - -} diff --git a/src/main/java/jp/sf/fess/synonym/SynonymManager.java b/src/main/java/jp/sf/fess/synonym/SynonymManager.java deleted file mode 100644 index b17f4120c..000000000 --- a/src/main/java/jp/sf/fess/synonym/SynonymManager.java +++ /dev/null @@ -1,136 +0,0 @@ -package jp.sf.fess.synonym; - -import java.io.File; -import java.util.ArrayList; -import java.util.Collection; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import jp.sf.fess.util.ResourceUtil; - -import org.apache.commons.io.FileUtils; -import org.apache.commons.io.filefilter.AbstractFileFilter; -import org.seasar.extension.timer.TimeoutManager; -import org.seasar.extension.timer.TimeoutTarget; -import org.seasar.extension.timer.TimeoutTask; -import org.seasar.framework.container.annotation.tiger.DestroyMethod; -import org.seasar.framework.container.annotation.tiger.InitMethod; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class SynonymManager { - private static final Logger logger = LoggerFactory - .getLogger(SynonymManager.class); - - protected List searchPathList = new ArrayList(); - - protected Map synonymFileMap; - - public String synonymFilePrefix = "synonym"; - - // public String[] excludedSynonymDirs = new String[] { "data", "txlog", - // "lib", "bin", "contrib" }; - - public Set excludedSynonymSet; - - public long keepAlive = 5 * 60 * 1000; // 5min - - public int watcherTimeout = 60; // 1min - - protected volatile long lifetime = 0; - - protected TimeoutTask watcherTargetTask; - - @InitMethod - public void init() { - // start - final WatcherTarget watcherTarget = new WatcherTarget(); - watcherTargetTask = TimeoutManager.getInstance().addTimeoutTarget( - watcherTarget, watcherTimeout, true); - } - - @DestroyMethod - public void destroy() { - if (watcherTargetTask != null && !watcherTargetTask.isStopped()) { - watcherTargetTask.stop(); - } - } - - public SynonymFile[] getSynonymFiles() { - final Map fileMap = getSynonymFileMap(); - - final Collection values = fileMap.values(); - return values.toArray(new SynonymFile[values.size()]); - } - - public SynonymFile getSynonymFile(final String uri) { - final Map fileMap = getSynonymFileMap(); - - return fileMap.get(uri); - } - - protected Map getSynonymFileMap() { - synchronized (this) { - if (lifetime > System.currentTimeMillis() && synonymFileMap != null) { - lifetime = System.currentTimeMillis() + keepAlive; - return synonymFileMap; - } - - final Map newFileMap = new LinkedHashMap(); - for (final String path : searchPathList) { - final File[] files = findFiles(path); - for (final File file : files) { - if (logger.isInfoEnabled()) { - logger.info("Synonym File: " + file.getAbsolutePath()); - } - newFileMap.put(file.getAbsolutePath(), - new SynonymFile(file)); - } - } - synonymFileMap = newFileMap; - lifetime = System.currentTimeMillis() + keepAlive; - return synonymFileMap; - } - } - - protected File[] findFiles(final String path) { - final Collection files = FileUtils.listFiles(new File(path), - new AbstractFileFilter() { - @Override - public boolean accept(final File dir, final String name) { - return name.startsWith(synonymFilePrefix); - } - }, new AbstractFileFilter() { - @Override - public boolean accept(final File dir, final String name) { - return excludedSynonymSet == null - || !excludedSynonymSet.contains(name); - } - }); - - return files.toArray(new File[files.size()]); - } - - public void addSearchPath(final String path) { - searchPathList.add(ResourceUtil.resolve(path)); - } - - protected class WatcherTarget implements TimeoutTarget { - - @Override - public void expired() { - synchronized (SynonymManager.this) { - if (lifetime <= System.currentTimeMillis() - && synonymFileMap != null) { - if (logger.isDebugEnabled()) { - logger.debug("Cleaning synonym files: " - + synonymFileMap); - } - synonymFileMap = null; - } - } - } - } -} diff --git a/src/main/resources/app.dicon b/src/main/resources/app.dicon index c47af2756..51c6394e3 100644 --- a/src/main/resources/app.dicon +++ b/src/main/resources/app.dicon @@ -10,6 +10,7 @@ + diff --git a/src/main/resources/fess_dic.dicon b/src/main/resources/fess_dic.dicon new file mode 100644 index 000000000..8d7b4a9c8 --- /dev/null +++ b/src/main/resources/fess_dic.dicon @@ -0,0 +1,19 @@ + + + + + + synonymLocator + + + + + {"data", "txlog", + "lib", "bin", "contrib"} + + "${solr.solr.home}" + + + + diff --git a/src/main/resources/fess_synonym.dicon b/src/main/resources/fess_synonym.dicon deleted file mode 100644 index d47005aac..000000000 --- a/src/main/resources/fess_synonym.dicon +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - "${solr.solr.home}" - - - - diff --git a/src/test/java/jp/sf/fess/dic/DictionaryManagerTest.java b/src/test/java/jp/sf/fess/dic/DictionaryManagerTest.java new file mode 100644 index 000000000..02b433e39 --- /dev/null +++ b/src/test/java/jp/sf/fess/dic/DictionaryManagerTest.java @@ -0,0 +1,75 @@ +/* + * Copyright 2009-2013 the Fess Project and the Others. + * + * 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 jp.sf.fess.dic; + +import java.io.File; +import java.util.HashSet; + +import jp.sf.fess.Constants; +import jp.sf.fess.dic.synonym.SynonymLocator; + +import org.apache.commons.io.FileUtils; +import org.seasar.extension.unit.S2TestCase; +import org.seasar.framework.util.FileUtil; + +public class DictionaryManagerTest extends S2TestCase { + + private File testDir; + + private File synonymFile1; + + @Override + protected void setUp() throws Exception { + testDir = File.createTempFile("synonymtest", "_dir"); + testDir.delete(); + testDir.mkdirs(); + synonymFile1 = new File(testDir, "synonym.txt"); + FileUtil.write(synonymFile1.getAbsolutePath(), + "abc=>123\nxyz,890".getBytes(Constants.UTF_8)); + } + + @Override + protected void tearDown() throws Exception { + FileUtils.deleteDirectory(testDir); + } + + public void test_getSynonymFiles() throws Exception { + final DictionaryManager dictionaryManager = new DictionaryManager(); + dictionaryManager.keepAlive = 1000; + dictionaryManager.watcherTimeout = 1; + final SynonymLocator synonymLocator = new SynonymLocator(); + synonymLocator.excludedSynonymSet = new HashSet(); + synonymLocator.excludedSynonymSet.add("data"); + synonymLocator.addSearchPath(testDir.getAbsolutePath()); + dictionaryManager.init(); + final DictionaryFile[] synonymFiles = dictionaryManager + .getDictionaryFiles(); + assertEquals(1, synonymFiles.length); + + assertNotNull(dictionaryManager.dicFileMap); + Thread.sleep(2000); + assertNull(dictionaryManager.dicFileMap); + + final DictionaryFile[] synonymFiles2 = dictionaryManager + .getDictionaryFiles(); + assertEquals(1, synonymFiles2.length); + + assertNotNull(dictionaryManager.dicFileMap); + Thread.sleep(2000); + assertNull(dictionaryManager.dicFileMap); + } +} diff --git a/src/test/java/jp/sf/fess/dic/synonym/SynonymFileTest.java b/src/test/java/jp/sf/fess/dic/synonym/SynonymFileTest.java new file mode 100644 index 000000000..d3fcb5259 --- /dev/null +++ b/src/test/java/jp/sf/fess/dic/synonym/SynonymFileTest.java @@ -0,0 +1,199 @@ +/* + * Copyright 2009-2013 the Fess Project and the Others. + * + * 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 jp.sf.fess.dic.synonym; + +import java.io.File; + +import jp.sf.fess.Constants; +import jp.sf.fess.dic.DictionaryFile.PagingList; +import jp.sf.fess.dic.DictionaryItem; + +import org.seasar.extension.unit.S2TestCase; +import org.seasar.framework.util.FileUtil; + +public class SynonymFileTest extends S2TestCase { + + private File file1; + + @Override + protected void setUp() throws Exception { + file1 = File.createTempFile("synonym", ".txt"); + FileUtil.write(file1.getAbsolutePath(), + "a1=>A1\nb1,b2 => B1\nc1 => C1, C2\nx1,X1\ny1, Y1, y2" + .getBytes(Constants.UTF_8)); + } + + @Override + protected void tearDown() throws Exception { + file1.delete(); + } + + public void test_selectList() { + final SynonymFile synonymFile = new SynonymFile(file1); + final PagingList itemList1 = synonymFile.selectList(0, + 20); + assertEquals(5, itemList1.size()); + assertEquals(5, itemList1.getAllRecordCount()); + assertEquals(1, itemList1.getCurrentPageNumber()); + assertEquals(20, itemList1.getPageSize()); + + final PagingList itemList2 = synonymFile.selectList(4, + 2); + assertEquals(1, itemList2.size()); + assertEquals(5, itemList2.getAllRecordCount()); + assertEquals(3, itemList2.getCurrentPageNumber()); + assertEquals(2, itemList2.getPageSize()); + + assertEquals(0, synonymFile.selectList(5, 5).size()); + assertEquals(0, synonymFile.selectList(-1, 5).size()); + } + + public void test_selectList2() { + final SynonymFile synonymFile = new SynonymFile(file1); + final PagingList itemList = synonymFile + .selectList(0, 5); + assertEquals(1, ((SynonymItem) itemList.get(0)).getInputs().length); + assertEquals(1, ((SynonymItem) itemList.get(0)).getOutputs().length); + assertEquals("a1", ((SynonymItem) itemList.get(0)).getInputs()[0]); + assertEquals("A1", ((SynonymItem) itemList.get(0)).getOutputs()[0]); + assertFalse(((SynonymItem) itemList.get(0)).isUpdated()); + + assertEquals(2, ((SynonymItem) itemList.get(1)).getInputs().length); + assertEquals(1, ((SynonymItem) itemList.get(1)).getOutputs().length); + assertEquals("b1", ((SynonymItem) itemList.get(1)).getInputs()[0]); + assertEquals("b2", ((SynonymItem) itemList.get(1)).getInputs()[1]); + assertEquals("B1", ((SynonymItem) itemList.get(1)).getOutputs()[0]); + assertFalse(((SynonymItem) itemList.get(1)).isUpdated()); + + assertEquals(1, ((SynonymItem) itemList.get(2)).getInputs().length); + assertEquals(2, ((SynonymItem) itemList.get(2)).getOutputs().length); + assertEquals("c1", ((SynonymItem) itemList.get(2)).getInputs()[0]); + assertEquals("C1", ((SynonymItem) itemList.get(2)).getOutputs()[0]); + assertEquals("C2", ((SynonymItem) itemList.get(2)).getOutputs()[1]); + assertFalse(((SynonymItem) itemList.get(2)).isUpdated()); + + assertEquals(2, ((SynonymItem) itemList.get(3)).getInputs().length); + assertEquals(2, ((SynonymItem) itemList.get(3)).getOutputs().length); + assertEquals("X1", ((SynonymItem) itemList.get(3)).getInputs()[0]); + assertEquals("x1", ((SynonymItem) itemList.get(3)).getInputs()[1]); + assertEquals("X1", ((SynonymItem) itemList.get(3)).getOutputs()[0]); + assertEquals("x1", ((SynonymItem) itemList.get(3)).getOutputs()[1]); + assertFalse(((SynonymItem) itemList.get(3)).isUpdated()); + + assertEquals(3, ((SynonymItem) itemList.get(4)).getInputs().length); + assertEquals(3, ((SynonymItem) itemList.get(4)).getOutputs().length); + assertEquals("Y1", ((SynonymItem) itemList.get(4)).getInputs()[0]); + assertEquals("y1", ((SynonymItem) itemList.get(4)).getInputs()[1]); + assertEquals("y2", ((SynonymItem) itemList.get(4)).getInputs()[2]); + assertEquals("Y1", ((SynonymItem) itemList.get(4)).getOutputs()[0]); + assertEquals("y1", ((SynonymItem) itemList.get(4)).getOutputs()[1]); + assertEquals("y2", ((SynonymItem) itemList.get(4)).getOutputs()[2]); + assertFalse(((SynonymItem) itemList.get(4)).isUpdated()); + } + + public void test_insert() { + final SynonymFile synonymFile = new SynonymFile(file1); + final PagingList itemList1 = synonymFile.selectList(0, + 20); + assertEquals(5, itemList1.size()); + + final SynonymItem synonymItem1 = new SynonymItem(0, new String[] { + "z1", "z2" }, new String[] { "Z1", "Z2" }); + synonymFile.insert(synonymItem1); + final PagingList itemList2 = synonymFile.selectList(0, + 20); + assertEquals(6, itemList2.size()); + assertEquals("z1", ((SynonymItem) itemList2.get(5)).getInputs()[0]); + assertEquals("z2", ((SynonymItem) itemList2.get(5)).getInputs()[1]); + assertEquals("Z1", ((SynonymItem) itemList2.get(5)).getOutputs()[0]); + assertEquals("Z2", ((SynonymItem) itemList2.get(5)).getOutputs()[1]); + + final SynonymItem synonymItem2 = new SynonymItem(0, new String[] { + "z1", "z2" }, new String[] { "z1", "z2" }); + synonymFile.insert(synonymItem2); + final PagingList itemList3 = synonymFile.selectList(0, + 20); + assertEquals(7, itemList3.size()); + assertEquals("z1", ((SynonymItem) itemList3.get(6)).getInputs()[0]); + assertEquals("z2", ((SynonymItem) itemList3.get(6)).getInputs()[1]); + assertEquals("z1", ((SynonymItem) itemList3.get(6)).getOutputs()[0]); + assertEquals("z2", ((SynonymItem) itemList3.get(6)).getOutputs()[1]); + } + + public void test_update() { + final SynonymFile synonymFile = new SynonymFile(file1); + final PagingList itemList1 = synonymFile.selectList(0, + 20); + assertEquals(5, itemList1.size()); + + final SynonymItem synonymItem1 = (SynonymItem) itemList1.get(0); + synonymItem1.setNewInputs(new String[] { "a1", "a2" }); + synonymItem1.setNewOutputs(new String[] { "A1", "A2" }); + synonymFile.update(synonymItem1); + final PagingList itemList2 = synonymFile.selectList(0, + 20); + assertEquals(5, itemList2.size()); + final SynonymItem synonymItem2 = (SynonymItem) itemList2.get(0); + assertEquals(2, synonymItem2.getInputs().length); + assertEquals(2, synonymItem2.getOutputs().length); + assertEquals("a1", synonymItem2.getInputs()[0]); + assertEquals("a2", synonymItem2.getInputs()[1]); + assertEquals("A1", synonymItem2.getOutputs()[0]); + assertEquals("A2", synonymItem2.getOutputs()[1]); + assertFalse(synonymItem2.isUpdated()); + + final SynonymItem synonymItem3 = (SynonymItem) itemList2.get(2); + synonymItem3.setNewInputs(new String[] { "c1", "c2" }); + synonymItem3.setNewOutputs(new String[] { "c1", "c2" }); + synonymFile.update(synonymItem3); + final PagingList itemList3 = synonymFile.selectList(0, + 20); + assertEquals(5, itemList3.size()); + final SynonymItem synonymItem4 = (SynonymItem) itemList3.get(2); + assertEquals(2, synonymItem4.getInputs().length); + assertEquals(2, synonymItem4.getOutputs().length); + assertEquals("c1", synonymItem4.getInputs()[0]); + assertEquals("c2", synonymItem4.getInputs()[1]); + assertEquals("c1", synonymItem4.getOutputs()[0]); + assertEquals("c2", synonymItem4.getOutputs()[1]); + assertFalse(synonymItem2.isUpdated()); + } + + public void test_delete() throws Exception { + final SynonymFile synonymFile = new SynonymFile(file1); + final PagingList itemList1 = synonymFile.selectList(0, + 20); + assertEquals(5, itemList1.size()); + + final SynonymItem synonymItem1 = (SynonymItem) itemList1.get(0); + synonymFile.delete(synonymItem1); + final PagingList itemList2 = synonymFile.selectList(0, + 20); + assertEquals(4, itemList2.size()); + + final SynonymItem synonymItem2 = (SynonymItem) itemList2.get(3); + synonymFile.delete(synonymItem2); + final PagingList itemList3 = synonymFile.selectList(0, + 20); + assertEquals(3, itemList3.size()); + + assertEquals("b1,b2=>B1" + System.lineSeparator() + "c1=>C1,C2" + + System.lineSeparator() + "X1,x1" + System.lineSeparator(), + new String(FileUtil.getBytes(file1), Constants.UTF_8)); + + } +} diff --git a/src/test/java/jp/sf/fess/dic/synonym/SynonymItemTest.java b/src/test/java/jp/sf/fess/dic/synonym/SynonymItemTest.java new file mode 100644 index 000000000..b0a60b9e0 --- /dev/null +++ b/src/test/java/jp/sf/fess/dic/synonym/SynonymItemTest.java @@ -0,0 +1,120 @@ +/* + * Copyright 2009-2013 the Fess Project and the Others. + * + * 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 jp.sf.fess.dic.synonym; + +import org.seasar.extension.unit.S2TestCase; + +public class SynonymItemTest extends S2TestCase { + + public void test_new1() { + final SynonymItem synonymItem = new SynonymItem(1, new String[] { "a", + "A" }, new String[] { "b", "B" }); + assertEquals(1, synonymItem.getId()); + assertEquals(2, synonymItem.getInputs().length); + assertEquals("A", synonymItem.getInputs()[0]); + assertEquals("a", synonymItem.getInputs()[1]); + assertEquals(2, synonymItem.getOutputs().length); + assertEquals("B", synonymItem.getOutputs()[0]); + assertEquals("b", synonymItem.getOutputs()[1]); + assertNull(synonymItem.getNewInputs()); + assertNull(synonymItem.getNewOutputs()); + assertFalse(synonymItem.isUpdated()); + assertFalse(synonymItem.isDeleted()); + + synonymItem.setNewInputs(new String[] { "1", "2" }); + synonymItem.setNewOutputs(new String[] { "3", "4" }); + assertTrue(synonymItem.isUpdated()); + assertFalse(synonymItem.isDeleted()); + + synonymItem.setNewInputs(new String[0]); + synonymItem.setNewOutputs(new String[0]); + assertTrue(synonymItem.isUpdated()); + assertTrue(synonymItem.isDeleted()); + } + + public void test_new2() { + final SynonymItem synonymItem = new SynonymItem(1, new String[] { "A", + "a" }, new String[] { "B", "b" }); + assertEquals(1, synonymItem.getId()); + assertEquals(2, synonymItem.getInputs().length); + assertEquals("A", synonymItem.getInputs()[0]); + assertEquals("a", synonymItem.getInputs()[1]); + assertEquals(2, synonymItem.getOutputs().length); + assertEquals("B", synonymItem.getOutputs()[0]); + assertEquals("b", synonymItem.getOutputs()[1]); + assertNull(synonymItem.getNewInputs()); + assertNull(synonymItem.getNewOutputs()); + assertFalse(synonymItem.isUpdated()); + assertFalse(synonymItem.isDeleted()); + + synonymItem.setNewInputs(new String[] { "2", "1" }); + synonymItem.setNewOutputs(new String[] { "4", "3" }); + assertTrue(synonymItem.isUpdated()); + assertFalse(synonymItem.isDeleted()); + + synonymItem.setNewInputs(new String[0]); + synonymItem.setNewOutputs(new String[0]); + assertTrue(synonymItem.isUpdated()); + assertTrue(synonymItem.isDeleted()); + } + + public void test_equals1() { + final SynonymItem synonymItem1 = new SynonymItem(1, new String[] { "a", + "A" }, new String[] { "b", "B" }); + + assertTrue(synonymItem1.equals(synonymItem1)); + assertTrue(synonymItem1.equals(new SynonymItem(1, new String[] { "A", + "a" }, new String[] { "B", "b" }))); + assertTrue(synonymItem1.equals(new SynonymItem(2, new String[] { "A", + "a" }, new String[] { "B", "b" }))); + assertFalse(synonymItem1.equals(new SynonymItem(2, new String[] { "A", + "a" }, new String[] { "B", }))); + assertFalse(synonymItem1.equals(new SynonymItem(2, + new String[] { "A" }, new String[] { "B", "b" }))); + assertFalse(synonymItem1.equals(new SynonymItem(1, new String[] { "A", + "a" }, new String[] { "B", "c" }))); + assertFalse(synonymItem1.equals(new SynonymItem(1, new String[] { "A", + "c" }, new String[] { "B", "b" }))); + } + + public void test_equals2() { + final SynonymItem synonymItem1 = new SynonymItem(1, + new String[] { "a" }, new String[] { "b" }); + + assertTrue(synonymItem1.equals(synonymItem1)); + assertTrue(synonymItem1.equals(new SynonymItem(1, new String[] { "a" }, + new String[] { "b" }))); + assertFalse(synonymItem1.equals(new SynonymItem(2, + new String[] { "a" }, new String[] { "B", }))); + assertFalse(synonymItem1.equals(new SynonymItem(2, + new String[] { "A" }, new String[] { "b" }))); + } + + public void test_toLineString() { + assertEquals("a1,a2,a3=>b1,b2,b3", + new SynonymItem(1, new String[] { "a1", "a2", "a3" }, + new String[] { "b1", "b2", "b3" }).toLineString()); + assertEquals("a=>b", new SynonymItem(1, new String[] { "a" }, + new String[] { "b" }).toLineString()); + assertEquals("A,a=>B,b", new SynonymItem(1, new String[] { "a", "A" }, + new String[] { "b", "B" }).toLineString()); + assertEquals("A,a", new SynonymItem(1, new String[] { "a", "A" }, + new String[] { "a", "A" }).toLineString()); + assertEquals("a", new SynonymItem(1, new String[] { "a" }, + new String[] { "a" }).toLineString()); + } +} diff --git a/src/test/java/jp/sf/fess/synonym/SynonymManagerTest.java b/src/test/java/jp/sf/fess/dic/synonym/SynonymLocatorTest.java similarity index 60% rename from src/test/java/jp/sf/fess/synonym/SynonymManagerTest.java rename to src/test/java/jp/sf/fess/dic/synonym/SynonymLocatorTest.java index 98f526199..2e80700d5 100644 --- a/src/test/java/jp/sf/fess/synonym/SynonymManagerTest.java +++ b/src/test/java/jp/sf/fess/dic/synonym/SynonymLocatorTest.java @@ -14,18 +14,20 @@ * governing permissions and limitations under the License. */ -package jp.sf.fess.synonym; +package jp.sf.fess.dic.synonym; import java.io.File; import java.util.HashSet; +import java.util.Map; import jp.sf.fess.Constants; +import jp.sf.fess.dic.DictionaryFile; import org.apache.commons.io.FileUtils; import org.seasar.extension.unit.S2TestCase; import org.seasar.framework.util.FileUtil; -public class SynonymManagerTest extends S2TestCase { +public class SynonymLocatorTest extends S2TestCase { private File testDir; @@ -75,37 +77,19 @@ public class SynonymManagerTest extends S2TestCase { FileUtils.deleteDirectory(testDir); } - public void test_findFiles() { - final SynonymManager synonymManager = new SynonymManager(); - synonymManager.excludedSynonymSet = new HashSet(); - synonymManager.excludedSynonymSet.add("data"); - final File[] files = synonymManager - .findFiles(testDir.getAbsolutePath()); - assertEquals(2, files.length); - assertEquals(synonymFile1.getAbsolutePath(), files[0].getAbsolutePath()); - assertEquals(synonymFile3.getAbsolutePath(), files[1].getAbsolutePath()); + public void test_find() { + final SynonymLocator synonymLocator = new SynonymLocator(); + synonymLocator.excludedSynonymSet = new HashSet(); + synonymLocator.excludedSynonymSet.add("data"); + synonymLocator.addSearchPath(testDir.getAbsolutePath()); + final Map fileMap = synonymLocator.find(); + assertEquals(2, fileMap.size()); + final DictionaryFile dicFile1 = fileMap.get(synonymFile1 + .getAbsolutePath()); + final DictionaryFile dicFile2 = fileMap.get(synonymFile3 + .getAbsolutePath()); + assertEquals(synonymFile1.getAbsolutePath(), dicFile1.getName()); + assertEquals(synonymFile3.getAbsolutePath(), dicFile2.getName()); } - public void test_getSynonymFiles() throws Exception { - final SynonymManager synonymManager = new SynonymManager(); - synonymManager.keepAlive = 1000; - synonymManager.watcherTimeout = 1; - synonymManager.excludedSynonymSet = new HashSet(); - synonymManager.excludedSynonymSet.add("data"); - synonymManager.addSearchPath(testDir.getAbsolutePath()); - synonymManager.init(); - final SynonymFile[] synonymFiles = synonymManager.getSynonymFiles(); - assertEquals(2, synonymFiles.length); - - assertNotNull(synonymManager.synonymFileMap); - Thread.sleep(2000); - assertNull(synonymManager.synonymFileMap); - - final SynonymFile[] synonymFiles2 = synonymManager.getSynonymFiles(); - assertEquals(2, synonymFiles2.length); - - assertNotNull(synonymManager.synonymFileMap); - Thread.sleep(2000); - assertNull(synonymManager.synonymFileMap); - } }