react dnd wip

get_morph_rule.py

@@ -1,168 +0,0 @@
-import sys
-import os
-
-sys.path.append(os.getcwd()+'/content-engine')
-import pluralize_en
-import pattern.en
-
-
-def noun_morphology(word):
-    morph = {}
-    morph['PLR'] = pluralize_en.pluralize(word)
-    return morph
-
-def adjective_morphology(word):
-    morph = {}
-    morph['SUP'] = pattern.en.superlative(word)
-    morph['CMP'] = pattern.en.comparative(word)
-    return morph
-
-def verb_morphology(word):
-    morph = {}
-    lex = pattern.en.lexeme(word)
-    morph['PAS'] = lex[0]
-    morph['PTP'] = lex[0]
-    if len(lex) >= 2:
-            morph['3PS&PRS'] = lex[1]
-    if len(lex) >= 3:
-            morph['GER'] = lex[2]
-    if len(lex) >= 4:
-            morph['PAS'] = lex[3]
-            morph['PTP'] = lex[3]
-    if len(lex) >= 5:
-            morph['PTP'] = lex[4]
-    return morph
-
-def adverb_morphology(word):
-    morph = {}
-    return morph
-
-def morphology(name, pos):
-    if pos == 'n':
-        return noun_morphology(name)
-    elif pos == 'v':
-        return verb_morphology(name)
-    elif pos == 's' or pos == 'a':
-        return adjective_morphology(name)
-    elif pos == 'r':
-        return adverb_morphology(name)
-    else:
-        raise Exception
-
-def getMorphRules():
-	f = open('content-engine/morphology.txt','r').readlines()
-	for idx,rule in enumerate(f):
-		f[idx] = rule.split(' ')
-	for idx,rule in enumerate(f):
-		if len(f[idx]) >= 3:
-			f[idx][2] = f[idx][2].strip()
-	rules = {}
-	for idx,rule in enumerate(f):
-		if len(rule) >= 3:
-			rules[rule[0]] = rule[2]
-		else:
-			rules[rule[0]] = {}
-	for i in rules:
-		if '#' in rules[i]:
-			rules[i] = rules[i].split('#')[0].strip()
-	for i in rules:
-		rules[i]=rules[i].split(';')
-	for i in rules:
-		rule_params = {}
-		for j in rules[i]:
-			j = j.split(':')
-			if len(j) >= 2:
-				rule_params[j[0]] = j[1]
-		rules[i] = rule_params
-	return rules
-
-def is_number(s):
-	try:
-		int(s)
-		return True
-	except ValueError:
-		return False
-
-def subRuleMatch(morph_dict_sub,sub_rule,word):
-	sub_rule = sub_rule.split('>')
-	if len(sub_rule) < 2:
-		sub_rule.append('')
-	if is_number(sub_rule[0]):
-		num = int(sub_rule[0])
-		if num == 0:
-			if word + sub_rule[1] != morph_dict_sub:
-				return False
-		else:
-			if word[:-1*num] + sub_rule[1] != morph_dict_sub:
-				return False
-		return True
-	if '^' in sub_rule[0]:
-		if sub_rule[1] + ' ' + word != morph_dict_sub:
-			return False
-		return True
-	if not word.endswith(sub_rule[0]):
-		return False
-	if word[:-1*len(sub_rule[0])] + sub_rule[1] != morph_dict_sub:
-		return False
-	return True
-
-def ruleMatch(morph_dict,morph_rule,word):
-	for parameter in morph_rule:
-		if parameter not in morph_dict:
-			return False
-		if not subRuleMatch(morph_dict[parameter],morph_rule[parameter],word):
-			return False
-	return True
-
-def morphRule(name, pos, morph_dict):
-     # morph_dict = morphology(name, pos)
-
-     morph_rules = getMorphRules()
-     specified_params = []
-     matching_rules = []
-
-     for rule in morph_rules:
-          specified_params = []
-          if rule != 'M0':
-               if ruleMatch(morph_dict,morph_rules[rule],name):
-                    if len(morph_rules[rule]) < len(morph_dict):
-                         for i in morph_dict:
-                              if i not in morph_rules[rule]:
-                                   specified_params.append(str(i)+','+morph_dict[i])
-                    matching_rules.append([rule,specified_params])
-
-     if len(matching_rules) != 0:
-          matching_rules.sort()
-          return matching_rules[0][0], matching_rules[0][1]
-
-     rule = 'M0'
-     if len(morph_rules[rule]) < len(morph_dict):
-          for i in morph_dict:
-               if i not in morph_rules[rule]:
-                    specified_params.append(str(i)+','+morph_dict[i])
-
-     return rule, specified_params
-
-def get_morph_rule(word,pos,morph_dict):
-    for m in morph_dict:
-        morph_dict[m] = morph_dict[m].lower()
-    m,r = morphRule(word.lower(),pos.lower(),morph_dict)
-    return m
-
-def get_morph(word,p):
-    syn_pos_map = {"n":"n","j":"a","v":"v","a":"r"}
-    pos = syn_pos_map[p.lower()]
-    morph_dict = morphology(word,pos)
-    for m in morph_dict:
-        morph_dict[m] = morph_dict[m].lower()
-    m,params = morphRule(word.lower(),pos,morph_dict)
-    morphs = {}
-    morphs["morphclass"] = m
-    for r in params:
-        [k,v] = r.split(",")
-        morphs[k] = v
-    return morphs
-
-if __name__ == '__main__':
-    print get_morph_rule("spell","v",{'3PS&PRS':'spells','PAS':'spellt','GER':'spelling','PTP':'spellt'})
-    print get_morph_rule("french fry","n",{'PLR':'french fries'})

src/LexEdit.tsx

@@ -3,7 +3,8 @@ import * as _ from 'lodash';
 import {
   textInput,
   selectInput,
-  imagePreview
+  imagePreview,
+  listInput
 } from './LexSingleInput';
 import {
   Card,
@@ -53,6 +54,9 @@ export class LexEdit extends React.Component<any, any> {
         case 'preview': {
           return imagePreview(params);
         }
+        case 'list': {
+          return listInput(params);
+        }
         default: {
           console.log('type discarded :', fieldMeta.type);
           console.log('values discarded :', fieldMeta.get(li));

src/LexSingleInput.tsx

@@ -6,6 +6,10 @@ import {
   Input,
   Image
 } from 'semantic-ui-react';
+// import {
+//   SortableContainer,
+//   SortableElement
+// } from 'react-sortable-hoc';
 
 class LexSingleInput extends React.Component<any, any> {
   public render() {
@@ -88,3 +92,27 @@ export function imagePreview(params: any) {
     </LexSingleInput>
   ) : textInput(params);
 }
+
+// const SortableItem = SortableElement(({ value }) =>
+//   <li>{value}</li>
+// );
+//
+// const SortableList = SortableContainer(({ items }) => {
+//   return (
+//     <ul>
+//       {items.map((value: any, index: any) => (
+//         <SortableItem key={`item-${index}`} index={index} value={value} />
+//       ))}
+//     </ul>
+//   );
+// });
+
+export function listInput(params: any) {
+  let { field, defaultText, changed } = params;
+  let imageSrc = imageRoot + defaultText;
+  return (
+    <LexSingleInput key={field} label={changedLabel(changed, field)}>
+      <Image src={imageSrc} size="tiny" bordered={true} />
+    </LexSingleInput>
+  );
+}