guitar_pro_parser 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Alexander Borovykh
+
+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,72 @@
+# GuitarProParser
+
+It is a gem for Ruby that allows to read Guitar Pro files.
+Now it supports Guitar Pro 4 and 5 files. Version 3 should work but is not tested at all.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'guitar_pro_parser'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install guitar_pro_parser
+
+## Usage
+  
+  Require the library:
+
+    require 'guitar_pro_parser'
+
+  Read the file:
+
+    song = GuitarProParser.read_file('path_to_file')
+
+  Now you can access song's properties like that:
+
+    # Get some attributes of the song
+    puts song.title
+    puts song.artist
+    puts song.bpm
+
+    # Or read notes
+    song.tracks.each do |track|
+      track.bars.each do |bar|
+        puts "There are #{bar.voices[:lead].count} beats in lead voice"
+        puts "There are #{bar.voices[:bass].count} beats in bass voice" unless bar.voices[:bass].nil?
+
+        bar.voice[:lead] do |beat|
+          beat.strings.each do |string, note|
+            puts "Play #{string} string on the #{note.fret} fret."
+            puts "Note's duration is #{note.duration}"
+          end
+        end
+      end
+    end
+
+  If you don't need any information about beats, notes and other music stuff you can read headers only:
+
+    song = GuitarProParser.read_headers('path_to_file')
+
+    # You'll have title, subtitle, artist, etc.
+    song.title # => 'Title'
+
+    # But no notes
+    song.tracks.first.bars # => []
+
+  All available methods and attributes could be found in the source code. :)
+  
+  TODO: Write documentation.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/guitar_pro_parser.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'guitar_pro_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "guitar_pro_parser"
+  spec.version       = GuitarProParser::VERSION
+  spec.authors       = ["Alexander Borovykh"]
+  spec.email         = ["immaculate.pine@gmail.com"]
+  spec.description   = %q{Gem for reading Guitar Pro files}
+  spec.summary       = %q{It is a gem that allows to read Guitar Pro files. Now it supports Guitar Pro 4 and 5 files. Version 3 should work but is not tested at all.}
+  spec.homepage      = "https://github.com/ImmaculatePine/guitar_pro_parser"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+end

data/lib/guitar_pro_parser/bar.rb

@@ -0,0 +1,29 @@
+module GuitarProParser
+  
+  # This class represents bars as containers of notes.
+  #
+  # == Attributes
+  #
+  # All attributes are read-only
+  #
+  # * +voices+     (hash)  Voices of this bar.
+  #                        Guitar Pro 5 files has :lead and :bass voices.
+  #                        Guitar Pro 4 and less files has only :lead voice.
+  #
+  #
+  class Bar
+
+    attr_accessor :voices
+
+    def initialize
+      @voices = {lead: [], bass: []}
+    end
+
+    # Returns selected beat of selected voice
+    def get_beat(number, voice = :lead)
+      @voices.fetch(voice).fetch(number)
+    end
+
+  end
+
+end

data/lib/guitar_pro_parser/bar_settings.rb

@@ -0,0 +1,74 @@
+module GuitarProParser
+
+  # This class represents settings of bars (measures).
+  #
+  # == Attributes
+  #
+  # *+new_time_signature+*                  (hash)      Info about new time signature in format 
+  #                                                     { numerator: 4, denominator: 4, beam_eight_notes_by_values: [2, 2, 2, 2] }
+  #                                                     or nil if doesn't present
+  #
+  # * +has_start_of_repeat+                 (boolean)   Is there start of repeat symbol?
+  # * +has_end_of_repeat+                   (boolean)   Is there end of repeat symbol?
+  # * +repeats_count+                       (integer)   Denominator of time signature if @has_end_of_repeat presents  
+  # * +alternate_endings+                   (array)     Contains numbers of all alternate endings in Guitar Pro 5 
+  #                                                     or the largest number of alternate endings in Guitar Pro 4 or less
+  #
+  # * +marker+                              (hash)      Info about marker in format:
+  #                                                     { name: "Marker name", color: [255, 0, 0] }
+  #                                                     or nil if doesn't present
+  #
+  # * +new_key_signature+                   (hash)      Info about new key signature in format:
+  #                                                     { key: 0, scale: :major }
+  #                                                     or nil if doesn't present.
+  #                                                     Key is encoded like this: # TODO: Convert to more readable format
+  #                                                       -2   Bb (bb)
+  #                                                       -1   F  (b)
+  #                                                        0   C
+  #                                                        1   G  (#)
+  #                                                        2   D  (##)
+  #                                                     Scale can be :major or :minor
+  #
+  # * +triplet_feel+                        (symbol)   Can be :no_triplet_feel, :triplet_8th or :triplet_16th
+  # * +double_bar+                          (boolean)  Is this bar double?
+  #
+  class BarSettings
+
+    attr_accessor :new_time_signature,
+                  :has_start_of_repeat,
+                  :has_end_of_repeat,
+                  :repeats_count,
+                  :alternate_endings,
+                  :marker,
+                  :new_key_signature,
+                  :triplet_feel,
+                  :double_bar
+
+    def initialize
+      # Initialize attributes by default values
+      @new_time_signature = nil
+      @has_start_of_repeat = false
+      @has_end_of_repeat = false
+      @repeats_count = 0
+      @alternate_endings = []
+      @marker = nil
+      @new_key_signature = nil
+      @triplet_feel = :no_triplet_feel
+      @double_bar = false
+    end
+
+    def set_new_key_signature(key, scale)
+      @new_key_signature = { key: key, scale: scale }
+    end
+
+    def set_new_time_signature(numerator, denominator, beam_eight_notes_by_values)
+      @new_time_signature = { numerator: numerator, denominator: denominator, beam_eight_notes_by_values: beam_eight_notes_by_values }
+    end
+
+    def set_marker(name, color)
+      @marker = { name: name, color: color }
+    end
+
+  end
+
+end

data/lib/guitar_pro_parser/beat.rb

@@ -0,0 +1,42 @@
+module GuitarProParser
+
+  class Beat
+
+    attr_accessor :dotted,
+                  :mix_table,
+                  :rest,
+                  :duration,
+                  :tuplet,
+                  :chord_diagram,
+                  :text,
+                  :effects,
+                  :strings,
+                  :transpose
+    
+    def initialize
+      # Initialize attributes by default values
+      @dotted = false
+      @mix_table = nil
+      @rest = nil
+      
+      @duration = :eighth
+      @tuplet = nil
+      @chord_diagram = nil
+      @text = nil
+      @effects = {}
+      @strings = {}
+
+      @transpose = nil
+    end
+
+    def has_effect?(effect)
+      @effects.include?(effect)
+    end
+
+    def add_effect(effect)
+      @effects[effect] = nil
+    end
+
+  end
+
+end

data/lib/guitar_pro_parser/channel.rb

@@ -0,0 +1,25 @@
+module GuitarProParser
+
+  class Channel
+
+    attr_accessor :instrument,
+                  :volume,
+                  :pan,
+                  :chorus,
+                  :reverb,
+                  :phaser,
+                  :tremolo
+
+    def initialize
+      @instrument = 0
+      @volume = 13
+      @pan = 8
+      @chorus = 0
+      @reverb = 0
+      @phaser = 0
+      @tremolo = 0
+    end
+
+  end
+
+end

data/lib/guitar_pro_parser/chord_diagram.rb

@@ -0,0 +1,14 @@
+module GuitarProParser
+
+  class ChordDiagram
+    
+    attr_accessor :name, :start_fret, :frets
+
+    def initialize
+      @name = ''
+      @start_fret = 0
+      @frets = []
+    end
+
+  end
+end

data/lib/guitar_pro_parser/guitar_pro_helper.rb

@@ -0,0 +1,73 @@
+module GuitarProHelper
+
+  NOTES = %w(C C# D D# E F F# G G# A A# B)
+  VOICES = [:lead, :bass]
+  FINGERS = [:thumb, :index, :middle, :ring, :pinky]
+  BEND_TYPES = [:none, :bend, :bend_and_release, :bend_release_bend, :prebend, :prebend_and_release,
+                :tremolo_dip, :tremolo_dive, :tremolo_release_up, :tremolo_inverted_dip, :tremolo_return, :tremolo_release_down]
+  BEND_VIBRATO_TYPES = [:none, :fast, :average, :slow]
+  MUSICAL_DIRECTIONS = [:coda, :double_coda, :segno, :segno_segno, :fine, :da_capo,
+                      :da_capo_al_coda, :da_capo_al_double_coda, :da_capo_al_fine,
+                      :da_segno, :da_segno_al_coda, :da_segno_al_double_coda,
+                      :da_segno_al_fine, :da_segno_segno, :da_segno_segno_al_coda,
+                      :da_segno_segno_al_double_coda, :da_segno_segno_al_fine,
+                      :da_coda, :da_double_coda]
+  TRIPLET_FEEL = [:no_triplet_feel, :triplet_8th, :triplet_16th]
+  REST_TYPES = { '0' => :empty_beat, 
+                 '2' => :rest }
+  DURATIONS = { '-2' => :whole,
+                '-1' => :half,
+                 '0' => :quarter,
+                 '1' => :eighth,
+                 '2' => :sixteens,
+                 '3' => :thirty_second,
+                 '4' => :sixty_fourth }
+  STRING_EFFECTS = [:tremolo_bar, :tapping, :slapping, :popping]
+  STROKE_EFFECT_SPEEDS = [:none, 128, 64, 32, 16, 8, 4]
+  STROKE_DIRECTIONS = [:none, :up, :down]
+  NOTE_TYPES = [:normal, :tie, :dead]
+  NOTE_DYNAMICS = %w(ppp pp p mp mf f ff fff)
+  GRACE_NOTE_TRANSITION_TYPES = [:none, :slide, :bend, :hammer]
+  GRACE_NOTE_DURATIONS = { '3' => 16, '2' => 32, '1' => 64 }
+  TREMOLO_PICKING_SPEEDS = { '3' => 32, '2' => 16, '1' => 8 }
+  
+  SLIDE_TYPES = [:no_slide, :shift_slide, :legato_slide, :slide_out_and_downwards, :slide_out_and_upwards, :slide_in_from_below, :slide_in_from_above]
+  MAP_SLIDE_TYPES_GP5 = { '0'=>0, '1'=>1, '2'=>2, '4'=>3, '8'=>4, '16'=>5, '32'=>6 }
+  MAP_SLIDE_TYPES_GP4 = { '-2'=>0, '-1'=>1, '0'=>2, '1'=>3, '2'=>4, '3'=>5, '4'=>6 }
+  
+  HARMONIC_TYPES = [:none, :natural, :artificial, :tapped, :pinch, :semi]
+  TRILL_PERIODS = [4, 8, 16]
+
+  # Macros to create boolean instance variables' getters like this:
+  #   attr_boolean :complete
+  # generates
+  #   complete?
+  # method that returns @complete instance variable
+  def attr_boolean(*variables)
+    variables.each do |variable|
+      define_method("#{variable}?") do
+        instance_variable_get("@#{variable}")
+      end
+    end
+  end
+
+  # Converts note's digit representation to its string equivalent:
+  # 0 for C0, 1 for C#0, etc.
+  def GuitarProHelper.digit_to_note(digit)
+    note_index = 0
+    octave = 0
+    digit.times do |i|
+      note_index = note_index + 1
+      if note_index == NOTES.count
+        note_index = 0
+        octave = octave + 1
+      end
+    end
+
+    "#{NOTES.fetch(note_index)}#{octave.to_s}"
+  end
+
+
+  # TODO: Create helper to convert number of increments of .1dB to float for equalizers
+  
+end

data/lib/guitar_pro_parser/io/input_stream.rb

@@ -0,0 +1,110 @@
+module GuitarProParser
+
+  class InputStream
+
+    INTEGER_LENGTH = 4
+    SHORT_INTEGER_LENGTH = 2
+    BYTE_LENGTH = 1
+
+    attr_accessor :offset
+
+    def initialize file_path
+      @file_path = file_path
+      @offset = 0
+    end
+
+    # Reads unsigned integer (4 bytes)
+    def read_integer
+      value = IO.binread(@file_path, INTEGER_LENGTH, @offset).unpack('i')[0]
+      skip_integer
+      value
+    end
+
+    # Reads signed integer (4 bytes)
+    def read_signed_integer
+      value = IO.binread(@file_path, INTEGER_LENGTH, @offset).unpack('I')[0]
+      skip_integer
+      value
+    end
+
+    # Reads unsigned short integer (2 bytes)
+    def read_short_integer
+      value = IO.binread(@file_path, SHORT_INTEGER_LENGTH, @offset).unpack('S_')[0]
+      skip_short_integer
+      value
+    end
+
+    # Reads signed short integer (2 bytes)
+    def read_signed_short_integer
+      value = IO.binread(@file_path, SHORT_INTEGER_LENGTH, @offset).unpack('s_')[0]
+      skip_short_integer
+      value
+    end
+
+    # Reads unsigned byte (8 bits) (0..255)
+    def read_byte
+      value = IO.binread(@file_path, BYTE_LENGTH, @offset).unpack('C')[0]
+      skip_byte
+      value
+    end
+
+    # Reads signed byte (8 bits) (-127..127)
+    def read_signed_byte
+      value = IO.binread(@file_path, BYTE_LENGTH, @offset).unpack('c')[0]
+      skip_byte
+      value
+    end
+    
+    # Reads signed byte as boolean (8 bit)
+    def read_boolean
+      !read_byte.zero?
+    end
+
+    # Reads string with specified length
+    def read_string(length)
+      value = IO.binread(@file_path, length, @offset)
+      increment_offset(length)
+      value
+    end
+
+    # Reads byte as 8-bit bitmask
+    def read_bitmask
+      bits = []
+      value = read_byte
+      value.to_s(2).each_char { |bit| bits << !bit.to_i.zero? }
+      bits.reverse!
+      bits << false while bits.count < 8
+      bits
+    end
+
+    # Reads data chunk from file.
+    #
+    # Chunk's format is:
+    # 4 bytes - field length (including string length byte that follows this value)
+    # 1 byte  - string length (N)
+    # N bytes - string
+    def read_chunk
+      skip_integer
+      string_length = read_byte
+      read_string string_length
+    end
+
+    def increment_offset delta
+      @offset = @offset + delta
+    end
+
+    def skip_integer
+      increment_offset(INTEGER_LENGTH)
+    end
+
+    def skip_short_integer
+      increment_offset(SHORT_INTEGER_LENGTH)
+    end
+
+    def skip_byte
+      increment_offset(BYTE_LENGTH)
+    end
+
+  end
+  
+end