onoma 0.0.0 → 0.1.0

data/lib/onoma/migration.rb

@@ -1,11 +1,122 @@
-class ::Hash
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/array'
+require 'benchmark'
 
+class ::Hash
   def simple_print
     map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
   end
-  
 end
 
+module Onoma
+  # Migration instance represents a migration file
+  class Migration
+    class << self
+      # Parse en XML migration to a Onoma::Migration object
+      def parse(file)
+        # puts "Parse #{file}"
+        f = File.open(file, 'rb')
+        document = Nokogiri::XML(f) do |config|
+          config.strict.nonet.noblanks.noent
+        end
+        f.close
+        root = document.root
+        number = file.basename.to_s.split('_').first.to_i
+        new(number, root['name']) do |m|
+          root.children.each do |child|
+            next unless child.is_a? Nokogiri::XML::Element
+            m.add "Onoma::Migration::Actions::#{child.name.underscore.classify}".constantize.new(child)
+          end
+        end
+      end
+    end
+
+    attr_reader :number, :name
+
+    def initialize(number, name)
+      @number = number
+      @name = name
+      @actions = []
+      yield self if block_given?
+    end
+
+    def label
+      "#{number} #{name}"
+    end
+
+    def add(action)
+      @actions << action
+    end
+
+    def each_action(&block)
+      @actions.each(&block)
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{format('%#x', object_id)} ##{number} #{name.inspect} (#{@actions.size} actions)>"
+    end
+
+    def migrate(conn)
+      puts ''
+      puts "== #{label}: migrating ".ljust(80, '=')
+      duration = Benchmark.measure do
+        each_action do |action|
+          puts "-- #{action.label}"
+          conn.exec_action(action)
+        end
+        conn.version = number
+      end
+      puts "== #{label}: migrated (#{duration.real.round(4)}s)".ljust(80, '=')
+      # puts "Write DB in #{Onoma.reference_path.relative_path_from(Onoma.root)}".yellow
+      if @steps
+        versions_dir = Onoma.root.join('tmp', 'versions')
+        FileUtils.mkdir_p(versions_dir)
+        conn.copy(versions_dir.join("#{number}.xml"))
+      end
+    end
+  end
+
+  # Migrator is a tool class to launch migrations
+  class Migrator
+    class << self
+      def migrate
+        Onoma::Migrator.new(Onoma.reference_path, Onoma.migrations_path).migrate
+      end
+    end
+
+    attr_accessor :database_path, :migrations_path
+
+    def initialize(database_path, migrations_path)
+      @database_path = database_path
+      @migrations_path = migrations_path
+    end
+
+    # Returns list of Onoma::Migration
+    def migrations
+      Dir.glob(@migrations_path.join('*.xml')).sort.collect do |f|
+        Onoma::Migration.parse(Pathname.new(f))
+      end
+    end
+
+    # Returns list of migrations since last done
+    def missing_migrations
+      last_version = connection.version
+      migrations.select do |m|
+        m.number > last_version
+      end
+    end
+
+    def migrate
+      missing_migrations.each do |migration|
+        migration.migrate(connection)
+      end
+      connection.write
+    end
+
+    def connection
+      @connection ||= Database.open(@database_path)
+    end
+  end
+end
 
 require 'onoma/migration/actions'
-require 'onoma/migration/base'

data/lib/onoma/nomenclature.rb

@@ -6,7 +6,7 @@ module Onoma
   class Nomenclature
     attr_reader :properties, :items, :name, :roots
     attr_accessor :name, :notions, :translateable, :forest_right
-    alias_method :property_natures, :properties
+    alias property_natures properties
 
     # Instanciate a new nomenclature
     def initialize(name, options = {})
@@ -24,15 +24,16 @@ module Onoma
       def harvest(element, 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'
         name = element.attr('name').to_s
         nomenclature = new(name, options)
-        for property in element.xpath('xmlns:properties/xmlns:property')
+        element.xpath('xmlns:properties/xmlns:property').each do |property|
           nomenclature.harvest_property(property)
         end
-        for item in element.xpath('xmlns:items/xmlns:item')
+        element.xpath('xmlns:items/xmlns:item').each do |item|
           nomenclature.harvest_item(item)
         end
+        nomenclature.list.each(&:fetch_parent)
         nomenclature.rebuild_tree!
         nomenclature
       end
@@ -96,7 +97,7 @@ module Onoma
       name = element.attr('name').to_s
       parent = attributes[:parent] || (element.key?('parent') ? element['parent'] : nil)
       attributes = element.attributes.each_with_object(HashWithIndifferentAccess.new) do |(k, v), h|
-        next if %w(name parent).include?(k)
+        next if %w[name parent].include?(k)
         h[k] = cast_property(k, v.to_s)
       end
       attributes[:parent] = parent if parent
@@ -115,7 +116,7 @@ module Onoma
       if element.has_attribute?('default')
         options[:default] = element.attr('default').to_sym
       end
-      options[:required] = !!(element.attr('required').to_s == 'true')
+      options[:required] = !!(element.attr('required').to_s != 'true')
       # options[:inherit]  = !!(element.attr('inherit').to_s == 'true')
       if type == :list
         type = element.has_attribute?('nomenclature') ? :item_list : :choice_list
@@ -134,11 +135,11 @@ module Onoma
         elsif element.has_attribute?('nomenclature')
           options[:choices] = element.attr('nomenclature').to_s.strip.to_sym
         else
-          fail MissingChoices, "[#{@name}] Property #{name} must have nomenclature as choices"
+          raise MissingChoices, "[#{@name}] Property #{name} must have nomenclature as choices"
         end
       end
       unless Property::TYPES.include?(type)
-        fail ArgumentError, "Property #{name} type is unknown: #{type.inspect}"
+        raise ArgumentError, "Property #{name} type is unknown: #{type.inspect}"
       end
       add_property(name, type, options)
     end
@@ -147,7 +148,7 @@ module Onoma
     def add_item(name, attributes = {}, options = {})
       i = Item.new(self, name, attributes)
       if @items[i.name]
-        fail "Item #{i.name} is already defined in nomenclature #{@name}"
+        raise "Item #{i.name} is already defined in nomenclature #{@name}"
       end
       @items[i.name] = i
       @roots << i unless i.parent?
@@ -162,7 +163,7 @@ module Onoma
       new_parent = changes[:parent]
       new_name = changes[:name]
       changes.each do |k, v|
-        next if [:parent, :name].include? k
+        next if %i[parent name].include? k
         i.set(k, v)
       end
       if has_parent
@@ -176,7 +177,7 @@ module Onoma
 
     def rename_item(name, new_name)
       if @items[new_name]
-        fail "Item #{new_name} is already defined in nomenclature #{@name}. Use merging instead."
+        raise "Item #{new_name} is already defined in nomenclature #{@name}. Use merging instead."
       end
       i = find!(name)
       i.children.each do |child|
@@ -232,7 +233,7 @@ module Onoma
     def add_property(name, type, options = {})
       p = Property.new(self, name, type, options)
       if @properties[p.name]
-        fail "Property #{p.name} is already defined in nomenclature #{@name}"
+        raise "Property #{p.name} is already defined in nomenclature #{@name}"
       end
       @properties[p.name] = p
       @references = nil
@@ -245,32 +246,32 @@ module Onoma
 
     def check!
       # Check properties
-      for property in @properties.values
+      @properties.values.each do |property|
         if property.choices_nomenclature && !property.inline_choices? && !Onoma[property.choices_nomenclature.to_s]
-          fail InvalidProperty, "[#{name}] #{property.name} nomenclature property must refer to an existing nomenclature. Got #{property.choices_nomenclature.inspect}. Expecting: #{Onoma.names.inspect}"
+          raise InvalidProperty, "[#{name}] #{property.name} nomenclature property must refer to an existing nomenclature. Got #{property.choices_nomenclature.inspect}. Expecting: #{Onoma.names.inspect}"
         end
         next unless property.type == :choice && property.default
         unless property.choices.include?(property.default)
-          fail InvalidProperty, "The default choice #{property.default.inspect} is invalid (in #{name}##{property.name}). Pick one from #{property.choices.sort.inspect}."
+          raise InvalidProperty, "The default choice #{property.default.inspect} is invalid (in #{name}##{property.name}). Pick one from #{property.choices.sort.inspect}."
         end
       end
 
       # Check items
-      for item in list
-        for property in @properties.values
+      list.each do |item|
+        @properties.values.each do |property|
           choices = property.choices
           if item.property(property.name) && property.type == :choice
             # Cleans for parametric reference
             name = item.property(property.name).to_s.split(/\(/).first.to_sym
             unless choices.include?(name)
-              fail InvalidProperty, "The given choice #{name.inspect} is invalid (in #{self.name}##{item.name}). Pick one from #{choices.sort.inspect}."
+              raise InvalidProperty, "The given choice #{name.inspect} is invalid (in #{self.name}##{item.name}). Pick one from #{choices.sort.inspect}."
             end
           elsif item.property(property.name) && property.type == :list && property.choices_nomenclature
             for name in item.property(property.name) || []
               # Cleans for parametric reference
               name = name.to_s.split(/\(/).first.to_sym
               unless choices.include?(name)
-                fail InvalidProperty, "The given choice #{name.inspect} is invalid (in #{self.name}##{item.name}). Pick one from #{choices.sort.inspect}."
+                raise InvalidProperty, "The given choice #{name.inspect} is invalid (in #{self.name}##{item.name}). Pick one from #{choices.sort.inspect}."
               end
             end
           end
@@ -282,7 +283,11 @@ module Onoma
     end
 
     def inspect
-      "Onoma::#{name.to_s.classify}"
+      "Nomen::#{name.to_s.classify}"
+    end
+
+    def table_name
+      @name.to_s.pluralize
     end
 
     # Returns hash with items in tree: {a => nil, b => {c => nil}}
@@ -303,7 +308,7 @@ module Onoma
     def human_name(options = {})
       "nomenclatures.#{name}.name".t(options.merge(default: ["labels.#{name}".to_sym, name.to_s.humanize]))
     end
-    alias_method :humanize, :human_name
+    alias humanize human_name
 
     def new_boundaries(count = 2)
       boundaries = []
@@ -326,12 +331,12 @@ module Onoma
     # List all item names. Can filter on a given item name and its children
     def to_a(item_name = nil)
       if item_name.present? && @items[item_name]
-        return @items[item_name].self_and_children.map(&:name)
+        @items[item_name].self_and_children.map(&:name)
       else
-        return @items.keys.sort
+        @items.keys.sort
       end
     end
-    alias_method :all, :to_a
+    alias all to_a
 
     def <=>(other)
       name <=> other.name
@@ -351,7 +356,7 @@ module Onoma
 
     # Returns a list for select as an array of pair (array)
     def selection(item_name = nil)
-      items = (item_name ? @items[item_name].self_and_children : @items.values)
+      items = (item_name ? find!(item_name).self_and_children : @items.values)
       items.collect do |item|
         [item.human_name, item.name.to_s]
       end.sort do |a, b|
@@ -361,21 +366,27 @@ module Onoma
 
     # Returns a list for select as an array of pair (hash)
     def selection_hash(item_name = nil)
-      @items[item_name].self_and_children.map do |item|
+      items = (item_name ? find!(item_name).self_and_children : @items.values)
+      items.collect do |item|
         { label: item.human_name, value: item.name }
       end.sort { |a, b| a[:label].lower_ascii <=> b[:label].lower_ascii }
     end
 
     # Returns a list for select, without specified items
     def select_without(already_imported)
-      selection = @items.values.collect do |item|
+      ActiveSupport::Deprecation.warn 'Nomen::Nomenclature#select_without method is deprecated. Please use Nomen::Nomenclature#without method instead.'
+      select_options = @items.values.collect do |item|
         [item.human_name, item.name.to_s] unless already_imported[item.name.to_s]
       end
-      selection.compact!
-      selection.sort! do |a, b|
+      select_options.compact!
+      select_options.sort! do |a, b|
         a.first <=> b.first
       end
-      selection
+      select_options
+    end
+
+    def degree_of_kinship(a, b)
+      a.degree_of_kinship_with(b)
     end
 
     # Return first item name
@@ -388,26 +399,36 @@ module Onoma
       first(item_name)
     end
 
-    # Return the Item for the given name
+    # Return the Item for the given name. Returns nil if no item found
     def find(item_name)
       @items[item_name]
     end
-    alias_method :item, :find
-
-    def property(property_name)
-      @properties[property_name]
-    end
+    alias item find
 
+    # Return the Item for the given name. Raises Nomen::ItemNotFound if no item
+    # found in nomenclature
     def find!(item_name)
-      unless i = @items[item_name]
-        fail "Cannot find item #{item_name} in #{name}"
-      end
+      i = find(item_name)
+      raise ItemNotFound, "Cannot find item #{item_name.inspect} in #{name}" unless i
       i
     end
 
+    # Returns +true+ if an item exists in the nomenclature that matches the
+    # name, or +false+ otherwise. The argument can take two forms:
+    #  * String/Symbol - Find an item with this primary name
+    #  * Nomen::Item - Find an item with the same name of the item
+    def exists?(item)
+      @items[item.respond_to?(:name) ? item.name : item].present?
+    end
+    alias include? exists?
+
+    def property(property_name)
+      @properties[property_name]
+    end
+
     # Returns list of items as an Array
     def list
-      Onoma::Relation.new(@items.values)
+      Onoma::Relation.new(self, @items.values)
     end
 
     # Iterates on items
@@ -441,6 +462,13 @@ module Onoma
       end
     end
 
+    def without(*names)
+      excluded = names.flatten.compact.map(&:to_sym)
+      list.reject do |item|
+        excluded.include?(item.name)
+      end
+    end
+
     def find_by(properties)
       items = where(properties)
       return nil unless items.any?
@@ -468,11 +496,11 @@ module Onoma
     def cast_options(options)
       return {} if options.nil?
       hash = options.each_with_object({}) do |(k, v), h|
-        if properties[k]
-          h[k.to_sym] = cast_property(k, v.to_s)
-        else
-          h[k.to_sym] = v
-        end
+        h[k.to_sym] = if properties[k]
+                        cast_property(k, v.to_s)
+                      else
+                        v
+                      end
       end
     end
 
@@ -481,7 +509,7 @@ module Onoma
       if property = properties[name]
         if property.type == :choice || property.type == :item
           if value =~ /\,/
-            fail InvalidProperty, 'A property nature of choice type cannot contain commas'
+            raise InvalidProperty, 'A property nature of choice type cannot contain commas'
           end
           value = value.strip.to_sym
         elsif property.list?
@@ -492,14 +520,16 @@ module Onoma
           value = value.to_d
         elsif property.type == :integer
           value = value.to_i
+        elsif property.type == :date
+          value = (value.blank? ? nil : value.to_date)
         elsif property.type == :symbol
           unless value =~ /\A\w+\z/
-            fail InvalidProperty, "A property '#{name}' must contains a symbol. /[a-z0-9_]/ accepted. No spaces. Got #{value.inspect}"
+            raise InvalidProperty, "A property '#{name}' must contains a symbol. /[a-z0-9_]/ accepted. No spaces. Got #{value.inspect}"
           end
           value = value.to_sym
         end
-      elsif !%w(name parent aliases).include?(name.to_s)
-        fail ArgumentError, "Undefined property '#{name}' in #{@name}"
+      elsif !%w[name parent aliases].include?(name.to_s)
+        raise ArgumentError, "Undefined property '#{name}' in #{@name}"
       end
       value
     end

data/lib/onoma/property.rb

@@ -1,8 +1,8 @@
 module Onoma
   class Property
-    TYPES = [:boolean, :item, :item_list, :choice, :choice_list, :string_list,
-             :date, :decimal, :integer, :nomenclature, :string, :symbol]
-    
+    TYPES = %i[boolean item item_list choice choice_list string_list
+               date decimal integer nomenclature string symbol].freeze
+
     attr_reader :nomenclature, :name, :type, :fallbacks, :default, :source
 
     # New item
@@ -10,7 +10,7 @@ module Onoma
       @nomenclature = nomenclature
       @name = name.to_sym
       @type = type
-      fail "Invalid type: #{@type.inspect}" unless TYPES.include?(@type)
+      raise "Invalid type: #{@type.inspect}" unless TYPES.include?(@type)
       @fallbacks = options[:fallbacks] if options[:fallbacks]
       @default = options[:default] if options[:default]
       @required = !!options[:required]
@@ -28,11 +28,11 @@ module Onoma
       attrs[:name] = @name.to_s
       attrs[:type] = @type.to_s
       if @source
-        if inline_choices?
-          attrs[:choices] = @source.join(', ')
-        else
-          attrs[:choices] = @source.to_s
-        end
+        attrs[:choices] = if inline_choices?
+                            @source.join(', ')
+                          else
+                            @source.to_s
+                          end
       end
       attrs[:required] = 'true' if @required
       attrs[:fallbacks] = @fallbacks.join(', ') if @fallbacks
@@ -68,19 +68,19 @@ module Onoma
     # Returns list of choices for a given property
     def choices
       if inline_choices?
-        return @source || []
+        @source || []
       elsif item_reference?
-        return @nomenclature.sibling(@source).all.map(&:to_sym)
+        @nomenclature.sibling(@source).all.map(&:to_sym)
       end
     end
 
     def selection
       if inline_choices?
-        return choices.collect do |c|
+        choices.collect do |c|
           [c, c]
         end
       elsif item_reference?
-        return @nomenclature.sibling(@source).selection
+        @nomenclature.sibling(@source).selection
       end
     end
 
@@ -89,7 +89,7 @@ module Onoma
       "nomenclatures.#{nomenclature.name}.properties.#{name}".t(default: ["nomenclatures.#{nomenclature.name}.properties.#{name}".to_sym, "properties.#{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
 
     def <=>(other)
       name <=> other.name

data/lib/onoma/reference.rb

@@ -7,7 +7,7 @@ module Onoma
       @type = type
       @property = property
       @foreign_nomenclature = foreign_nomenclature
-      fail "Invalid nomenclature: #{@foreign_nomenclature.inspect}" unless @foreign_nomenclature.is_a?(Nomenclature)
+      raise "Invalid nomenclature: #{@foreign_nomenclature.inspect}" unless @foreign_nomenclature.is_a?(Nomenclature)
     end
 
     def nomenclature

data/lib/onoma/reflection.rb

@@ -2,24 +2,29 @@ module Onoma
   class Reflection
     attr_reader :active_record, :name, :class_name, :foreign_key, :scope, :options, :nomenclature, :klass
 
+    # name:       things
+    # class_name: Thing
+    # klass:      Nomen::Thing
     def initialize(active_record, name, options = {})
       @options = options
       @name = name.to_s
       @active_record = active_record
       @class_name = options[:class_name] || name.to_s.classify
-      @foreign_key = options[:foreign_key] || name
+      @foreign_key = (options[:foreign_key] || name).to_s
       @scope = options[:scope]
       @nomenclature = class_name.underscore.pluralize
       @klass = Onoma.find(@nomenclature)
     end
 
-    alias_method :model, :active_record
+    alias model active_record
 
     def macro
       :belongs_to
     end
 
-    # Returns true if self and other_aggregation have the same name attribute, active_record attribute, and other_aggregation has an options hash assigned to it.
+    # Returns true if self and other_aggregation have the same name attribute,
+    # active_record attribute, and other_aggregation has an options hash
+    # assigned to it.
     def ==(other_aggregation)
       other_aggregation.is_a?(self.class) &&
         name == other_aggregation.name &&

data/lib/onoma/relation.rb

@@ -1,9 +1,31 @@
 module Onoma
   class Relation < Array
-    alias_method :find_each, :each
+    attr_reader :nomenclature
 
-    def select(*args, &block)
-      self.class.new(super(*args, &block))
+    alias find_each each
+
+    def initialize(nomenclature, *args)
+      super(*args)
+      @nomenclature = nomenclature
+    end
+
+    %w[drop drop_while select reject reverse slice_after slice_before slice_when sort].each do |meth|
+      define_method meth do |*args, &block|
+        self.class.new(@nomenclature, super(*args, &block))
+      end
+    end
+
+    def selection(sorted = true)
+      unit_selec = collect do |item|
+        [item.human_name, item.name.to_s]
+      end
+      if sorted
+        unit_selec.sort! do |a, b|
+          a.first.lower_ascii <=> b.first.lower_ascii
+        end
+      end
+
+      unit_selec
     end
   end
 end

data/lib/onoma/version.rb

@@ -1,3 +1,3 @@
 module Onoma
-  VERSION = "0.0.0"
+  VERSION = '0.1.0'.freeze
 end