musa-dsl 0.14.16

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 233adb825ed72badf41723781c9ca578b1ba7a38f01191376207fa44d0bfbe84
+  data.tar.gz: cb6e9d1557645c9cef7bc1e963438c54c7d9c0ffb3b8dac8cc6f45619fdd1616
+SHA512:
+  metadata.gz: dc451b441bfdf0a9814f2a4cdd88fb3a991ec1d5edd35eeed09fbe72735d8615da33645995d35a842c392d0810db8b9d166d1c8eae43c0c000687bff0824a989
+  data.tar.gz: d094f68c240f775035cbe4dc2aeed3086368826e99af91cbe9e68a3ef9f19c3dd95f328f71d63e97b457ff7f647b1c02d750793dc8bbcf3c1dfef842cb59cc01

data/.gitignore

@@ -0,0 +1,10 @@
+**/.DS_Store
+*.gem
+.bundle
+.rspec
+.idea
+Gemfile.lock
+bin
+*.mindnode
+
+

data/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+group :neuma do
+  gem 'citrus', '~> 3.0.0'
+
+end
+
+group :transport do
+  gem 'midi-message', '~> 0.4', '>= 0.4.9'
+  gem 'midi-nibbler', '~> 0.2', '>= 0.2.4'
+end
+
+group :test do
+  gem 'rspec', '~> 3.0'
+  gem 'descriptive-statistics'
+end
+
+group :documentation do
+  gem 'rdoc'
+end

data/LICENSE.md

@@ -0,0 +1,157 @@
+### GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc.
+<https://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This version of the GNU Lesser General Public License incorporates the
+terms and conditions of version 3 of the GNU General Public License,
+supplemented by the additional permissions listed below.
+
+#### 0. Additional Definitions.
+
+As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the
+GNU General Public License.
+
+"The Library" refers to a covered work governed by this License, other
+than an Application or a Combined Work as defined below.
+
+An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+#### 1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+#### 2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+-   a) under this License, provided that you make a good faith effort
+    to ensure that, in the event an Application does not supply the
+    function or data, the facility still operates, and performs
+    whatever part of its purpose remains meaningful, or
+-   b) under the GNU GPL, with none of the additional permissions of
+    this License applicable to that copy.
+
+#### 3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from a
+header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+-   a) Give prominent notice with each copy of the object code that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+-   b) Accompany the object code with a copy of the GNU GPL and this
+    license document.
+
+#### 4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that, taken
+together, effectively do not restrict modification of the portions of
+the Library contained in the Combined Work and reverse engineering for
+debugging such modifications, if you also do each of the following:
+
+-   a) Give prominent notice with each copy of the Combined Work that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+-   b) Accompany the Combined Work with a copy of the GNU GPL and this
+    license document.
+-   c) For a Combined Work that displays copyright notices during
+    execution, include the copyright notice for the Library among
+    these notices, as well as a reference directing the user to the
+    copies of the GNU GPL and this license document.
+-   d) Do one of the following:
+    -   0) Convey the Minimal Corresponding Source under the terms of
+        this License, and the Corresponding Application Code in a form
+        suitable for, and under terms that permit, the user to
+        recombine or relink the Application with a modified version of
+        the Linked Version to produce a modified Combined Work, in the
+        manner specified by section 6 of the GNU GPL for conveying
+        Corresponding Source.
+    -   1) Use a suitable shared library mechanism for linking with
+        the Library. A suitable mechanism is one that (a) uses at run
+        time a copy of the Library already present on the user's
+        computer system, and (b) will operate properly with a modified
+        version of the Library that is interface-compatible with the
+        Linked Version.
+-   e) Provide Installation Information, but only if you would
+    otherwise be required to provide such information under section 6
+    of the GNU GPL, and only to the extent that such information is
+    necessary to install and execute a modified version of the
+    Combined Work produced by recombining or relinking the Application
+    with a modified version of the Linked Version. (If you use option
+    4d0, the Installation Information must accompany the Minimal
+    Corresponding Source and Corresponding Application Code. If you
+    use option 4d1, you must provide the Installation Information in
+    the manner specified by section 6 of the GNU GPL for conveying
+    Corresponding Source.)
+
+#### 5. Combined Libraries.
+
+You may place library facilities that are a work based on the Library
+side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+-   a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities, conveyed under the terms of this License.
+-   b) Give prominent notice with the combined library that part of it
+    is a work based on the Library, and explaining where to find the
+    accompanying uncombined form of the same work.
+
+#### 6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+as you received it specifies that a certain numbered version of the
+GNU Lesser General Public License "or any later version" applies to
+it, you have the option of following the terms and conditions either
+of that published version or of any later version published by the
+Free Software Foundation. If the Library as you received it does not
+specify a version number of the GNU Lesser General Public License, you
+may choose any version of the GNU Lesser General Public License ever
+published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -0,0 +1,8 @@
+# Musa-DSL
+
+Work in progress.
+
+A programming language DSL based on Ruby for musical composition. 
+Emphasizes the creation of complex temporal structures independently of the audio rendering engine.
+
+Some works can be listened on [yeste.studio](https://soundcloud.com/yeste-studio) Soundcloud.

data/lib/musa-dsl/core-ext/array-apply-get.rb

@@ -0,0 +1,18 @@
+# TODO hacer que *_nice permitar recibir atributos para indicar cómo se quieren procesar los parámetros (haciendo *, **, o sin hacer nada)
+
+class Array
+	def apply method_name, source
+	
+		source = [source] unless source.is_a? Array
+		
+		self.each_with_index do |o, i|
+			o.send method_name, source[i % source.length]
+		end
+	end
+
+	def get method_name
+		self.collect { |o| o.send method_name }
+	end
+end
+
+

data/lib/musa-dsl/core-ext/array-explode-ranges.rb

@@ -0,0 +1,29 @@
+class Array
+  def arrayfy
+    self
+  end
+
+  def repeat_to_size(new_size)
+    pos = -1
+    new_size -= 1
+
+    new_array = clone
+    new_array << self[(pos += 1) % size] while (pos + size) < new_size
+
+    new_array
+  end
+
+  def explode_ranges
+    array = []
+
+    each do |element|
+      if element.is_a? Range
+        element.to_a.each { |element| array << element }
+      else
+        array << element
+      end
+    end
+
+    array
+  end
+end

data/lib/musa-dsl/core-ext/array-to-neumas.rb

@@ -0,0 +1,28 @@
+require 'musa-dsl/series'
+require 'musa-dsl/neumalang'
+
+class Array
+  def to_neumas
+    if length > 1
+      MERGE(*collect { |e| convert_to_neumas(e) })
+    else
+      convert_to_neumas(first)
+    end
+  end
+
+  alias_method :neumas, :to_neumas
+  alias_method :n, :to_neumas
+
+  private
+
+  def convert_to_neumas(e)
+    case e
+    when Musa::Neumalang::Neumas then e
+    when Musa::Neumalang::Neuma::Parallel then _SE([e], extends: Musa::Neumalang::Neumas)
+    when String then e.to_neumas
+    else
+      raise ArgumentError, "Don't know how to convert to neumas #{e}"
+    end
+  end
+end
+

data/lib/musa-dsl/core-ext/array-to-serie.rb

@@ -0,0 +1,20 @@
+require 'musa-dsl/series'
+
+class Array
+  def to_serie(of_series: nil, recursive: nil)
+    of_series ||= false
+    recursive ||= false
+
+    raise ArgumentError, 'Cannot convert to serie of_series and recursive simultaneously' if recursive && of_series
+
+    if recursive
+      S(*(collect { |_| _.is_a?(Array) ? _.to_serie(recursive: true) : _ }))
+    elsif of_series
+      S(*(collect { |_| S(*_) }))
+    else
+      S(*self)
+    end
+  end
+
+  alias_method :s, :to_serie
+end

data/lib/musa-dsl/core-ext/arrayfy.rb

@@ -0,0 +1,15 @@
+class Object
+  def arrayfy
+    if nil?
+      []
+    else
+      [self]
+    end
+  end
+end
+
+class Array
+  def arrayfy
+    self
+  end
+end

data/lib/musa-dsl/core-ext/as-context-run.rb

@@ -0,0 +1,44 @@
+# TODO: hacer que *_nice permitar recibir atributos para indicar cómo se quieren procesar los parámetros (haciendo *, **, o sin hacer nada)
+
+class Object
+  def as_context_run(procedure, *list_or_key_args, **key_args)
+    _as_context_run procedure, list_or_key_args, key_args
+  end
+
+  def _as_context_run(procedure, list_or_key_args = nil, key_args = nil)
+    if !list_or_key_args.nil? && list_or_key_args.is_a?(Hash)
+      key_args = list_or_key_args
+      list_or_key_args = nil
+    end
+
+    if procedure.lambda?
+      if !list_or_key_args.nil? && !list_or_key_args.empty?
+        if !key_args.nil? && !key_args.empty?
+          procedure.call *list_or_key_args, **key_args
+        else
+          procedure.call *list_or_key_args
+        end
+      else
+        if !key_args.nil? && !key_args.empty?
+          procedure.call **key_args
+        else
+          procedure.call
+        end
+      end
+    else
+      if !list_or_key_args.nil? && !list_or_key_args.empty?
+        if !key_args.nil? && !key_args.empty?
+          instance_exec *list_or_key_args, **key_args, &procedure
+        else
+          instance_exec *list_or_key_args, &procedure
+        end
+      else
+        if !key_args.nil? && !key_args.empty?
+          instance_exec **key_args, &procedure
+        else
+          instance_eval &procedure
+        end
+      end
+    end
+  end
+end

data/lib/musa-dsl/core-ext/duplicate.rb

@@ -0,0 +1,134 @@
+# Based on https://github.com/adamluzsi/duplicate.rb/blob/master/lib/duplicate.rb
+# Modifications by JSY
+
+module Duplicate
+  extend self
+
+  def duplicate(object)
+    register = {}
+
+    _dup(register, object)
+  end
+
+  protected
+
+  def registered(object, register)
+    register[object.__id__]
+  end
+
+  def register_duplication(register, object, duplicate)
+    register[object.__id__] = duplicate
+    duplicate
+  end
+
+  def _dup(register, object)
+    return registered(object, register) if registered(object, register)
+    return register_duplication(register, object, object) unless identifiable?(object)
+
+    case object
+
+    when Array
+      dup_array(register, object)
+
+    when Hash
+      dup_hash(register, object)
+
+    when Range
+      dup_range(register, object)
+
+    when Struct
+      dup_struct(register, object)
+
+    when NilClass, Symbol, Numeric, TrueClass, FalseClass, Method
+      register_duplication(register, object, object)
+
+    else
+      dup_object(register, object)
+
+    end
+  end
+
+  def identifiable?(object)
+    object.class && object.respond_to?(:is_a?)
+  rescue NoMethodError
+    false
+  end
+
+  def dup_array(register, object)
+    duplication = dup_object(register, object)
+    duplication.map! { |e| _dup(register, e) }
+  end
+
+  def dup_hash(register, object)
+    duplication = dup_object(register, object)
+    object.reduce(duplication) { |hash, (k, v)| hash.merge!(_dup(register, k) => _dup(register, v)) }
+  end
+
+  def dup_range(register, range)
+    register_duplication(register, range, range.class.new(_dup(register, range.first), _dup(register, range.last)))
+  rescue StandardError
+    register_duplication(register, range, range.dup)
+  end
+
+  def dup_struct(register, struct)
+    duplication = register_duplication(register, struct, struct.dup)
+
+    struct.each_pair do |attr, value|
+      duplication.__send__("#{attr}=", _dup(register, value))
+    end
+
+    duplication
+  end
+
+  def dup_object(register, object)
+    dup_instance_variables(register, object, register_duplication(register, object, try_dup(object)))
+  end
+
+  def dup_instance_variables(register, object, duplication)
+    return duplication unless respond_to_instance_variables?(object)
+
+    object.instance_variables.each do |instance_variable|
+      value = get_instance_variable(object, instance_variable)
+
+      set_instance_variable(duplication, instance_variable, _dup(register, value))
+    end
+
+    duplication
+  end
+
+  def get_instance_variable(object, instance_variable_name)
+    object.instance_variable_get(instance_variable_name)
+  rescue NoMethodError
+    object.instance_eval(instance_variable_name.to_s)
+  end
+
+  def set_instance_variable(duplicate, instance_variable_name, value_to_set)
+    duplicate.instance_variable_set(instance_variable_name, value_to_set)
+  rescue NoMethodError
+    duplicate.instance_eval("#{instance_variable_name} = Marshal.load(#{Marshal.dump(value_to_set).inspect})")
+  end
+
+  def try_dup(object)
+    o = object.dup
+
+    o.tap do
+      object.singleton_class.included_modules.each do |m|
+        o.extend m unless o.is_a? m
+      end
+    end
+  rescue NoMethodError, TypeError
+    object
+  end
+
+  def respond_to_instance_variables?(object)
+    object.respond_to?(:instance_variables) && object.instance_variables.is_a?(Array)
+  rescue NoMethodError
+    false
+  end
+end
+
+class Object
+  def duplicate
+    Duplicate.duplicate(self)
+  end
+end

data/lib/musa-dsl/core-ext/dynamic-proxy.rb

@@ -0,0 +1,55 @@
+require_relative 'send-nice'
+
+module DynamicProxyModule
+  def method_missing(method_name, *args, **key_args, &block)
+    if @receiver.respond_to? method_name
+      @receiver._send_nice method_name, args, key_args, &block
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private)
+    @receiver.respond_to?(method_name, include_private) || super
+  end
+
+  alias _is_a? is_a?
+
+  def is_a?(klass)
+    _is_a?(klass) || @receiver.is_a?(klass)
+  end
+
+  alias _kind_of? kind_of?
+
+  def kind_of?(klass)
+    _kind_of?(klass) || @receiver.is_a?(klass)
+  end
+
+  alias _instance_of? instance_of?
+
+  def instance_of?(klass)
+    _instance_of?(klass) || @receiver.instance_of?(klass)
+  end
+
+  alias _equalequal ==
+
+  def ==(object)
+    _equalequal(object) || @receiver.==(object)
+  end
+
+  alias _eql? eql?
+
+  def eql?(object)
+    _eql?(object) || @receiver.eql?(object)
+  end
+end
+
+class DynamicProxy
+  include DynamicProxyModule
+
+  def initialize(receiver = nil)
+    @receiver = receiver
+  end
+
+  attr_accessor :receiver
+end

data/lib/musa-dsl/core-ext/inspect-nice.rb

@@ -0,0 +1,28 @@
+class Hash
+  def inspect
+    all = collect { |key, value| [', ', key.is_a?(Symbol) ? key.to_s + ': ' : key.to_s + ' => ', value.inspect] }.flatten
+    all.shift
+    '{ ' + all.join + ' }'
+  end
+end
+
+class Rational
+  def inspect
+    d = self - to_i
+    if d != 0
+      "#{to_i}(#{d.numerator}/#{d.denominator})"
+    else
+      to_i.to_s
+    end
+  end
+
+  alias _to_s to_s
+
+  def to_s
+    if to_i == self
+      to_i.to_s
+    else
+      _to_s
+    end
+  end
+end

data/lib/musa-dsl/core-ext/key-parameters-procedure-binder.rb

@@ -0,0 +1,85 @@
+class KeyParametersProcedureBinder
+  attr_reader :procedure
+
+  def initialize(procedure, on_rescue: nil)
+    @procedure = procedure
+    @on_rescue = on_rescue
+
+    @parameters = {}
+    @has_rest = false
+    @value_parameters_count = 0
+
+    procedure.parameters.each do |parameter|
+      @parameters[parameter[1]] = nil if parameter[0] == :key || parameter[0] == :keyreq
+      @has_rest = true if parameter[0] == :keyrest
+
+      @value_parameters_count += 1 if parameter[0] == :req || parameter[0] == :opt
+    end
+  end
+
+  def call(*value_parameters, **key_parameters)
+    _call value_parameters, key_parameters
+  end
+
+  def _call(value_parameters, key_parameters)
+    if @on_rescue
+      begin
+        __call value_parameters, key_parameters
+      rescue StandardError, ScriptError => e
+        @on_rescue.call e
+      end
+    else
+      __call value_parameters, key_parameters
+    end
+  end
+
+  def __call(value_parameters, key_parameters)
+    effective_key_parameters = apply(key_parameters)
+
+    if effective_key_parameters.empty?
+      if value_parameters.nil? || value_parameters.empty? || @value_parameters_count == 0
+        @procedure.call
+      else
+        @procedure.call *value_parameters.first(@value_parameters_count)
+      end
+    else
+      if value_parameters.nil? || value_parameters.empty?
+        @procedure.call **effective_key_parameters
+      else
+        @procedure.call *value_parameters, **effective_key_parameters
+      end
+    end
+  end
+
+  private :__call
+
+  def key?(key)
+    @has_rest || @parameters.include?(key)
+  end
+
+  alias_method :has_key?, :key?
+
+  def apply(hsh)
+    hsh ||= {}
+
+    result = @parameters.clone
+
+    @parameters.each_key do |parameter_name|
+      result[parameter_name] = hsh[parameter_name]
+    end
+
+    if @has_rest
+      hsh.each do |key, value|
+        result[key] = value unless result.key?(key)
+      end
+    end
+
+    result
+  end
+
+  def inspect
+    "KeyParametersProcedureBinder: parameters = #{@parameters} has_rest = #{@has_rest}"
+  end
+
+  alias to_s inspect
+end

data/lib/musa-dsl/core-ext/proc-nice.rb

@@ -0,0 +1,13 @@
+class Proc
+  def _call(value_args, key_value_args)
+    if value_args && key_value_args
+      call(*value_args, **key_value_args)
+    elsif value_args
+      call(*value_args)
+    elsif key_value_args
+      call(**key_value_args)
+    else
+      call
+    end
+  end
+end