musique 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 49ee2d5eebc0c30d67c830b2e8fe5abaf97e91b9
+  data.tar.gz: 5850e2bdb290e8eddf82336f6aa897849455feaa
+SHA512:
+  metadata.gz: 467fbe00501716a9b449ae782d1ea925884449e879d9508107fa0c820954a76a2a5397e24bb5035aba7b7f9d77df3136c20bb3a64020a6e6f8495d0f1dbae859
+  data.tar.gz: fe2d69a49b2c4c31189dc5a84024f5b3388a8dd13a25648e6347dcbefa54ff993f1baeac03a0cb02757475d7e2358919593fa51491d5895450a61a36f89b141e

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014-ω Janko Marohnić
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,100 @@
+# Musique
+
+Musique is a gem for manipulating with musical constructs, such as notes,
+chords and intervals.
+
+Installation
+------------
+
+```sh
+$ gem install musique
+```
+
+Usage
+-----
+
+### `Music::Note`
+
+```rb
+require "musique"
+
+include Music
+
+note = Note.new("C#1")
+note.letter     #=> "C"
+note.accidental #=> "#"
+note.octave     #=> 1
+
+# Comparison
+Note.new("C1")  <  Note.new("E1")  #=> true
+Note.new("C#1") == Note.new("D♭1") #=> true
+
+# Transposing
+major_third = Interval.new(3, :major)
+Note.new("C1").transpose_up(major_third).name   #=> "E1"
+Note.new("E1").transpose_down(major_third).name #=> "C1"
+
+# Difference
+Note.new("C2") - Note.new("C1") #=> #<Music::Interval @number=8, @quality=:perfect>
+```
+
+### `Music::Chord`
+
+```rb
+require "musique"
+
+include Music
+
+chord = Chord.new("C#7")
+chord.root.name #=> "C#"
+chord.kind      #=> "7"
+
+# Notes
+Chord.new("C").notes.map(&:name)   #=> ["C", "E", "G"]
+Chord.new("Cm7").notes.map(&:name) #=> ["C", "E♭", "G", "B♭"]
+
+# Transposing
+major_third = Interval.new(3, :major)
+Chord.new("C").transpose_up(major_third).notes.map(&:name) #=> ["E", "G#", "B"]
+```
+
+Into `Chord.new(...)` you should be able to pass in any chord name. For example,
+`"Cm"` and `"Cmin"` both represent the "C minor" chord, and both can be passed in.
+
+If you come across a chord name that doesn't work, please open an issue,
+I would like to know about it.
+
+### `Music::Interval`
+
+```rb
+require "musique"
+
+include Music
+
+interval = Interval.new(3, :minor)
+interval.number  #=> 3
+interval.quality #=> :minor
+
+# Comparison
+Interval.new(3, :minor) >  Interval.new(2, :major)     #=> true
+Interval.new(3, :minor) == Interval.new(2, :augmented) #=> true
+
+# Kinds
+Interval.new(6, :major).consonance?           #=> true
+Interval.new(6, :major).perfect_consonance?   #=> false (perfect consonances are 1, 4, and 5)
+Interval.new(6, :major).imperfect_consonance? #=> true
+Interval.new(6, :major).dissonance?           #=> false
+
+# Size
+Interval.new(3, :major).size #=> 4 (semitones)
+```
+
+Social
+------
+
+You can follow me on Twitter, I'm [@m_janko](http://twitter.com/m_janko).
+
+License
+-------
+
+This project is released under the [MIT license](/LICENSE).

data/lib/music/chord.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+
+module Music
+
+  class Chord
+
+    RULES = {
+      "5"  => ["1", "major 3", "5"],
+      "m5" => ["1", "minor 3", "5"],
+
+      "7"  => ["1", "major 3", "5", "major 7"],
+      "m7" => ["1", "minor 3", "5", "minor 7"],
+    }
+
+    REGEXP = /
+      (?<root> [CDEFGAB][#♭b]? )
+      (?<kind> m?\d*           )
+    /x
+
+    ##
+    # @return [Music::Note]
+    # @example
+    #   Chord.new("C").root #=> #<Music::Note @letter="C">
+    #
+    attr_reader :root
+    ##
+    #
+    # @return [String]
+    # @example
+    #   Chord.new("C7").kind #=> "7"
+    #
+    attr_reader :kind
+
+    ##
+    # @param name [String] Name of the chord, in any form.
+    # @example
+    #   Chord.new("Cm") == Chord.new("Cmin") #=> true
+    #
+    def initialize(name)
+      unless match = name.match(/^#{REGEXP}$/)
+        raise ArgumentError, "invalid chord format: #{name}"
+      end
+
+      @root = Note.new(match[:root])
+
+      @kind = match[:kind]
+      @kind << "5" if @kind !~ /\d+/
+    end
+
+    def name
+      [root, kind].join
+    end
+
+    ##
+    # Compares the names.
+    #
+    def ==(other)
+      self.name == other.name
+    end
+
+    ##
+    # @return [Array<Music::Note>]
+    #
+    def notes
+      RULES[kind].map do |interval_name|
+        quality  = interval_name[/^[a-z]+/] || "perfect"
+        number   = interval_name[/\d+$/]
+        interval = Interval.new(number.to_i, quality.to_sym)
+
+        root.transpose_by(interval)
+      end
+    end
+
+    ##
+    # @param interval [Music::Interval]
+    # @return [Music::Note]
+    # @example
+    #   major_third = Interval.new(3, :major)
+    #   Chord.new("C7").transpose_by(major_third) == Note.new("E7") #=> true
+    #   Note.new("E7").transpose_by(-major_third) == Note.new("C7") #=> true
+    #
+    def transpose_by(interval)
+      Chord.new(root.transpose_by(interval).name + kind)
+    end
+
+    ##
+    # @param (see #transpose_by)
+    # @return (see #transpose_by)
+    #
+    # @see #transpose_by
+    #
+    def transpose_up(interval)
+      transpose_by(interval)
+    end
+
+    ##
+    # @param (see #transpose_by)
+    # @return (see #transpose_by)
+    #
+    # @see #transpose_by
+    #
+    def transpose_down(interval)
+      transpose_by(-interval)
+    end
+
+  end
+
+end

data/lib/music/interval.rb

@@ -0,0 +1,173 @@
+module Music
+
+  class Interval
+
+    include Comparable
+
+    ##
+    # @private
+    #
+    SIZES = {
+      1 => [0],
+      2 => [1, 2],
+      3 => [3, 4],
+      4 => [5],
+      5 => [7],
+      6 => [8, 9],
+      7 => [10, 11],
+      8 => [12],
+    }
+
+    ##
+    # @private
+    #
+    OCTAVE = 8
+
+    QUALITIES = [:minor, :major, :perfect, :augmented, :diminished]
+
+    ##
+    # @return [Integer]
+    #
+    attr_reader :number
+    ##
+    # @return [Symbol]
+    #
+    attr_reader :quality
+    ##
+    # Indicates if the interval is positive or negative.
+    #
+    # @return [1, -1]
+    #
+    attr_reader :direction
+
+    ##
+    # @param number [Integer]
+    # @param quality [Symbol] See the {QUALITIES} constant for the list of
+    #   possible values.
+    #
+    # @example
+    #   Interval.new(3, :major)   # a major third
+    #   Interval.new(5, :perfect) # a perfect fifth
+    #
+    def initialize(number, quality)
+      if not QUALITIES.include?(quality)
+        raise ArgumentError, "invalid interval quality: #{quality}"
+      elsif [1, 4, 5].include?((number.abs - 1) % 7 + 1) and [:major, :minor].include?(quality)
+        raise ArgumentError, "interval #{number} doesn't have quality \"#{quality}\""
+      end
+
+      @number, @quality = number.abs, quality
+      @direction = number >= 0 ? +1 : -1
+    end
+
+    ##
+    # Perfect consonants are perfect unisons, fourths and fifths (and their
+    # compound intervals).
+    #
+    # @return [Boolean]
+    #
+    def perfect_consonance?
+      [1, 4, 5].include?(normalized_number) and [:perfect].include?(quality)
+    end
+
+    ##
+    # Imperfect consonants are minor/major thirds and sixths (and their compound
+    # intervals).
+    #
+    # @return [Boolean]
+    #
+    def imperfect_consonance?
+      [3, 6].include?(normalized_number) and [:minor, :major].include?(quality)
+    end
+
+    ##
+    # Consonances are perfect and imperfect consonances together.
+    #
+    # @return [Boolean]
+    #
+    # @see #perfect_consonance?
+    # @see #imperfect_consonance?
+    #
+    def consonance?
+      perfect_consonance? or imperfect_consonance?
+    end
+
+    ##
+    # Disonances are all intervals that are not consonances.
+    #
+    # @return [Boolean]
+    #
+    # @see #consonance?
+    #
+    def dissonance?
+      not consonance?
+    end
+
+    ##
+    # Returns the same inteval with changed direction.
+    #
+    # @return [Music::Interval]
+    #
+    def -@
+      Interval.new((-1 * direction) * number, quality)
+    end
+
+    ##
+    # Returns the number of semitones that interval covers.
+    #
+    # @return [Integer]
+    #
+    def size
+      result = 0
+      current_number = number
+
+      while current_number >= OCTAVE
+        result += SIZES[OCTAVE][0]
+        current_number -= OCTAVE - 1
+      end
+
+      sizes = SIZES.fetch(current_number)
+      result +=
+        case quality
+        when :diminished then sizes.first - 1
+        when :minor      then sizes.first
+        when :perfect    then sizes[0]
+        when :major      then sizes.last
+        when :augmented  then sizes.last  + 1
+        end
+
+      result * direction
+    end
+
+    ##
+    # Compares intervals by their size.
+    #
+    # @param other [Music::Interval]
+    # @example
+    #   Interval.new(3, :major) >  Interval.new(4, :perfect)    #=> true
+    #   Interval.new(3, :major) == Interval.new(4, :diminished) #=> true
+    #
+    def <=>(other)
+      self.size.abs <=> other.size.abs
+    end
+
+    ##
+    # The actual diatonic difference. For example, seconds are numbered with
+    # `2`, but the actual diatonic difference between two notes that
+    # are in a second is `1`.
+    #
+    # @return [Integer]
+    #
+    def diff
+      (number - 1) * direction
+    end
+
+    private
+
+    def normalized_number
+      (number - 1) % 7 + 1
+    end
+
+  end
+
+end

data/lib/music/note.rb

@@ -0,0 +1,173 @@
+# encoding: utf-8
+
+module Music
+
+  class Note
+
+    include Comparable
+
+    CHROMATIC_SCALE = %w[C C/D D D/E E F F/G G G/A A A/B B]
+    DIATONIC_SCALE  = %w[C D E F G A B]
+
+    ACCIDENTALS     = %w[# ♭]
+
+    REGEXP = /
+      (?<letter>     [CDEFGAB] )
+      (?<accidental> [#♭b]?    )
+      (?<octave>     (-?\d+)?  )
+    /x
+
+    ##
+    # C, D, E, F, G, A or B.
+    #
+    # @return [String]
+    #
+    attr_reader :letter
+    ##
+    # \# or ♭.
+    #
+    # @return [String]
+    #
+    attr_reader :accidental
+    ##
+    # An integer.
+    #
+    # @return [Integer]
+    #
+    attr_reader :octave
+
+    ##
+    # @param name [String] Consists of a letter (C, D, E, F, G, A, B),
+    #   accidental (# or ♭) and octave (any integer).
+    #
+    # @example
+    #   Note.new("C")
+    #   Note.new("C#")
+    #   Note.new("C♭") #=> or Note.new("Cb")
+    #
+    #   Note.new("C1")
+    #   Note.new("B-1")
+    #
+    def initialize(name)
+      unless match = name.match(/^#{REGEXP}$/)
+        raise ArgumentError, "invalid note name: #{name} (example: C#1)"
+      end
+
+      @letter     = match[:letter]
+      @accidental = match[:accidental].sub("b", "♭") unless match[:accidental].empty?
+      @octave     = match[:octave].to_i              unless match[:octave].empty?
+    end
+
+    def name
+      [letter, accidental, octave].join
+    end
+    alias to_s name
+
+    ##
+    # Compares notes by their pitch.
+    #
+    # @param other [Music::Note]
+    # @example
+    #   Note.new("C#") == Note.new("D♭") #=> true
+    #   Note.new("C")  <  Note.new("D")  #=> true
+    #   Note.new("C2") >  Note.new("C1") #=> true
+    #
+    def <=>(other)
+      self.pitch <=> other.pitch
+    end
+
+    ##
+    # @param interval [Music::Interval]
+    # @return [Music::Note]
+    # @example
+    #   major_third = Interval.new(3, :major)
+    #   Note.new("C").transpose_by(major_third)  == Note.new("E") #=> true
+    #   Note.new("E").transpose_by(-major_third) == Note.new("C") #=> true
+    #
+    def transpose_by(interval)
+      transposed_pitch = pitch + interval.size
+      transposed_pitch %= CHROMATIC_SCALE.size if octave.nil?
+
+      transposed_diatonic_idx = (diatonic_idx + interval.diff) % DIATONIC_SCALE.size
+      transposed_letter = DIATONIC_SCALE.fetch(transposed_diatonic_idx)
+
+      transposed_octave = octave + (diatonic_idx + interval.diff) / DIATONIC_SCALE.size if octave
+
+      transposed_accidental = ACCIDENTALS.find do |accidental|
+        note = Note.new [transposed_letter, accidental, transposed_octave].join
+        note.pitch == transposed_pitch
+      end
+
+      Note.new [transposed_letter, transposed_accidental, transposed_octave].join
+    end
+
+    ##
+    # @param (see #transpose_by)
+    # @return (see #transpose_by)
+    #
+    # @see #transpose_by
+    #
+    def transpose_up(interval)
+      transpose_by(interval)
+    end
+
+    ##
+    # @param (see #transpose_by)
+    # @return (see #transpose_by)
+    #
+    # @see #transpose_by
+    #
+    def transpose_down(interval)
+      transpose_by(-interval)
+    end
+
+    ##
+    # @param other [Music::Note]
+    # @return [Music::Interval]
+    # @example
+    #   Note.new("E") - Note.new("C") #=> #<Music::Interval @number=3, @quality=:major>
+    #
+    def -(other)
+      number = (self.diatonic_idx - other.diatonic_idx).abs + 1
+      number += (self.octave - other.octave).abs * DIATONIC_SCALE.size unless octave.nil?
+
+      distance = (self.pitch - other.pitch).abs
+      quality = Interval::QUALITIES.find do |quality|
+        begin; Interval.new(number, quality).size == distance; rescue ArgumentError; end
+      end
+
+      interval = Interval.new(number, quality)
+      self >= other ? interval : -interval
+    end
+
+    protected
+
+    ##
+    # Internal integer representation on the note.
+    #
+    # @return [Integer]
+    #
+    def pitch
+      result = chromatic_idx + (octave.to_i * CHROMATIC_SCALE.size)
+      result %= CHROMATIC_SCALE.size if octave.nil?
+      result
+    end
+
+    ##
+    # @return [Integer] An integer from 0 to 6
+    #
+    def diatonic_idx
+      DIATONIC_SCALE.index(letter)
+    end
+
+    ##
+    # @return [Integer] An integer from 0 to 11
+    #
+    def chromatic_idx
+      accidental_effect = {"#" => +1, "♭" => -1}.fetch(accidental, 0)
+      CHROMATIC_SCALE.index(letter) + accidental_effect
+    end
+
+  end
+
+end

data/lib/music.rb

@@ -0,0 +1,6 @@
+module Music
+  autoload :Note,     "music/note"
+  autoload :Interval, "music/interval"
+  autoload :Chord,    "music/chord"
+  autoload :Scale,    "music/scale"
+end

data/lib/musique.rb

@@ -0,0 +1 @@
+require "music"

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: musique
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Janko Marohnić
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-19 00:00:00.000000000 Z
+dependencies: []
+description: This gem is an object-oriented wrapper for the Flickr API.
+email:
+- janko.marohnic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/music.rb
+- lib/music/chord.rb
+- lib/music/interval.rb
+- lib/music/note.rb
+- lib/musique.rb
+homepage: http://janko-m.github.com/flickr-objects
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: This gem is an object-oriented wrapper for the Flickr API.
+test_files: []
+has_rdoc: