musa-dsl 0.23.8 → 0.23.13

data/lib/musa-dsl/generative/backboner.rb

@@ -1,13 +1,13 @@
 require_relative '../core-ext/smart-proc-binder'
 require_relative '../core-ext/with'
 
-using Musa::Extension::Arrayfy
-
 # TODO hacer que pueda funcionar en tiempo real? le vas suministrando seeds y le vas diciendo qué opción has elegido (p.ej. para hacer un armonizador en tiempo real)
 # TODO esto mismo sería aplicable en otros generadores? variatio/darwin? generative-grammar? markov?
 
 module Musa
   module Backboner
+    using Musa::Extension::Arrayfy
+
     class Backboner
       include Musa::Extension::With
 

data/lib/musa-dsl/generative/generative-grammar.rb

@@ -1,5 +1,7 @@
 module Musa
   module GenerativeGrammar
+    # TODO: refactor & reorganize regarding use of include Musa::GenerativeGrammar problems as default consumption mode (it forces the consumer to have new public methods -P, PN- and class names -OptionElement-)
+
     extend self
 
     def N(content = nil, **attributes, &block)

data/lib/musa-dsl/generative/markov.rb

@@ -6,7 +6,6 @@ module Musa
 
   module Markov
     class Markov
-      include Musa::Extension::SmartProcBinder
       include Musa::Series::Serie.base
 
       def initialize(transitions:, start:, finish: nil, random: nil)
@@ -59,7 +58,7 @@ module Musa
                   r >= accumulated - probability && r < accumulated }[0]
 
               when Proc
-                procedure_binder = @procedure_binders[options] ||= SmartProcBinder.new(options)
+                procedure_binder = @procedure_binders[options] ||= Musa::Extension::SmartProcBinder::SmartProcBinder.new(options)
                 @current = procedure_binder.call @history
               else
                 raise ArgumentError, "Option #{option} is not allowed. Only Array, Hash or Proc are allowed."

data/lib/musa-dsl/generative/variatio.rb

@@ -2,16 +2,14 @@ require_relative '../core-ext/smart-proc-binder'
 require_relative '../core-ext/arrayfy'
 require_relative '../core-ext/with'
 
-using Musa::Extension::Arrayfy
-using Musa::Extension::ExplodeRanges
-
 # TODO: permitir definir un variatio a través de llamadas a métodos y/o atributos, además de a través del block del constructor
 
 module Musa
   module Variatio
-    class Variatio
-      include Musa::Extension::SmartProcBinder
+    using Musa::Extension::Arrayfy
+    using Musa::Extension::ExplodeRanges
 
+    class Variatio
       def initialize(instance_name, &block)
         raise ArgumentError, 'instance_name should be a symbol' unless instance_name.is_a?(Symbol)
         raise ArgumentError, 'block is needed' unless block
@@ -26,8 +24,8 @@ module Musa
       end
 
       def on(**values)
-        constructor_binder = SmartProcBinder.new @constructor
-        finalize_binder = SmartProcBinder.new @finalize if @finalize
+        constructor_binder = Musa::Extension::SmartProcBinder::SmartProcBinder.new @constructor
+        finalize_binder = Musa::Extension::SmartProcBinder::SmartProcBinder.new @finalize if @finalize
 
         run_fieldset = @fieldset.clone # TODO: verificar que esto no da problemas
 
@@ -202,8 +200,6 @@ module Musa
       private_constant :A2
 
       class B
-        include Musa::Extension::SmartProcBinder
-
         attr_reader :parameter_name, :options, :affected_field_names, :blocks, :inner
 
         def initialize(parameter_name, options, affected_field_names, inner, blocks)
@@ -212,7 +208,7 @@ module Musa
           @affected_field_names = affected_field_names
           @inner = inner
 
-          @procedures = blocks.collect { |proc| SmartProcBinder.new proc }
+          @procedures = blocks.collect { |proc| Musa::Extension::SmartProcBinder::SmartProcBinder.new proc }
         end
 
         def run(parameters_with_depth, parent_parameters = nil)

data/lib/musa-dsl/logger/logger.rb

@@ -1,37 +1,37 @@
 require 'logger'
-
 require_relative '../core-ext/inspect-nice'
 
+module Musa
+  module Logger
+    class Logger < ::Logger
+      using Musa::Extension::InspectNice
 
-module Musa; module Logger
-  class Logger < ::Logger
-    using Musa::Extension::InspectNice
-
-    def initialize(sequencer: nil, position_format: nil)
-      super STDERR, level: WARN
+      def initialize(sequencer: nil, position_format: nil)
+        super STDERR, level: WARN
 
-      @sequencer = sequencer
-      @position_format = position_format || 3.3
+        @sequencer = sequencer
+        @position_format = position_format || 3.3
 
 
-      self.formatter = proc do |severity, time, progname, msg|
-        level = "[#{severity}] " unless severity == 'DEBUG'
+        self.formatter = proc do |severity, time, progname, msg|
+          level = "[#{severity}] " unless severity == 'DEBUG'
 
-        if msg
-          position = if @sequencer
-                       integer_digits = @position_format.to_i
-                       decimal_digits = ((@position_format - integer_digits) * 10).round
+          if msg
+            position = if @sequencer
+                         integer_digits = @position_format.to_i
+                         decimal_digits = ((@position_format - integer_digits) * 10).round
 
-                       "%#{integer_digits + decimal_digits + 1}s: " % ("%.#{decimal_digits}f" % sequencer.position.to_f)
-                     end
+                         "%#{integer_digits + decimal_digits + 1}s: " % ("%.#{decimal_digits}f" % sequencer.position.to_f)
+                       end
 
-          progname = "[#{progname}]" if progname
+            progname = "[#{progname}]" if progname
 
-          "#{position}#{level}#{progname}#{' ' if position || level || progname}#{msg}\n"
-        else
-          "\n"
+            "#{position}#{level}#{progname}#{' ' if position || level || progname}#{msg}\n"
+          else
+            "\n"
+          end
         end
       end
     end
   end
-end; end
+end

data/lib/musa-dsl/matrix/matrix.rb

@@ -67,8 +67,6 @@ module Musa
       end
 
       refine ::Matrix do
-        include Musa::Datasets
-
         def to_p(time_dimension:, keep_time: nil)
           decompose(self.to_a, time_dimension).collect do |points|
             line = []
@@ -76,7 +74,7 @@ module Musa
             start_point = points[0]
             start_time = start_point[time_dimension]
 
-            line << start_point.clone.tap { |_| _.delete_at(time_dimension) unless keep_time; _ }.extend(Datasets::V)
+            line << start_point.clone.tap { |_| _.delete_at(time_dimension) unless keep_time; _ }.extend(Musa::Datasets::V)
 
             (1..points.size-1).each do |i|
               end_point = points[i]
@@ -84,12 +82,12 @@ module Musa
               end_time = end_point[time_dimension]
 
               line << end_time - start_time
-              line << end_point.clone.tap { |_| _.delete_at(time_dimension) unless keep_time; _ }.extend(Datasets::V)
+              line << end_point.clone.tap { |_| _.delete_at(time_dimension) unless keep_time; _ }.extend(Musa::Datasets::V)
 
               start_time = end_time
             end
 
-            line.extend(Datasets::P)
+            line.extend(Musa::Datasets::P)
           end
         end
 

data/lib/musa-dsl/midi/midi-recorder.rb

@@ -36,8 +36,8 @@ module Musa
         @messages.each do |m|
           mm = m.message
 
-          if mm.is_a?(MIDIMessage::NoteOn)
-
+          case mm
+          when MIDIMessage::NoteOn
             if last_note[mm.channel]
               notes << { position: last_note[mm.channel], channel: mm.channel, pitch: :silence, duration: m.position - last_note[mm.channel] }
               last_note.delete mm.channel
@@ -50,8 +50,7 @@ module Musa
 
             notes << note
 
-          elsif mm.is_a?(MIDIMessage::NoteOff)
-
+          when MIDIMessage::NoteOff
             note_on[mm.channel] ||= {}
 
             note = note_on[mm.channel][mm.note]

data/lib/musa-dsl/midi/midi-voices.rb

@@ -4,11 +4,11 @@ require 'midi-message'
 require_relative '../core-ext/arrayfy'
 require_relative '../core-ext/array-explode-ranges'
 
-using Musa::Extension::Arrayfy
-using Musa::Extension::ExplodeRanges
-
 module Musa
   module MIDIVoices
+    using Musa::Extension::Arrayfy
+    using Musa::Extension::ExplodeRanges
+
     class MIDIVoices
       attr_accessor :do_log
 

data/lib/musa-dsl/music/chords.rb

@@ -1,10 +1,10 @@
 require_relative 'scales'
 require_relative 'chord-definition'
 
-using Musa::Extension::Arrayfy
-
 module Musa
   module Chords
+    using Musa::Extension::Arrayfy
+
     class Chord
       def initialize(name_or_notes_or_pitches = nil, # name | [notes] | [pitches]
                      # definitory
@@ -51,7 +51,7 @@ module Musa
 
         allow_chromatic ||= scale.nil?
 
-        if root && root.is_a?(Scales::NoteInScale)
+        if root&.is_a?(Scales::NoteInScale)
           root_pitch = root.pitch
           scale ||= root.scale
         end
@@ -98,29 +98,27 @@ module Musa
         # Eval definitory atributes
         #
 
-        if _source.nil?
-          @notes = compute_notes(name, root_pitch, scale, notes, pitches, features, allow_chromatic)
-        else
-          @notes = compute_notes_from_source(_source, name, root_pitch, scale, notes, pitches, features, allow_chromatic)
-        end
+        @notes = if _source.nil?
+                   compute_notes(name, root_pitch, scale, notes, pitches, features, allow_chromatic)
+                 else
+                   compute_notes_from_source(_source, name, root_pitch, scale, notes, pitches, features, allow_chromatic)
+                 end
 
         # Eval adding / droping operations
         #
 
-        if add
-          add.each do |to_add|
-            case to_add
-            when NoteInScale
-              @notes << to_add
-            when Numeric # pitch increment
-              pitch = root_pitch + to_add
-              @notes << scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)
-            when Symbol # interval name
-              pitch = root_pitch + scale.offset_of_interval(to_add)
-              @notes << scale.note_of_pitch(pitch)
-            else
-              raise ArgumentError, "Can't recognize element to add #{to_add}"
-            end
+        add&.each do |to_add|
+          case to_add
+          when NoteInScale
+            @notes << to_add
+          when Numeric # pitch increment
+            pitch = root_pitch + to_add
+            @notes << scale.note_of_pitch(pitch) || scale.chromatic.note_of_pitch(pitch)
+          when Symbol # interval name
+            pitch = root_pitch + scale.offset_of_interval(to_add)
+            @notes << scale.note_of_pitch(pitch)
+          else
+            raise ArgumentError, "Can't recognize element to add #{to_add}"
           end
         end
 
@@ -167,14 +165,14 @@ module Musa
 
       def name(name = nil)
         if name.nil?
-          @chord_definition.name if @chord_definition
+          @chord_definition&.name
         else
           Chord.new(_source: self, name: name)
         end
       end
 
       def features
-        @chord_definition.features if @chord_definition
+        @chord_definition&.features
       end
 
       def featuring(*values, allow_chromatic: nil, **hash)
@@ -220,18 +218,17 @@ module Musa
       def as_scale
       end
 
-
       def project_on_all(*scales, allow_chromatic: nil)
         # TODO add match to other chords... what does it means?
         allow_chromatic ||= false
 
         note_sets = {}
         scales.each do |scale|
-          if allow_chromatic
-            note_sets[scale] = @notes.values.flatten(1).collect { |n| n.on(scale) || n.on(scale.chromatic) }
+          note_sets[scale] = if allow_chromatic
+            @notes.values.flatten(1).collect { |n| n.on(scale) || n.on(scale.chromatic) }
           else
-            note_sets[scale] = @notes.values.flatten(1).collect { |n| n.on(scale) }
-          end
+            @notes.values.flatten(1).collect { |n| n.on(scale) }
+                             end
         end
 
         note_sets_in_scale = note_sets.values.reject { |notes| notes.include?(nil) }

data/lib/musa-dsl/musicxml/builder/direction.rb

@@ -1,12 +1,12 @@
 require_relative '../../core-ext/with'
 require_relative 'helper'
 
-using Musa::Extension::Arrayfy
-
 module Musa
   module MusicXML
     module Builder
       module Internal
+        using Musa::Extension::Arrayfy
+
         class Direction
           extend Musa::Extension::AttributeBuilder
           include Musa::Extension::With

data/lib/musa-dsl/neumalang/neumalang.rb

@@ -11,64 +11,49 @@ module Musa
         module Grammar; end
 
         module Sentences
-          include Musa::Series
-          include Musa::Neumas
-
           def value
-            S(*captures(:expression).collect(&:value)).extend(Neuma::Serie)
+            Musa::Series::Constructors.S(*captures(:expression).collect(&:value)).extend(Musa::Neumas::Neuma::Serie)
           end
         end
 
         module BracketedBarSentences
-          include Musa::Series
-          include Musa::Neumas
-
           def value
             { kind: :parallel,
               parallel: [{ kind: :serie,
                            serie: S(*capture(:aa).value) }] +
-                                  captures(:bb).collect { |c| { kind: :serie, serie: S(*c.value) } }
-            }.extend(Neuma::Parallel)
+                                  captures(:bb).collect { |c| { kind: :serie, serie: Musa::Series::Constructors.S(*c.value) } }
+            }.extend(Musa::Neumas::Neuma::Parallel)
           end
         end
 
         module BracketedSentences
-          include Musa::Series
-          include Musa::Neumas
-
           def value
             { kind: :serie,
-              serie: S(*capture(:sentences).value) }.extend Neuma
+              serie: Musa::Series::Constructors.S(*capture(:sentences).value) }.extend Musa::Neumas::Neuma
           end
         end
 
         module ReferenceExpression
-          include Musa::Neumas
-
           def value
             { kind: :reference,
-              reference: capture(:expression).value }.extend Neuma
+              reference: capture(:expression).value }.extend Musa::Neumas::Neuma
           end
         end
 
         module VariableAssign
-          include Musa::Neumas
-
           def value
             { kind: :assign_to,
               assign_to: captures(:use_variable).collect { |c| c.value[:use_variable] },
               assign_value: capture(:expression).value
-            }.extend Neuma
+            }.extend Musa::Neumas::Neuma
           end
         end
 
         module Event
-          include Musa::Neumas
-
           def value
             { kind: :event,
               event: capture(:name).value.to_sym
-            }.merge(capture(:parameters) ? capture(:parameters).value : {}).extend Neuma
+            }.merge(capture(:parameters) ? capture(:parameters).value : {}).extend Musa::Neumas::Neuma
           end
         end
 
@@ -104,40 +89,31 @@ module Musa
         end
 
         module BracedCommand
-          include Musa::Neumas
-
           def value
             { kind: :command,
               command: eval("proc { #{capture(:complex_command).value.strip} }")
-            }.merge(capture(:parameters) ? capture(:parameters).value : {}).extend Neuma
+            }.merge(capture(:parameters) ? capture(:parameters).value : {}).extend Musa::Neumas::Neuma
           end
         end
 
         module CallMethodsExpression
-          include Musa::Neumas
-
           def value
             { kind: :call_methods,
               call_methods: captures(:method_call).collect(&:value),
-              on: capture(:object_expression).value }.extend Neuma
+              on: capture(:object_expression).value }.extend Musa::Neumas::Neuma
           end
         end
 
         module UseVariable
-          include Musa::Neumas
-
           def value
             { kind: :use_variable,
-              use_variable: "@#{capture(:name).value}".to_sym }.extend Neuma
+              use_variable: "@#{capture(:name).value}".to_sym }.extend Musa::Neumas::Neuma
           end
         end
 
         module NeumaAsAttributes
-          include Musa::Neumas
-          include Musa::Datasets
-
           def value
-            h = {}.extend GDVd
+            h = {}.extend Musa::Datasets::GDVd
 
             capture(:grade)&.value&.tap { |_| h.merge! _ if _ }
             capture(:octave)&.value&.tap { |_| h.merge! _ if _ }
@@ -147,46 +123,35 @@ module Musa
             h[:modifiers] = {} unless captures(:modifiers).empty?
             captures(:modifiers).collect(&:value).each { |_| h[:modifiers].merge! _ if _ }
 
-            { kind: :gdvd, gdvd: h }.extend Neuma
+            { kind: :gdvd, gdvd: h }.extend Musa::Neumas::Neuma
           end
         end
 
         module PackedVector
-          include Musa::Neumas
-
           def value
-            { kind: :packed_v, packed_v: capture(:raw_packed_vector).value }.extend(Neuma)
+            { kind: :packed_v, packed_v: capture(:raw_packed_vector).value }.extend(Musa::Neumas::Neuma)
           end
         end
 
         module RawPackedVector
-          include Musa::Datasets
-
           def value
-            captures(:key_value).collect(&:value).to_h.extend(PackedV)
+            captures(:key_value).collect(&:value).to_h.extend(Musa::Datasets::PackedV)
           end
         end
 
         module Vector
-          include Musa::Neumas
-
           def value
-            { kind: :v, v: capture(:raw_vector).value }.extend(Neuma)
+            { kind: :v, v: capture(:raw_vector).value }.extend(Musa::Neumas::Neuma)
           end
         end
 
         module RawVector
-          include Musa::Datasets
-
           def value
-            captures(:raw_number).collect(&:value).extend(V)
+            captures(:raw_number).collect(&:value).extend(Musa::Datasets::V)
           end
         end
 
         module ProcessOfVectors
-          include Musa::Datasets
-          include Musa::Neumas
-
           def value
             durations_rest = []
             i = 0
@@ -198,8 +163,8 @@ module Musa
               i += 1
             end
 
-            p = ([ capture(:first).value ] + durations_rest).extend(P)
-            { kind: :p, p: p }.extend(Neuma)
+            p = ([ capture(:first).value ] + durations_rest).extend(Musa::Datasets::P)
+            { kind: :p, p: p }.extend(Musa::Neumas::Neuma)
           end
         end
 
@@ -326,39 +291,31 @@ module Musa
         end
 
         module Symbol
-          include Musa::Neumas
-
           def value
             { kind: :value,
-              value: capture(:name).value.to_sym }.extend Neuma
+              value: capture(:name).value.to_sym }.extend Musa::Neumas::Neuma
           end
         end
 
         module String
-          include Musa::Neumas
-
           def value
             { kind: :value,
-              value: capture(:everything_except_double_quote).value }.extend Neuma
+              value: capture(:everything_except_double_quote).value }.extend Musa::Neumas::Neuma
           end
         end
 
         module Number
-          include Musa::Neumas
-
           def value
             { kind: :value,
-              value: capture(:raw_number).value }.extend Neuma
+              value: capture(:raw_number).value }.extend Musa::Neumas::Neuma
           end
         end
 
         module Special
-          include Musa::Neumas
-
           def value
             v = captures(0)
             { kind: :value,
-              value: v == 'nil' ? nil : (v == 'true' ? true : false) }.extend Neuma
+              value: v == 'nil' ? nil : (v == 'true' ? true : false) }.extend Musa::Neumas::Neuma
           end
         end
       end
@@ -366,10 +323,11 @@ module Musa
       extend self
 
       def parse(string_or_file, decode_with: nil, debug: nil)
-        if string_or_file.is_a? String
+        case string_or_file
+        when String
           match = Parser::Grammar::Grammar.parse string_or_file
 
-        elsif string_or_file.is_a? File
+        when File
           match = Parser::Grammar::Grammar.parse string_or_file.read
 
         else