mindwords 0.6.0 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa290828ca8b921917460e6f8958c8b21d461c269a060e63c6079f57090d7d3e
-  data.tar.gz: e719d8986ece5f93bc994682a02b8f9826f1b5554349b40402d2a699920ba40b
+  metadata.gz: 7510e9608c67e4af590bf024b9910a592c28c6f949d66d37499f940265b5e9d0
+  data.tar.gz: f982e7b27d1cd9d230d2f2783bf89a75d296ae0bcf6c32324aeb2d089fab113a
 SHA512:
-  metadata.gz: 407b282223460ffb5585e15c5acaa1b377cefb17350b7626680cafd6d4f742a2ab1a0b19223385f74ca332f2830f5cc618e22fff93d6a704a0a3921b18dfb65c
-  data.tar.gz: 1f4c83f14c4e5c2ad51925445edb600a9e60a14482f7b4e057703b8ea980d8e631d5c901ebe49b034db3ce73e7ce0515ef936214e18ba138a93b0aee472f1b93
+  metadata.gz: eb7c8532b2a5a46edace11d960f568b306b01ef3edd8c45557176451d158b42ae57e1ee3818c1df9ac202bdd17aefde8bbd2e036d913b40d57caed7d365749d1
+  data.tar.gz: d50c913670f4a5c567b5a9c81c0f1c3ef3c9293957a91128befb76196dc672e075b4f2db925a4e1156f269ab1963cbdf774192b739c9e8a4eb7b634640e969d8

data/lib/mindwords.rb

@@ -8,99 +8,132 @@ require 'line-tree'
 
 module HashCopy
   refine Hash do
-    
+
     def deep_clone()
       Marshal.load(Marshal.dump(self))
     end
-    
+
   end
 end
 
 class MindWords
   using ColouredText
   using HashCopy
-  
+
   attr_accessor :lines, :filepath
-  
+
   def initialize(raws='', parent: nil, debug: false)
 
     @parent, @debug = parent, debug
-        
+
     s, type = RXFHelper.read raws
-    
+
     @filepath = raws if type == :file or type == :dfs
-    lines = s.strip.gsub(/^\n/,'').lines
-    lines.shift if lines.first =~ /<\?mindwords\?>/       
-    
+    lines = (s.strip.gsub(/(^\n|\r)/,'') + "\n").lines.uniq
+    lines.shift if lines.first =~ /<\?mindwords\?>/
+
     @lines = lines.inject([]) do |r,line|
-      
+
       # the following does 2 things:
       #      1. splits words separated by a bar (|) onto their own line
-      #      2. prefixes a word with an underscore if the word is the 
-      #         same as the hashtag. That way it's not removed by the 
+      #      2. prefixes a word with an underscore if the word is the
+      #         same as the hashtag. That way it's not removed by the
       #         redundancy checker
 
       raw_words, raw_hashtags = line.split(/(?= #)/,2)
       words = raw_words.split(/ *\| */)
       hashtags = raw_hashtags.scan(/(?<=#)\w+/)
-      
-      words.each do |word| 
-        
-        linex = (word + ' ' + raw_hashtags)
+
+      words.each do |word|
+
+        linex = (word +  raw_hashtags)
         r << (hashtags.include?(word) ? linex.sub!(/\b#{word}\b/, '_\0') \
               : linex)
       end
 
       r
     end
-    
+
   end
-  
-  def add(line)
-    @lines << line
+
+  def add(s)
+
+    @lines.concat s.strip.lines
+
   end
-  
+
   def breadcrumb()
     @parent.attributes[:breadcrumb].split(/ +\/ +/) if @parent
   end
-  
+
   def headings()
     breadcrumb[0..-2]
   end
-    
-  
+
+
   def element(id)
-    
+
     doc = Rexle.new(to_xml())
     e =  doc.root.element("//*[@id='#{id}']")
     #e.attributes[:breadcrumb].to_s if e
-    
+
+  end
+
+  # If title supplied, searches for a requested title and returns the
+  #   associated hashtags
+  # When no title is supplied, it will return the hashtags for the
+  #   parent element of a search result object
+  #
+  def hashtags(title=nil)
+
+    if title then
+      found = search(title)
+      found.hashtags() if found
+    else
+      @parent.attributes[:hashtags].split if @parent
+    end
+
+  end
+
+  # helpful when searching for a word itself using autosuggest
+  #
+  def lookup(s)
+    self.to_words.keys.sort.grep /^#{s}/i
   end
-  
-  def hashtags()
-    @parent.attributes[:hashtags].split if @parent
+
+  # same as #lines but inludes the breadcrumb path; Helpful to identify
+  # which words don't have a breadcrumb path.
+  #
+  def linesplus()
+
+    to_a.map do |word, _|
+      r = search word
+      r ? [word, r.breadcrumb] : [r, nil]
+    end
+
   end
 
   def save(file=@filepath)
-    
+
     return if @lines.empty?
-    
+
     puts 'before save' if @debug
+
     File.write file, to_s()
-    
+
   end
 
-  # Accepts a list of words with the aim of returning a MindWords document 
+  # Accepts a list of words with the aim of returning a MindWords document
   # using matched words with hashtags from the existing MindWords document.
   #
   def reflect(raws)
-    
+
     h = to_h
-    
+
     missing_words = []
-    
+
     # add the tags from the main list
-    a = raws.strip.lines.map do |x| 
+    a = raws.strip.lines.map do |x|
       if h[x.chomp] then
         [x.chomp, h[x.chomp]]
       else
@@ -122,153 +155,162 @@ class MindWords
     raws3 = a.uniq.map {|s,tags| [s, tags.map {|x| '#' + x }.join(' ')].join(' ') }.join("\n")
 
     [MindWords.new(raws3), missing_words]
-    
+
   end
-  
+
   def search(keyword, succinct: true)
-    
+
     a = @lines.grep(/#{keyword}/i).map do |line|
-      
+
       puts 'line: ' + line.inspect if @debug
-      
+
       words = line.split
       r = words.grep /#{keyword}/i
       i = words.index r[0]
-      
+
       [line, i]
-      
+
     end
-    
+
     return nil if a.empty?
     #return a[0][0] if a.length < 2
 
     a2 = a.sort_by(&:last).map(&:first)
     puts 'a2: ' + a2.inspect if @debug
     e = element(keyword.downcase.gsub(/ +/,'-'))
-    
+
     return MindWords.new(a2.uniq.join,  debug: @debug) if e.nil?
 
     # find and add any linkage support lines
     #
-    
+
     a3 = []
 
     a2.each do |line|
-      
+
       line.chomp.scan(/#[^ ]+/).each do |hashtag|
-        
+
         puts 'hashtag: ' + hashtag.inspect  if @debug
         r2 = @lines.grep(/^#{hashtag[1..-1]} #/)
-        a3 << r2.first if r2        
-        
+        a3 << r2.first if r2
+
       end
     end
 
     puts 'a2: ' + a2.inspect if @debug
     a2.concat a3
-    
+
     if succinct then
       MindWords.new(a2.uniq.join, parent: e, debug: @debug)
     else
       MindWords.new(a2.uniq.join,  debug: @debug)
     end
-    
+
   end
-  
+
   def sort()
     s = @lines.sort.join
-    
+
     def s.to_s()
       self.lines.map do |x|
         title, hashtags = x.split(/(?=#)/,2)
         title + hashtags.chomp.brown
       end.join("\n")
-    end    
-    
+    end
+
     return s
   end
-  
+
   def sort!()
     @lines = sort().lines
     self
   end
-  
+
   def tag_sort()
-    
-    h = @lines.group_by  {|x| x[/#\w+/]}    
+
+    h = @lines.group_by  {|x| x[/#\w+/]}
     s = h.sort.map {|key, value| value.sort }.join
-    
+
     def s.to_s()
       self.lines.map do |x|
         title, hashtags = x.split(/(?=#)/,2)
         title + hashtags.chomp.brown
       end.join("\n")
     end
-    
+
     return s
-    
+
   end
-  
+
   def tag_sort!()
     @lines = tag_sort().lines
     self
   end
 
   def to_a()
-    
-    @lines.map do |x| 
+
+    @lines.map do |x|
       s, rawtags = x.split(/(?= #)/,2)
       [s, rawtags.scan(/(?<=#)\w+/)]
     end
-    
+
   end
-  
+
   def to_h()
     to_a.to_h
   end
-    
+
   def to_hashtags()
     @hashtags
   end
 
   def to_outline(sort: true)
+
     build()
-    sort ? a2tree(tree_sort(LineTree.new(@outline).to_a)) : @outline
+
+    if sort then
+      a = LineTree.new(@outline).to_a
+      puts ('a: ' + a.inspect).debug if @debug
+      a2tree(tree_sort(a))
+    else
+      @outline
+    end
+
   end
-  
+
   alias to_tree to_outline
-  
+
   def to_s(colour: false)
-    
+
     header = "<?mindwords?>\n\n"
     return header + @lines.map(&:chomp).join("\n") unless colour
-    
+
     body = @lines.map do |x|
         title, hashtags = x.split(/(?=#)/,2)
         title + hashtags.chomp.brown
     end.join("\n")
-    
+
     header + body
-    
-  end  
-  
+
+  end
+
   def to_words()
-    
+
     h = {}
-    
+
     Rexle.new(to_xml).root.each_recursive do |e|
-      
+
       h[e.attributes[:title]] = {
-        breadcrumb: e.attributes[:breadcrumb], 
+        breadcrumb: e.attributes[:breadcrumb],
         hashtags: e.attributes[:hashtags]
       }
-      
+
     end
-    
+
     h
-    
-  end  
-  
+
+  end
+
   def to_xml()
     build() unless @xml
     @xml
@@ -277,46 +319,46 @@ class MindWords
   private
 
   def build()
-    
+
     h = {}
 
     @lines.each do |line|
 
-      title, rawtags = line.split(/ (?=#)/,2)
-      
+      title, rawtags = line.split(/(?= #)/,2)
+
       rawtags.scan(/#(\w+)/).flatten(1).each do |rawtag|
         tag = rawtag.gsub(/ +/, '_')
         h[tag] ||= []
-        h[tag] << title
+        h[tag] << title.strip
       end
 
     end
-    
+
     @hashtags = h.deep_clone.sort.map {|tag, fields| [tag, fields.sort]}.to_h
 
-    
+
     a = rexlize(h)
     doc = Rexle.new(['root', {}, '', *a])
 
     # apply node nesting
 
     doc.root.elements.each do |e|
-      
+
       doc.root.xpath('//' + e.name).each do |e2|
-        
+
         next if e2 === e
-        
+
         e2.parent.add e
         e2.delete
-        
+
       end
-      
+
     end
 
-    
+
     # remove duplicates which appear in the same branch above the nested node
     rm_duplicates(doc)
-    
+
     # remove redundant nodes (outsiders)
     # a redundant node is where all children exist in existing nested nodes
 
@@ -330,56 +372,59 @@ class MindWords
 
     end
 
+    puts 'redundants: ' + redundants.inspect if @debug
+
     redundants.compact.each {|x| doc.element(x).delete }
- 
+
     node = if @parent then
       found = doc.root.element('//' + @parent.name)
       found ? found.parent : doc.root
     else
       doc.root
     end
-    
-    # the following removes any undescore prefix from words which were the 
+
+    # the following removes any undescore prefix from words which were the
     # same as the hashtag
-    
+
     node.root.each_recursive do |e|
 
       next unless e
       puts 'e: ' + e.inspect if @debug
-      
+
       e.attributes[:id] = e.attributes[:id].sub(/^_/,'') if e.attributes[:id]
       e.attributes[:title] = e.attributes[:title].sub(/^_/,'') if e.attributes[:title]
       e.value = e.value.sub(/^_/,'')
-      
-    end    
-    
+      e.name = e.name.sub(/^_/,'')
+
+    end
+
     # ----
-    
+
     @outline = treeize node
-    
+
     node.root.each_recursive do |e|
-    
-      e.attributes[:id] = e.attributes[:title].downcase.gsub(/ +/,'-')      
-      
+
+      e.attributes[:id] = e.attributes[:title].downcase.gsub(/ +/,'-')
+
       s = e.parent.attributes[:breadcrumb] ? \
           e.parent.attributes[:breadcrumb].to_s  + ' / ' : ''
       e.attributes[:breadcrumb] = s +  e.value.strip
-      
+
       r = @lines.grep(/^#{e.attributes[:title]} #/i)
       next unless r.any?
       e.attributes[:hashtags] = r[0].scan(/(?<=#)\w+/).join(' ')
 
-      
+
     end
-    
+
     @xml = node.xml pretty: true
 
   end
-  
+
   def rexlize(a)
-    
+
     a.map do |x|
-     
+
       puts 'x: ' + x.inspect if @debug
 
       case x
@@ -387,41 +432,41 @@ class MindWords
         [x.downcase.gsub(/ +/,''),  {title: x}, x]
       when Hash
         [
-          x.keys.first.downcase.gsub(/_/,' '), 
-          {title: x.keys.first}, 
+          x.keys.first.downcase.gsub(/_/,' '),
+          {title: x.keys.first},
           x.keys.first,
          *rexlize(x.values.first)
         ]
       when Array
         [
-          x.first.downcase.gsub(/_/,' '), 
+          x.first.downcase.gsub(/_/,' '),
           {title: x.first}, x.first, *rexlize(x.last)
         ]
       end
     end
 
   end
-  
+
   def rm_duplicates(doc)
-    
+
     duplicates = []
-    
+
     doc.root.each_recursive do |e|
 
       rows = e.parent.xpath('//' + e.name)
       next if rows.length < 2
 
       rows[0..-2].each {|e2| duplicates << e.backtrack.to_s }
-    
+
     end
 
     duplicates.each do |path|
-      
+
       puts 'pathx: ' + path.inspect if @debug
       e = doc.element(path)
       e.delete if e
-      
-    end   
+
+    end
 
   end
 
@@ -433,13 +478,13 @@ class MindWords
 
       puts 'e: ' + e.inspect if @debug
       if e.is_a? Rexle::Element then
-        ('  ' * indent) + e.value.to_s +  "\n" + treeize(e,indent+1) 
+        ('  ' * indent) + e.value.to_s +  "\n" + treeize(e,indent+1)
       end
     end
 
     lines.join
   end
-  
+
   def tree_sort(a)
 
     if a.first.is_a? Array then
@@ -459,7 +504,7 @@ class MindWords
       ('  ' * indent) + title + "\n" + children
     end.join
 
-  end  
+  end
 
 end
 
@@ -469,7 +514,7 @@ class MindWordsWidget
 
   end
 
-  
+
   # can be used for main entries or a words list
   #
   def input(content: '', action: 'mwupdate', target: 'icontent')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mindwords
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.5
 platform: ruby
 authors:
 - James Robertson
@@ -35,7 +35,7 @@ cert_chain:
   aWH7D2AmhOpqNwWnPHzWR/yzpigAVTrvpHfRxZleQj6Z/090nIH2KR0RdioMmPFq
   3+574KQzs/gR9Y5a+iMcvHRN
   -----END CERTIFICATE-----
-date: 2021-04-09 00:00:00.000000000 Z
+date: 2022-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: line-tree
@@ -46,7 +46,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 0.9.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -56,7 +56,7 @@ dependencies:
         version: '0.9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: 0.9.3
 - !ruby/object:Gem::Dependency
   name: rxfhelper
   requirement: !ruby/object:Gem::Requirement