mittens 0.1.0

data/vendor/snowball/csharp/Snowball/Stemmer.cs

@@ -0,0 +1,660 @@
+// Copyright (c) 2001, Dr Martin Porter
+// Copyright (c) 2002, Richard Boulton
+// Copyright (c) 2015, Cesar Souza
+// Copyright (c) 2018, Olly Betts
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//     * Redistributions of source code must retain the above copyright notice,
+//     * this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//     * notice, this list of conditions and the following disclaimer in the
+//     * documentation and/or other materials provided with the distribution.
+//     * Neither the name of the copyright holders nor the names of its contributors
+//     * may be used to endorse or promote products derived from this software
+//     * without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+namespace Snowball
+{
+    using System;
+    using System.Linq;
+    using System.Text;
+
+    /// <summary>
+    ///   Class holding current state.
+    /// </summary>
+    /// 
+    public class Env
+    {
+        /// <summary>
+        ///   Initializes a new instance of the <see cref="Env"/> class.
+        /// </summary>
+        /// 
+        protected Env()
+        {
+        }
+
+        /// <summary>
+        ///   Gets the current string.
+        /// </summary>
+        /// 
+        protected StringBuilder current;
+
+        /// <summary>
+        ///   Current cursor position.
+        /// </summary>
+        /// 
+        protected int cursor;
+
+        /// <summary>
+        ///   Forward limit for inspecting the buffer.
+        /// </summary>
+        /// 
+        protected int limit;
+
+        /// <summary>
+        ///   Backward limit for inspecting the buffer.
+        /// </summary>
+        /// 
+        protected int limit_backward;
+
+        /// <summary>
+        ///   Starting bracket position.
+        /// </summary>
+        /// 
+        protected int bra;
+
+        /// <summary>
+        ///   Ending bracket position.
+        /// </summary>
+        /// 
+        protected int ket;
+
+        /// <summary>
+        ///   Copy another Env object.
+        /// </summary>
+        /// 
+        public Env(Env other)
+        {
+            copy_from(other);
+        }
+
+        /// <summary>
+        ///   Copy another Env object.
+        /// </summary>
+        /// 
+        protected void copy_from(Env other)
+        {
+            current          = other.current;
+            cursor           = other.cursor;
+            limit            = other.limit;
+            limit_backward   = other.limit_backward;
+            bra              = other.bra;
+            ket              = other.ket;
+        }
+    }
+
+
+    /// <summary>
+    ///   Base class for Snowball's stemmer algorithms.
+    /// </summary>
+    /// 
+    public abstract class Stemmer : Env
+    {
+        /// <summary>
+        ///   Initializes a new instance of the <see cref="Stemmer"/> class.
+        /// </summary>
+        /// 
+        protected Stemmer()
+        {
+            current = new StringBuilder();
+            setBufferContents("");
+        }
+
+
+        /// <summary>
+        ///   Calls the stemmer to process the next word.
+        /// </summary>
+        /// 
+        protected abstract bool stem();
+
+
+        /// <summary>
+        ///   Stems the buffer's contents.
+        /// </summary>
+        /// 
+        public bool Stem()
+        {
+            return this.stem();
+        }
+
+        /// <summary>
+        ///   Stems a given word.
+        /// </summary>
+        /// 
+        /// <param name="word">The word to be stemmed.</param>
+        /// 
+        /// <returns>The stemmed word.</returns>
+        /// 
+        public string Stem(string word)
+        {
+            setBufferContents(word);
+            this.stem();
+            return current.ToString();
+        }
+
+
+        /// <summary>
+        ///   Gets the current processing buffer.
+        /// </summary>
+        /// 
+        public StringBuilder Buffer
+        {
+            get { return current; }
+        }
+
+        /// <summary>
+        ///   Gets or sets the current word to be stemmed
+        ///   or the stemmed word, if the stemmer has been
+        ///   processed.
+        /// </summary>
+        /// 
+        public string Current
+        {
+            get { return current.ToString(); }
+            set { setBufferContents(value); }
+        }
+
+        private void setBufferContents(string value)
+        {
+            current.Clear();
+            current.Insert(0, value);
+
+            cursor = 0;
+            limit = current.Length;
+            limit_backward = 0;
+            bra = cursor;
+            ket = limit;
+        }
+
+
+        /// <summary>
+        ///   Determines whether the current character is 
+        ///   inside a given group of characters <c>s</c>.
+        /// </summary>
+        protected int in_grouping(string s, int min, int max, bool repeat)
+        {
+            do
+            {
+                if (cursor >= limit)
+                    return -1;
+
+                char ch = current[cursor];
+                if (ch > max || ch < min)
+                    return 1;
+
+                if (!s.Contains(ch))
+                    return 1;
+
+                cursor++;
+            }
+            while (repeat);
+
+            return 0;
+        }
+
+        /// <summary>
+        ///   Determines whether the current character is 
+        ///   inside a given group of characters <c>s</c>.
+        /// </summary>
+        protected int in_grouping_b(string s, int min, int max, bool repeat)
+        {
+            do
+            {
+                if (cursor <= limit_backward)
+                    return -1;
+
+                char ch = current[cursor - 1];
+                if (ch > max || ch < min)
+                    return 1;
+
+                if (!s.Contains(ch))
+                    return 1;
+
+                cursor--;
+            } while (repeat);
+
+            return 0;
+        }
+
+        /// <summary>
+        ///   Determines whether the current character is 
+        ///   outside a given group of characters <c>s</c>.
+        /// </summary>
+        protected int out_grouping(string s, int min, int max, bool repeat)
+        {
+            do
+            {
+                if (cursor >= limit)
+                    return -1;
+
+                char ch = current[cursor];
+                if (ch > max || ch < min)
+                {
+                    cursor++;
+                    continue;
+                }
+
+                if (!s.Contains(ch))
+                {
+                    cursor++;
+                    continue;
+                }
+
+                return 1;
+
+            } while (repeat);
+
+            return 0;
+        }
+
+        /// <summary>
+        ///   Determines whether the current character is 
+        ///   outside a given group of characters <c>s</c>.
+        /// </summary>
+        protected int out_grouping_b(string s, int min, int max, bool repeat)
+        {
+            do
+            {
+                if (cursor <= limit_backward)
+                    return -1;
+
+                char ch = current[cursor - 1];
+                if (ch > max || ch < min)
+                {
+                    cursor--;
+                    continue;
+                }
+
+                if (!s.Contains(ch))
+                {
+                    cursor--;
+                    continue;
+                }
+
+                return 1;
+            }
+            while (repeat);
+
+            return 0;
+        }
+
+
+        /// <summary>
+        ///   Determines if the current buffer contains the
+        ///   string s, starting from the current position and
+        ///   going forward.
+        /// </summary>
+        protected bool eq_s(String s)
+        {
+            if (limit - cursor < s.Length)
+                return false;
+
+            for (int i = 0; i != s.Length; i++)
+            {
+                if (current[cursor + i] != s[i])
+                    return false;
+            }
+
+            cursor += s.Length;
+            return true;
+        }
+
+        /// <summary>
+        ///   Determines if the current buffer contains the
+        ///   string s, starting from the current position and
+        ///   going backwards.
+        /// </summary>
+        protected bool eq_s_b(String s)
+        {
+            if (cursor - limit_backward < s.Length)
+                return false;
+
+            for (int i = 0; i != s.Length; i++)
+            {
+                if (current[cursor - s.Length + i] != s[i])
+                    return false;
+            }
+
+            cursor -= s.Length;
+            return true;
+        }
+
+        /// <summary>
+        ///   Determines if the current buffer contains the
+        ///   string s, starting from the current position and
+        ///   going backwards.
+        /// </summary>
+        protected bool eq_s_b(StringBuilder s)
+        {
+            if (cursor - limit_backward < s.Length)
+                return false;
+
+            for (int i = 0; i != s.Length; i++)
+            {
+                if (current[cursor - s.Length + i] != s[i])
+                    return false;
+            }
+
+            cursor -= s.Length;
+            return true;
+        }
+
+
+        /// <summary>
+        ///   Searches if the current buffer matches against one of the 
+        ///   amongs, starting from the current cursor position and going
+        ///   forward.
+        /// </summary>
+        /// 
+        protected int find_among(Among[] v)
+        {
+            int i = 0;
+            int j = v.Length;
+
+            int c = cursor;
+            int l = limit;
+
+            int common_i = 0;
+            int common_j = 0;
+
+            bool first_key_inspected = false;
+
+            while (true)
+            {
+                int k = i + ((j - i) >> 1);
+                int diff = 0;
+                int common = common_i < common_j ? common_i : common_j; // smaller
+
+                Among w = v[k];
+
+                for (int i2 = common; i2 < w.SearchString.Length; i2++)
+                {
+                    if (c + common == l)
+                    {
+                        diff = -1;
+                        break;
+                    }
+
+                    diff = current[c + common] - w.SearchString[i2];
+
+                    if (diff != 0)
+                        break;
+
+                    common++;
+                }
+
+                if (diff < 0)
+                {
+                    j = k;
+                    common_j = common;
+                }
+                else
+                {
+                    i = k;
+                    common_i = common;
+                }
+
+                if (j - i <= 1)
+                {
+                    if (i > 0)
+                        break; // v->s has been inspected
+
+                    if (j == i)
+                        break; // only one item in v
+
+                    // - but now we need to go round once more to get
+                    // v->s inspected. This looks messy, but is actually
+                    // the optimal approach.
+
+                    if (first_key_inspected)
+                        break;
+
+                    first_key_inspected = true;
+                }
+            }
+
+            while (true)
+            {
+                Among w = v[i];
+
+                if (common_i >= w.SearchString.Length)
+                {
+                    cursor = c + w.SearchString.Length;
+
+                    if (w.Action == null)
+                        return w.Result;
+
+                    bool res = w.Action();
+                    cursor = c + w.SearchString.Length;
+
+                    if (res)
+                        return w.Result;
+                }
+
+                i = w.MatchIndex;
+
+                if (i < 0)
+                    return 0;
+            }
+        }
+
+        /// <summary>
+        ///   Searches if the current buffer matches against one of the 
+        ///   amongs, starting from the current cursor position and going
+        ///   backwards.
+        /// </summary>
+        /// 
+        protected int find_among_b(Among[] v)
+        {
+            int i = 0;
+            int j = v.Length;
+
+            int c = cursor;
+            int lb = limit_backward;
+
+            int common_i = 0;
+            int common_j = 0;
+
+            bool first_key_inspected = false;
+
+            while (true)
+            {
+                int k = i + ((j - i) >> 1);
+                int diff = 0;
+                int common = common_i < common_j ? common_i : common_j;
+                Among w = v[k];
+
+                for (int i2 = w.SearchString.Length - 1 - common; i2 >= 0; i2--)
+                {
+                    if (c - common == lb)
+                    {
+                        diff = -1;
+                        break;
+                    }
+
+                    diff = current[c - 1 - common] - w.SearchString[i2];
+
+                    if (diff != 0)
+                        break;
+
+                    common++;
+                }
+
+                if (diff < 0)
+                {
+                    j = k;
+                    common_j = common;
+                }
+                else
+                {
+                    i = k;
+                    common_i = common;
+                }
+
+                if (j - i <= 1)
+                {
+                    if (i > 0)
+                        break;
+
+                    if (j == i)
+                        break;
+
+                    if (first_key_inspected)
+                        break;
+
+                    first_key_inspected = true;
+                }
+            }
+
+            while (true)
+            {
+                Among w = v[i];
+
+                if (common_i >= w.SearchString.Length)
+                {
+                    cursor = c - w.SearchString.Length;
+
+                    if (w.Action == null)
+                        return w.Result;
+
+                    bool res = w.Action();
+                    cursor = c - w.SearchString.Length;
+
+                    if (res)
+                        return w.Result;
+                }
+
+                i = w.MatchIndex;
+
+                if (i < 0)
+                    return 0;
+            }
+        }
+
+        /// <summary>
+        ///   Replaces the characters between <c>c_bra</c>
+        ///   and <c>c_ket</c> by the characters in s.
+        /// </summary>
+        ///   
+        protected int replace_s(int c_bra, int c_ket, String s)
+        {
+            int adjustment = s.Length - (c_ket - c_bra);
+            Replace(current, c_bra, c_ket, s);
+            limit += adjustment;
+            if (cursor >= c_ket)
+                cursor += adjustment;
+            else if (cursor > c_bra)
+                cursor = c_bra;
+            return adjustment;
+        }
+
+        /// <summary>
+        ///   Checks if a slicing can be done.
+        /// </summary>
+        protected void slice_check()
+        {
+            if (bra < 0 || bra > ket || ket > limit || limit > current.Length)
+            {
+                System.Diagnostics.Trace.WriteLine("faulty slice operation");
+            }
+        }
+
+        /// <summary>
+        ///   Replaces the contents of the bracket with the string s.
+        /// </summary>
+        /// 
+        /// <param name="s">The s.</param>
+        protected void slice_from(String s)
+        {
+            slice_check();
+            replace_s(bra, ket, s);
+        }
+
+        /// <summary>
+        ///   Removes the current bracket contents.
+        /// </summary>
+        /// 
+        protected void slice_del()
+        {
+            slice_from("");
+        }
+
+        /// <summary>
+        ///   Replaces the contents of the bracket with the string s.
+        /// </summary>
+        /// 
+        protected void insert(int c_bra, int c_ket, String s)
+        {
+            int adjustment = replace_s(c_bra, c_ket, s);
+            if (c_bra <= bra) bra += adjustment;
+            if (c_bra <= ket) ket += adjustment;
+        }
+
+        /// <summary>
+        ///   Replaces the contents of the bracket with the string s.
+        /// </summary>
+        /// 
+        protected void insert(int c_bra, int c_ket, StringBuilder s)
+        {
+            int adjustment = replace_s(c_bra, c_ket, s.ToString());
+            if (c_bra <= bra) bra += adjustment;
+            if (c_bra <= ket) ket += adjustment;
+        }
+
+        /// <summary>
+        ///   Replaces the contents of the bracket with the string s.
+        /// </summary>
+        /// 
+        protected void slice_to(StringBuilder s)
+        {
+            slice_check();
+            Replace(s, 0, s.Length, current.ToString(bra, ket - bra));
+        }
+
+        /// <summary>
+        ///   Replaces the contents of the bracket with the string s.
+        /// </summary>
+        /// 
+        protected void assign_to(StringBuilder s)
+        {
+            Replace(s, 0, s.Length, current.ToString(0, limit));
+        }
+
+
+
+        /// <summary>
+        ///   Replaces a specific region of the buffer with another text.
+        /// </summary>
+        public static StringBuilder Replace(StringBuilder sb, int index, int length, string text)
+        {
+            sb.Remove(index, length - index);
+            sb.Insert(index, text);
+            return sb;
+        }
+
+    }
+}

data/vendor/snowball/csharp/Stemwords/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
+    </startup>
+</configuration>