hammelin 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+.rvmrc
+*.mid
+*.gem
+

data/.rvmrc.example

@@ -0,0 +1,2 @@
+rvm use jruby
+export JRUBY_OPTS=--1.9

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in hammelin.gemspec
+gemspec

data/README.md

@@ -0,0 +1,66 @@
+# Integration Exercise: Java Library Wrapper
+
+# Hammelin 
+
+JFugue (http://www.jfugue.org/index.html) is a Java library that let's developers program a melody through using the basic notes, chords, etc. The music can be saved to a MIDI file, or played just then. 
+
+Hammelin wraps around JFugue functionality to let JRuby users create, play and save MIDIs file using Ruby syntax and some sugar with that. 
+
+# Using Hammelin
+
+Hammelin gaves you easiness of play. Right now, you can use a MusicString 
+to play your own music: 
+
+    Hammelin.play("E5s A5s C6s B5s E5s B5s D6s C6i E6i G#5i E6i | A5s E5s A5s C6s B5s E5s B5s D6s C6i A5i Ri")
+
+You could also work with notes: 
+
+    note = Hammelin::Note.new("E5s")
+
+And then just play it
+
+    note.play
+
+Hammelin also allows you to play with ranges:
+
+    note = Hammelin::Note.new("C")
+    note.upto("E5s").play
+
+If wanted, you also have access to each note of the range:
+
+    note.upto("E5s").each do {|note| note.play }
+    note.upto("E5s").each do {|note| note.increase_octave }
+
+
+Now go and make some interesting tunes :)
+
+    Hammelin.compose do
+
+      note = Hammelin::Note.new("C")
+      tune = note.upto("D#")
+
+      2.times do 
+        play tune
+        play tune.reverse
+
+        2.times do 
+           play tune
+           play tune.increase_octave
+           play tune.increase_octave(2)
+        end
+
+      end
+
+    end
+
+## Saving your work
+
+Just send a filename to the compose method:
+
+    Hammelin.compose("file.mid") do
+
+### Running on GNU/Linux? 
+
+There was a reported bug when a missing library wasn't found by the Java VM. The file (libpuse-java.so) should be on 
+
+    /usr/lib/jvm/java-6-openjdk/jre/lib/i386

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/demos/nested_play.rb

@@ -0,0 +1,20 @@
+require_relative '../lib/hammelin'
+
+Hammelin.compose("file.mid") do
+
+  note = Hammelin::Note.new("C")
+  tune = note.upto("D#")
+
+  2.times do 
+    play tune
+    play tune.reverse
+
+    2.times do 
+      play tune
+      play tune.increase_octave
+      play tune.increase_octave(2)
+    end
+
+  end
+
+end

data/hammelin.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hammelin/version"
+
+Gem::Specification.new do |s|
+  s.name        = "hammelin"
+  s.version     = Hammelin::VERSION
+  s.authors     = ["Alvaro Pereyra"]
+  s.email       = "alvaro@xendacentral.com"
+  s.homepage    = ""
+  s.summary     = %q{Hammelin allows you to play around with JFugue MIDI capabilities}
+  s.description = %q{Hammelin wraps around JFugue and lets your play with notes, making Ruby sing}
+
+  s.rubyforge_project = "hammelin"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  # s.executables   = []
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/hammelin.rb

@@ -0,0 +1,3 @@
+require_relative 'hammelin/hammelin'
+require_relative 'hammelin/note'
+require_relative 'hammelin/notes_range'

data/lib/hammelin/hammelin.rb

@@ -0,0 +1,70 @@
+require 'java'
+
+require_relative '../../bin/jfugue-4.0.3.jar'
+
+java_import org.jfugue.Player
+java_import org.jfugue.Pattern
+java_import org.jfugue.Rhythm
+java_import org.jfugue.MusicStringParser
+
+module Hammelin
+
+  extend self
+
+  PADDING = " "
+  @logged_music_string = ""
+
+  def play(tune)
+    if playable_tune?(tune)
+      play_tune(tune)
+    else
+      play_string(tune)
+     end
+  end
+
+  def play_string(tune)
+    player.play(tune)
+    add_to_log(tune)
+    player.close
+  end
+
+  def playable_tune?(tune)
+    return true if tune.respond_to? :play
+    return true if tune.is_a?(Array) ? playable_tune?(tune.first) : false
+  end
+
+  def play_tune(tune)
+    if tune.respond_to? :play
+      tune.play
+    else
+      tune.each(&:play) if playable_tune?(tune.first)
+    end
+  end
+
+  def compose(filename=nil,&block)
+    instance_eval &block
+    save_to_file(filename) if filename
+  ensure
+    player.close
+  end
+
+  private
+
+  def add_to_log(tune)
+    logged_music_string << tune + PADDING
+  end
+
+  def logged_music_string
+    @logged_music_string
+  end
+
+  def save_to_file(filename)
+    file = java.io.File.new(filename)
+    player.save_midi(logged_music_string,file)
+  end
+
+  def player
+    @player ||= Player.new
+  end
+
+end

data/lib/hammelin/note.rb

@@ -0,0 +1,84 @@
+module Hammelin
+
+  class Note
+    
+    include Comparable
+    attr_accessor :token
+
+    OCTAVE_JUMP = 12
+    MAX_VALUE = 127
+    CAPPED_VALUE = MAX_VALUE - OCTAVE_JUMP
+    
+    def initialize(note)
+      self.token = note
+    end
+
+    def play
+      Hammelin.play(music_string)
+    end
+
+    def upto(note)
+      NotesRange.new(self,Note.new(note))
+    end
+
+    def downto(note)
+      NotesRange.new(Note.new(note),self)
+    end
+
+    def self.from_value(value)
+      Note.new("[#{value}]")
+    end
+
+    def music_string
+      "[#{parse_value}]"
+    end
+
+    def increase_octave(times)
+      Note.from_value(higher_octave(times))
+    end
+
+    def decrease_octave(times)
+      Note.from_value(lower_octave(times))
+    end
+
+    def increase_octave!(times)
+      self.token = increase_octaves(times).value
+    end
+
+    def decrease_octave!(times)
+      self.token = decrease_octaves(times).value
+    end
+
+    def value
+      parse_value
+    end
+
+    def <=>(other)
+      self.value <=> other.value
+    end
+
+    private
+
+    def parse_value
+      MusicStringParser.get_note(self.token).get_value
+    end
+
+    def higher_octave(times=1)
+      OCTAVE_JUMP*times + self.value unless highest_octave?
+    end
+
+    def lower_octave(times=1)
+      OCTAVE_JUMP*times + self.value unless lowest_octave?
+    end
+
+    def highest_octave?
+      self.value >= CAPPED_VALUE
+    end
+
+    def lowest_octave?
+      self.value <= OCTAVE_JUMP
+    end
+
+  end
+  
+end

data/lib/hammelin/notes_range.rb

@@ -0,0 +1,55 @@
+require 'delegate'
+
+module Hammelin
+
+  class NotesRange < DelegateClass(Array)
+
+    def initialize(from,to)
+      @from, @to = from,to
+      super(transverse_notes)
+    end
+
+    def play
+      Hammelin.play music_string
+      self
+    end
+
+    def reverse
+      NotesRange.new(@to,@from)
+    end
+
+    # downto and upto are just some sintactic sugar for expanding the range to 
+    # a new value. It will create a new NotesRange object with the last Note 
+    # and then will figure out how to get to the newest one. 
+    def downto(value)
+      NotesRange.new(@to,value)
+    end
+
+    alias :upto :downto
+
+    def increase_octave(times=1)
+      NotesRange.new(@from.increase_octave(times), @to.increase_octave(times))
+    end
+
+    def decrease_octave(times=1)
+      NotesRange.new(@from.decrease_octave(times), @to.decrease_octave(times))
+    end
+
+    def music_string
+      map{|i| i.music_string }.join(" ")
+    end
+
+    private
+
+    def transverse_notes
+      enum = if @from > @to
+        @from.value.downto(@to.value)
+      else
+        @from.value.upto(@to.value)
+      end
+      enum.map{|value| Note.from_value(value) }
+    end
+
+  end
+
+end

data/lib/hammelin/version.rb

@@ -0,0 +1,3 @@
+module Hammelin
+  VERSION = "0.0.2"
+end

data/reference/Main.java

@@ -0,0 +1,13 @@
+import org.jfugue.*; 
+public class Main 
+{ 
+    public static void main(String[] args) 
+    { 
+        Player player = new Player(); 
+        // Pattern pattern = new Pattern("C D E F G A B"); 
+        Pattern pattern = new Pattern("G B C D E A B"); 
+        
+        player.play(pattern); 
+        System.exit(0); // If using Java 1.4 or lower
+    } 
+} 

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: hammelin
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.2
+platform: ruby
+authors: 
+  - Alvaro Pereyra
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-16 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Hammelin wraps around JFugue and lets your play with notes, making Ruby sing
+email: alvaro@xendacentral.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - .gitignore
+  - .rvmrc.example
+  - Gemfile
+  - README.md
+  - Rakefile
+  - bin/jfugue-4.0.3.jar
+  - demos/nested_play.rb
+  - hammelin.gemspec
+  - lib/hammelin.rb
+  - lib/hammelin/hammelin.rb
+  - lib/hammelin/note.rb
+  - lib/hammelin/notes_range.rb
+  - lib/hammelin/version.rb
+  - reference/Main.class
+  - reference/Main.java
+has_rdoc: true
+homepage: ""
+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: hammelin
+rubygems_version: 1.5.1
+signing_key: 
+specification_version: 3
+summary: Hammelin allows you to play around with JFugue MIDI capabilities
+test_files: []
+