mesh-medical-subject-headings 1.3.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e0859a3e5c4757eb7babc4072ac97177ae0feee
-  data.tar.gz: 2488bf617fa6761cf5b91c47c7b6a0b0641afca4
+  metadata.gz: 246c3f1005660ea5801534254a71eea1b0c1037c
+  data.tar.gz: 793b97acd06ab80e225f20b9d8f753b22b9fb6bb
 SHA512:
-  metadata.gz: 2770ad376f99544f8825eaab301ab457ad29d559beeca42cc0e66fee92bc68f70d6eecdf23775c34de57734a31505e2e44e79461fa052ab73e8eba27738c2fad
-  data.tar.gz: 9be16f17ace608d05d8dca68c407f76e7c450ffd1b79907a00fe20d6879aaa21acbfc1c2b0e5820f9ff04a0b52067f9f5e9464b19639d3b2135b0d6eae08d56d
+  metadata.gz: 7f21c94d6daa57f989777800f472fd679571c398fd535445fd8b75aabad1cfef38393cc0947b0545499211e3247b776531c9eab49a080e3d7893c0bd805ebf94
+  data.tar.gz: ab02026193ce2ce3d46099a00c1923bc76490a873eb81410f07c209666d8e34e2ee9f92edcd15bffb42f1391772a413be689e1abd9004123b7f0ac225a778848

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+#2.0.1 / 2014-04-28
+* [FEATURE] Load translations from static file to improve load times
+
+#2.0.0 / 2014-04-28
+* [FEATURE] Refactored to instances for future running of multiple trees
+
 #1.3.0 / 2014-04-10
 * [FEATURE] Released classifier to group and score matched headings
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mesh-medical-subject-headings (1.3.0)
+    mesh-medical-subject-headings (2.0.1)
 
 GEM
   remote: https://rubygems.org/

data/lib/MESH.rb

@@ -1,4 +1,5 @@
 require 'MESH/version'
+require 'MESH/tree'
+require 'MESH/heading'
 require 'MESH/translator'
-require 'MESH/mesh'
 require 'MESH/classifier'

data/lib/MESH/classifier.rb

@@ -23,20 +23,11 @@ module MESH
         scored = {}
         weighted_headings.each do |weight, heading|
           calculate_scores(scored, root, heading, weight)
-          #scored[heading] ||= 0
-          #scored[heading] += weight
-          #heading.parents.each do |p|
-          #  if p.roots.include? root
-          #    scored[p] ||= 0
-          #    scored[p] += weight / 3.0
-          #  end
-          #end
         end
         scored.each { |h,s| scored[h] = s.round(3) }
         scored.delete_if { |h,s| s == 0 }
         best_score, best_connected = scored.reduce({}) { |h, (k, v)| (h[v] ||= []) << k; h }.max
         most_specific = best_connected.max_by { |h| h.deepest_position(root) }
-        #chosen[root] = [most_specific, best_score]
         chosen[root] = [best_score, scored]
       end
 
@@ -54,25 +45,6 @@ module MESH
       end
     end
 
-
-
-
-    #text = "#{document[:title]}\n#{document[:abstract]}\n#{document[:content]}"
-    #matches = MESH::Mesh.match_in_text(text)
-    #headings = matches.map { |m| m[:heading] }
-    #root_groups = headings.reduce({}) do |rg, heading|
-    #  heading.roots.each { |root| (rg[root] ||= []) << heading }
-    #  rg
-    #end
-    #root_groups.reduce({}) do |chosen, (root, candidates)|
-    #  connections = calculate_connections(root, candidates)
-    #  best_score, best_connected = connections.reduce({}) { |h, (k, v)| (h[v] ||= []) << k; h }.max
-    #  most_specific = best_connected.max_by { |h| h.deepest_position }
-    #  chosen[root] = most_specific
-    #  chosen
-    #end
-    #end
-
     private
 
     def calculate_connections(root, headings, weight)
@@ -90,11 +62,7 @@ module MESH
       heading.parents.each do |p|
         connections[p] ||= 0
         connections[p] += weight
-        #add_connection(connections, root, p, weight)
       end
-      #heading.siblings.each do |p|
-      #  add_connection(connections, p)
-      #end
     end
 
   end

data/lib/MESH/heading.rb

@@ -0,0 +1,155 @@
+module MESH
+  class Heading
+
+    include Comparable
+    attr_accessor :unique_id, :tree_numbers, :roots, :parents, :children, :useful, :descriptor_class, :default_locale
+
+    def <=> other
+      self.unique_id <=> other.unique_id
+    end
+
+    def original_heading(locale = default_locale)
+      return @original_heading[locale]
+    end
+
+    def natural_language_name(locale = default_locale)
+      return @natural_language_name[locale]
+    end
+
+    def summary(locale = default_locale)
+      return @summary[locale]
+    end
+
+    def entries(locale = default_locale)
+      @entries[locale] ||= []
+      return @entries[locale]
+    end
+
+
+    def has_ancestor(heading)
+      return false if parents.empty?
+      return true if parents.include? heading
+      in_grandparents = parents.map { |p| p.has_ancestor(heading) }
+      return in_grandparents.include? true
+    end
+
+    def has_descendant(heading)
+      return false if children.empty?
+      return true if children.include? heading
+      in_grandchildren = children.map { |p| p.has_descendant(heading) }
+      return in_grandchildren.include? true
+    end
+
+    def sibling?(heading)
+      common_parents = parents & heading.parents
+      !common_parents.empty?
+    end
+
+    def deepest_position(root = '')
+      return nil if tree_numbers.empty?
+      deepest_tree_number = tree_numbers.max_by { |tn| tn.start_with?(root) ? tn.length : 0 }
+      deepest_tree_number.split('.').length
+    end
+
+    def shallowest_position
+      return nil if tree_numbers.empty?
+      shallowest_tree_number = tree_numbers.min_by { |tn| tn.length }
+      shallowest_tree_number.split('.').length
+    end
+
+    def matches(conditions)
+      conditions.each do |field, pattern|
+        field_content = self.send(field)
+        if field_content.kind_of?(Array)
+          return false unless field_content.find { |fc| pattern =~ fc }
+        elsif field_content.is_a?(TrueClass) || field_content.is_a?(FalseClass)
+          return false unless field_content == pattern
+        elsif field_content.is_a? Symbol
+          return field_content == pattern
+        else
+          return false unless pattern =~ field_content
+        end
+      end
+      return true
+    end
+
+    def inspect
+      return "#{unique_id}, #{original_heading}, [#{tree_numbers.join(',')}]"
+    end
+
+    def set_original_heading(heading, locale = default_locale)
+      @original_heading[locale] = heading
+    end
+
+    def set_natural_language_name(name, locale = default_locale)
+      @natural_language_name[locale] = name
+    end
+
+    def set_summary(summary, locale = default_locale)
+      @summary[locale] = summary
+    end
+
+    private
+
+    def initialize
+      @useful = true
+      @tree_numbers = []
+      @roots = []
+      @parents = []
+      @children = []
+      @entries = {}
+      @original_heading = {}
+      @natural_language_name = {}
+      @summary = {}
+    end
+
+
+  end
+end
+
+#
+#*NEWRECORD
+#RECTYPE = D
+#MH = Calcimycin
+#AQ = AA AD AE AG AI AN BI BL CF CH CL CS CT DU EC HI IM IP ME PD PK PO RE SD ST TO TU UR
+#ENTRY = A-23187|T109|T195|LAB|NRW|NLM (1991)|900308|abbcdef
+#ENTRY = A23187|T109|T195|LAB|NRW|UNK (19XX)|741111|abbcdef
+#ENTRY = Antibiotic A23187|T109|T195|NON|NRW|NLM (1991)|900308|abbcdef
+#ENTRY = A 23187
+#ENTRY = A23187, Antibiotic
+#MN = D03.438.221.173
+#PA = Anti-Bacterial Agents
+#PA = Calcium Ionophores
+#MH_TH = FDA SRS (2014)
+#MH_TH = NLM (1975)
+#ST = T109
+#ST = T195
+#N1 = 4-Benzoxazolecarboxylic acid, 5-(methylamino)-2-((3,9,11-trimethyl-8-(1-methyl-2-oxo-2-(1H-pyrrol-2-yl)ethyl)-1,7-dioxaspiro(5.5)undec-2-yl)methyl)-, (6S-(6alpha(2S*,3S*),8beta(R*),9beta,11alpha))-
+#    RN = 37H9VM9WZL
+#RR = 52665-69-7 (Calcimycin)
+#PI = Antibiotics (1973-1974)
+#PI = Carboxylic Acids (1973-1974)
+#MS = An ionophorous, polyether antibiotic from Streptomyces chartreusensis. It binds and transports CALCIUM and other divalent cations across membranes and uncouples oxidative phosphorylation while inhibiting ATPase of rat liver mitochondria. The substance is used mostly as a biochemical tool to study the role of divalent cations in various biological systems.
+#                                                                                                                                                                                                                                                                                                                                                                      OL = use CALCIMYCIN to search A 23187 1975-90
+#PM = 91; was A 23187 1975-90 (see under ANTIBIOTICS 1975-83)
+#HN = 91(75); was A 23187 1975-90 (see under ANTIBIOTICS 1975-83)
+#MED = *62
+#MED = 847
+#M90 = *299
+#M90 = 2405
+#M85 = *454
+#M85 = 2878
+#M80 = *316
+#M80 = 1601
+#M75 = *300
+#M75 = 823
+#M66 = *1
+#M66 = 3
+#M94 = *153
+#M94 = 1606
+#MR = 20130708
+#DA = 19741119
+#DC = 1
+#DX = 19840101
+#UI = D000001
+#

data/lib/MESH/tree.rb

@@ -0,0 +1,216 @@
+module MESH
+
+  class Tree
+
+    @@descriptor_classes = [:make_array_start_at_1, :topical_descriptor, :publication_type, :check_tag, :geographic_descriptor]
+    @@default_locale = :en_us
+
+    def initialize
+
+      @headings = []
+      @by_unique_id = {}
+      @by_tree_number = {}
+      @by_original_heading = {}
+      @locales = [@@default_locale]
+
+      filename = File.expand_path('../../../data/mesh_data_2014/d2014.bin.gz', __FILE__)
+      gzipped_file = File.open(filename)
+      file = Zlib::GzipReader.new(gzipped_file)
+
+      current_heading = MESH::Heading.new
+      current_heading.default_locale = @@default_locale
+      file.each_line do |line|
+
+        case
+
+          when matches = line.match(/^\*NEWRECORD$/)
+            unless current_heading.unique_id.nil?
+              current_heading.entries.sort!
+              @headings << current_heading
+              @by_unique_id[current_heading.unique_id] = current_heading
+              @by_original_heading[current_heading.original_heading] = current_heading
+              current_heading.tree_numbers.each do |tree_number|
+                @by_tree_number[tree_number] = current_heading
+              end
+            end
+            current_heading = MESH::Heading.new
+            current_heading.default_locale = @@default_locale
+
+          when matches = line.match(/^UI = (.*)/)
+            current_heading.unique_id = matches[1]
+
+          when matches = line.match(/^MN = (.*)/)
+            current_heading.tree_numbers << matches[1]
+            current_heading.roots << matches[1][0] unless current_heading.roots.include?(matches[1][0])
+
+          when matches = line.match(/^MS = (.*)/)
+            current_heading.set_summary(matches[1])
+
+          when matches = line.match(/^DC = (.*)/)
+            current_heading.descriptor_class = @@descriptor_classes[matches[1].to_i]
+
+          when matches = line.match(/^MH = (.*)/)
+            mh = matches[1]
+            current_heading.set_original_heading(mh)
+            current_heading.entries << mh
+            librarian_parts = mh.match(/(.*), (.*)/)
+            nln = librarian_parts.nil? ? mh : "#{librarian_parts[2]} #{librarian_parts[1]}"
+            current_heading.set_natural_language_name(nln)
+
+          when matches = line.match(/^(?:PRINT )?ENTRY = ([^|]+)/)
+            entry = matches[1].chomp
+            current_heading.entries << entry
+
+        end
+
+      end
+
+      @by_unique_id.each do |id, heading|
+        heading.tree_numbers.each do |tree_number|
+          #D03.438.221.173
+          parts = tree_number.split('.')
+          if parts.size > 1
+            parts.pop
+            parent_tree_number = parts.join '.'
+            parent = @by_tree_number[parent_tree_number]
+            heading.parents << parent unless parent.nil?
+            parent.children << heading unless parent.nil?
+          end
+        end
+      end
+
+    end
+
+    def load_translation(locale)
+      return if @locales.include? locale
+      filename = File.expand_path("../../../data/mesh_data_2014/d2014.#{locale}.bin.gz", __FILE__)
+      gzipped_file = File.open(filename)
+      file = Zlib::GzipReader.new(gzipped_file)
+
+      entries = []
+      original_heading = nil
+      natural_language_name = nil
+      summary = nil
+      unique_id = nil
+      file.each_line do |line|
+
+        case
+
+          when matches = line.match(/^\*NEWRECORD$/)
+            unless unique_id.nil?
+              entries.sort!
+              entries.uniq!
+              if heading = find(unique_id)
+                heading.set_original_heading(original_heading, locale) unless original_heading.nil?
+                heading.set_natural_language_name(natural_language_name, locale) unless natural_language_name.nil?
+                heading.set_summary(summary, locale) unless summary.nil?
+                entries.each { |entry| heading.entries(locale) << entry }
+              end
+
+              entries = []
+              original_heading = nil
+              summary = nil
+              unique_id = nil
+            end
+
+          when matches = line.match(/^UI = (.*)/)
+            unique_id = matches[1]
+
+          when matches = line.match(/^MS = (.*)/)
+            summary = matches[1]
+
+          when matches = line.match(/^MH = (.*)/)
+            mh = matches[1]
+            original_heading = mh
+            entries << mh
+            librarian_parts = mh.match(/(.*), (.*)/)
+            natural_language_name = librarian_parts.nil? ? mh : "#{librarian_parts[2]} #{librarian_parts[1]}"
+
+          when matches = line.match(/^(?:PRINT )?ENTRY = ([^|]+)/)
+            entry = matches[1].chomp
+            entries << entry
+
+        end
+
+      end
+      @locales << locale
+    end
+
+    # NO LONGER COVERED BY TESTS
+    # def translate(locale, tr)
+    #   return if @locales.include? locale
+    #   @headings.each_with_index do |h, i|
+    #     h.set_original_heading(tr.translate(h.original_heading), locale)
+    #     h.set_natural_language_name(tr.translate(h.natural_language_name), locale)
+    #     h.set_summary(tr.translate(h.summary), locale)
+    #     h.entries.each { |entry| h.entries(locale) << tr.translate(entry) }
+    #     h.entries(locale).sort!
+    #   end
+    #
+    #   @locales << locale
+    # end
+
+    def find(unique_id)
+      return @by_unique_id[unique_id]
+    end
+
+    def find_by_tree_number(tree_number)
+      return @by_tree_number[tree_number]
+    end
+
+    def find_by_original_heading(heading)
+      return @by_original_heading[heading]
+    end
+
+    def where(conditions)
+      matches = []
+      @headings.each do |heading|
+        matches << heading if heading.matches(conditions)
+      end
+      matches
+    end
+
+    def each
+      for i in 0 ... @headings.size
+        yield @headings[i] if @headings[i].useful
+      end
+    end
+
+    def match_in_text(text)
+      return [] if text.nil?
+      downcased = text.downcase
+      matches = []
+      @headings.each do |heading|
+        next unless heading.useful
+        @locales.each do |locale|
+          heading.entries(locale).each do |entry|
+            if downcased.include? entry.downcase #This is a looser check than the regex but much, much faster
+              if /^[A-Z0-9]+$/ =~ entry
+                regex = /(^|\W)#{Regexp.quote(entry)}(\W|$)/
+              else
+                regex = /(^|\W)#{Regexp.quote(entry)}(\W|$)/i
+              end
+              text.to_enum(:scan, regex).map do |m,|
+                matches << {heading: heading, matched: entry, index: $`.size}
+              end
+            end
+          end
+        end
+      end
+      confirmed_matches = []
+      matches.combination(2) do |l, r|
+        if (r[:index] >= l[:index]) && (r[:index] + r[:matched].length <= l[:index] + l[:matched].length)
+          #r is within l
+          r[:delete] = true
+        elsif (l[:index] >= r[:index]) && (l[:index] + l[:matched].length <= r[:index] + r[:matched].length)
+          #l is within r
+          l[:delete] = true
+        end
+      end
+      matches.delete_if { |match| match[:delete] }
+    end
+
+
+  end
+
+end