precedences 1.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7a84c172e64b8c245d28b5b61fc6971242e5e4754ebe5de552a4b6af27b33014
+  data.tar.gz: 5e43bfe49c64c21b8ab134330f922bc4820dd66c9eceec6b45f36245d208467b
+SHA512:
+  metadata.gz: 5a0600fae85efe979be58a31250bd0d983b9163305e2e2ba5c3dba9d39ab91ca5cb5203360ec7540ce9d3a50313ddab67d684bf05cbb8a2b4ccefd86007872d0
+  data.tar.gz: ee8ca855b132b278b78b4d84e3933821a4e6e0094069b7f1855af81c5938a0b73fcac6ccd20d42be0380f54637bb9430981ffec2097d5fccbdb9f6d094bb9bc7

data/.gitignore

@@ -0,0 +1,13 @@
+.DS_Store
+
+.precedences
+*.precedences
+
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.3
+before_install: gem install bundler -v 2.1.4

data/CHANGELOG

@@ -0,0 +1,43 @@
+# 1.4.1
+
+  - option :filter à true pour le TTY::select
+
+# 1.4.0
+
+  - On peut appeler `set_precedence` avec un fichier pour une utilisation sans pré-traitement.
+
+# 1.3.2
+
+  - Traitement plus fin du nom du fichier enregistrant les précédences
+
+# 1.3.1
+
+  - correction du bug sur le check des choices (on prend le premier
+    au lieu du deuxième qui pourrait ne pas exister)
+    
+# 1.3.0
+
+  - Possibilité de faire Control-C pour interrompre (annuler)
+  - Cancel en orange
+
+# 1.2.0
+
+  - Ajout d'un menu Cancel/Renoncer à la demande.
+
+# 1.1.1
+
+  - Quelques corrections
+
+# 1.1.0
+
+  - Option :precedences_per_index pour pouvoir utiliser n'importe
+    quel type de value, mais un enregistrement des précédences par
+    index.
+    
+# 1.0.1
+
+  - :value of a choice can be nil.
+
+# 1.0.0
+  
+  - First operational release.

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in precedences.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.0"
+gem "clir", ">= 0.16"

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    precedences (1.4.1)
+      clir (>= 0.16)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    clir (0.22.1)
+      json
+      tty-prompt
+    json (2.6.3)
+    minitest (5.20.0)
+    minitest-color (0.0.2)
+      minitest (~> 5)
+    pastel (0.8.0)
+      tty-color (~> 0.5)
+    rake (12.3.3)
+    tty-color (0.6.0)
+    tty-cursor (0.7.1)
+    tty-prompt (0.23.1)
+      pastel (~> 0.8)
+      tty-reader (~> 0.8)
+    tty-reader (0.9.0)
+      tty-cursor (~> 0.7)
+      tty-screen (~> 0.8)
+      wisper (~> 2.0)
+    tty-screen (0.8.1)
+    wisper (2.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  clir (>= 0.16)
+  minitest (~> 5.0)
+  minitest-color
+  precedences!
+  rake (~> 12.0)
+
+BUNDLED WITH
+   2.1.4

data/Manual/Manuel-fr.md

@@ -0,0 +1,170 @@
+# Precedences
+
+Gestion de précédences dans les listes de choix pour `Tty-Prompt#select`.
+
+Deux modes d'utilisation sont possibles.
+
+Le plus simple, par block :
+
+~~~ruby
+require 'precedences'
+
+#
+# Tty-prompt#select choices
+#
+choices = [
+  {name:"Choix premier", value: :first},
+  {name:"Deuxième choix", value: :second}
+]
+
+# 
+# Fichier où les précédences seront enregistrées
+# 
+precfile = File.join(__dir__, '.precedences')
+
+choix = precedencize(choices, precfile) do |q|
+  q.question "Choisir la valeur :"
+end
+
+~~~
+
+`choix` contiendra la valeur choisie, soit `:first` soit `:second`.
+
+Le second mode d'utilisation fonctionne sans bloc, avec les valeurs par défaut :
+
+~~~ruby
+require 'precedences'
+
+##
+# On définit choices et prefile de la même façon
+# puis…
+
+choices = precedencize(choices, precfile)
+
+choix = Q.select("Choisir parmi : ", choices)
+#
+# Pour enregistrer cette précédence (ne pas l'oublier !)
+# 
+set_precedence(choix)
+
+# ...
+~~~
+
+On peut même considérer un troisième bloc qui utilise juste la méthode `set_precedence(choix, fichier)` quand le traitement du choix se fait ailleurs. Typiquement, on l’utilise quand la valeur peut être transmise directement au script, par exemple en ligne de commande.
+
+~~~ruby
+require 'precedences'
+
+choix = ARGV[0] || demande_la_valeur_du_choix || return
+
+set_precedence(choix, "<file/to/precedences_file>")
+~~~
+
+
+
+## Valeurs possibles
+
+Dans l'utilisation normale, l'attribut `:value` des choices doit obligatoirement être de type `String`, `Symbol` ou `Numeric`, mais avec l’option `precedences_per_index`, il est possible d’utiliser n’importe quelle valeur (note : l’ordre est alors mémorisé par index — ce qui signifie qu’il ne faut pas modifier la liste en cours de route).
+
+Par exemple :
+
+~~~ruby
+require 'precedences'
+
+#
+# Des choix avec des valeurs spéciales
+#
+choices = [
+  {name:"La classe Integer"		, value: Integer},
+  {name:"La classe Array"			, value: Array},
+  {name:"La classe Hash"			, value: Hash},
+]
+
+choix = precedencize(choices, file) do |q|
+  q.question "Choisis une classe"
+  q.precedences_per_index  # <=== option pour que ça passe
+end
+~~~
+
+
+
+## Options possibles
+
+En mode block, on peut définir plusieurs choses :
+
+~~~ruby
+require 'precedences'
+
+choix = precedencize(choices, precfile) do |q|
+  # 
+  # La question
+  # 
+  q.question = "Ma question"
+  # ou
+  q.question "Ma question"
+  
+  #
+  # Le nombre de menus affichés
+  # (noter que par défaut, tous les menus sont affichés, contrairement
+  #  à tty-prompt qui les limite toujours)
+  #
+  q.per_page 5
+  # ou q.per_page = 5
+
+  # 
+  # L'affichage ou non de l'aide (:never par défaut)
+  # 
+  q.show_help = :always
+  # ou
+  q.show_help :start
+
+  # 
+  # Le message d'aide à afficher
+  # 
+  q.help = "Mon message d'aide"
+  # ou
+  q.help "Message d'aide"
+
+  #
+  # La valeur sélectionnée par défaut (lorsqu'il faut passer
+  # outre l'ordre de précédence par exemple)
+  # Cette valeur peut être passée par…
+  # 
+  # Par index 1-based explicite
+  q.default = 4
+  # ou q.default 4
+  # 
+  # Par valeur du :value
+  q.default = :second
+  # ou q.default :second
+  # 
+  # Par extrait du name (ou name exact)
+  q.default = "premier"
+  # ou q.default "premier"
+  # => Sélectionnera le choix "Choix premier"
+
+end
+
+~~~
+
+#### Ajouter un menu “Renoncer”
+
+~~~ruby
+choix = precedencize(choices, file) do |q|
+  q.add_choice_cancel(:up, {value: :cancel, name: "Renoncer"})
+end
+~~~
+
+Si on doit utiliser les valeurs par défaut que sont :
+
+* `:name` est “Cancel”
+* `:value` est `nil`
+* position est `:down` alors on peut faire simplement
+
+~~~ruby
+choix = precedencize(choices, file) do |q|
+  q.add_choice_cancel
+end
+~~~
+
+> 😃 Noter qu’on peut en fait se servir de ce menu pour ajouter n’importe quel autre menu que “Renoncer”.

data/README.md

@@ -0,0 +1,90 @@
+# Precedences
+
+Deal with order of items in a select list of TTY-Prompt, applying the "last is the first" principle. Hence, last choice in the list will always be the first in the future.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'precedences'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install precedences
+
+## Usage
+
+~~~ruby
+require 'precedences'
+
+choices = [
+  {name:"First choix", value: :first},
+  {name:"Second choix", value: :second},
+  {name:"Third choix", value: :third},
+]
+
+myfile = File.join(__dir__, 'my.precedences')
+
+choix = precedencize(choices, myfile) do |q|
+  q.question "Choose a item among:"
+end
+
+~~~
+
+With the code above, the first time, the list will display:
+
+~~~
+> First choix
+  Second choix
+  Third choix
+~~~
+
+I choose "Second choix":
+
+~~~
+  First choix
+> Second choix
+  Third choix
+~~~
+
+The next time I use the command, the list will display:
+
+~~~
+> Second choix
+  First choix
+  Third choix
+~~~
+
+Then I choose "Third choix":
+
+~~~
+  Second choix
+  First choix
+> Third choix
+~~~
+
+The next time I use the command, the list displayed should be:
+
+~~~
+> Third choix
+  Second choix
+  First choix
+~~~
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/precedences.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "precedences"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/precedences/exposed.rb

@@ -0,0 +1,16 @@
+
+
+def precedencize(choices, filename, &block)
+  prec = Clir::Precedence.new(filename)
+  Clir::Precedence.current = prec
+  return prec.sort(choices, &block)
+end
+
+def set_precedence(choix, filename = nil)
+  prec =  if filename.nil?
+            Clir::Precedence.current  
+          else
+            Clir::Precedence.new(filename)
+          end
+  prec.send(:set_precedences_ids, choix)
+end

data/lib/precedences/precedence.rb

@@ -0,0 +1,330 @@
+module Clir
+class Precedence
+
+###################       CLASSE      ###################
+  class << self
+
+    attr_accessor :current
+
+  end #/<< self
+###################       INSTANCE      ###################
+
+  attr_reader :filepath
+
+  def initialize(filepath)
+    @filepath = filepath
+    filepath_validize_or_raises
+    # --- Default values ---
+    @question   = "Choose:"
+    @show_help  = nil
+    @help       = ''
+    @per_page   = nil
+    @default    = 1
+    @precedences_per_index  = false
+    @add_choice_cancel      = nil
+  end
+
+  def sort(choices_ini, &block)
+
+    # 
+    # On doit évaluer le bloc ici car certaines valeurs peuvent
+    # modifier le comportement de la suite.
+    # Par exemple, si @precedences_per_index a été mis à true,
+    # on peut permettre n'importe quel type de :value dans les 
+    # hash
+    if block_given?
+      block.call(self)
+    end
+
+    # 
+    # List of choices must be valid
+    # 
+    choices_valid_or_raises(choices_ini)
+
+    # 
+    # Use a clone rather than original list to leave the initial
+    # list of choices alone.
+    # 
+    choices = choices_ini.dup
+  
+    #
+    # Sort the list of choices 
+    # (and treate other choices — add cancel, etc.)
+    # 
+    choices = prepare_choices(choices)
+
+    if block_given?
+      # 
+      # Tty-select options
+      # 
+      options = define_tty_options(choices)
+      # 
+      # On procède au choix
+      # 
+      begin
+        choix = Q.select(question.jaune, choices, **options)
+      rescue TTY::Reader::InputInterrupt
+        # Annulation par ^C
+        return nil
+      end
+      # 
+      # On enregistre ce choix (sauf si null ou :cancel)
+      # 
+      set_precedence(choix) unless choix.nil? || choix == :cancel
+      # 
+      # On retourne le choix
+      # 
+      return choix
+    else
+      # 
+      # Sinon, sans block, on renvoie la liste classée
+      # 
+      return choices
+    end
+  end
+
+  # --- Predicate Methods ---
+
+  def precedences_per_index?
+    @precedences_per_index === true
+  end
+
+  def add_choice_cancel?
+    not(@add_choice_cancel.nil?)
+  end
+
+  # --- Tty prompt Methods ---
+
+  def question(quest = nil)
+    @question = quest unless quest.nil?
+    return @question
+  end
+  def question=(quest) ; question(quest) end
+
+  def per_page(value = nil)
+    @per_page = value unless value.nil?
+    return @per_page
+  end
+  def per_page=(value); per_page(value) end
+
+  def show_help(value = nil)
+    @show_help = value unless value === nil
+    return @show_help
+  end
+  def show_help=(value) ; show_help(value) end
+
+  def default(value = nil)
+    @default = value unless value.nil?
+    return @default
+  end
+  def default=(value) ; default(value) end
+
+  def help(value = nil)
+    @help = value unless value.nil?
+    return @help
+  end
+  def help=(value) ; help(value) end
+
+  def precedences_per_index(value = nil)
+    if value === false
+      @precedences_per_index = false
+    else
+      @precedences_per_index = true
+    end
+    return @precedences_per_index
+  end
+  def precedences_per_index=(value) ; precedences_per_index(value) end
+
+  ##
+  # To add the cancel choice
+  # 
+  def add_choice_cancel(where = :down, **params)
+    if where.is_a?(Hash)
+      params = where
+      where   = nil
+    else
+      params ||= {}
+    end
+    params ||= {}
+    default_params = {value: nil, name: "Cancel", position: :down}
+    params = default_params.merge(params)
+    params.merge!(position: where.to_s.downcase.to_sym) unless where.nil?
+    params.merge!(name: params[:name].orange)
+    @add_choice_cancel = params
+  end
+
+  private
+
+    ##
+    # = main =
+    #
+    def prepare_choices(choices)
+      # 
+      # Classement des choix par précédence
+      # 
+      choices = sort_items(choices)
+      # 
+      # Faut-il ajouter un choix cancel ?
+      # 
+      if add_choice_cancel?
+        add_method = (@add_choice_cancel[:position] == :down) ? :push : :unshift
+        choices.send(add_method, @add_choice_cancel)
+      end
+      # 
+      # On retourne les choix préparés
+      # 
+      return choices
+    end
+    #
+    # Main method whose sort items
+    # 
+    # @api private
+    def sort_items(choices)
+      return choices unless File.exist?(filepath)
+      prec_ids = get_precedences_ids
+      if precedences_per_index?
+        choices_copy = choices.dup
+        choices = prec_ids.map do |id| 
+          item = choices_copy[id.to_i - 1]
+          choices_copy[id.to_i - 1] = nil
+          item
+        end
+        # On ajoute les choix restants
+        choices += choices_copy.compact
+      else
+        # 
+        # Cas normal
+        # 
+        choices.sort!{|a, b|
+          (prec_ids.index(a[:value].to_s)||10000) <=> (prec_ids.index(b[:value].to_s)||10000)
+        }
+      end
+      return choices
+    end
+
+    ##
+    # Define default tty-options (last parameter of select)
+    # 
+    def define_tty_options(choices)
+      {
+        per_page:   self.per_page || choices.count,
+        show_help:  self.show_help ? :always : :never,
+        echo:       nil,
+        help:       self.help,
+        default:    get_default_value_index(choices),
+        filter:     true,
+      }
+    end
+
+    # Save the values order in filepath file
+    # 
+    # @api private
+    def set_precedences_ids(value)
+      if precedences_per_index?
+        # 
+        # Mémorisation des choix par index
+        # (:value de n'importe quel type, mais la liste original
+        #  ne peut pas être changée)
+        # 
+        @choices_ini.each_with_index do |choice, idx|
+          value = (idx + 1).to_s and break if choice[:value] == value
+        end
+      else
+        # 
+        # Mémorisation des choix par valeur
+        # (plus fiable, la liste peut être changée)
+        # 
+        value = value.to_s
+      end
+      pids = get_precedences_ids
+      pids.delete(value)
+      pids.unshift(value)
+      File.write(filepath, pids.join("\n"))
+    end
+
+    # Get the values sorted if filepath exists.
+    # 
+    # @api private
+    def get_precedences_ids
+      @get_precedences_ids ||= begin
+        File.exist?(filepath) ? File.read(filepath).split("\n") : [] 
+      end
+    end
+
+    ##
+    # Check if given filepath (for saving order of choices) is valid.
+    # Raise an argument error otherwise.
+    # If it's a folder, set to .precedences file
+    # 
+    # @api private
+    def filepath_validize_or_raises
+      File.exist?(File.dirname(filepath)) || raise(ArgumentError.new("Precedences incorrect file: its folder should exist."))
+      if File.exist?(filepath) && File.directory?(filepath)
+        @filepath = File.join(filepath, '.precedences')
+      elsif File.extname(filepath).empty? && !File.basename(filepath).start_with?('.')
+        @filepath = "#{filepath}.precedences"
+      end
+    end
+
+    ##
+    # Check if given choices are valid. Raise an ArgumentError otherwise
+    # 
+    # @api private
+    def choices_valid_or_raises(choices)
+      # 
+      # On en aura besoin
+      # 
+      @choices_ini = choices.dup.freeze
+
+      choices.is_a?(Array) || raise(ArgumentError.new('Bad choices. Should be an Array.'))
+      choices.empty? && raise(ArgumentError.new("Bad choices. Shouldn't be empty." ))
+      choices[0].is_a?(Hash) || raise(ArgumentError.new('Bad choices. Should be an Array of Hash(s).'))
+      # 
+      # To check unicity of values
+      # 
+      cvalues = {}
+      # 
+      # Check every choice
+      # 
+      choices.each do |choice|
+        choice.key?(:name) || raise(ArgumentError.new("Bad choices. Every choice should define :name attribute."))
+        choice.key?(:value) || raise(ArgumentError.new("Bad choices. Every choice should define :value attribute."))
+        case choice[:value]
+        when Symbol, String, Numeric, NilClass then
+          val = choice[:value].to_s
+          if cvalues.key?(val)
+            raise ArgumentError.new("Bad choices. Value collision: #{choice[:value].inspect} and #{cvalues[val].inspect} are the same, for precedences.")
+          else
+            cvalues.merge!(val => choice[:value])
+          end
+        else
+          if precedences_per_index?
+            # ok, :value peut avoir n'importe quelle valeur
+          else
+            raise(ArgumentError.new("Bad choices. Attribute :value of choice should only be a String, a Symbol, a Numeric or NilClass. #{choice[:value]} is a #{choice[:value].class}. Add option q.precedences_per_index in block if init never changes."))
+          end
+        end
+      end
+    end
+
+    ##
+    # @return index (1-based) of default value if defined (even it's a
+    # bit silly with precedences…)
+    # 
+    def get_default_value_index(choices)
+      return default if default.is_a?(Integer) && default > 0
+      # 
+      # On recherche la valeur dans les choix (:name or :value)
+      # 
+      choices.each_with_index do |choice, idx|
+        the_index = idx + 1
+        return the_index if choice[:value] == default
+        return the_index if choice[:name].match?(/#{default}/)
+      end
+      # 
+      # Si on n'a rien trouvé, on s'en retourne avec le premier
+      # 
+      return 1
+    end
+end #/class Precedence
+end #/module Clir

data/lib/precedences/version.rb

@@ -0,0 +1,3 @@
+module Precedences
+  VERSION = "1.4.1"
+end

data/lib/precedences.rb

@@ -0,0 +1,9 @@
+require 'clir'
+require "precedences/version"
+require "precedences/precedence"
+require "precedences/exposed"
+
+module Precedences
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/precedences.gemspec

@@ -0,0 +1,32 @@
+require_relative 'lib/precedences/version'
+
+Gem::Specification.new do |s|
+  s.name          = "precedences"
+  s.version       = Precedences::VERSION
+  s.authors       = ["PhilippePerret"]
+  s.email         = ["philippe.perret@yahoo.fr"]
+
+  s.summary       = %q{Sort list with "the last is the first" principle}
+  s.description   = %q{Tty-prompt extension to sort a list of choices along the "last is firts" principle.}
+  s.homepage      = "https://rubygems.org/gems/precedences"
+  s.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  s.add_dependency 'clir', '>= 0.16'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'minitest-color'
+
+  s.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  s.metadata["homepage_uri"] = s.homepage
+  s.metadata["source_code_uri"] = "https://github.com/PhilippePerret/precedences"
+  s.metadata["changelog_uri"] = "https://github.com/PhilippePerret/precedences/CHANGELOG"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  s.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|features)/}) }
+  end
+  s.bindir        = "exe"
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: precedences
+version: !ruby/object:Gem::Version
+  version: 1.4.1
+platform: ruby
+authors:
+- PhilippePerret
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: clir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Tty-prompt extension to sort a list of choices along the "last is firts"
+  principle.
+email:
+- philippe.perret@yahoo.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG
+- Gemfile
+- Gemfile.lock
+- Manual/Manuel-fr.md
+- Manual/Manuel-fr.pdf
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/precedences.rb
+- lib/precedences/exposed.rb
+- lib/precedences/precedence.rb
+- lib/precedences/version.rb
+- precedences.gemspec
+homepage: https://rubygems.org/gems/precedences
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://rubygems.org/gems/precedences
+  source_code_uri: https://github.com/PhilippePerret/precedences
+  changelog_uri: https://github.com/PhilippePerret/precedences/CHANGELOG
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Sort list with "the last is the first" principle
+test_files: []