dodecaphony 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2cdb493c58e0f214ef7cc89dac4bafd38d7826b9
-  data.tar.gz: 807fe2e936382444b1c9612969105a7215bf9307
+  metadata.gz: 68d01640c510abfd7e48edade6c57d6dfcb35e07
+  data.tar.gz: b285ae148dff3451117edeb016e5f8ef4af039dc
 SHA512:
-  metadata.gz: 9662162bdee955579875ba1e37a41b591176ea4cd9e24c92c9c829ef3f211e49fd3c38ce629ca8d570cdaecdc4234746c95ba7cc0b0dbacd088ef2ca17ca6273
-  data.tar.gz: 06baece067f2ad549ce6808a10c5dba842fef4e924698f56c01f7c1bc69a1d6099b7c31cd5a79cec703847714bfd92ed64b7c85565e285c950b948006187e992
+  metadata.gz: 9228481081aa85c962421bfcee1f5e744238f169566b874c42d2b16d0be9e2b8b3f451bfbacef20053a3e4c0f912b624873a80e3d4f97d91a9daa79368e2ee98
+  data.tar.gz: 29489b6ba21afca6133b533d0e4c71944f1b48c09b0e0914d70c0124c1de2a3e1a7cc2799484e3689724e59ae1a54a97473f61a625059fe8eba6d75279ddcd7a

data/Readme.md

@@ -5,45 +5,58 @@ Dodecaphony calculates twelve tone rows for
 you. To learn more about what this means, [read
 this](http://www.tufts.edu/~mdevoto/12TonePrimer.pdf).
 
+Dodecaphony is a ruby gem. Install with
+```
+gem install dodecaphony
+```
+
 Examples
 ---
 
-Dodecaphony takes an array of twelve strings, one for each pitch in your
-twelve tone row.
+First, you'll need a `Dodecaphony::Row` object. `Dodecaphony::Row`
+requires an array of 12 strings, each representing a unique pitch. Each
+pitch must begin with a valid letter name (a through g) and can be
+followed by one or more accidentals. `#`, `+`, `b` and `-` are the four
+valid accidentals.
 
 ```ruby
-Dodecaphony::Row.new %w[a a# b c c# d d# e f f# g g#]
+my_row = Dodecaphony::Row.new %w[a a# b c c# d d# e f f# g g#]
 ```
+A row can be converted to either an array of pitch names, or a string with
+pitch names separated by a space.
+```ruby
+my_row.to_a    # ['a', 'a#', 'b', 'c', 'c#', 'd', 'd#', 'e', 'f', 'f#', 'g', 'g#']
 
-Each pitch must begin with a valid letter name (a through g) and can be
-followed by one or more accidentals. `#`, `+`, `b` and `-` are the four valid
-accidentals.
+my_row.to_s    # "a a# b c c# d d# e f f# g g#"
+```
+You can also ask a row to respell itself, favoring flats or sharps:
+```ruby
+tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
 
-Once you have your row, you can ask it for any prime, inversion, retrograde, or
-retrograde inversion like so:
+tone_row.spell_with_sharps # ["A", "F#", "G", "G#", "E", "F", "B", "A#", "D", "C#", "C", "D#"]
 
+tone_row.spell_with_flats # ["A", "Gb", "G", "Ab", "E", "F", "B", "Bb", "D", "Db", "C", "Eb"]
+```
+The `Dodecaphony::Calculator` class initializes with a `Dodecaphony::Row`
+object.
 ```ruby
 tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
-
+calc = Dodecaphony::Calculator.new tone_row
+```
+The calculator can then return any prime, inversion, retrograde, or retrograde
+inversion. Each of these rows is a method of the calculator object, the names
+being the initial of the type of row you want, followed by the number of the
+row you want. Observe:
+```ruby
 #  "p" followed by 0 through 11 returns the corresponding prime row
-tone_row.p0    # ["a", "f#", "g", "ab", "e", "f", "b", "bb", "d", "c#", "c", "eb"]
+calc.p0    # ["a", "f#", "g", "ab", "e", "f", "b", "bb", "d", "c#", "c", "eb"]
 
 #  "r" followed by 0 through 11 returns the corresponding retrograde
-tone_row.r11   # ["d", "b", "c", "c#", "a", "bb", "e", "eb", "g", "f#", "f", "ab"]
+calc.r11   # ["d", "b", "c", "c#", "a", "bb", "e", "eb", "g", "f#", "f", "ab"]
 
 #  "i" followed by 0 through 11 returns the corresponding inversion
-tone_row.i2    # ["b", "d", "c#", "c", "e", "eb", "a", "bb", "f#", "g", "ab", "f"]
+calc.i2    # ["b", "d", "c#", "c", "e", "eb", "a", "bb", "f#", "g", "ab", "f"]
 
 # "ri" followed by 0 through 11 returns the corresponding retrograde inversion
-tone_row.ri6   # ["a", "c", "b", "bb", "d", "c#", "g", "ab", "e", "f", "f#", "eb"]
-```
-
-You can also ask a row to respell itself, favoring flats or sharps:
-```ruby
-tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
-
-tone_row.spell_with_sharps # ["A", "F#", "G", "G#", "E", "F", "B", "A#", "D", "C#", "C", "D#"]
-
-tone_row.spell_with_flats # ["A", "Gb", "G", "Ab", "E", "F", "B", "Bb", "D", "Db", "C", "Eb"]
+calc.ri6   # ["a", "c", "b", "bb", "d", "c#", "g", "ab", "e", "f", "f#", "eb"]
 ```
-

data/lib/calculator.rb

@@ -0,0 +1,53 @@
+require_relative 'row'
+
+module Dodecaphony
+  class Calculator
+
+    def initialize row
+      self.row = row
+    end
+
+    def i0
+      row.each_with_object([]) { |pitch, new_row|
+        new_row << row.intervals[((row.intervals.key(pitch) - 12).abs)].name
+      }
+    end
+
+    (1..11).each do |i|
+      define_method "i#{i}".to_sym do
+        corresponding_p = self.send("p#{i}").to_a
+        new_row = Dodecaphony::Row.new corresponding_p
+        (self.class.new new_row).i0
+      end
+    end
+
+    (0..11).each do |i|
+      define_method "p#{i}".to_sym do
+        row.pitches.each_with_object([]) { |pitch, new_row|
+          new_row << row.intervals[(transpose i, pitch)].name
+        }
+      end
+
+      define_method "r#{i}".to_sym do
+        self.send("p#{i}").reverse
+      end
+
+      define_method "ri#{i}".to_sym do
+        self.send("i#{i}").reverse
+      end
+    end
+
+    private
+
+    attr_accessor :row
+
+    def transpose interval, pitch
+      (starting_pitch.distance_from(pitch) + interval) % 12
+    end
+
+    def starting_pitch
+      row.pitches[0]
+    end
+
+  end
+end

data/lib/pitch.rb

@@ -26,6 +26,13 @@ module Dodecaphony
       respell :+, "b"
     end
 
+    def == other
+      numbers = (distance_from(other) == 0)
+      names = (starting_letter == other.name.upcase.split(//)[0])
+
+      names && numbers
+    end
+
     protected
 
     attr_reader :pitch_number

data/lib/{dodecaphony.rb → row.rb}

@@ -3,18 +3,27 @@ require 'set'
 
 module Dodecaphony
   class Row
+    include Enumerable
 
-    attr_reader :original_row
+    attr_reader :original_row, :intervals
+
+    alias_method :pitches, :original_row
 
     def initialize tone_row
       self.original_row = create_row_with_pitches(tone_row)
       validate_size_of original_row
-      self.row_with_intervals = create_list_with_intervals(original_row,
+      self.intervals = create_list_with_intervals(original_row,
                                                            starting_pitch)
     end
 
     def to_s
-      p0.join(" ")
+      to_a.join(" ")
+    end
+    
+    def to_a
+      pitches.each_with_object([]) do |pitch, row|
+        row << pitch.name
+      end
     end
 
     def spell_with_sharps
@@ -25,49 +34,18 @@ module Dodecaphony
       normalize_row(:spell_as_flat)
     end
 
-    def i0
-      original_row.each_with_object([]) do |pitch, row|
-        row << row_with_intervals[((row_with_intervals.key(pitch) - 12).abs)].name
-      end
-    end
-
-    (0..11).each do |i|
-      define_method "p#{i}".to_sym do
-        original_row.each_with_object([]) do |pitch, row|
-          row << row_with_intervals[(transpose i, pitch)].name
-        end
-      end
-    end
-
-    (1..11).each do |i|
-      define_method "i#{i}".to_sym do
-        corresponding_p = self.send("p#{i}")
-        new_row = self.class.new corresponding_p
-        new_row.i0
+    def == other
+      (other.pitches).zip(pitches).all? do |pitches|
+        pitches[0] == pitches[1]
       end
     end
 
-    (0..11).each do |i|
-      define_method "r#{i}".to_sym do
-        self.send("p#{i}".to_sym).reverse.each_with_object([]) do |pitch, row|
-          row << pitch
-        end
-      end
-    end
-
-    (0..11).each do |i|
-      define_method "ri#{i}".to_sym do
-        self.send("i#{i}").reverse.each_with_object([]) do |pitch, row|
-          row << pitch
-        end
-      end
+    def each &block
+      pitches.each &block
     end
-
     private
 
-    attr_writer :original_row
-
-    attr_accessor :row_with_intervals
+    attr_writer :intervals, :original_row
 
     def create_list_with_intervals(row, first_pitch)
       row_list = row.each_with_object({}) do |pitch, hash|
@@ -112,9 +90,5 @@ module Dodecaphony
       end
     end
 
-    def transpose interval, pitch
-      (starting_pitch.distance_from(pitch) + interval) % 12
-    end
-
   end
 end

data/spec/calculator_spec.rb

@@ -0,0 +1,84 @@
+require 'calculator'
+require 'ostruct'
+
+describe Dodecaphony::Calculator do
+
+  it "initializes with a row" do
+    row = Dodecaphony::Row.new %w[a b b- c c# d d# e f gb g g#]
+    calc = Dodecaphony::Calculator.new row
+    
+    expect(calc).to be_kind_of(Dodecaphony::Calculator)
+  end
+
+  it "can provide the original row" do
+    row = Dodecaphony::Row.new %w[a b b- c c# d d# e f gb g g#]
+    calc = Dodecaphony::Calculator.new row
+
+    expect(calc.p0).to eq row.to_a
+  end
+
+  it "can provide p1" do
+    row = Dodecaphony::Row.new %w[ bb b c c# d f e eb g gb a ab ]
+    p1_row = %w[ b c c# d eb gb f e ab g bb a ]
+    calc = Dodecaphony::Calculator.new row
+
+    expect(calc.p1).to eq p1_row.to_a
+  end
+
+   it "can give p7" do
+     row = Dodecaphony::Row.new %w[ d c# a b- f eb e c ab g f# b ]
+     prime7 = %w[ a ab e f c b- b g eb d c# f# ]
+     calc = Dodecaphony::Calculator.new row
+       
+     expect(calc.p7).to eq prime7
+   end
+  
+  it "can give i0" do
+    row = Dodecaphony::Row.new %w[ A ab a# b c c# d eb e f gb g ]
+    new_row = %w[ A a# ab g gb f e eb d c# c b ]
+    calc = Dodecaphony::Calculator.new row
+
+    expect(calc.i0).to eq new_row
+  end
+
+  it "can give i8" do
+    row = Dodecaphony::Row.new %w[ A ab a# b c c# d eb e f gb g ]
+    new_row = %w[ f gb e eb d c# c b a# A ab g ]
+    calc = Dodecaphony::Calculator.new row
+
+    expect(calc.i8).to eq new_row
+  end
+
+  it "can give r0" do
+    row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+    new_row = %w[ eb c c# d bb b f e ab g f# a ]
+    calc = Dodecaphony::Calculator.new row
+
+    expect(calc.r0).to eq new_row
+  end
+
+  it "can give r9" do
+    row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+    new_row = %w[ c a bb b g ab d c# f e eb f# ]
+    calc = Dodecaphony::Calculator.new row
+
+    expect(calc.r9).to eq new_row
+  end
+
+  it "can give ri0" do
+    row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+    new_row = %w[eb f# f e ab g c# d bb b c a ] 
+    calc = Dodecaphony::Calculator.new row
+
+    expect(calc.ri0).to eq new_row
+  end
+
+  it "can give ri11" do
+    row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+    new_row = %w[ c# e eb d f# f b c ab a bb g ]
+    calc = Dodecaphony::Calculator.new row
+
+    expect(calc.ri10).to eq new_row
+  end
+
+end

data/spec/pitch_spec.rb

@@ -51,4 +51,25 @@ describe Dodecaphony::Pitch do
   it "raises an error with an invalid pitch name" do
     expect {Dodecaphony::Pitch.new "H"}.to raise_error(ArgumentError, 'invalid pitch name')
   end
+
+  it "knows when it is not equal to another pitch" do
+    p1 = Dodecaphony::Pitch.new "a#"
+    p2 = Dodecaphony::Pitch.new "b-"
+
+    expect(p1).to_not eq p2
+  end
+
+  it "knows when it is equal to another pitch" do
+    p1 = Dodecaphony::Pitch.new "a"
+    p2 = Dodecaphony::Pitch.new "a"
+
+    expect(p1).to eq p2
+  end
+
+  it "doesn't factor accidental style into equality" do
+    p1 = Dodecaphony::Pitch.new "c#"
+    p2 = Dodecaphony::Pitch.new "c+"
+
+    expect(p1).to eq p2
+  end
 end

data/spec/{dodecaphony_spec.rb → row_spec.rb}

@@ -1,4 +1,4 @@
-require 'dodecaphony'
+require 'row'
 
 describe Dodecaphony::Row do
 
@@ -6,7 +6,7 @@ describe Dodecaphony::Row do
     tone_row = %w[ a a# b c db d eb e f f# g g# ]
     new_dod = Dodecaphony::Row.new tone_row
 
-    expect(new_dod.p0).to eq tone_row
+    expect(new_dod.to_a).to eq tone_row
   end
 
   it "raises an error for a row with more than 12 pitches" do
@@ -38,59 +38,36 @@ describe Dodecaphony::Row do
     expect(new_dod.spell_with_flats).to eq %w[ C Db D Eb E F Gb G Ab A Bb B ]
   end
 
-  it "can give p1" do
-    tone_row = %w[ bb b c c# d f e eb g gb a ab ]
-    new_dod = Dodecaphony::Row.new tone_row
-
-    expect(new_dod.p1).to eq %w[ b c c# d eb gb f e ab g bb a ]
-  end
-
-  it "can give p7" do
-    tone_row = Dodecaphony::Row.new %w[ d c# a b- f eb e c ab g f# b ]
-      
-    expect(tone_row.p7).to eq %w[ a ab e f c b- b g eb d c# f# ]
-  end
-
-  it "can give i0" do
-    tone_row = Dodecaphony::Row.new %w[ A ab a# b c c# d eb e f gb g ]
-
-    expect(tone_row.i0).to eq %w[ A a# ab g gb f e eb d c# c b ]
-  end
-
-  it "can give i8" do
-    tone_row = Dodecaphony::Row.new %w[ A ab a# b c c# d eb e f gb g ]
-
-    expect(tone_row.i8).to eq %w[ f gb e eb d c# c b a# A ab g ]
-  end
-  
-  it "can give r0" do
+  it "returns a reasonable string" do
     tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
 
-    expect(tone_row.r0).to eq %w[ eb c c# d bb b f e ab g f# a ]
+    expect(tone_row.to_s).to eq "a f# g ab e f b bb d c# c eb"
   end
-  
-  it "can give r9" do
-    tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
 
-    expect(tone_row.r9).to eq %w[ c a bb b g ab d c# f e eb f# ]
+  it "returns an array" do
+    tone_row = Dodecaphony::Row.new %w[a f# g ab e f b b- d c# c eb]
+
+    expect(tone_row.to_a).to eq %w[a f# g ab e f b b- d c# c eb]
   end
 
-  it "can give ri0" do
-    tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+  it "returns its pitches" do
+    tone_row = Dodecaphony::Row.new %w[a f# g ab e f b b- d c# c eb]
+    first_pitch = Dodecaphony::Pitch.new "a"
 
-    expect(tone_row.ri0).to eq %w[eb f# f e ab g c# d bb b c a ]
+    expect(tone_row.pitches.to_a[0].name).to eq first_pitch.name
   end
 
-  it "can give ri11" do
-    tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+  it "can check for equality with other rows" do
+    row1 = Dodecaphony::Row.new %w[a f# g ab e f b b- d c# c eb]
+    row2 = Dodecaphony::Row.new %w[a f# g ab e f b b- d c# c eb]
 
-    expect(tone_row.ri10).to eq %w[ c# e eb d f# f b c ab a bb g ]
+    expect(row1).to eq row2
   end
 
-  it "converts to a reasonable string" do
-    tone_row = Dodecaphony::Row.new %w[ a f# g ab e f b bb d c# c eb ]
+  it "knows when rows are unequal" do
+    row1 = Dodecaphony::Row.new %w[a f# g ab e f b b- d c# c eb]
+    row2 = Dodecaphony::Row.new %w[a b b- c d- d e- e f g- g a-]
 
-    expect(tone_row.to_s).to eq "a f# g ab e f b bb d c# c eb"
+    expect(row1).to_not eq row2
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dodecaphony
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kevin McGladdery
@@ -39,10 +39,12 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - Readme.md
-- lib/dodecaphony.rb
+- lib/calculator.rb
 - lib/pitch.rb
-- spec/dodecaphony_spec.rb
+- lib/row.rb
+- spec/calculator_spec.rb
 - spec/pitch_spec.rb
+- spec/row_spec.rb
 homepage: http://github.com/runkmc/dodecaphony
 licenses:
 - MIT
@@ -63,10 +65,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.3.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Tone Row Calculator
 test_files:
-- spec/dodecaphony_spec.rb
+- spec/calculator_spec.rb
 - spec/pitch_spec.rb
+- spec/row_spec.rb