roborabb 0.0.1

data/HISTORY.md

@@ -0,0 +1,5 @@
+# History
+
+## 0.0.1 / 10 December 2011
+
+* Initial release

data/README.md

@@ -0,0 +1,61 @@
+Roborabb
+========
+
+Generates drumming practice charts in [lilypond][lilypond] notation.
+
+<img
+  src="https://img.skitch.com/20111210-n7ey6x4jrmiaq11tjj1j8qqd4u.jpg"
+  alt='example score' />
+
+Example
+-------
+
+Install the gem:
+
+    gem install roborabb
+
+Then use it:
+
+    require 'roborabb'
+
+    rock_1 = Roborabb.construct(
+      title:          "Rock",
+      subdivisions:   8,
+      unit:           8,
+      time_signature: "4/4",
+      notes: {
+        hihat: L{|env| true },
+        kick:  L{|env| (env.subdivision + 0) % 4 == 0 },
+        snare: L{|env| (env.subdivision + 2) % 4 == 0 },
+      }
+    )
+
+    puts Roborabb::Lilypond.new(rock_1, bars: 16).to_lilypond
+
+The resulting file is immediately compilable with [lilypond][lilypond]:
+
+    ruby examples/rock.rb > rock.ly && lilypond rock.ly # Generates rock.pdf
+
+See `examples` directory for more.
+
+[lilypond]: http://lilypond.org/
+
+Compatibility
+-------------
+
+Only tested on ruby 1.9.3. Require 1.9, since it uses new style hashes.
+
+Developing
+----------
+
+    git clone git://github.com/xaviershay/roborabb.git
+    bundle           # Install development dependencies
+    bundle exec rake # Runs the specs
+
+Any big new features require an acceptance test, bug fixes should only require
+unit tests. Follow the conventions already present.
+
+Status
+------
+
+New, but complete.

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+  $stderr.puts "rspec not available, spec task not provided"
+end

data/lib/roborabb.rb

@@ -0,0 +1,16 @@
+require 'roborabb/version'
+
+require 'roborabb/core_ext'
+require 'roborabb/builder'
+require 'roborabb/lilypond'
+
+module Roborabb
+  def construct(plan)
+    unless plan.has_key?(:notes)
+      raise(ArgumentError, "Plan does not contain :notes")
+    end
+    Builder.new(plan)
+  end
+  module_function :construct
+end
+

data/lib/roborabb/bar.rb

@@ -0,0 +1,23 @@
+module Roborabb
+  class Bar
+    ATTRIBUTES = [
+      :beat_structure,
+      :notes,
+      :subdivisions,
+      :time_signature,
+      :title,
+      :unit,
+    ]
+    attr_reader *ATTRIBUTES
+
+    def initialize(attributes)
+      ATTRIBUTES.each do |x|
+        send("#{x}=", attributes[x])
+      end
+    end
+
+    protected
+
+    attr_writer *ATTRIBUTES
+  end
+end

data/lib/roborabb/builder.rb

@@ -0,0 +1,77 @@
+require 'ostruct'
+
+require 'roborabb/bar'
+
+module Roborabb
+  class Builder
+    attr_reader :plan
+
+    def initialize(plan_hash)
+      self.plan       = OpenStruct.new(plan_hash)
+      self.bar_env    = OpenStruct.new(index: 0)
+      self.enumerator = Enumerator.new do |yielder|
+        loop do
+          yielder.yield(generate_bar)
+          bar_env.index += 1
+        end
+      end
+    end
+
+    def next
+      enumerator.next
+    end
+
+    protected
+
+    def generate_bar
+      notes = subdivisions.inject(empty_notes) do |notes, subdivision|
+        env = build_env(subdivision)
+
+        plan.notes.map do |name, f|
+          notes[name] << resolve(f, env)
+        end
+
+        notes
+      end
+
+      Bar.new(
+        subdivisions:   subdivisions.max + 1,
+        unit:           resolve(plan.unit, bar_env),
+        time_signature: resolve(plan.time_signature, bar_env),
+        beat_structure: resolve(plan.beat_structure, bar_env),
+        title:          resolve(plan.title, bar_env),
+        notes:          notes
+      )
+    end
+
+    def resolve(f, env)
+      if f.respond_to?(:call)
+        f.call(env)
+      else
+        f
+      end
+    end
+
+    def subdivisions
+      (0...resolve(plan.subdivisions, bar_env))
+    end
+
+    def empty_notes
+      x = plan.notes.keys.map do |name|
+        [name, []]
+      end
+      Hash[x]
+    end
+
+    def build_env(subdivision)
+      OpenStruct.new(
+        subdivision: subdivision,
+        bar:         bar_env
+      )
+    end
+
+    attr_writer :plan
+    attr_accessor :enumerator
+    attr_accessor :bar_env
+  end
+end

data/lib/roborabb/core_ext.rb

@@ -0,0 +1 @@
+alias :L :lambda

data/lib/roborabb/lilypond.rb

@@ -0,0 +1,149 @@
+require 'roborabb/bar'
+
+module Roborabb
+  class Lilypond
+    def initialize(generator, opts)
+      self.generator = generator
+      self.opts      = opts
+    end
+
+    def to_lilypond
+      score = opts[:bars].times.map do
+        bar = generator.next
+
+        format_bar(bar)
+      end
+
+      lilypond do
+        voice(:up)   { format_bars(score, :upper) } +
+        voice(:down) { format_bars(score, :lower) }
+      end
+    end
+
+    protected
+
+    attr_accessor :generator, :opts, :title
+
+    def format_bars(bars, voice)
+      last_plan = Bar.new({})
+      bars.map do |bar|
+        plan = bar[:bar]
+
+        preamble = ""
+        if last_plan.time_signature != plan.time_signature
+          preamble += %(\\time #{plan.time_signature}\n)
+        end
+
+        if last_plan.beat_structure != plan.beat_structure && plan.beat_structure
+          preamble += %(\\set Staff.beatStructure = #'(%s)\n) % [
+            plan.beat_structure.join(' ')
+          ]
+        end
+        last_plan = plan
+        self.title = plan.title
+
+        preamble + bar[voice]
+      end.join(' | ') + ' \\bar "|."'
+    end
+
+    def lilypond
+      # Evaluating the content first is necessary to infer the title.
+      content = yield
+
+      <<-LP
+      \\version "2.14.2"
+      \\header {
+        title = "#{title}"
+        subtitle = " "
+      }
+      \\new DrumStaff <<
+        #{content}
+      >>
+      LP
+    end
+
+    def voice(direction)
+      result = <<-LP
+      \\new DrumVoice {
+        \\override Rest #'direction = ##{direction}
+        \\stem#{direction == :up ? "Up" : "Down"}   \\drummode {
+          #{yield}
+        }
+      }
+      LP
+    end
+
+    def format_bar(bar)
+      {
+        bar:   bar,
+        upper: format_notes(bar, expand(hashslice(bar.notes, :hihat))),
+        lower: format_notes(bar, expand(hashslice(bar.notes, :kick, :snare)))
+      }
+    end
+
+    def format_notes(bar, notes)
+      notes.map do |note|
+        if note[0].length == 1
+          mappings[note[0][0]] + duration(bar, note[1]).to_s
+        elsif note[0].length > 1
+          "<%s>%s" % [
+            note[0].map {|x| mappings[x] }.join(' '),
+            duration(bar, note[1])
+          ]
+        else
+          "r%s" % duration(bar, note[1])
+        end
+      end.join(" ")
+    end
+
+    def mappings
+      {
+        kick:  'bd',
+        snare: 'sn',
+        hihat: 'hh'
+      }
+    end
+
+    def duration(bar, x)
+      unit = bar.unit
+      [
+        unit,
+        unit / 2,
+        (unit / 2).to_s + ".",
+        unit / 4
+      ].map(&:to_s)[x-1] || raise("Unsupported duration: #{x}")
+    end
+
+    def hashslice(hash, *keep_keys)
+      h = {}
+      keep_keys.each do |key|
+        h[key] = hash[key] if hash.has_key?(key)
+      end
+      h
+    end
+
+    def expand(notes)
+      accum = []
+      time  = 0
+      out = notes.values.transpose.inject([]) do |out, on_notes|
+        on = [*on_notes].map.with_index do |x, i|
+          notes.keys[i] if x
+        end.compact
+
+        if !on.empty? || time >= 4
+          if time > 0
+            out << [accum, time]
+          end
+          accum = on
+          time = 0
+        end
+        time += 1
+
+        out
+      end
+
+      out << [accum, time] if time > 0
+      out
+    end
+  end
+end

data/lib/roborabb/version.rb

@@ -0,0 +1,3 @@
+module Roborabb
+  VERSION = "0.0.1"
+end

data/roborabb.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/roborabb/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Xavier Shay"]
+  gem.email         = ["hello@xaviershay.com"]
+  gem.description   = %q{Algorithmically generate practice drum scores}
+  gem.summary       = %q{
+    Algorithmically generate practice drum scores. Customize algorithms with
+    ruby with an archaeopteryx-inspired style, output to lilypond format.
+  }
+  gem.homepage      = "http://github.com/xaviershay/roborabb"
+
+  gem.executables   = []
+  gem.files         = Dir.glob("{spec,lib}/**/*.rb") + %w(
+                        README.md
+                        HISTORY.md
+                        Rakefile
+                        roborabb.gemspec
+                      )
+  gem.test_files    = Dir.glob("spec/**/*.rb")
+  gem.name          = "roborabb"
+  gem.require_paths = ["lib"]
+  gem.version       = Roborabb::VERSION
+  gem.has_rdoc      = false
+  gem.add_development_dependency 'rspec', '~> 2.0'
+  gem.add_development_dependency 'rake'
+end

data/spec/acceptance_spec.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+require 'roborabb'
+
+describe 'outputting to lilypond' do
+  it 'outputs a basic rock beat' do
+    rabb = Roborabb.construct(
+      subdivisions:   8,
+      unit:           8,
+      time_signature: "4/4",
+      notes: {
+        hihat: L{|env| true },
+        kick:  L{|env| (env.subdivision + 0) % 4 == 0 },
+        snare: L{|env| (env.subdivision + 2) % 4 == 0 },
+      }
+    )
+    ly = Roborabb::Lilypond.new(rabb, bars: 2)
+    output = ly.to_lilypond.lines.map(&:chomp).join
+    output.should include('\\time 4/4')
+    output.should include('hh8 hh8 hh8 hh8 | hh8 hh8 hh8 hh8')
+    output.should include('bd4 sn4 | bd4 sn4')
+  end
+end

data/spec/unit_spec.rb

@@ -0,0 +1,259 @@
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+require 'roborabb'
+
+describe Roborabb do
+  def notes(rabb)
+    rabb.next.notes
+  end
+
+  def default_attributes
+    {
+      subdivisions:   2,
+      unit:           8,
+      time_signature: '1/4',
+      notes:          {}
+    }
+  end
+
+  def construct(attributes)
+    Roborabb.construct(default_attributes.merge(attributes))
+  end
+
+  describe '#construct' do
+    it 'raises Argument error when no :notes given' do
+      lambda {
+        Roborabb.construct(default_attributes.delete_if {|k, _| k == :notes })
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe '#next' do
+    it 'allows a value for notes' do
+      rabb = construct(
+        subdivisions: 2,
+        notes:        { a: 'A' }
+      )
+
+      notes(rabb).should == { a: ['A', 'A'] }
+    end
+
+    it 'includes subdivision in env yielded to notes' do
+      rabb = construct(
+        subdivisions: 3,
+        notes: {
+          a: :subdivision.to_proc
+        }
+      )
+
+      notes(rabb).should == { a: [0, 1, 2] }
+    end
+
+    it 'includes bar number in env yielded to config' do
+      rabb = construct(
+        subdivisions: L{|e| e.index + 1 },
+        notes:        { a: 1 }
+      )
+
+      3.times.map { notes(rabb) }.should == [
+        { a: [1] },
+        { a: [1, 1] },
+        { a: [1, 1, 1] }
+      ]
+    end
+
+    it 'includes bar number in env yielded to notes' do
+      rabb = construct(
+        subdivisions: 2,
+        notes:        { a: L{|e| e.bar.index } }
+      )
+
+      3.times.map { notes(rabb) }.should == [
+        { a: [0, 0] },
+        { a: [1, 1] },
+        { a: [2, 2] }
+      ]
+    end
+
+    it 'includes subdivisons in returned object' do
+      rabb = construct(subdivisions: 2)
+      rabb.next.subdivisions.should == 2
+    end
+
+    it 'includes unit in returned object' do
+      rabb = construct(unit: 8)
+      rabb.next.unit.should == 8
+    end
+
+    it 'includes generated unit in returned object' do
+      rabb = construct(unit: L{|e| 8 })
+      rabb.next.unit.should == 8
+    end
+
+    it 'includes time_signature in returned object' do
+      rabb = construct(time_signature: "7/8")
+      rabb.next.time_signature.should == "7/8"
+    end
+
+    it 'includes generated time_signature in returned object' do
+      rabb = construct(time_signature: L{|e| "7/8" })
+      rabb.next.time_signature.should == "7/8"
+    end
+
+    it 'includes beat_structure in returned object' do
+      rabb = construct(beat_structure: [3, 2, 2])
+      rabb.next.beat_structure.should == [3, 2, 2]
+    end
+
+    it 'includes generated beat_structure in returned object' do
+      rabb = construct(beat_structure: L{|e| [3, 2, 2] })
+      rabb.next.beat_structure.should == [3, 2, 2]
+    end
+
+    it 'includes title in returned object' do
+      rabb = construct(title: "Hello")
+      rabb.next.title.should == "Hello"
+    end
+
+    it 'includes generated title in returned object' do
+      rabb = construct(title: L{|e| "Hello" })
+      rabb.next.title.should == "Hello"
+    end
+  end
+
+end
+
+describe Roborabb::Lilypond do
+  describe '#to_lilypond' do
+    def bar(attributes = {})
+      double("Bar", {
+        title:          nil,
+        unit:           8,
+        notes:          {hihat: [true]},
+        time_signature: "4/4",
+        beat_structure: [4, 4]
+      }.merge(attributes))
+    end
+
+    def output(generator, opts = {bars: 1})
+      formatter = described_class.new(generator.each, opts)
+      formatter.to_lilypond
+    end
+
+    it 'outputs rests' do
+      generator = [bar(notes: {hihat: [false]})]
+      output(generator).should include("r")
+    end
+
+    it 'outputs hihats' do
+      generator = [bar(notes: {hihat: [true]})]
+      output(generator).should include("hh")
+    end
+
+    it 'calculates durations correctly to a maximum of four units' do
+      generator = [bar(unit: 32, notes: {hihat:
+        [true] +
+        [true] + [false] * 1 +
+        [true] + [false] * 2 +
+        [true] + [false] * 3 +
+        [true] + [false] * 4
+      })]
+
+      output(generator).should include("hh32 hh16 hh16. hh8 hh8 r32")
+    end
+
+    it 'outputs kicks and snares' do
+      generator = [bar(unit: 4, notes: {
+        kick:  [true, false],
+        snare: [false, true]
+      })]
+      output(generator).should include("bd4 sn4")
+    end
+
+    it 'can output two notes at the same time' do
+      generator = [bar(unit: 4, notes: {kick: [true], snare: [true]})]
+      output(generator).should include("<bd sn>4")
+    end
+
+    it 'can output a rest before a note' do
+      generator = [bar(unit: 8, notes: {hihat: [false, true]})]
+      output(generator).should include("r8 hh8")
+    end
+
+    it 'includes lilypond preamble' do
+      lilypond = output([bar])
+      lilypond.should include("\\version")
+      lilypond.should include("\\new DrumStaff")
+    end
+
+    it 'places hihats and kick/snare in different voices' do
+      generator = [bar(unit: 8, notes: {
+        hihat: [true, true],
+        kick:  [true, false],
+        snare: [false, true]
+      })]
+      voices = output(generator).split("\\new DrumVoice")[1..-1]
+      voices[0].should include("hh8 hh8")
+      voices[0].should include("\\override Rest #'direction = #up")
+      voices[0].should include("\\stemUp")
+      voices[1].should include("bd8 sn8")
+      voices[1].should include("\\stemDown")
+    end
+
+    it 'includes bar lines' do
+      generator = [
+        bar(notes: {hihat: [true] }),
+        bar(notes: {hihat: [false] }),
+      ]
+      bars = output(generator, bars: 2).split('|')
+      bars[0].should include('hh')
+      bars[1].should include('r')
+    end
+
+    it 'includes time signature changes per bar' do
+      generator = [
+        bar(time_signature: "1/8"),
+        bar(time_signature: "1/8"),
+        bar(time_signature: "1/4"),
+      ]
+      bars = output(generator, bars: 3).split('|')
+      bars[0].should     include(%(\\time 1/8))
+      bars[1].should_not include(%(\\time))
+      bars[2].should     include(%(\\time 1/4))
+    end
+
+    it 'includes beat structure changes per bar' do
+      generator = [
+        bar(beat_structure: [3, 2]),
+        bar(beat_structure: [3, 2]),
+        bar(beat_structure: [2, 3]),
+      ]
+      bars = output(generator, bars: 3).split('|')
+      bars[0].should     include(%(\\set Staff.beatStructure = #'(3 2)))
+      bars[1].should_not include(%(\\set Staff.beatStructure))
+      bars[2].should     include(%(\\set Staff.beatStructure = #'(2 3)))
+    end
+
+    it 'does not include beat structure if none provided' do
+      generator = [
+        bar(beat_structure: [3, 2]),
+        bar(beat_structure: nil)
+      ]
+      bars = output(generator, bars: 2).split('|')
+      bars[0].should     include(%(\\set Staff.beatStructure = #'(3 2)))
+      bars[1].should_not include(%(\\set Staff.beatStructure))
+    end
+
+    it 'includes a final double bar line' do
+      output([bar]).should include(' \\bar "|."')
+    end
+
+    it "includes the final bar's title as the document title" do
+      lilypond = output([
+        bar(title: 'Wrong'),
+        bar(title: 'Hello'),
+      ], bars: 2)
+      lilypond.should     include(%(title = "Hello"))
+      lilypond.should_not include("Wrong")
+    end
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: roborabb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Xavier Shay
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156657040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156657040
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2156656460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156656460
+description: Algorithmically generate practice drum scores
+email:
+- hello@xaviershay.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- spec/acceptance_spec.rb
+- spec/unit_spec.rb
+- lib/roborabb/bar.rb
+- lib/roborabb/builder.rb
+- lib/roborabb/core_ext.rb
+- lib/roborabb/lilypond.rb
+- lib/roborabb/version.rb
+- lib/roborabb.rb
+- README.md
+- HISTORY.md
+- Rakefile
+- roborabb.gemspec
+homepage: http://github.com/xaviershay/roborabb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Algorithmically generate practice drum scores. Customize algorithms with
+  ruby with an archaeopteryx-inspired style, output to lilypond format.
+test_files:
+- spec/acceptance_spec.rb
+- spec/unit_spec.rb