pfa 1.0.1

data/lib/pfa/relative_pfa_node.rb

@@ -0,0 +1,238 @@
+require_relative 'imagemagick_module'
+require_relative 'pfa_element_module'
+
+module PFA
+class RelativePFA
+class Node
+
+  include PFAElementModule
+  include MagickPFA
+
+  attr_reader :pfa, :key
+
+  attr_reader :description
+
+  def initialize(pfa, key, value = nil)
+    @pfa        = pfa
+    @key        = key
+    parse_raw_value(value)
+  end
+
+  def code_image_magick
+    pfa.img_builder.code_image_magick
+  end
+
+  # --- MÉTHODES TEMPORELLES ---
+
+  # -- Temps relatifs --
+
+  # [PFA::NTime] Temps (relatif) de début du nœud
+  # @note : défini à l'instantiation
+  def start_at
+    @start_at
+  end
+
+  # [PFA::NTime] Temps (relatif) de fin du noeud
+  def end_at
+    @end_at ||= start_at + duration # attention : 2 NTime
+  end
+
+  # \PFA::NTime Durée 
+  # Soit elle a été explicitement définie en renseignant le noeud, 
+  # soit on lui donne la valeur de la durée absolue.
+  # Sauf pour les actes, qui possèdent leur propre calcul, étant
+  # donné qu'ils dépendent d'autres éléments
+  def duration
+    @duration ||= begin
+      if type == :part
+        case key
+        when :exposition          then @end_at = pfa.developpement_part1.start_at
+        when :developpement_part1 then @end_at = pfa.developpement_part2.start_at
+        when :developpement_part2 then @end_at = pfa.denouement.start_at
+        when :denouement          then @end_at = PFA::NTime.new(pfa.duration.to_i)
+        end
+        end_at - start_at 
+      else
+        abs_duration
+      end
+    end
+  end
+
+  # [String] Horloge du temps (relatif) de départ
+  def horloge
+    @horloge ||= start_at.to_horloge
+  end
+
+  # -- Temps Absolus --
+
+  # [PFA::NTime] Temps absolu (idéal) de départ
+  def abs_start
+    @abs_start ||= calc_with_fraction_of_duree(abs_data[:abs_start])
+  end
+
+  def abs_end
+    @abs_end ||= abs_start + abs_duration
+  end
+
+  def abs_duration
+    @abs_duration ||= calc_with_fraction_of_duree(abs_data[:abs_duration])
+  end
+
+  # --- MÉTHODES DE DIMENSIONNEMENT ---
+
+  # -- Dimensions Absolues --
+
+  def abs_left
+    @abs_left ||= abs_start.to_px(pfa)#.tap { |n| dbg "abs_left: #{n}".bleu}
+  end
+
+  def abs_width
+    @abs_width ||= abs_duration.to_px(pfa)
+  end
+
+  def abs_right
+    @abs_right ||= begin
+      if id == 'DE' # denouement
+        # Pour que le trait du dénouement soit dans l'image
+        abs_left + abs_width - 2
+      else
+        abs_left + abs_width
+      end
+    end
+  end
+
+  def abs_top
+    @abs_top ||= MagickPFA::ABS_TOPS[type]
+  end
+
+  def abs_bottom
+    @abs_bottom ||= MagickPFA::ABS_BOTTOMS[type]
+  end
+
+  def abs_height
+    @abs_height ||= MagickPFA::HEIGHTS[type]
+  end
+
+  def img_abs_surface
+    @img_abs_surface ||= "#{abs_width}x#{abs_height}"
+  end
+
+  # -- Dimensions Relatives --
+
+  def left
+    @left ||= start_at.to_px(pfa)
+  end
+
+  def width
+    @width ||= duration.to_px(pfa)
+  end
+
+  def right
+    @right ||= begin 
+      if id == 'DE' # denouement
+        # Pour que le trait du dénouement soit dans l'image
+        left + width - 2
+      else
+        left + width
+      end
+    end
+  end
+
+  def top
+    @top ||= MagickPFA::TOPS[type]
+  end
+
+  def bottom
+    @bottom ||= MagickPFA::BOTTOMS[type]
+  end
+  
+  # Hauteur de la boite pour écrire le texte
+  def height
+    @height ||= (MagickPFA::HEIGHTS[type]).to_i
+  end
+
+  def img_surface
+    @img_surface ||= "#{width}x#{height}"
+  end
+
+
+  # --- Predicate Methods ---
+
+  # @return [Bool] true si le nœud courant est après 
+  # le nœud [RelativePFA::Node] +node+
+  # 
+  def after?(node)
+    # dbg "node = #{node.inspect}".orange
+    return start_at > node.start_at
+  end
+
+
+  # --- Absolute Data ---
+
+  # \Hash Données absolues du nœud
+  def abs_data
+    @abs_data ||= AbsolutePFA.data[:nodes][key]
+  end
+  
+  def mark
+    abs_data[:hname]
+  end
+
+  def type
+    abs_data[:type].to_sym
+  end
+
+  def id
+    abs_data[:id]
+  end
+
+  # --- Calculated Values (dimensions) ---
+
+
+
+  # -- Des valeurs qui peuvent servir… --
+  def demiheight      ; @demiheight   ||= height / 2                end
+  def demiwidth       ; @demiwidth    ||= width  / 2                end
+  def abs_demiwidth   ; @absdemiwidth ||= abs_width  / 2            end
+  def hcenter         ; @hcenter      ||= left  + demiwidth         end
+  def abs_hcenter     ; @abshcenter   ||= abs_left + abs_demiwidth  end
+  def vcenter         ; @vcenter      ||= top   + demiheight        end
+  # Le bas ultime du paradigme ?
+  def box_bottom      ; @box_bottom   ||= top + 13 * MagickPFA::LINE_HEIGHT end
+
+
+  private
+
+  
+  # Méthode qui parse la valeur fournie à l'instantiation pour en
+  # tirer les valeurs (@start_at et @duration)  
+  def parse_raw_value(value)
+    @raw_value = value 
+    if value.is_a?(Hash)
+      @start_at     = NTime.new(value[:t], pfa.zero.to_i)
+      @description  = value[:d]
+      if value.key?(:duree) || value.key?(:duration)
+        # La durée est fournie en secondes, elle doit donc être 
+        # ramenée à la valeur sur 120 minutes
+        @duration = NTime.new(value[:duree]||value[:duration], 0)
+      end
+    end
+  end
+
+  # @return [PFA::NTime] le temps représenté par une fraction dans
+  # les données absolues du Paradigme de Field Augmenté
+  # 
+  # @param [String] fraction_str
+  #   Cette fraction peut avoir les aspects suivants :
+  #     1/2
+  #     1/2 + 1/48
+  #     1/2 - 1/24
+  # 
+  def calc_with_fraction_of_duree(fraction_str)
+    fraction = eval(fraction_str.to_s.gsub(/\//,'.0/')) # p.e. 1/24 => 1.0/24
+    return PFA::NTime.new(pfa.duration.to_i * fraction, 0)
+  end
+
+end #/class Node
+end #/class RelativePFA
+end #/module PFA

data/lib/pfa/temporal_methods.rb

@@ -0,0 +1,69 @@
+module PFA
+
+  # Reçoit une valeur temporelle quelconque (mais valide) et retourne
+  # le temps \Time correspondant
+  # 
+  # Les valeurs adminissibles sont \Time, \String (format horloge)
+  # ou \Integer (nombre de secondes)
+  # 
+  def self.time_from(value)
+    case value
+    when Time     then value
+    when String   then PFA.h2t(value)
+    when Integer  then Time.at(value)
+    else raise PFAFatalError.new(52, **{value:"#{value.inspect}::#{value.class}"})
+    end
+  end
+
+  # Reçoit une horloge au format \String et retourne un nombre
+  # de secondes correspondant.
+  # 
+  # @param \String horloge L'horloge transmise, sous différents 
+  #     formats possible, comme 'H:M:S', 'H+M+S' ou 'H,M,S'
+  # 
+  def self.h2s(horloge)
+    horloge.match?(REG_HORLOGE) || raise(PFAFatalError.new(52, **{value:"#{horloge.inspect}::#{horloge.class}"}))
+    s, m, h = horloge.split(/[+,:]/).reverse.collect {|n| n.to_i}
+    return (s||0) + (m||0) * 60 + (h||0) * 3600
+  end
+
+  # Reçoit une horloge et retourne le temps correspondant
+  def self.h2t(horloge)
+    Time.at(h2s(horloge))
+  end
+
+  # Reçoit un nombre de secondes \Integer et retourne une horloge
+  # au format 'H:MM:SS'
+  # Si +options[:as]+ = :duree, on renvoie une version durée, 
+  # c'est-à-dire avec les heures, et les minutes sur deux chiffres
+  # seulement s'il y a des heures.
+  def self.s2h(secondes, **options)
+    secondes.is_a?(Integer) || raise(PFAFatalError.new(51), **{value: "#{secondes.inspect}::#{secondes.class}"})
+    h = secondes / 3600
+    r = secondes % 3600
+    m = r / 60
+    s = r % 60
+    if options[:as] == :duree
+      # -- Version durée --
+      # (on ne met les heures que si elles sont définies)
+      segs = []
+      segs << "#{h}" if h > 0
+      m = m.to_s.rjust(2,'0') if h > 0
+      segs << "#{m}"
+      segs << s.to_s.rjust(2,'0')
+      segs.join(':') # => "1:02:54" ou "2:45"
+    else
+      # -- Version horloge normale --
+      # (toujours avec les heures)
+      "#{h}:" + [m,s].collect{|n|n.to_s.rjust(2,'0')}.join(':')
+    end
+  end
+
+  # Reçoit un temps \Time et retourne une horloge 'H:MM:SS' 
+  def self.t2h(time)
+    time.is_a?(Time) || raise(PFAFatalError.new(50, **{value: "#{time.inspect}::#{time.class}"}))
+    return s2h(time.to_i)
+  end
+
+  REG_HORLOGE = /^([0-9][+:,])?([0-9]{1,2}[+:,])?[0-9]{1,2}$/.freeze
+end#/module PFA

data/lib/pfa/version.rb

@@ -0,0 +1,3 @@
+module PFA
+  VERSION = "1.0.1"
+end

data/lib/pfa.rb

@@ -0,0 +1,20 @@
+def dbg(str)
+  STDOUT.write("\n#{str}\n")
+end
+require 'clir'
+require 'yaml'
+require 'singleton'
+require "pfa/version"
+require 'pfa/constants'
+require 'pfa/errors_manager'
+require 'pfa/temporal_methods'
+require 'pfa/node_time'
+require 'pfa/relative_pfa'
+require 'pfa/absolute_pfa'
+require 'pfa/relative_pfa_node'
+require 'pfa/relative_pfa_datatime'
+require 'pfa/img_builder'
+
+module PFA
+
+end

data/pfa.gemspec

@@ -0,0 +1,34 @@
+require_relative 'lib/pfa/version'
+
+Gem::Specification.new do |s|
+  s.name          = "pfa"
+  s.version       = PFA::VERSION
+  s.authors       = ["PhilippePerret"]
+  s.email         = ["philippe.perret@yahoo.fr"]
+
+  s.summary       = %q{Gestion d'un Paradigme de Field Augmentée (Field Augmented Paradigm)}
+  s.description   = %q{Gestion complète d'un PFA, pour le produire soit en HTML soit en PDF et calculer les différences entre PFA relatif et PFA absolu.}
+  s.homepage      = "https://rubygems.org/gems/pfa"
+  s.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  s.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  s.add_dependency 'yaml'
+  s.add_dependency 'clir'
+  s.add_dependency 'singleton'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'minitest-color'
+
+  s.metadata["homepage_uri"] = s.homepage
+  s.metadata["source_code_uri"] = "https://github.com/PhilippePerret/pfa"
+  s.metadata["changelog_uri"] = "https://github.com/PhilippePerret/pfa/CHANGELOG.md"
+
+  # 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)/}) }
+  end
+  s.bindir        = "exe"
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: pfa
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- PhilippePerret
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: clir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: singleton
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: Gestion complète d'un PFA, pour le produire soit en HTML soit en PDF
+  et calculer les différences entre PFA relatif et PFA absolu.
+email:
+- philippe.perret@yahoo.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/assets/Manuel/ImageMagick.md
+- lib/assets/Manuel/Manuel-developer.md
+- lib/assets/fr/PFA_ABSOLUTE_DATA.yaml
+- lib/assets/fr/errors.yaml
+- lib/pfa.rb
+- lib/pfa/absolute_pfa.rb
+- lib/pfa/any_builder.rb
+- lib/pfa/constants.rb
+- lib/pfa/errors_manager.rb
+- lib/pfa/imagemagick_module.rb
+- lib/pfa/img_builder.rb
+- lib/pfa/node_time.rb
+- lib/pfa/pfa_element_module.rb
+- lib/pfa/relative_pfa.rb
+- lib/pfa/relative_pfa_datatime.rb
+- lib/pfa/relative_pfa_node.rb
+- lib/pfa/temporal_methods.rb
+- lib/pfa/version.rb
+- pfa.gemspec
+- pfa.jpg
+homepage: https://rubygems.org/gems/pfa
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://rubygems.org/gems/pfa
+  source_code_uri: https://github.com/PhilippePerret/pfa
+  changelog_uri: https://github.com/PhilippePerret/pfa/CHANGELOG.md
+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: Gestion d'un Paradigme de Field Augmentée (Field Augmented Paradigm)
+test_files: []