onoma 0.0.0 → 0.1.0

data/lib/onoma/database.rb

@@ -2,24 +2,26 @@ module Onoma
   # This class represents a set of nomenclature like the reference DB
   class Database
     attr_accessor :version
+    attr_reader :path
 
-    def initialize
+    def initialize(path)
+      @path = Pathname.new(path)
       @nomenclatures = ActiveSupport::HashWithIndifferentAccess.new
       @version = 0
     end
 
-    def self.load_file(file)
-      set = new
-      f = File.open(file, 'rb')
-      document = Nokogiri::XML(f) do |config|
-        config.strict.nonet.noblanks.noent
-      end
-      f.close
-      document.root.children.each do |nomenclature|
-        set.harvest_nomenclature(nomenclature)
-      end
-      set.version = document.root['version'].to_i
-      set
+    def self.open(path)
+      db = new(path)
+      db.send(:parse_file, path) if path.exist?
+      db
+    end
+
+    def write
+      File.write(@path, to_xml)
+    end
+
+    def copy(path)
+      File.write(path, to_xml)
     end
 
     def nomenclature_names
@@ -34,8 +36,8 @@ module Onoma
     def [](nomenclature_name)
       @nomenclatures[nomenclature_name]
     end
-    alias_method :find, :[]
-    alias_method :nomenclature, :[]
+    alias find []
+    alias nomenclature []
 
     # Find item
     def item(nomenclature_name, item_name)
@@ -51,7 +53,7 @@ module Onoma
 
     def find!(name)
       unless nomenclature = @nomenclatures[name]
-        fail "Nomenclature #{name} does not exist"
+        raise "Nomenclature #{name} does not exist"
       end
       nomenclature
     end
@@ -82,16 +84,20 @@ module Onoma
         xml.nomenclatures(xmlns: Onoma::XMLNS, version: @version) do
           @nomenclatures.values.sort.each do |nomenclature|
             xml.nomenclature(nomenclature.to_xml_attrs) do
-              xml.properties do
-                nomenclature.properties.values.sort.each do |property|
-                  xml.property(property.to_xml_attrs)
+              if nomenclature.properties.any?
+                xml.properties do
+                  nomenclature.properties.values.sort.each do |property|
+                    xml.property(property.to_xml_attrs)
+                  end
                 end
-              end if nomenclature.properties.any?
-              xml.items do
-                nomenclature.items.values.sort { |a, b| a.name <=> b.name }.each do |item|
-                  xml.item(item.to_xml_attrs)
+              end
+              if nomenclature.items.any?
+                xml.items do
+                  nomenclature.items.values.sort_by(&:name).each do |item|
+                    xml.item(item.to_xml_attrs)
+                  end
                 end
-              end if nomenclature.items.any?
+              end
             end
           end
         end
@@ -99,22 +105,42 @@ module Onoma
       builder.to_xml
     end
 
-    def harvest_nomenclature(element)
-      nomenclature = Nomenclature.harvest(element, set: self)
-      @nomenclatures[nomenclature.name] = nomenclature
+    def exec_action(action)
+      case action.action_name.to_sym
+      when :nomenclature_creation
+        add_nomenclature(action.name, action.options)
+      when :nomenclature_change
+        change_nomenclature(action.nomenclature, action.changes)
+      when :nomenclature_removal
+        remove_nomenclature(action.nomenclature)
+      when :property_creation
+        add_property(action.nomenclature, action.name, action.type, action.options)
+      when :property_change
+        add_property(action.nomenclature, action.name, action.changes)
+      when :item_creation
+        add_item(action.nomenclature, action.name, action.options)
+      when :item_change
+        change_item(action.nomenclature, action.name, action.changes)
+      when :item_merging
+        merge_item(action.nomenclature, action.name, action.into)
+      when :item_removal
+        remove_item(action.nomenclature, action.name)
+      else
+        raise "Unknown action: #{action.action_name}"
+      end
     end
 
     def add_nomenclature(name, options = {})
-      fail "Nomenclature #{name} already exists" if @nomenclatures[name]
+      raise "Nomenclature #{name} already exists" if @nomenclatures[name]
       options[:set] = self
       @nomenclatures[name] = Nomenclature.new(name, options)
     end
 
     def move_nomenclature(old_name, new_name)
       unless @nomenclatures[old_name]
-        fail "Nomenclature #{old_name} does not exist"
+        raise "Nomenclature #{old_name} does not exist"
       end
-      fail "Nomenclature #{new_name} already exists" if @nomenclatures[new_name]
+      raise "Nomenclature #{new_name} already exists" if @nomenclatures[new_name]
       @nomenclatures[new_name] = @nomenclatures.delete(old_name)
       @nomenclatures[new_name]
     end
@@ -139,11 +165,11 @@ module Onoma
     end
 
     def change_property(_nomenclature_name, _property_name, _updates = {})
-      fail NotImplementedError
+      raise NotImplementedError
     end
 
     def remove_property(_nomenclature_name, _property_name, _options = {})
-      fail NotImplementedError
+      raise NotImplementedError
     end
 
     def add_item(nomenclature_name, item_name, options = {})
@@ -167,5 +193,24 @@ module Onoma
       nomenclature = find!(nomenclature_name)
       nomenclature.remove_item(item_name)
     end
+
+    protected
+
+    def harvest_nomenclature(element)
+      nomenclature = Nomenclature.harvest(element, set: self)
+      @nomenclatures[nomenclature.name] = nomenclature
+    end
+
+    def parse_file(file)
+      f = File.open(file, 'rb')
+      document = Nokogiri::XML(f) do |config|
+        config.strict.nonet.noblanks.noent
+      end
+      f.close
+      document.root.children.each do |nomenclature|
+        harvest_nomenclature(nomenclature)
+      end
+      self.version = document.root.attr('version').to_i
+    end
   end
 end

data/lib/onoma/item.rb

@@ -3,7 +3,7 @@ module Onoma
   class Item
     attr_reader :nomenclature, :left, :right, :depth, :aliases, :parent_name
     attr_accessor :name, :attributes
-    alias_method :properties, :attributes
+    alias properties attributes
 
     # New item
     def initialize(nomenclature, name, options = {})
@@ -18,6 +18,7 @@ module Onoma
         self.parent = parent
       end
       @attributes = ActiveSupport::HashWithIndifferentAccess.new
+      @children = Set.new
       options.each do |k, v|
         set(k, v)
       end
@@ -29,6 +30,7 @@ module Onoma
 
     def parent=(item)
       old_parent_name = @parent_name
+      old_parent = @parent
       if item.nil?
         @parent = nil
         @parent_name = nil
@@ -37,15 +39,27 @@ module Onoma
           item = nomenclature.find!(item.to_s)
         end
         if item.nomenclature != nomenclature
-          fail 'Item must come from same nomenclature'
+          raise 'Item must come from same nomenclature'
         end
-        if item.parents.include?(self) || item == self
-          fail 'Circular dependency. Item can be parent of itself.'
+        if item.parents.any? { |p| self == p } || self == item
+          raise 'Circular dependency. Item can be parent of itself.'
         end
         @parent = item
         @parent_name = @parent.name.to_s
       end
-      @nomenclature.rebuild_tree! if old_parent_name != @parent_name
+      if old_parent_name != @parent_name
+        old_parent.delete_child(self) if old_parent
+        @parent.add_child(self) if @parent
+        @nomenclature.rebuild_tree!
+      end
+    end
+
+    def add_child(item)
+      @children << item
+    end
+
+    def delete_child(item)
+      @children.delete(item)
     end
 
     # Changes parent without rebuilding
@@ -59,7 +73,28 @@ module Onoma
     end
 
     def parent
-      @parent ||= @nomenclature.find(@parent_name)
+      return @parent if @parent
+      @parent = find_parent
+      @parent.add_child(self) if @parent
+      @parent
+    end
+    alias fetch_parent parent
+
+    def find_parent
+      @nomenclature.find(@parent_name)
+    end
+
+    def degree_of_kinship_with(other)
+      other_item = item_for_comparison(other)
+      a = self_and_parents.reverse
+      b = other_item.self_and_parents.reverse
+      return nil if a.first != b.first
+      common_lineage = 0
+      a.size.times do |index|
+        break if a[index].nil? || b[index].nil? || a[index] != b[index]
+        common_lineage += 1
+      end
+      a.size + b.size - 2 * common_lineage
     end
 
     def original_nomenclature_name
@@ -71,11 +106,9 @@ module Onoma
     def children(options = {})
       if options[:index].is_a?(FalseClass)
         if options[:recursively].is_a?(FalseClass)
-          return nomenclature.list.select do |item|
-            (item.parent == self)
-          end
+          @children.to_a
         else
-          return children(index: false, recursive: false).each_with_object([]) do |item, list|
+          children(index: false, recursive: false).each_with_object([]) do |item, list|
             list << item
             list += item.children(index: false, recursive: true)
             list
@@ -83,12 +116,12 @@ module Onoma
         end
       else
         if options[:recursively].is_a?(FalseClass)
-          return nomenclature.list.select do |item|
+          nomenclature.list.select do |item|
             @left < item.left && item.right < @right && item.depth == @depth + 1
           end
         else
           # @children ||=
-          return nomenclature.list.select do |item|
+          nomenclature.list.select do |item|
             @left < item.left && item.right < @right
           end
         end
@@ -96,7 +129,7 @@ module Onoma
     end
 
     def root
-      self.parent? ? parent.root : self
+      parent? ? parent.root : self
     end
 
     # Returns direct parents from the closest to the farthest
@@ -112,6 +145,12 @@ module Onoma
       [self] + parents
     end
 
+    def rise(&block)
+      result = yield(self)
+      return result if result
+      parent ? parent.rise(&block) : nil
+    end
+
     # Computes left/right value for nested set
     # Returns right index
     def rebuild_tree!
@@ -139,7 +178,9 @@ module Onoma
     def human_name(options = {})
       "nomenclatures.#{nomenclature.name}.items.#{name}".t(options.merge(default: ["items.#{name}".to_sym, "enumerize.#{nomenclature.name}.#{name}".to_sym, "labels.#{name}".to_sym, name.humanize]))
     end
-    alias_method :humanize, :human_name
+    alias humanize human_name
+    alias localize human_name
+    alias l localize
 
     def human_notion_name(notion_name, options = {})
       "nomenclatures.#{nomenclature.name}.notions.#{notion_name}.#{name}".t(options.merge(default: ["labels.#{name}".to_sym]))
@@ -190,7 +231,7 @@ module Onoma
     def to_xml_attrs
       attrs = {}
       attrs[:name] = name
-      attrs[:parent] = @parent_name if self.parent?
+      attrs[:parent] = @parent_name if parent?
       properties.each do |pname, pvalue|
         if p = nomenclature.properties[pname.to_s]
           if p.type == :decimal
@@ -206,11 +247,12 @@ module Onoma
 
     # Returns property value
     def property(name)
+      return @name.to_sym if name == :name
       property = @nomenclature.properties[name]
       value = @attributes[name]
       if property
         if value.nil? && property.fallbacks
-          for fallback in property.fallbacks
+          property.fallbacks.each do |fallback|
             value ||= @attributes[fallback]
             break if value
           end
@@ -227,11 +269,15 @@ module Onoma
           ["nomenclatures.#{@nomenclature.name}.item_lists.#{self.name}.#{name}.#{i}".t, i]
         end
       elsif property.nomenclature?
-        return Onoma[property(name)].list.collect do |i|
+        target_nomenclature = Onoma.find(property(name).to_sym)
+        unless target_nomenclature
+          raise "Cannot find nomenclature: for #{property(name).inspect}"
+        end
+        return target_nomenclature.list.collect do |i|
           [i.human_name, i.name]
         end
       else
-        fail StandardError, 'Cannot call selection for a non-list property'
+        raise StandardError, 'Cannot call selection for a non-list property'
       end
     end
 
@@ -247,12 +293,16 @@ module Onoma
     end
 
     def set(name, value)
-      fail "Invalid property: #{name.inspect}" if [:name, :parent].include?(name.to_sym)
-      # TODO: check format
-      if property = nomenclature.properties[name]
-        value ||= [] if property.list?
+      raise "Invalid property: #{name.inspect}" if %i[name parent].include?(name.to_sym)
+      # # TODO: check format
+      # if property = nomenclature.properties[name]
+      #   value ||= [] if property.list?
+      # end
+      if value.nil?
+        @attributes.delete(name)
+      else
+        @attributes[name] = value
       end
-      @attributes[name] = value
     end
 
     private
@@ -264,7 +314,7 @@ module Onoma
     def item_for_comparison(other)
       item = nomenclature[other.is_a?(Item) ? other.name : other]
       unless item
-        fail StandardError, "Invalid operand to compare: #{other.inspect} not in #{nomenclature.name}"
+        raise StandardError, "Invalid operand to compare: #{other.inspect} not in #{nomenclature.name}"
       end
       item
     end

data/lib/onoma/migration/actions/base.rb

@@ -1,5 +1,5 @@
 module Onoma
-  module Migration
+  class Migration
     module Actions
       class Base
         def self.action_name

data/lib/onoma/migration/actions/item_change.rb

@@ -1,5 +1,5 @@
 module Onoma
-  module Migration
+  class Migration
     module Actions
       class ItemChange < Onoma::Migration::Actions::Base
         attr_reader :nomenclature, :name, :changes
@@ -8,9 +8,9 @@ module Onoma
           @nomenclature = name.first
           @name = name.second
           @changes = element.attributes.delete_if do |k, _v|
-            %w(item).include?(k)
+            %w[item].include?(k)
           end.each_with_object({}) do |(k, v), h|
-            h[k.to_sym] = v.to_s
+            h[k.to_sym] = (v.to_s.blank? ? nil : v.to_s)
           end
         end
 
@@ -23,9 +23,9 @@ module Onoma
         end
 
         def label
-          "change_item #{@nomenclature}##{@name}(" + changes.simple_print + ")"
+          "change_item #{@nomenclature}##{@name}(" + changes.simple_print + ')'
         end
-        
+
         def human_name
           "Change item #{@nomenclature}##{@name} with " + changes.inspect
         end

data/lib/onoma/migration/actions/item_creation.rb

@@ -1,15 +1,15 @@
 module Onoma
-  module Migration
+  class Migration
     module Actions
       class ItemCreation < Onoma::Migration::Actions::Base
         attr_reader :nomenclature, :name, :options
         def initialize(element)
-          fail 'Need item attribute' unless element['item']
+          raise 'Need item attribute' unless element['item']
           name = element['item'].split('#')
           @nomenclature = name.first
           @name = name.second
           @options = element.attributes.delete_if do |k, _v|
-            k =~ /name(:[a-z]{3})?/ || %w(item parent nomenclature).include?(k)
+            k =~ /name(:[a-z]{3})?/ || %w[item parent nomenclature].include?(k)
           end.each_with_object({}) do |(k, v), h|
             h[k.to_sym] = v.to_s
           end
@@ -23,7 +23,7 @@ module Onoma
         def label
           "create_item #{@nomenclature}##{@name}" + (@options.any? ? "(#{@options.simple_print})" : '')
         end
-        
+
         def human_name
           updates = []
           updates << "#{@name} as name"

data/lib/onoma/migration/actions/item_merging.rb

@@ -1,5 +1,5 @@
 module Onoma
-  module Migration
+  class Migration
     module Actions
       class ItemMerging < Onoma::Migration::Actions::Base
         attr_reader :nomenclature, :name, :into
@@ -10,6 +10,10 @@ module Onoma
           @into = element['into'].to_s
         end
 
+        def label
+          "merge_item #{@nomenclature}##{@name} into " + @into.to_s
+        end
+
         def human_name
           "Merge item #{@nomenclature}##{@name} into #{@into}"
         end

data/lib/onoma/migration/actions/item_removal.rb

@@ -1,5 +1,5 @@
 module Onoma
-  module Migration
+  class Migration
     module Actions
       class ItemRemoval < Onoma::Migration::Actions::Base
         attr_reader :nomenclature, :name

data/lib/onoma/migration/actions/nomenclature_change.rb

@@ -1,11 +1,11 @@
 module Onoma
-  module Migration
+  class Migration
     module Actions
       class NomenclatureChange < Onoma::Migration::Actions::Base
         attr_reader :nomenclature, :changes
 
         def initialize(element)
-          fail 'No given name' unless element.key?('nomenclature')
+          raise 'No given name' unless element.key?('nomenclature')
           @nomenclature = element['nomenclature'].to_s
           @changes = {}
           @changes[:name] = element['name'].to_s if element.key?('name')
@@ -13,7 +13,7 @@ module Onoma
             @changes[:notions] = element.attr('notions').to_s.split(/\s*\,\s*/).map(&:to_sym)
           end
           if element.key?('translateable')
-            @changes[:translateable] = !(element.attr('translateable').to_s == 'false')
+            @changes[:translateable] = element.attr('translateable').to_s != 'false'
           end
         end
 

data/lib/onoma/migration/actions/nomenclature_creation.rb

@@ -1,19 +1,19 @@
 module Onoma
-  module Migration
+  class Migration
     module Actions
       class NomenclatureCreation < Onoma::Migration::Actions::Base
         attr_reader :nomenclature, :options
 
         def initialize(element)
           @nomenclature = element.key?('nomenclature') ? element['nomenclature'].to_s : element.key?('name') ? element['name'].to_s : nil
-          fail 'No given name' unless @nomenclature
+          raise 'No given name' unless @nomenclature
           @options = {}
           notions = element.attr('notions').to_s.split(/\s*\,\s*/).map(&:to_sym)
           @options[:notions] = notions if notions.any?
-          @options[:translateable] = !(element.attr('translateable').to_s == 'false')
+          @options[:translateable] = element.attr('translateable').to_s != 'false'
         end
 
-        alias_method :name, :nomenclature
+        alias name nomenclature
 
         def human_name
           "Create nomenclature #{@name}"

data/lib/onoma/migration/actions/nomenclature_removal.rb

@@ -1,15 +1,15 @@
 module Onoma
-  module Migration
+  class Migration
     module Actions
       class NomenclatureRemoval < Onoma::Migration::Actions::Base
         attr_reader :nomenclature
 
         def initialize(element)
           @nomenclature = element['nomenclature']
-          fail 'No given nomenclature' if @nomenclature.blank?
+          raise 'No given nomenclature' if @nomenclature.blank?
         end
 
-        alias_method :name, :nomenclature
+        alias name nomenclature
 
         def label
           "remove_nomenclature #{@name}"

data/lib/onoma/migration/actions/property_creation.rb

@@ -1,5 +1,5 @@
 module Onoma
-  module Migration
+  class Migration
     module Actions
       class PropertyCreation < Onoma::Migration::Actions::Base
         attr_reader :nomenclature, :name, :type, :options
@@ -9,7 +9,7 @@ module Onoma
           @name = name.second
           @type = element['type'].to_sym
           unless Property::TYPES.include?(@type)
-            fail ArgumentError, "Property #{name} type is unknown: #{@type.inspect}"
+            raise ArgumentError, "Property #{name} type is unknown: #{@type.inspect}"
           end
           @options = {}
           if element.has_attribute?('fallbacks')