def test_find_identicals(self):
     expected_pks = []
     for p in self.pdm.pronoun_set.all()[0:3]:
         p.entries.add(Lexicon.objects.create(
             editor=self.editor, 
             source=self.source,
             language=self.lang,
             word=self.word,
             entry="fudge"
         ))
         p.save()
         expected_pks.append(p.id)
     
     ident = find_identicals(self.pdm)
     # right length? 
     assert len(ident) == 3, "Expected 3, got: %r" % ident
     # right PKs found? 
     seen_pks = set()
     for i, j in ident:
         assert i[0] in expected_pks
         assert j[0] in expected_pks
         seen_pks.add(i[0])
         seen_pks.add(j[0])
     
     # All PKs found? 
     assert len(seen_pks) == 3
     for seen_pk in seen_pks:
         assert seen_pk in expected_pks
Ejemplo n.º 2
0
def process_rule(request, paradigm_id):
    p = get_object_or_404(Paradigm, pk=paradigm_id)
    # do we have do_identicals? 
    if 'process_identicals' in request.POST:
        # 1. process form
        members = find_identicals(p)
        
        # 2. implement rule
        if len(members) > 0:
            # 3. save rule to rule table.
            rule = Rule.objects.create(
                paradigm = p,
                rule="Identical Entries set to Total Syncretism",
                editor=request.user
            )
            for m1, m2 in members:
                # Ignore anything we've already set
                if not Relationship.objects.has_relationship_between(m1[0], m2[0]):
                    rel = Relationship.objects.create(
                        paradigm = p, 
                        pronoun1_id=m1[0], pronoun2_id=m2[0], 
                        relationship='TS',
                        editor=request.user
                    )
                    rule.relationships.add(rel)
        
        return redirect('pronouns:edit_relationships', p.id)
        
    elif 'process_rule' in request.POST:
        # 1. process form
        rule_form = RuleForm(request.POST or None)
        if rule_form.is_valid():
            # 2. implement rule
            try:
                rule = extract_rule(ruleform.clean())
            except ValueError:
                # form is broken - go away.
                return redirect('pronouns:edit_relationships', p.id)
                
            # members = process_rule(rule, p.pronoun_set.all())
            
            # 3. save rule to rule table.
            # rule = Rule.objects.create(
            #     paradigm = p,
            #     rule="Identical Entries set to Total Syncretism",
            #     editor=request.user
            # )
            # for p1, p2 in members:
            #     # Ignore anything we've already set
            #     if Relationship.objects.has_relationship_between(p1, p2) == False:
            #         rel = Relationship.objects.create(
            #             paradigm = p, pronoun1=p1, pronoun2=p2, relationship='TS',
            #             editor=request.user
            #         )
            #         rule.relationships.add(rel)
        
        # Note: Invalid forms are IGNORED
        return redirect('pronouns:edit_relationships', p.id)
    else:
        return redirect('pronouns:detail', p.id)
 def test_ignore_self(self):
     p = self.pdm.pronoun_set.all()[0]
     p.entries.add(Lexicon.objects.create(
         editor=self.editor, 
         source=self.source,
         language=self.lang,
         word=self.word,
         entry="fudge"
     ))
     p.save()
     ident = find_identicals(self.pdm)
     assert len(ident) == 0
 def test_ignore_empties(self):
     ident = find_identicals(self.pdm)
     assert len(ident) == 0