musa-dsl 0.14.32 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38849caa61ab0d2381beb2b3dfc85686c9b7592b027dfd5a4f1f3aadae60ae7d
-  data.tar.gz: cdea129555d1bba7a5933cf71a522852463196a27fdca1ac39e10d8d0aca2dcb
+  metadata.gz: 41f779e846e1b9c6a9281384feca8f04e5f43e115847c33fa53874418ef332ca
+  data.tar.gz: 1d22315101af69d0a49fcee3146328bcf7e979fc6a8d663a54240bec7424667e
 SHA512:
-  metadata.gz: 9ae1524d885d66a1d6dc5e1cb4d88e17d069e38cd6a98c3ce8fe4131b2fb2e2df09490e3e2fbcb657a6e35a6ce27f363734e742393d10af5300502262b8d44a1
-  data.tar.gz: 7b8186dd41f7243f2b1b168929a845efa93a6028c13ff286628b505de7515cb91b4c4861c89c1a1759ab9fb3512bb042b0e20821ff300458e9fec671b9304975
+  metadata.gz: 489fd45c150778a288b054cf6a90ed435332606adeeb2804a6c3e6007e5c05339c9f7aeb4e1a905df19668c0108beb8dbe079821f7999d31a288c9dafc6430ff
+  data.tar.gz: 38fb6c56f67a8a44f900d60132a7ebae87ea247167f786ef68f1fb8bb8ed6faa6d4ea748ae8751350c0e7408ac9d80b4cbe4b3b93527fb672afe689bb35aa5e7

data/.gitignore

@@ -3,8 +3,10 @@
 .bundle
 .rspec
 .idea
+.ruby-gemset
+.ruby-version
 Gemfile.lock
 bin
 *.mindnode
-
+test.musicxml
 

data/README.md

@@ -2,7 +2,11 @@
 
 Work in progress.
 
-A programming language DSL based on Ruby for musical composition. 
+A programming language DSL based on Ruby for sonic and 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.
+
+---
+
+Coded on [Jetbrains RubyMine IDE](https://www.jetbrains.com/?from=Musa-DSL). Thanks a lot for your support letting me use an Open Source project free license! 

data/lib/musa-dsl.rb

@@ -1,17 +1,60 @@
-require 'musa-dsl/core-ext'
+module Musa
+  VERSION = '0.21.0'
+end
 
-require 'musa-dsl/series'
-require 'musa-dsl/neuma'
-require 'musa-dsl/datasets'
+require_relative 'musa-dsl/core-ext'
 
-require 'musa-dsl/neumalang'
+require_relative 'musa-dsl/series'
+require_relative 'musa-dsl/datasets'
+require_relative 'musa-dsl/matrix'
 
-require 'musa-dsl/transport'
-require 'musa-dsl/sequencer'
-require 'musa-dsl/repl'
+require_relative 'musa-dsl/neumalang'
+require_relative 'musa-dsl/neumas'
 
-require 'musa-dsl/midi'
+require_relative 'musa-dsl/logger'
 
-require 'musa-dsl/music'
+require_relative 'musa-dsl/transport'
+require_relative 'musa-dsl/sequencer'
+require_relative 'musa-dsl/repl'
 
-require 'musa-dsl/generative'
+require_relative 'musa-dsl/midi'
+require_relative 'musa-dsl/musicxml'
+
+require_relative 'musa-dsl/transcription'
+
+require_relative 'musa-dsl/music'
+
+require_relative 'musa-dsl/generative'
+
+module Musa::All
+  include Musa::Logger
+
+  include Musa::Clock
+  include Musa::Transport
+  include Musa::Sequencer
+
+  include Musa::Scales
+  include Musa::Chords
+  include Musa::Datasets
+
+  include Musa::Neumalang
+  include Musa::Neumas
+  include Musa::Matrix
+
+  include Musa::Series
+
+  include Musa::Darwin
+  include Musa::Markov
+  include Musa::Backboner
+  include Musa::Variatio
+
+  include Musa::MIDIRecorder
+  include Musa::MIDIVoices
+
+  include Musa::MusicXML
+
+  include Musa::Transcription
+  include Musa::Transcriptors
+
+  include Musa::REPL
+end

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

@@ -1,13 +1,7 @@
-require 'musa-dsl/core-ext/array-apply-get'
-require 'musa-dsl/core-ext/array-explode-ranges'
-require 'musa-dsl/core-ext/array-to-serie'
-require 'musa-dsl/core-ext/string-to-neumas'
-require 'musa-dsl/core-ext/array-to-neumas'
-require 'musa-dsl/core-ext/arrayfy'
-require 'musa-dsl/core-ext/duplicate'
-require 'musa-dsl/core-ext/key-parameters-procedure-binder'
-require 'musa-dsl/core-ext/as-context-run'
-require 'musa-dsl/core-ext/inspect-nice'
-require 'musa-dsl/core-ext/send-nice'
-require 'musa-dsl/core-ext/proc-nice'
-require 'musa-dsl/core-ext/dynamic-proxy'
+require_relative 'core-ext/array-explode-ranges'
+require_relative 'core-ext/arrayfy'
+require_relative 'core-ext/deep-copy'
+require_relative 'core-ext/smart-proc-binder'
+require_relative 'core-ext/inspect-nice'
+require_relative 'core-ext/dynamic-proxy'
+require_relative 'core-ext/with'

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

@@ -1,29 +1,21 @@
-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
+module Musa
+  module Extension
+    module ExplodeRanges
+      refine Array do
+        def explode_ranges
+          array = []
 
-    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
 
-    each do |element|
-      if element.is_a? Range
-        element.to_a.each { |element| array << element }
-      else
-        array << element
+          array
+        end
       end
     end
-
-    array
   end
 end

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

@@ -1,15 +1,33 @@
-class Object
-  def arrayfy
-    if nil?
-      []
-    else
-      [self]
-    end
-  end
-end
+require_relative 'deep-copy'
 
-class Array
-  def arrayfy
-    self
+module Musa
+  module Extension
+    module Arrayfy
+      refine Object do
+        def arrayfy(size: nil)
+          if size
+            size.times.collect { self }
+          else
+            if nil?
+              []
+            else
+              [self]
+            end
+          end
+        end
+      end
+
+      refine Array do
+        def arrayfy(size: nil)
+          if size
+            DeepCopy::DeepCopy.copy_singleton_class_modules(
+                self,
+                (self * (size / self.size + ((size % self.size).zero? ? 0 : 1) )).take(size))
+          else
+            self.clone
+          end
+        end
+      end
+    end
   end
 end

data/lib/musa-dsl/core-ext/attribute-builder.rb

@@ -0,0 +1,194 @@
+module Musa
+  module Extension
+    module AttributeBuilder
+      # add_thing id, parameter
+      # things id1: parameter1, id2: parameter2 -> { id1: Thing(id1, parameter1), id2: Thing(id2, parameter2) }
+      # things -> { id1: Thing(id1, parameter1), id2: Thing(id2, parameter2) }
+      #
+      def attr_tuple_adder_to_hash(name, klass, plural: nil, variable: nil)
+
+        plural ||= name.to_s + 's'
+        variable ||= ('@' + plural.to_s).to_sym
+
+        adder_method = "add_#{name}".to_sym
+
+        define_method adder_method do |id, parameter|
+          klass.new(id, parameter).tap do |object|
+            instance_variable_get(variable)[id] = object
+          end
+        end
+
+        define_method plural do |**parameters|
+          parameters&.each_pair do |id, value|
+            send adder_method, id, value
+          end
+          instance_variable_get variable
+        end
+      end
+
+      # add_thing id, parameter
+      # things id1: parameter1, id2: parameter2 -> [ Thing(id1, parameter1), Thing(id2, parameter2) ]
+      # things -> [ Thing(id1, parameter1), Thing(id2, parameter2) ]
+
+      def attr_tuple_adder_to_array(name, klass, plural: nil, variable: nil)
+
+        plural ||= name.to_s + 's'
+        variable ||= ('@' + plural.to_s).to_sym
+
+        adder_method = "add_#{name}".to_sym
+
+        define_method adder_method do |id, parameter, &block|
+          klass.new(id, parameter, &block).tap do |object|
+            instance_variable_get(variable) << object
+          end
+        end
+
+        define_method plural do |**parameters, &block|
+          parameters.each_pair do |id, value|
+            send adder_method, id, value, &block
+          end
+          instance_variable_get variable
+        end
+      end
+
+      # add_thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
+      # thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
+      # things -> (collection)
+
+      def attr_complex_adder_to_array(name, klass, plural: nil, variable: nil)
+
+        plural ||= name.to_s + 's'
+        variable ||= ('@' + plural.to_s).to_sym
+
+        adder_method = "add_#{name}".to_sym
+
+        define_method adder_method do |*parameters, **key_parameters, &block|
+          klass.new(*parameters, **key_parameters, &block).tap do |object|
+            instance_variable_get(variable) << object
+          end
+        end
+
+        if plural == name
+          define_method plural do |*parameters, **key_parameters, &block|
+            if parameters.empty? && key_parameters.empty? && block.nil?
+              instance_variable_get variable
+            else
+              send adder_method, *parameters, **key_parameters, &block
+            end
+          end
+        else
+          alias_method name, adder_method
+
+          define_method plural do
+            instance_variable_get variable
+          end
+        end
+      end
+
+
+      # add_thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
+      # thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
+      # things -> (collection)
+
+      def attr_complex_adder_to_custom(name, plural: nil, variable: nil, &constructor_and_adder)
+
+        plural ||= name.to_s + 's'
+
+        adder_method = "add_#{name}".to_sym
+
+        define_method adder_method do |*parameters, **key_parameters, &block|
+          instance_exec(*parameters, **key_parameters, &constructor_and_adder).tap do |object|
+            object.with &block if block
+          end
+        end
+
+        if plural == name && variable
+          define_method plural do |*parameters, **key_parameters, &block|
+            if parameters.empty? && key_parameters.empty? && block.nil?
+              instance_variable_get variable
+            else
+              send adder_method, *parameters, **key_parameters, &block
+            end
+          end
+        else
+          alias_method name, adder_method
+
+          if variable
+            define_method plural do
+              instance_variable_get variable
+            end
+          end
+        end
+      end
+
+      # thing value -> crea Thing(value)
+      # thing -> Thing(value)
+
+      def attr_simple_builder(name, klass = nil, variable: nil)
+        variable ||= ('@' + name.to_s).to_sym
+
+        define_method name do |parameter = nil, &block|
+          if parameter.nil?
+            instance_variable_get variable
+          else
+            (klass&.new(parameter, &block) || parameter).tap do |object|
+              instance_variable_set variable, object
+            end
+          end
+        end
+
+        attr_writer name
+      end
+
+      # thing id: value -> crea Thing(id, value)
+      # thing -> Thing(id, value)
+
+      def attr_tuple_builder(name, klass, variable: nil)
+        variable ||= ('@' + name.to_s).to_sym
+
+        define_method name do |**parameters, &block|
+          raise ArgumentError, "Method #{name} can only create instances with one id: value arguments pattern" unless parameters.size == 1
+
+          if parameters.empty?
+            instance_variable_get variable
+          else
+            parameter = parameters.first
+            klass.new(*parameter, &block).tap do |object|
+              instance_variable_set variable, object
+            end
+          end
+        end
+
+        attr_writer name
+      end
+
+      # thing value1, value2, key1: value3, key2: value4 -> crea Thing(value1, value2, key1: value3, key2: value3)
+      # thing -> Thing(value1, value2, key1: value3, key2: value4)
+      # y también...
+      # thing value1, value2, key1: value3, key2: value4 -> crea Thing(first_parameter, value1, value2, key1: value3, key2: value3)
+      # thing -> Thing(first_parameter, value1, value2, key1: value3, key2: value4)
+
+      def attr_complex_builder(name, klass, variable: nil, first_parameter: nil)
+        variable ||= ('@' + name.to_s).to_sym
+
+        define_method name do |*parameters, **key_parameters, &block|
+          if parameters.empty? && key_parameters.empty? && block.nil?
+            instance_variable_get variable
+          else
+            if first_parameter
+              klass.new(first_parameter, *parameters, **key_parameters, &block).tap do |object|
+                instance_variable_set variable, object
+              end
+            else
+              klass.new(*parameters, **key_parameters, &block).tap do |object|
+                instance_variable_set variable, object
+              end
+            end
+          end
+        end
+
+        attr_writer name
+      end
+    end
+  end
+end

data/lib/musa-dsl/core-ext/deep-copy.rb

@@ -0,0 +1,185 @@
+# Based on https://github.com/adamluzsi/duplicate.rb/blob/master/lib/duplicate.rb
+# Modifications by Javier Sánchez Yeste
+
+module Musa
+  module Extension
+    module DeepCopy
+      module DeepCopy
+        extend self
+
+        def deep_copy(object, method: :dup, freeze: true)
+          raise ArgumentError, "deep_copy method can only be :dup or :clone" unless method == :dup || method == :clone
+          register = {}
+
+          _deep_copy(register, object, method, freeze)
+        end
+
+        def copy_singleton_class_modules(source, target)
+          source.singleton_class.included_modules.each do |m|
+            target.extend m unless target.is_a?(m)
+          end
+
+          target
+        end
+
+        protected
+
+        def registered(object, register)
+          register[object.__id__]
+        end
+
+        def register(register, object, duplicate)
+          register[object.__id__] = duplicate
+          duplicate
+        end
+
+        def _deep_copy(register, object, method, freeze)
+          return registered(object, register) if registered(object, register)
+          return register(register, object, object) unless identifiable?(object)
+
+          case object
+
+          when Array
+            deep_copy_array(register, object, method, freeze)
+
+          when Hash
+            deep_copy_hash(register, object, method, freeze)
+
+          when Range
+            deep_copy_range(register, object, method, freeze)
+
+          when Struct
+            deep_copy_struct(register, object, method, freeze)
+
+          when Proc
+            deep_copy_proc(register, object, method, freeze)
+
+          when NilClass, Symbol, Numeric, TrueClass, FalseClass, Method
+            register(register, object, object)
+
+          else
+            deep_copy_object(register, object, method, freeze)
+
+          end
+        end
+
+        def identifiable?(object)
+          object.class && object.respond_to?(:is_a?)
+        rescue NoMethodError
+          false
+        end
+
+        def deep_copy_array(register, object, method, freeze)
+          deep_copy_object(register, object, method, freeze) do |_, copy|
+            copy.map! { |e| _deep_copy(register, e, method, freeze) }
+          end
+        end
+
+        def deep_copy_hash(register, object, method, freeze)
+          deep_copy_object(register, object, method, freeze) do |object, copy|
+            object.reduce(copy) { |hash, (k, v)| hash.merge!(_deep_copy(register, k, method, freeze) => _deep_copy(register, v, method, freeze)) }
+          end
+        end
+
+        def deep_copy_range(register, range, method, freeze)
+          copy = range.class.new(_deep_copy(register, range.first, method, freeze), _deep_copy(register, range.last, method, freeze))
+          copy.freeze if range.frozen?
+
+          register(register, range, copy)
+        rescue StandardError
+          register(register, range, range.send(method))
+        end
+
+        def deep_copy_struct(register, struct, method, freeze)
+          duplication = register(register, struct, struct.send(method))
+
+          struct.each_pair do |attr, value|
+            duplication.__send__("#{attr}=", _deep_copy(register, value, method, freeze))
+          end
+
+          duplication
+        end
+
+        def deep_copy_object(register, object, method, freeze)
+          if method == :clone && object.frozen?
+            copy = try_deep_copy(object, :clone, false)
+          else
+            copy = try_deep_copy(object, method, freeze)
+          end
+
+          register(register, object, copy)
+          deep_copy_instance_variables(register, object, register(register, object, copy), method, freeze)
+
+          yield object, copy if block_given?
+
+          copy.freeze if method == :clone && object.frozen? && freeze
+
+          copy
+        end
+
+        def deep_copy_proc(register, object, method, freeze)
+          register(register, object, object.dup)
+        end
+
+        def deep_copy_instance_variables(register, object, duplication, method, freeze)
+          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, _deep_copy(register, value, method, freeze))
+          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_deep_copy(object, method, freeze)
+          if method == :dup
+            object.dup
+          else
+            object.clone(freeze: freeze)
+          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
+
+      refine Object do
+        def dup(deep: false)
+          if deep
+            Musa::Extension::DeepCopy::DeepCopy.deep_copy(self, method: :dup)
+          else
+            super()
+          end
+        end
+
+        def clone(freeze: true, deep: false)
+          if deep
+            Musa::Extension::DeepCopy::DeepCopy.deep_copy(self, method: :clone, freeze: freeze)
+          else
+            super(freeze: freeze)
+          end
+        end
+      end
+    end
+  end
+end
+