201504.mbox/raw/%3c20150406171412.56800AC0E2D@hades.apache.org%3e

+
+    /*
+     * Licensed to the Apache Software Foundation (ASF) under one
+     * or more contributor license agreements.  See the NOTICE file
+     * distributed with this work for additional information
+     * regarding copyright ownership.  The ASF licenses this file
+     * to you 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 org.apache.chemistry.opencmis.util.content.loremipsum;
+
+    import java.io.IOException;
+    import java.io.StringWriter;
+    import java.util.ArrayList;
+    import java.util.Arrays;
+    import java.util.HashMap;
+    import java.util.HashSet;
+    import java.util.List;
+    import java.util.Map;
+    import java.util.Random;
+    import java.util.Set;
+
+    /**
+     * A generator of lorem ipsum text ported from the Python implementation at
+     * http://code.google.com/p/lorem-ipsum-generator/. Note: original code licensed
+     * under the BSD license
+     *
+     */
+    public class LoremIpsum {
+
+        private static class WordLengthPair {
+            public int len1;
+            public int len2;
+
+            public WordLengthPair(int len1, int len2) {
+                this.len1 = len1;
+                this.len2 = len2;
+            }
+
+            @Override
+            public String toString() {
+                return "WordLengthPair: len1: " + len1 + ", len2: " + len2;
+            }
+
+            @Override
+            public boolean equals(Object other) {
+                if (this == null || other == null) {
+                    return false;
+                }
+                if (other.getClass() != getClass()) {
+                    return false;
+                }
+
+                return (len1 == ((WordLengthPair) other).len1 && len2 == ((WordLengthPair) other).len2);
+            }
+
+            @Override
+            public int hashCode() {
+                return len1 ^ len2;
+            }
+        }
+
+        /**
+         * Delimiters that end sentences.
+         *
+         * @type {Array.<string>}
+         * @private
+         */
+        private static final String DELIMITERS_SENTENCES[] = { ".", "?", "!" };
+
+        /**
+         * Regular expression for splitting a text into sentences.
+         *
+         * @type {RegExp}
+         * @private
+         */
+        private static final String SENTENCE_SPLIT_REGEX = "[\\.\\?\\!]";
+
+        /**
+         * Delimiters that end words.
+         *
+         * @type {Array.<string>}
+         * @private
+         */
+        private static final String DELIMITERS_WORDS[] = { ".", ",", "?", "!" };
+
+        /**
+         * Regular expression for splitting text into words.
+         *
+         * @type {RegExp}
+         * @private
+         */
+        private static final String WORD_SPLIT_REGEX = "\\s";
+
+        private static final String LINE_SEPARATOR = System.getProperty("line.separator");
+
+        /**
+         * Words that can be used in the generated output. Maps a word-length to a
+         * list of words of that length.
+         *
+         * @type {goog.structs.Map}
+         * @private
+         */
+        private Map<Integer, List<String>> words;
+
+        /**
+         * Chains of three words that appear in the sample text Maps a pair of
+         * word-lengths to a third word-length and an optional piece of trailing
+         * punctuation (for example, a period, comma, etc.).
+         *
+         * @type {goog.structs.Map}
+         * @private
+         */
+        private Map<WordLengthPair, List<WordInfo>> chains;
+
+        /**
+         * Pairs of word-lengths that can appear at the beginning of sentences.
+         *
+         * @type {Array}
+         */
+        private List<WordLengthPair> starts;
+
+        /**
+         * Average sentence length in words.
+         *
+         * @type {number}
+         * @private
+         */
+        private double sentenceMean;
+
+        /**
+         * Sigma (sqrt of Objectiance) for the sentence length in words.
+         *
+         * @type {number}
+         * @private
+         */
+        private double sentenceSigma;
+
+        /**
+         * Average paragraph length in sentences.
+         *
+         * @type {number}
+         * @private
+         */
+        private double paragraphMean;
+
+        /**
+         * Sigma (sqrt of variance) for the paragraph length in sentences.
+         *
+         * @type {number}
+         * @private
+         */
+        private double paragraphSigma;
+
+        /**
+         * Sample that the generated text is based on .
+         *
+         * @type {string}
+         */
+        private String sample = SAMPLE;
+
+        /**
+         * Dictionary of words.
+         *
+         * @type {string}
+         */
+        private String dictionary = DICT;
+
+        /**
+         * Picks a random element of the array.
+         *
+         * @param {Array} array The array to pick from.
+         * @return {*} An element from the array.
+         */
+        private WordInfo randomChoice(WordInfo[] array) {
+            return array[randomInt(array.length)];
+        };
+
+        private String randomChoice(String[] array) {
+            return array[randomInt(array.length)];
+        };
+
+        private int randomInt(int length) {
+            return randomGenerator.nextInt(length);
+        }
+
+        private static class WordInfo {
+            int len;
+            String delim;
+        }
+
+        private Random randomGenerator = new Random();
+
+        /**
+         * Generates random strings of "lorem ipsum" text, based on the word
+         * distribution of a sample text, using the words in a dictionary.
+         *
+         * @constructor
+         */
+        public LoremIpsum() {
+            generateChains(this.sample);
+            generateStatistics(this.sample);
+            initializeDictionary(this.dictionary);
+        };
+
+        public LoremIpsum(String sample, String dictionary) {
+            this.sample = sample;
+            this.dictionary = dictionary;
+            generateChains(this.sample);
+            generateStatistics(this.sample);
+            initializeDictionary(this.dictionary);
+        };
+
+        public LoremIpsum(String sample, String[] newDictionary) {
+            this.sample = sample;
+            this.dictionary = null;
+            generateChains(this.sample);
+            generateStatistics(this.sample);
+            initializeDictionary(newDictionary);
+        };
+
+        public LoremIpsum(String sample) {
+            this.sample = sample;
+            String[] dictWords = filterNotEmptyOrWhiteSpace(sample.split("[^\\p{L}]"/* "\\W" */)).toArray(new String[0]);
+            Set<String> dict = new HashSet<String>(Arrays.asList(dictWords));
+            dictWords = dict.toArray(new String[0]);
+            Arrays.sort(dictWords);
+
+            generateChains(this.sample);
+            generateStatistics(this.sample);
+            initializeDictionary(dictWords);
+        };
+
+        /**
+         * Generates a single lorem ipsum paragraph, of random length.
+         *
+         * @param {boolean} optStartWithLorem Whether to start the sentence with the
+         *        standard "Lorem ipsum..." first sentence.
+         * @return {string} The generated sentence.
+         */
+        public String generateParagraph(boolean optStartWithLorem) {
+            // The length of the paragraph is a normally distributed random
+            // Objectiable.
+            Double paragraphLengthDbl = randomNormal(this.paragraphMean, this.paragraphSigma);
+            int paragraphLength = Math.max((int) Math.floor(paragraphLengthDbl), 1);
+
+            // Construct a paragraph from a number of sentences.
+            List<String> paragraph = new ArrayList<String>();
+            boolean startWithLorem = optStartWithLorem;
+            while (paragraph.size() < paragraphLength) {
+                String sentence = this.generateSentence(startWithLorem);
+                paragraph.add(sentence);
+                startWithLorem = false;
+            }
+
+            StringBuffer result = new StringBuffer();
+            // Form the paragraph into a string.
+            for (String sentence : paragraph) {
+                result.append(sentence);
+                result.append(" ");
+            }
+            return result.toString();
+        }
+
+        /**
+         * Generates a single sentence, of random length.
+         *
+         * @param {boolean} optStartWithLorem Whether to start the setnence with the
+         *        standard "Lorem ipsum..." first sentence.
+         * @return {string} The generated sentence.
+         */
+        public String generateSentence(boolean optStartWithLorem) {
+            if (this.chains.size() == 0 || this.starts.size() == 0) {
+                throw new RuntimeException("No chains created (Invalid sample text?)");
+            }
+
+            if (this.words.size() == 0) {
+                throw new RuntimeException("No dictionary");
+            }
+
+            // The length of the sentence is a normally distributed random
+            // Objectiable.
+            double sentenceLengthDbl = randomNormal(this.sentenceMean, this.sentenceSigma);
+            int sentenceLength = Math.max((int) Math.floor(sentenceLengthDbl), 1);
+
+            String wordDelimiter = ""; // Defined here in case while loop doesn't
+                                       // run
+
+            // Start the sentence with "Lorem ipsum...", if desired
+            List<String> sentence;
+
+            if (optStartWithLorem) {
+                String lorem = "lorem ipsum dolor sit amet, consecteteur adipiscing elit";
+                sentence = new ArrayList<String>(Arrays.asList(splitWords(lorem)));
+                if (sentence.size() > sentenceLength) {
+                    sentence.subList(0, sentenceLength);
+                }
+                String lastWord = sentence.get(sentence.size() - 1);
+                String lastChar = lastWord.substring(lastWord.length() - 1);
+                if (contains(DELIMITERS_WORDS, lastChar)) {
+                    wordDelimiter = lastChar;
+                }
+            } else {
+                sentence = new ArrayList<String>();
+            }
+
+            WordLengthPair previous = new WordLengthPair(0, 0);
+
+            // Generate a sentence from the "chains"
+            while (sentence.size() < sentenceLength) {
+                // If the current starting point is invalid, choose another randomly
+                if (!this.chains.containsKey(previous)) {
+                    previous = this.chooseRandomStart_();
+                }
+
+                // Choose the next "chain" to go to. This determines the next word
+                // length we use, and whether there is e.g. a comma at the end of
+                // the word.
+                WordInfo chain = randomChoice(this.chains.get(previous).toArray(new WordInfo[0]));
+                int wordLength = chain.len;
+
+                // If the word delimiter contained in the chain is also a sentence
+                // delimiter, then we don"t include it because we don"t want the
+                // sentence to end prematurely (we want the length to match the
+                // sentence_length value).
+                if (contains(DELIMITERS_SENTENCES, chain.delim)) {
+                    wordDelimiter = "";
+                } else {
+                    wordDelimiter = chain.delim;
+                }
+
+                // Choose a word randomly that matches (or closely matches) the
+                // length we're after.
+                int closestLength = chooseClosest(this.words.keySet().toArray(new Integer[0]), wordLength);
+                String word = randomChoice(this.words.get(closestLength).toArray(new String[0]));
+
+                sentence.add(word + wordDelimiter);
+                previous = new WordLengthPair(previous.len2, wordLength);
+
+            }
+
+            // Finish the sentence off with capitalisation, a period and
+            // form it into a string
+            StringBuffer result = new StringBuffer();
+            for (String s : sentence) {
+                result.append(s);
+                result.append(" ");
+            }
+            result.deleteCharAt(result.length() - 1);
+
+            result.replace(0, 1, result.substring(0, 1).toUpperCase());
+            int strLen = result.length() - 1;
+            if (wordDelimiter.length() > 0 && wordDelimiter.charAt(0) == result.charAt(strLen)) {
+                result.deleteCharAt(strLen);
+            }
+            result.append(".");
+            return result.toString();
+        }
+
+        public String getSample() {
+            return sample;
+        }
+
+        public void setSample(String sample) {
+            this.sample = sample;
+            generateChains(this.sample);
+            generateStatistics(this.sample);
+        }
+
+        public String getDictionary() {
+            return dictionary;
+        }
+
+        public void setDictionary(String dictionary) {
+            this.dictionary = dictionary;
+            initializeDictionary(this.dictionary);
+        }
+
+        /**
+         * Generates multiple paragraphs of text, with begin before the paragraphs,
+         * end after the paragraphs, and between between each two paragraphs.
+         */
+        private String generateMarkupParagraphs(String begin, String end, String between, int quantity,
+                boolean startWithLorem) {
+
+            StringBuffer text = new StringBuffer();
+
+            text.append(begin);
+            String para = generateParagraph(startWithLorem);
+            text.append(para);
+            while (text.length() < quantity) {
+                para = generateParagraph(false);
+                text.append(para);
+                if (text.length() < quantity) {
+                    text.append(between);
+                }
+            }
+
+            text.append(end);
+            return text.toString();
+        }
+
+        /**
+         * Generates multiple paragraphs of text, with begin before the paragraphs,
+         * end after the paragraphs, and between between each two paragraphs.
+         *
+         * @throws IOException
+         */
+        private void generateMarkupParagraphs(Appendable writer, String begin, String end, String between, int quantity,
+                boolean startWithLorem) throws IOException {
+
+            int len = begin.length();
+            writer.append(begin);
+            String para = generateParagraph(startWithLorem);
+            len += para.length();
+            writer.append(para);
+            while (len < quantity) {
+                para = generateParagraph(false);
+                len += para.length();
+                writer.append(para);
+                if (len < quantity) {
+                    writer.append(between);
+                    len += para.length();
+                }
+            }
+
+            writer.append(end);
+        }
+
+        /**
+         * Generates multiple sentences of text, with begin before the sentences,
+         * end after the sentences, and between between each two sentences.
+         */
+        private String generateMarkupSentences(String begin, String end, String between, int quantity,
+                boolean startWithLorem) {
+
+            StringBuffer text = new StringBuffer();
+            text.append(begin);
+            String sentence = generateSentence(startWithLorem);
+            text.append(sentence);
+
+            while (text.length() < quantity) {
+                sentence = generateSentence(false);
+                text.append(sentence);
+                if (text.length() < quantity) {
+                    text.append(between);
+                }
+            }
+
+            text.append(end);
+            return text.toString();
+        }
+
+        /**
+         * Generates the chains and starts values required for sentence generation.
+         *
+         * @param {string} sample The same text.
+         * @private
+         */
+        private void generateChains(String sample) {
+
+            String[] words = splitWords(sample);
+            WordInfo[] wordInfos = generateWordInfo(words);
+            WordLengthPair previous = new WordLengthPair(0, 0);
+            List<WordLengthPair> starts = new ArrayList<WordLengthPair>();
+            List<String> delimList = Arrays.asList(DELIMITERS_SENTENCES);
+            Map<WordLengthPair, List<WordInfo>> chains = new HashMap<WordLengthPair, List<WordInfo>>();
+
+            for (WordInfo wi : wordInfos) {
+                if (wi.len == 0) {
+                    continue;
+                }
+
+                List<WordInfo> value = chains.get(previous);
+                if (null == value) {
+                    chains.put(previous, new ArrayList<WordInfo>());
+                } else {
+                    chains.get(previous).add(wi);
+                }
+
+                if (delimList.contains(wi.delim)) {
+                    starts.add(previous);
+                }
+
+                previous.len1 = previous.len2;
+                previous.len2 = wi.len;
+            }
+
+            if (chains.isEmpty()) {
+                throw new RuntimeException("Invalid sample text.");
+            }
+
+            this.chains = chains;
+            this.starts = starts;
+        }
+
+        /**
+         * Calculates the mean and standard deviation of sentence and paragraph
+         * lengths.
+         *
+         * @param {string} sample The same text.
+         * @private
+         */
+        private void generateStatistics(String sample) {
+            this.generateSentenceStatistics(sample);
+            this.generateParagraphStatistics(sample);
+        }
+
+        /**
+         * Calculates the mean and standard deviation of the lengths of sentences
+         * (in words) in a sample text.
+         *
+         * @param {string} sample The same text.
+         * @private
+         */
+        private void generateSentenceStatistics(String sample) {
+            List<String> sentences = filterNotEmptyOrWhiteSpace(splitSentences(sample));
+            int sentenceLengths[] = new int[sentences.size()];
+            for (int i = 0; i < sentences.size(); i++) {
+                String[] words = splitWords(sentences.get(i));
+                sentenceLengths[i] = words.length;
+            }
+            this.sentenceMean = mean(sentenceLengths);
+            this.sentenceSigma = sigma(sentenceLengths);
+        }
+
+        /**
+         * Calculates the mean and standard deviation of the lengths of paragraphs
+         * (in sentences) in a sample text.
+         *
+         * @param {string} sample The same text.
+         * @private
+         */
+        private void generateParagraphStatistics(String sample) {
+            List<String> paragraphs = filterNotEmptyOrWhiteSpace(splitParagraphs(sample));
+
+            int paragraphLengths[] = new int[paragraphs.size()];
+            for (int i = 0; i < paragraphs.size(); i++) {
+                String[] sentences = splitSentences(paragraphs.get(i));
+                paragraphLengths[i] = sentences.length;
+            }
+
+            this.paragraphMean = mean(paragraphLengths);
+            this.paragraphSigma = sigma(paragraphLengths);
+        }
+
+        /**
+         * Sets the generator to use a given selection of words for generating
+         * sentences with.
+         *
+         * @param {string} dictionary The dictionary to use.
+         */
+        private void initializeDictionary(String dictionary) {
+            String[] dictionaryWords = splitWords(dictionary);
+            initializeDictionary(dictionaryWords);
+        }
+
+        private void initializeDictionary(String[] dictionaryWords) {
+            words = new HashMap<Integer, List<String>>();
+            for (String word : dictionaryWords) {
+                List<String> wordWithLen = words.get(word.length());
+                if (null == wordWithLen) {
+                    List<String> list = new ArrayList<String>();
+                    list.add(word);
+                    words.put(word.length(), list);
+                } else {
+                    wordWithLen.add(word);
+                }
+            }
+
+            if (words.size() == 0) {
+                throw new RuntimeException("Invalid dictionary.");
+            }
+        }
+
+        /**
+         * Picks a random starting chain.
+         *
+         * @return {string} The starting key.
+         * @private
+         */
+        private WordLengthPair chooseRandomStart_() {
+            Set<WordLengthPair> keys = chains.keySet();
+            Set<WordLengthPair> validStarts = new HashSet<WordLengthPair>(starts);
+            validStarts.retainAll(keys);
+            int index = randomInt(validStarts.size());
+            WordLengthPair wlPair = validStarts.toArray(new WordLengthPair[0])[index];
+            return wlPair;
+        }
+
+        /**
+         * Splits a piece of text into paragraphs.
+         *
+         * @param {string} text The text to split.
+         * @return {Array.<string>} An array of paragraphs.
+         * @private
+         */
+
+        static String[] splitParagraphs(String text) {
+            return filterNotEmptyOrWhiteSpace(text.split("\n")).toArray(new String[0]);
+        }
+
+        /**
+         * Splits a piece of text into sentences.
+         *
+         * @param {string} text The text to split.
+         * @return {Array.<string>} An array of sentences.
+         * @private
+         */
+        static String[] splitSentences(String text) {
+            return filterNotEmptyOrWhiteSpace(text.split(SENTENCE_SPLIT_REGEX)).toArray(new String[0]);
+        }
+
+        /**
+         * Splits a piece of text into words..
+         *
+         * @param {string} text The text to split.
+         * @return {Array.<string>} An array of words.
+         * @private
+         */
+        static String[] splitWords(String text) {
+            return filterNotEmptyOrWhiteSpace(text.split(WORD_SPLIT_REGEX)).toArray(new String[0]);
+        }
+
+        /**
+         * Find the number in the list of values that is closest to the target.
+         *
+         * @param {Array.<number>} values The values.
+         * @param {number} target The target value.
+         * @return {number} The closest value.
+         */
+        static int chooseClosest(Integer[] values, int target) {
+            int closest = values[0];
+            for (int value : values) {
+                if (Math.abs(target - value) < Math.abs(target - closest)) {
+                    closest = value;
+                }
+            }
+
+            return closest;
+        }
+
+        /**
+         * Gets info about a word used as part of the lorem ipsum algorithm.
+         *
+         * @param {string} word The word to check.
+         * @return {Array} A two element array. The first element is the size of the
+         *         word. The second element is the delimiter used in the word.
+         * @private
+         */
+        private static WordInfo getWordInfo(String word) {
+            WordInfo ret = new WordInfo();
+            for (String delim : DELIMITERS_WORDS) {
+                if (word.endsWith(delim)) {
+                    ret.len = word.length() - delim.length();
+                    ret.delim = delim;
+                    return ret;
+                }
+            }
+            ret.len = word.length();
+            ret.delim = "";
+            return ret;
+        }
+
+        private static WordInfo[] generateWordInfo(String[] words) {
+            WordInfo[] result = new WordInfo[words.length];
+            int i = 0;
+            for (String word : words) {
+                result[i++] = getWordInfo(word);
+            }
+            return result;
+        }
+
+        /**
+         * Constant used for {@link #randomNormal_}.
+         *
+         * @type {number}
+         * @private
+         */
+        private static final double NV_MAGICCONST_ = 4 * Math.exp(-0.5) / Math.sqrt(2.0);
+
+        /**
+         * Generates a random number for a normal distribution with the specified
+         * mean and sigma.
+         *
+         * @param {number} mu The mean of the distribution.
+         * @param {number} sigma The sigma of the distribution.
+         * @private
+         */
+        private static double randomNormal(double mu, double sigma) {
+            double z = 0.0d;
+            while (true) {
+                double u1 = Math.random();
+                double u2 = 1.0d - Math.random();
+                z = NV_MAGICCONST_ * (u1 - 0.5d) / u2;
+                double zz = z * z / 4.0d;
+                if (zz <= -Math.log(u2)) {
+                    break;
+                }
+            }
+            return mu + z * sigma;
+        }
+
+        /**
+         * Returns the text if it is not empty or just whitespace.
+         *
+         * @param {string} text the text to check.
+         * @return {boolean} Whether the text is neither empty nor whitespace.
+         * @private
+         */

[... 461 lines stripped ...]