onoma 0.0.0

data/lib/onoma/database.rb

@@ -0,0 +1,171 @@
+module Onoma
+  # This class represents a set of nomenclature like the reference DB
+  class Database
+    attr_accessor :version
+
+    def initialize
+      @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
+    end
+
+    def nomenclature_names
+      @nomenclatures.keys
+    end
+
+    def nomenclatures
+      @nomenclatures.values
+    end
+
+    # Find nomenclature
+    def [](nomenclature_name)
+      @nomenclatures[nomenclature_name]
+    end
+    alias_method :find, :[]
+    alias_method :nomenclature, :[]
+
+    # Find item
+    def item(nomenclature_name, item_name)
+      nomenclature = find!(nomenclature_name)
+      nomenclature.item(item_name)
+    end
+
+    # Find property
+    def property(nomenclature_name, property_name)
+      nomenclature = find!(nomenclature_name)
+      nomenclature.property(property_name)
+    end
+
+    def find!(name)
+      unless nomenclature = @nomenclatures[name]
+        fail "Nomenclature #{name} does not exist"
+      end
+      nomenclature
+    end
+
+    def exist?(name)
+      @nomenclatures[name].present?
+    end
+
+    def each(&block)
+      if block.arity == 2
+        @nomenclatures.each(&block)
+      else
+        nomenclatures.each(&block)
+      end
+    end
+
+    # Returns references between nomenclatures
+    def references
+      list = []
+      each do |nomenclature|
+        list += nomenclature.references
+      end
+      list
+    end
+
+    def to_xml
+      builder = Nokogiri::XML::Builder.new do |xml|
+        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)
+                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
+              end if nomenclature.items.any?
+            end
+          end
+        end
+      end
+      builder.to_xml
+    end
+
+    def harvest_nomenclature(element)
+      nomenclature = Nomenclature.harvest(element, set: self)
+      @nomenclatures[nomenclature.name] = nomenclature
+    end
+
+    def add_nomenclature(name, options = {})
+      fail "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"
+      end
+      fail "Nomenclature #{new_name} already exists" if @nomenclatures[new_name]
+      @nomenclatures[new_name] = @nomenclatures.delete(old_name)
+      @nomenclatures[new_name]
+    end
+
+    def change_nomenclature(nomenclature_name, updates = {})
+      nomenclature = find!(nomenclature_name)
+      nomenclature.update_attributes(updates)
+      if updates[:name]
+        nomenclature = move_nomenclature(nomenclature_name, updates[:name])
+      end
+      nomenclature
+    end
+
+    def remove_nomenclature(nomenclature_name)
+      nomenclature = find!(nomenclature_name)
+      @nomenclatures.delete(nomenclature_name)
+    end
+
+    def add_property(nomenclature_name, property_name, type, options = {})
+      nomenclature = find!(nomenclature_name)
+      nomenclature.add_property(property_name, type, options)
+    end
+
+    def change_property(_nomenclature_name, _property_name, _updates = {})
+      fail NotImplementedError
+    end
+
+    def remove_property(_nomenclature_name, _property_name, _options = {})
+      fail NotImplementedError
+    end
+
+    def add_item(nomenclature_name, item_name, options = {})
+      nomenclature = find!(nomenclature_name)
+      options = nomenclature.cast_options(options)
+      nomenclature.add_item(item_name, options)
+    end
+
+    def change_item(nomenclature_name, item_name, updates = {})
+      nomenclature = find!(nomenclature_name)
+      updates = nomenclature.cast_options(updates)
+      nomenclature.change_item(item_name, updates)
+    end
+
+    def merge_item(nomenclature_name, item_name, into)
+      nomenclature = find!(nomenclature_name)
+      nomenclature.merge_item(item_name, into)
+    end
+
+    def remove_item(nomenclature_name, item_name)
+      nomenclature = find!(nomenclature_name)
+      nomenclature.remove_item(item_name)
+    end
+  end
+end

data/lib/onoma/item.rb

@@ -0,0 +1,272 @@
+module Onoma
+  # An item of a nomenclature is the core data.
+  class Item
+    attr_reader :nomenclature, :left, :right, :depth, :aliases, :parent_name
+    attr_accessor :name, :attributes
+    alias_method :properties, :attributes
+
+    # New item
+    def initialize(nomenclature, name, options = {})
+      @nomenclature = nomenclature
+      @name = name.to_s
+      @left, @right = @nomenclature.new_boundaries
+      @depth = 0
+      parent = options.delete(:parent)
+      if parent.is_a?(Symbol) || parent.is_a?(String)
+        @parent_name = parent.to_s
+      else
+        self.parent = parent
+      end
+      @attributes = ActiveSupport::HashWithIndifferentAccess.new
+      options.each do |k, v|
+        set(k, v)
+      end
+    end
+
+    def root?
+      !parent
+    end
+
+    def parent=(item)
+      old_parent_name = @parent_name
+      if item.nil?
+        @parent = nil
+        @parent_name = nil
+      else
+        if item.is_a?(Symbol) || item.is_a?(String)
+          item = nomenclature.find!(item.to_s)
+        end
+        if item.nomenclature != nomenclature
+          fail 'Item must come from same nomenclature'
+        end
+        if item.parents.include?(self) || item == self
+          fail '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
+    end
+
+    # Changes parent without rebuilding
+    def parent_name=(name)
+      @parent = nil
+      @parent_name = name.to_s
+    end
+
+    def parent?
+      parent.present?
+    end
+
+    def parent
+      @parent ||= @nomenclature.find(@parent_name)
+    end
+
+    def original_nomenclature_name
+      return parent.name.to_sym unless root?
+      nil
+    end
+
+    # Returns children recursively by default
+    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
+        else
+          return children(index: false, recursive: false).each_with_object([]) do |item, list|
+            list << item
+            list += item.children(index: false, recursive: true)
+            list
+          end
+        end
+      else
+        if options[:recursively].is_a?(FalseClass)
+          return nomenclature.list.select do |item|
+            @left < item.left && item.right < @right && item.depth == @depth + 1
+          end
+        else
+          # @children ||=
+          return nomenclature.list.select do |item|
+            @left < item.left && item.right < @right
+          end
+        end
+      end
+    end
+
+    def root
+      self.parent? ? parent.root : self
+    end
+
+    # Returns direct parents from the closest to the farthest
+    def parents
+      @parents ||= (parent.nil? ? [] : [parent] + parent.parents)
+    end
+
+    def self_and_children(options = {})
+      [self] + children(options)
+    end
+
+    def self_and_parents
+      [self] + parents
+    end
+
+    # Computes left/right value for nested set
+    # Returns right index
+    def rebuild_tree!
+      @nomenclature.forest_right = rebuild_tree(@nomenclature.forest_right + 1)
+    end
+
+    # Computes left/right value for nested set
+    # Returns right index
+    def rebuild_tree(left = 0, depth = 0)
+      @depth = depth
+      @left = left
+      @right = @left + 1
+      children(index: false, recursively: false).each do |child|
+        @right = child.rebuild_tree(@right, @depth + 1) + 1
+      end
+      @right
+    end
+
+    # Returns true if the given item name match the current item or its children
+    def include?(other)
+      self >= other
+    end
+
+    # Return human name of item
+    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
+
+    def human_notion_name(notion_name, options = {})
+      "nomenclatures.#{nomenclature.name}.notions.#{notion_name}.#{name}".t(options.merge(default: ["labels.#{name}".to_sym]))
+    end
+
+    def ==(other)
+      other = item_for_comparison(other)
+      nomenclature == other.nomenclature && name == other.name
+    end
+
+    def <=>(other)
+      other = item_for_comparison(other)
+      nomenclature.name <=> other.nomenclature.name && name <=> other.name
+    end
+
+    def <(other)
+      other = item_for_comparison(other)
+      (other.left < @left && @right < other.right)
+    end
+
+    def >(other)
+      other = item_for_comparison(other)
+      (@left < other.left && other.right < @right)
+    end
+
+    def <=(other)
+      other = item_for_comparison(other)
+      (other.left <= @left && @right <= other.right)
+    end
+
+    def >=(other)
+      other = item_for_comparison(other)
+      (@left <= other.left && other.right <= @right)
+    end
+
+    def inspect
+      "#{@nomenclature.name}-#{@name}(#{@left}-#{@right})"
+    end
+
+    def tree(depth = 0)
+      text = "#{left.to_s.rjust(4)}-#{right.to_s.ljust(4)} #{'  ' * depth}#{@name}:\n"
+      text << children(index: false, recursively: false).collect do |c|
+        c.tree(depth + 1)
+      end.join("\n")
+      text
+    end
+
+    def to_xml_attrs
+      attrs = {}
+      attrs[:name] = name
+      attrs[:parent] = @parent_name if self.parent?
+      properties.each do |pname, pvalue|
+        if p = nomenclature.properties[pname.to_s]
+          if p.type == :decimal
+            pvalue = pvalue.to_s.to_f
+          elsif p.list?
+            pvalue = pvalue.join(', ')
+          end
+        end
+        attrs[pname] = pvalue.to_s
+      end
+      attrs
+    end
+
+    # Returns property value
+    def property(name)
+      property = @nomenclature.properties[name]
+      value = @attributes[name]
+      if property
+        if value.nil? && property.fallbacks
+          for fallback in property.fallbacks
+            value ||= @attributes[fallback]
+            break if value
+          end
+        end
+        value ||= cast_property(name, property.default) if property.default
+      end
+      value
+    end
+
+    def selection(name)
+      property = @nomenclature.properties[name]
+      if property.list?
+        return property(name).collect do |i|
+          ["nomenclatures.#{@nomenclature.name}.item_lists.#{self.name}.#{name}.#{i}".t, i]
+        end
+      elsif property.nomenclature?
+        return Onoma[property(name)].list.collect do |i|
+          [i.human_name, i.name]
+        end
+      else
+        fail StandardError, 'Cannot call selection for a non-list property'
+      end
+    end
+
+    # Checks if item has property with given name
+    def has_property?(name)
+      !@nomenclature.properties[name].nil?
+    end
+
+    # Returns property descriptor
+    def method_missing(method_name, *args)
+      return property(method_name) if has_property?(method_name)
+      super
+    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?
+      end
+      @attributes[name] = value
+    end
+
+    private
+
+    def cast_property(name, value)
+      @nomenclature.cast_property(name, value)
+    end
+
+    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}"
+      end
+      item
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Onoma
+  module Migration
+    module Actions
+      class Base
+        def self.action_name
+          name.split('::').last.underscore
+        end
+
+        def action_name
+          self.class.action_name
+        end
+
+        def label
+          action_name
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,39 @@
+module Onoma
+  module Migration
+    module Actions
+      class ItemCreation < Onoma::Migration::Actions::Base
+        attr_reader :nomenclature, :name, :options
+        def initialize(element)
+          fail '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)
+          end.each_with_object({}) do |(k, v), h|
+            h[k.to_sym] = v.to_s
+          end
+          @options[:parent] = element['parent'].to_sym if element.key?('parent')
+        end
+
+        def options?
+          @options.any?
+        end
+
+        def label
+          "create_item #{@nomenclature}##{@name}" + (@options.any? ? "(#{@options.simple_print})" : '')
+        end
+        
+        def human_name
+          updates = []
+          updates << "#{@name} as name"
+          updates << "#{@parent} as parent" if parent?
+          @options.each do |k, v|
+            updates << "#{v} as #{k}"
+          end
+          sentence = "Create item #{@nomenclature}##{@name} with " + updates.to_sentence
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Onoma
+  module Migration
+    module Actions
+      class ItemMerging < Onoma::Migration::Actions::Base
+        attr_reader :nomenclature, :name, :into
+        def initialize(element)
+          name = element['item'].split('#')
+          @nomenclature = name.first
+          @name = name.second
+          @into = element['into'].to_s
+        end
+
+        def human_name
+          "Merge item #{@nomenclature}##{@name} into #{@into}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Onoma
+  module Migration
+    module Actions
+      class ItemRemoval < Onoma::Migration::Actions::Base
+        attr_reader :nomenclature, :name
+        def initialize(element)
+          name = element['item'].split('#')
+          @nomenclature = name.first
+          @name = name.second
+        end
+
+        def human_name
+          "Remove item #{@nomenclature}##{@name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Onoma
+  module Migration
+    module Actions
+      class NomenclatureChange < Onoma::Migration::Actions::Base
+        attr_reader :nomenclature, :changes
+
+        def initialize(element)
+          fail 'No given name' unless element.key?('nomenclature')
+          @nomenclature = element['nomenclature'].to_s
+          @changes = {}
+          @changes[:name] = element['name'].to_s if element.key?('name')
+          if element.key?('notions')
+            @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')
+          end
+        end
+
+        def human_name
+          "Update nomenclature #{@name} with " + changes.inspect
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Onoma
+  module 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
+          @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')
+        end
+
+        alias_method :name, :nomenclature
+
+        def human_name
+          "Create nomenclature #{@name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Onoma
+  module 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?
+        end
+
+        alias_method :name, :nomenclature
+
+        def label
+          "remove_nomenclature #{@name}"
+        end
+
+        def human_name
+          "Remove nomenclature #{@name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Onoma
+  module Migration
+    module Actions
+      class PropertyCreation < Onoma::Migration::Actions::Base
+        attr_reader :nomenclature, :name, :type, :options
+        def initialize(element)
+          name = element['property'].split('.')
+          @nomenclature = name.first
+          @name = name.second
+          @type = element['type'].to_sym
+          unless Property::TYPES.include?(@type)
+            fail ArgumentError, "Property #{name} type is unknown: #{@type.inspect}"
+          end
+          @options = {}
+          if element.has_attribute?('fallbacks')
+            @options[:fallbacks] = element.attr('fallbacks').to_s.strip.split(/[[:space:]]*\,[[:space:]]*/).map(&:to_sym)
+          end
+          if element.has_attribute?('default')
+            @options[:default] = element.attr('default').to_sym
+          end
+          @options[:required] = !!(element.attr('required').to_s == 'true')
+          # @options[:inherit]  = !!(element.attr('inherit').to_s == 'true')
+          if element.has_attribute?('choices')
+            if type == :choice || type == :choice_list
+              @options[:choices] = element.attr('choices').to_s.strip.split(/[[:space:]]*\,[[:space:]]*/).map(&:to_sym)
+            elsif type == :item || type == :item_list
+              @options[:choices] = element.attr('choices').to_s.strip.to_sym
+            end
+          end
+        end
+
+        def human_name
+          updates = []
+          updates << "#{@name} as name"
+          @options.each do |k, v|
+            updates << "#{v} as #{k}"
+          end
+          sentence = "Create property #{@nomenclature}.#{@name} with " + updates.to_sentence
+        end
+      end
+    end
+  end
+end