music-transcription 0.3.0 → 0.4.0

data/lib/music-transcription/profile.rb

@@ -6,33 +6,25 @@ module Transcription
 # @author James Tunnell
 #
 class Profile
-  include Hashmake::HashMakeable
-  
   attr_accessor :start_value, :value_changes
-  
-  # hashed-arg specs (for hash-makeable idiom)
-  ARG_SPECS = {
-    :start_value => arg_spec(:reqd => true),
-    :value_changes => arg_spec_hash(:reqd => false, :type => ValueChange)
-  }
 
   # A new instance of Profile.
   #
   # @param [Hash] args Hashed args. Required key is :start_value. Optional key is :value_changes.
-  def initialize args
-    hash_make args, Profile::ARG_SPECS
+  def initialize start_value, value_changes = {}
+    @start_value = start_value
+    @value_changes = value_changes
   end
   
   # Compare to another Profile object.
   def == other
-    (self.class == other.class) && 
     (self.start_value == other.start_value) &&
     (self.value_changes == other.value_changes)
   end
   
   # Produce an identical Profile object.
   def clone
-    Profile.new(:start_value => @start_value, :value_changes => @value_changes.clone)
+    Profile.new(@start_value, @value_changes.clone)
   end
   
   # Returns true if start value and value changes all are between given A and B.
@@ -60,7 +52,7 @@ class Profile
   end
   
   def clone_and_collate computer_class, program_segments
-    new_profile = Profile.new :start_value => start_value
+    new_profile = Profile.new start_value
     
     segment_start_offset = 0.0
     comp = computer_class.new(self)
@@ -94,12 +86,5 @@ class Profile
   end
 end
 
-module_function
-
-# Create a Profile object
-def profile start_value, value_changes = {}
-  return Profile.new(:start_value => start_value, :value_changes => value_changes)
-end
-
 end
 end

data/lib/music-transcription/program.rb

@@ -6,43 +6,14 @@ module Transcription
 # @author James Tunnell
 #
 class Program
-  include Hashmake::HashMakeable
-  attr_reader :segments
-
-  # hashed-arg specs (for hash-makeable idiom)
-  ARG_SPECS = {
-    :segments => arg_spec_array(:reqd => false, :type => Range)
-  }
+  attr_accessor :segments
 
   # A new instance of Program.
   # @param [Hash] args Hashed arguments. Required key is :segments.
-  def initialize args={}
-    hash_make args
-  end
-
-  # Assign program segments. Each segment is a Range to specify which range of 
-  # notes from a score should be played.
-  #
-  # @param [Array] segments An array of program segements. Each segment is a 
-  #                         Range to specify which range of 
-  # @raise [ArgumentError] if segments is not an Array.
-  # @raise [ArgumentError] if segments contains a non-Range
-  #
-  def segments= segments
-    ARG_SPECS[:segments].validate_value segments
+  def initialize segments = []
     @segments = segments
   end
 
-  # @return [Float] the starting note offset for the program
-  def start
-    @segments.first.first
-  end
-
-  # @return [Float] the ending note offset for the program
-  def stop
-    @segments.last.last
-  end
-
   # @return [Float] the sum of all program segment lengths
   def length
     segments.inject(0.0) { |length, segment| length + (segment.last - segment.first) }

data/lib/music-transcription/score.rb

@@ -1,7 +1,7 @@
 module Music
 module Transcription
 
-# Abstraction of a musical score. Contains parts and a program.
+# Score, containing parts and a program.
 #
 # @author James Tunnell
 #
@@ -12,49 +12,13 @@ module Transcription
 #   @return [Array] Score program.
 #
 class Score
-  include Hashmake::HashMakeable
   attr_reader :parts, :program
-
-  # hashed-arg specs (for hash-makeable idiom)
-  ARG_SPECS = {
-    :parts => arg_spec_hash(:reqd => false, :type => Part),
-    :program => arg_spec(:reqd => false, :type => Program, :default => ->(){ Program.new }),
-  }
-  
-  # A new instance of Score.
-  # @param [Hash] args Hashed arguments. Optional keys are :program and :parts.
-  def initialize args={}
-    hash_make args, ARG_SPECS
-  end
   
-  def clone
-    Marshal.load(Marshal.dump(self))
-  end
-  
-  # Compare the equality of another Score object.
-  def ==(other)
-    return (@program == other.program) &&
-    (@parts == other.parts)
-  end
-  
-  # Set the score parts.
-  # @param [Hash] parts The score parts, mapped to IDs.
-  # @raise [ArgumentError] if notes is not a Hash.
-  # @raise [ArgumentError] if parts contain a non-Part object.
-  def parts= parts
-    Score::ARG_SPECS[:parts].validate_value parts
+  def initialize parts: {}, program: Program.new
     @parts = parts
-  end
-
-  # Set the score program, which determines which defines sections and how they 
-  # are played.
-  # @param [Program] program The score program.
-  # @raise [ArgumentError] if tempos is not a Program.
-  def program= program
-    Score::ARG_SPECS[:program].validate_value program
     @program = program
   end
-
+    
   # Find the start of a score. The start will be at then start of whichever part begins
   # first, or 0 if no parts have been added.
   def start
@@ -82,39 +46,38 @@ class Score
   end
 end
 
-# Score with a tempo profile.
-#
-# @author James Tunnell
-#
-# @!attribute [rw] tempo_profile
-#   @return [Profile] The tempo profile.
-#
-class TempoScore < Score
-  include Hashmake::HashMakeable
-  attr_reader :tempo_profile
+# Score where time is based on absolute time in seconds
+class TimeScore < Score
+  attr_reader :program, :parts
 
-  # hashed-arg specs (for hash-makeable idiom)
-  ARG_SPECS = {
-    :tempo_profile => arg_spec(:reqd => true, :type => Profile, :validator => ->(a){ a.values_positive? }),
-  }
+  def clone
+    TimeScore.new @parts, @programs
+  end
   
-  # A new instance of Score.
-  # @param [Hash] args Hashed arguments. Required key is :tempo_profile.
-  def initialize args={}
-    hash_make args
-    super(args)
+  def ==(other)
+    return (@program == other.program) &&
+    (@parts == other.parts)
+  end
+end
+
+# Score where time is based on notes and tempo.
+class TempoScore < Score
+  attr_reader :tempo_profile, :program, :parts
+
+  def initialize tempo_profile, parts: {}, program: Program.new
+    @tempo_profile = tempo_profile
+    raise ValueNotPositiveError unless @tempo_profile.values_positive?
+    super(parts: parts, program: program)
   end
   
   def clone
-    Marshal.load(Marshal.dump(self))
+    TempoScore.new @tempo_profile.clone, @parts.clone, @program.clone
   end
   
-  # Set the score tempo Profile.
-  # @param [Profile] tempo_profile The tempo profile for the score.
-  # @raise [ArgumentError] if tempo_profile is not a Profile.
-  def tempo_profile= tempo_profile
-    TempoScore::ARG_SPECS[:tempo_profile].validate_value tempo_profile
-    @tempo_profile = tempo_profile
+  def ==(other)
+    return (@tempo_profile == other.tempo_profile) &&
+    (@program == other.program) &&
+    (@parts == other.parts)
   end
 end
 

data/lib/music-transcription/tempo.rb

@@ -4,17 +4,11 @@ module Transcription
 # Represent the musical tempo, with beats ber minute and beat duration.
 class Tempo
   include Comparable
-  include Hashmake::HashMakeable
-  
   attr_reader :beats_per_minute, :beat_duration
   
-  ARG_SPECS = {
-    :beats_per_minute => arg_spec(:reqd => true, :type => Numeric, :validator => ->(a){a > 0} ),
-    :beat_duration => arg_spec(:reqd => false, :type => Numeric, :validator => ->(a){a > 0}, :default =>  Rational(1,4))
-  }
-  
-  def initialize args
-    hash_make args
+  def initialize beats_per_minute, beat_duration: Rational(1,4)
+    @beats_per_minute = beats_per_minute
+    @beat_duration = beat_duration
   end
   
   def notes_per_second
@@ -34,11 +28,5 @@ class Tempo
   end
 end
 
-module_function
-
-def tempo beats_per_minute, beat_duration = Tempo::ARG_SPECS[:beat_duration].default
-  Tempo.new(:beats_per_minute => beats_per_minute, :beat_duration => beat_duration)
-end
-
 end
 end

data/lib/music-transcription/transition.rb

@@ -3,69 +3,53 @@ module Transcription
 
 # Describes how to transition from one value to another.
 class Transition
-  include Hashmake::HashMakeable
+  attr_reader :duration
   
-  IMMEDIATE = :transitionImmediate  # no transition really. Immediately change value.
-  LINEAR = :transitionLinear  # transition in a linear fashion.
-  SIGMOID = :transitionSigmoid  # transition smoothly
-  TYPES = [ IMMEDIATE, LINEAR, SIGMOID ]  # the transitions which are valid and expected
-  
-  # hashed-arg specs (for hash-makeable idiom)
-  ARG_SPECS = {
-    :duration => arg_spec(:reqd => false, :type => Numeric, :default => 0.0, :validator => ->(a){ a >= 0.0 } ),
-    :type => arg_spec(:reqd => false, :type => Symbol, :default => IMMEDIATE, :validator => ->(a) { Transition::TYPES.include?(a)}),
-    :abruptness => arg_spec(:reqd => false, :type => Numeric, :default => 0.5, :validator => ->(a){ a.between?(0,1) })
-  }
-  
-  attr_reader :type, :duration, :abruptness
+  def initialize duration
+    @duration = duration
+  end
   
-  def initialize args = {}
-    hash_make args, Transition::ARG_SPECS
+  def ==(other)
+    @duration == other.duration
   end
 
-  # Compare the equality of another Transition object.
-  def == other
-    return (@type == other.type) &&
-    (@duration == other.duration) && 
-    (@abruptness) == other.abruptness
+  class Immediate < Transition
+    def initialize
+      super(0)
+    end
+    
+    def clone
+      Immediate.new
+    end
   end
   
-  # Change the transition duration.
-  def duration= duration
-    Transition::ARG_SPECS[:duration].validate_value duration
-    @duration = duration
+  class Linear < Transition
+    def initialize duration
+      super(duration)
+    end
+    
+    def clone
+      Linear.new @duration
+    end
   end
   
-  # Change the transition type.
-  def type= type
-    Transition::ARG_SPECS[:type].validate_value type
-    @type = type
-  end
-
-  def abruptness= abruptness
-    Transition::ARG_SPECS[:abruptness].validate_value abruptness
-    @abruptness = abruptness
+  class Sigmoid < Transition
+    attr_reader :abruptness
+    def initialize duration, abruptness = 0.5
+      @abruptness = abruptness
+      super(duration)
+    end
+    
+    def clone
+      Sigmoid.new @duration, @abruptness
+    end
+    
+    def == other
+      @abruptness == other.abruptness &&
+      @duration == other.duration
+    end
   end
 end
 
-module_function
-
-# Create a Transition object with 0 duration and of IMMEDIATE type.
-def immediate
-  Transition.new(:duration => 0.0, :type => Transition::IMMEDIATE)
-end
-
-
-# Create a Transition object of IMMEDIATE type, with the given duration.
-def linear duration
-  Transition.new(:duration => duration, :type => Transition::LINEAR)
-end
-
-
-# Create a Transition object of SIGMOID type, with the given duration.
-def sigmoid duration, abruptness = Transition::ARG_SPECS[:abruptness].default
-  Transition.new(:duration => duration, :type => Transition::SIGMOID, :abruptness => abruptness)
-end
-
 end
 end

data/lib/music-transcription/value_change.rb

@@ -12,20 +12,13 @@ module Transcription
 #   @return [Numeric] The value of the event.
 #
 class ValueChange
-  include Hashmake::HashMakeable
-
-  attr_reader :value, :transition
-  
-  # hashed-arg specs (for hash-makeable idiom)
-  ARG_SPECS = {
-    :value => arg_spec(:reqd => true),
-    :transition => arg_spec(:reqd => false, :type => Transition, :default => ->(){ immediate() })
-  }
+  attr_accessor :value, :transition
 
   # New instance of ValueChange.
   # @param [Hash] args Hashed arguments for initialization.
-  def initialize args
-    hash_make args, ValueChange::ARG_SPECS
+  def initialize value, transition = Transition::Immediate.new
+    @value = value
+    @transition = transition
   end
   
   # Compare the equality of another ValueChange object.
@@ -36,49 +29,30 @@ class ValueChange
   
   # Produce an identical ValueChange object
   def clone
-    return ValueChange.new(:value => @value, :transition => @transition)
-  end
-
-  # Set the event value. Can be any object.
-  def value= value
-    ValueChange::ARG_SPECS[:value].validate_value value
-    @value = value
-  end
-
-  # Set the transition.
-  def transition= transition
-    ValueChange::ARG_SPECS[:transition].validate_value transition
-    @transition = transition
+    return ValueChange.new(@value, @transition.clone)
   end
 end
 
 module_function
 
-# Creates a ValueChange object
-# @param [Object] value
-# @param [Transition] transition
-def value_change(value, transition = immediate())
-  return ValueChange.new(:value => value, :transition => transition)
-end
-
 # Creates a ValueChange object using an immediate transition.
 # @param [Object] value
 def immediate_change(value)
-  return ValueChange.new(:value => value, :transition => immediate())
+  return ValueChange.new(value, Transition::Immediate.new)
 end
 
 # Creates a ValueChange object using a linear transition.
 # @param [Object] value
 # @param [Transition] transition_duration Length of the transition
 def linear_change(value, transition_duration = 0.0)
-  return ValueChange.new(:value => value, :transition => linear(transition_duration))
+  return ValueChange.new(value, Transition::Linear.new(transition_duration))
 end
 
 # Creates a ValueChange object using a sigmoid transition.
 # @param [Object] value
 # @param [Transition] transition_duration Length of the transition
-def sigmoid_change(value, transition_duration = 0.0, abruptness = Transition::ARG_SPECS[:abruptness].default)
-  return ValueChange.new(:value => value, :transition => sigmoid(transition_duration, abruptness))
+def sigmoid_change(value, transition_duration = 0.0, abruptness = 0.5)
+  return ValueChange.new(value, Transition::Sigmoid.new(transition_duration, abruptness))
 end
 
 end