chordpro 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8c3a004dac5edc5dabd80b9ee292460013c79cc4
-  data.tar.gz: 9aa3b8f96010c1a14ed487d0ebdf308ba81f8e6d
+SHA256:
+  metadata.gz: e3edc27bf8140ea8f823be328ea4bbb0445c8043bff80bb7a96282bc1620d6fc
+  data.tar.gz: c226e03871b162324c61f852b2b19b90abc7e238a2cb4e3bc8526d28b4388093
 SHA512:
-  metadata.gz: 497c61b56fb5ff17f4fb85621bdb43e1a2d87f5fe15bdaba179ac3e402df71dbdbbc5a00e9c26c611b5a6798faca964a1cde14612aef6cd98aa274a70a611351
-  data.tar.gz: fa3c1f328439bff9d08a798ba297d51a408c203124045a4873fd89c3beadbb374f85846ebd7cd09c1958335c7c8f0598291c8f737a2d5827248897973e499f1c
+  metadata.gz: 5411d453a8a82e400c4b89f4f5f5010d03cb921c426b52957c06d81c3e9bf6129e8f642483bb3274f921232f4cd516cc2d369640479599cea3280b142d5b22a8
+  data.tar.gz: aaa2e883a32b1942c000d2b8db0654a0078a5822ecdf592123566096bb100a67078ab74e71139dad48c6100909f5e43333562c121e1ba2144ca2f9fd1049d88d

data/Gemfile

@@ -1,6 +1,7 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in chordpro.gemspec
 gemspec
 
-gem 'pry'
+gem "pry"
+gem "standardrb"

data/Guardfile

@@ -1,5 +1,5 @@
-guard 'rspec' do
+guard "rspec", cmd: "bundle exec rspec" do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^spec/spec_helper.rb$})    { "spec" }
-  watch(%r{^lib/(.+)\.rb$})           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^spec/spec_helper.rb$}) { "spec" }
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
 end

data/README.md

@@ -1,6 +1,28 @@
 # Chordpro
 
-A ruby parser for the [chordpro](http://tenbyten.com/software/songsgen/help/HtmlHelp/files_reference.htm) song file format.
+A ruby parser for the [chordpro](http://tenbyten.com/software/songsgen/help/HtmlHelp/files_reference.htm) song file format. It converts songs in the chordpro format like this…
+
+```chordpro
+{title: You Are My Sunshine}
+
+{c:Verse 1}
+[G]The other night dear as I lay sleeping
+[G7]I dreamed I [C]held you in my [G]arms
+[G7]But when I a[C]woke dear I was mis[G]taken
+So I hung my [D7]head and [G]cried
+
+{c:Chorus}
+{soc}
+You are my sunshine my only sunshine
+[G7]You make me [C]happy when skies are [G]gray
+[G7]You'll never [C]know dear how much I [G]love you
+Please don't take [D7]my sunshine a[G]way
+{eoc}
+```
+
+…to HTML, which can be styled to look something like this…
+
+![Screenshot of HTML rendering](http://cl.ly/image/1u1j3W1k3J05/content)
 
 ## Installation
 
@@ -19,7 +41,15 @@ Or install it yourself as:
 ## Usage
 
 ```ruby
-html = Chordpro.html(File.read('spec/fixtures/sunshine.crd'))
+contents = File.read('spec/fixtures/sunshine.crd')
+
+# Generate HTML from the chordpro song
+File.write('sunshine.html', Chordpro.html(contents))
+
+# Parse and inspect the chordpro song
+song = Chordpro.parse(contents)
+song.title # => "You Are My Sunshine"
+song.metadata.to_h # => {"title" => "You Are My Sunshine", "key" => "G"}
 ```
 
 ## Contributing

data/Rakefile

@@ -1,6 +1,6 @@
 require "bundler/gem_tasks"
 
-require 'rspec/core/rake_task'
+require "rspec/core/rake_task"
 
 desc "Run all specs"
 RSpec::Core::RakeTask.new(:spec) do |t|
@@ -8,4 +8,4 @@ RSpec::Core::RakeTask.new(:spec) do |t|
   t.verbose = false
 end
 
-task :default => :spec
+task default: :spec

data/chordpro.gemspec

@@ -1,27 +1,27 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'chordpro/version'
+require "chordpro/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "chordpro"
-  spec.version       = Chordpro::VERSION
-  spec.authors       = ["Brandon Keepers"]
-  spec.email         = ["brandon@opensoul.org"]
-  spec.summary       = %q{A ruby parser for the chordpro song file format.}
-  spec.description   = %q{A ruby parser for the chordpro song file format.}
-  spec.homepage      = "https://github.com/bkeepers/chordpro"
-  spec.license       = "MIT"
+  spec.name = "chordpro"
+  spec.version = Chordpro::VERSION
+  spec.authors = ["Brandon Keepers"]
+  spec.email = ["brandon@opensoul.org"]
+  spec.summary = "A ruby parser for the chordpro song file format."
+  spec.description = "A ruby parser for the chordpro song file format."
+  spec.homepage = "https://github.com/bkeepers/chordpro"
+  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.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_dependency 'parslet'
+  spec.add_dependency "parslet"
+  spec.add_dependency "builder"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"
 end

data/lib/chordpro/chord.rb

@@ -0,0 +1,27 @@
+module Chordpro
+  class Chord < Struct.new(:name)
+    SUBSTITUTIONS = {
+      "b" => "♭",
+      "#" => "♯",
+      "aug" => "+",
+      "dim" => "°",
+      "2" => "²",
+      "4" => "⁴",
+      "5" => "⁵",
+      "6" => "⁶",
+      "7" => "⁷",
+      "9" => "⁹",
+      "sus" => "ˢᵘˢ"
+    }
+
+    REGEX = /(#{SUBSTITUTIONS.keys.join('|')})/
+
+    def to_s
+      name.gsub(REGEX) { |match| SUBSTITUTIONS[match] }
+    end
+
+    def accept(visitor)
+      visitor.respond_to?(:chord) ? visitor.chord(self) : self
+    end
+  end
+end

data/lib/chordpro/directive.rb

@@ -0,0 +1,37 @@
+module Chordpro
+  class Directive < Struct.new(:name, :value)
+    class Name
+      attr_reader :aka, :meta
+
+      def initialize(name, aka: nil, meta: false)
+        @name, @aka, @meta = name, aka, meta
+      end
+
+      def to_s
+        @name
+      end
+
+      def ==(other)
+        to_s == other.to_s || (aka && aka == other.to_s)
+      end
+    end
+
+    BY_NAME = {}
+    BY_ALIAS = {}
+
+    def self.register(name, **options)
+      directive = Name.new(name, **options)
+
+      BY_NAME[directive.to_s] = directive
+      BY_ALIAS[directive.aka] = directive if directive.aka
+    end
+
+    def self.find(name)
+      BY_NAME[name.to_s] || BY_ALIAS[name.to_s]
+    end
+
+    def accept(visitor)
+      visitor.respond_to?(name.to_s) ? visitor.send(name.to_s, value) : self
+    end
+  end
+end

data/lib/chordpro/html.rb

@@ -1,49 +1,41 @@
-require 'nokogiri'
+require "builder"
 
 module Chordpro
   class HTML
-    def initialize(tree)
-      @song = tree[:song]
+    def initialize(song)
+      @song = song
+      @html = Builder::XmlMarkup.new
+      @song.accept(self)
     end
 
     def to_s
-      @song.map { |e| elements(e) }.flatten.join("\n")
+      @html.target!
     end
 
-    def elements(element)
-      element.map do |key, value|
-        send key, value
-      end
-    end
-
-    def directive(directive)
-      send directive[:name], directive if respond_to?(directive[:name])
-    end
-
-    def title(directive)
-      %Q|<h1 class="title">#{directive[:value]}</h1>|
+    def title(title)
+      @html.h1(class: "title") { |h1| h1.text! title }
     end
     alias_method :t, :title
 
-    def subtitle(directive)
-      %Q|<h2 class="subtitle">#{directive[:value]}</h2>|
+    def subtitle(subtitle)
+      @html.h2(class: "subtitle") { |h2| h2.text! subtitle }
     end
     alias_method :st, :subtitle
     alias_method :su, :subtitle
 
-    def line(line)
+    def line(line, parts)
       chords = []
       lyrics = []
 
       line.each do |element|
-        if lyric = element[:lyric]
-          lyrics << lyric
-        elsif chord = element[:chord]
+        if element.is_a?(Lyric)
+          lyrics << element
+        elsif element.is_a?(Chord)
           if chords[lyrics.size]
-            chord << chord
+            chords << element
             lyrics << nil
           else
-            chords[lyrics.size] = chord
+            chords[lyrics.size] = element
           end
         end
       end
@@ -51,21 +43,31 @@ module Chordpro
       # ensure chords has same number of cells as lyrics
       chords[lyrics.size - 1] ||= nil if lyrics.size > 0
 
-      %Q|<table><tr class="chords">#{
-        chords.map {|l| "<td>#{l}</td>" }.join
-      }</tr><tr>#{
-        lyrics.map {|l| "<td>#{l}</td>" }.join
-      }</tr></table>|
+      @html.table do |table|
+        if chords.any?
+          table.tr(class: "chords") do |tr|
+            chords.each do |chord|
+              tr.td { |td| td.text! chord.to_s }
+            end
+          end
+        end
+        if lyrics.any?
+          table.tr do |tr|
+            lyrics.each do |lyric|
+              tr.td { |td| td.text! lyric.to_s }
+            end
+          end
+        end
+      end
     end
 
-    def newline(_)
-      '<br>'
+    def linebreak(_)
+      @html.br
     end
 
-    def comment(directive)
-      %|<span class="comment">#{directive[:value]}</span>|
+    def comment(text)
+      @html.span(text, class: "comment")
     end
     alias_method :c, :comment
-
   end
 end

data/lib/chordpro/line.rb

@@ -0,0 +1,18 @@
+module Chordpro
+  class Line < Struct.new(:parts)
+    include Enumerable
+
+    def each(&block)
+      parts.each(&block)
+    end
+
+    def accept(visitor)
+      parts = map { |part| part.accept(visitor) }
+      if visitor.respond_to?(:line)
+        visitor.line(self, parts)
+      else
+        Line.new(parts)
+      end
+    end
+  end
+end

data/lib/chordpro/linebreak.rb

@@ -0,0 +1,11 @@
+module Chordpro
+  class Linebreak
+    def accept(visitor)
+      if visitor.respond_to?(:linebreak)
+        visitor.linebreak(self)
+      else
+        self
+      end
+    end
+  end
+end

data/lib/chordpro/lyric.rb

@@ -0,0 +1,11 @@
+module Chordpro
+  class Lyric < Struct.new(:text)
+    def to_s
+      text
+    end
+
+    def accept(visitor)
+      visitor.respond_to?(:lyric) ? visitor.lyric(self) : self
+    end
+  end
+end

data/lib/chordpro/metadata.rb

@@ -0,0 +1,29 @@
+module Chordpro
+  class Metadata
+    include Enumerable
+
+    def initialize(elements)
+      @elements = elements
+    end
+
+    def directives
+      @elements.lazy.select { |e| e.is_a?(Directive) && e.name.meta }
+    end
+
+    def each(&block)
+      directives.each(&block)
+    end
+
+    def [](key)
+      values = select { |directive| directive.name == key }.map(&:value)
+      values.length > 1 ? values : values[0]
+    end
+
+    def to_h
+      each_with_object({}) do |d, h|
+        key = d.name.to_s
+        h[key] = h.has_key?(key) ? Array(h[key]).push(d.value) : d.value
+      end
+    end
+  end
+end

data/lib/chordpro/parser.rb

@@ -1,26 +1,27 @@
-require 'parslet'
+require "parslet"
 
 module Chordpro
   class Parser < Parslet::Parser
     # Characters
-    rule(:space)    { match('\s').repeat }
-    rule(:colon)    { space >> str(':') >> space }
-    rule(:newline)  { str("\n") }
-    rule(:lbrace)   { str('{') }
-    rule(:rbrace)   { str('}') }
-    rule(:lbracket) { str('[') }
-    rule(:rbracket) { str(']') }
+    rule(:space) { match('\s').repeat }
+    rule(:colon) { space >> str(":") >> space }
+    rule(:newline) { str("\n") }
+    rule(:lbrace) { str("{") }
+    rule(:rbrace) { str("}") }
+    rule(:lbracket) { str("[") }
+    rule(:rbracket) { str("]") }
 
-
-    rule(:identifier) { match['a-z'].repeat(1) }
+    rule(:identifier) { match["a-z"].repeat(1) }
     rule(:value) { (rbrace.absent? >> any).repeat }
 
+    rule(:comment) { str("#") >> (newline.absent? >> any).repeat >> newline.maybe }
+
     rule(:directive) do
       (
         lbrace >> space >>
         identifier.as(:name) >>
         (
-          space >> colon >> space >>
+          colon >>
           value.as(:value)
         ).maybe >>
         rbrace
@@ -28,9 +29,9 @@ module Chordpro
     end
     rule(:chord) { lbracket >> (rbracket.absent? >> any).repeat.as(:chord) >> rbracket }
     rule(:lyric) { (lbracket.absent? >> newline.absent? >> any).repeat(1).as(:lyric) }
-    rule(:line)  { (chord | lyric).repeat(1).as(:line) >> newline.maybe }
+    rule(:line) { (chord | lyric).repeat(1).as(:line) >> newline.maybe }
 
-    rule(:song)  { (directive | newline.as(:newline) | line).repeat.as(:song) }
+    rule(:song) { (comment | directive | newline.as(:linebreak) | line).repeat.as(:song) }
 
     root(:song)
   end

data/lib/chordpro/setup.rb

@@ -0,0 +1,63 @@
+# Register documented directives
+# https://www.chordpro.org/chordpro/chordpro-directives/
+Chordpro::Directive.class_eval do
+  # preamble
+  register "new_song", aka: "ns"
+
+  # metadata
+  register "title", aka: "t", meta: true
+  register "sorttitle", meta: true
+  register "subtitle", aka: "st", meta: true
+  register "artist", meta: true
+  register "composer", meta: true
+  register "lyricist", meta: true
+  register "copyright", meta: true
+  register "album", meta: true
+  register "year", meta: true
+  register "key", meta: true
+  register "time", meta: true
+  register "tempo", meta: true
+  register "duration", meta: true
+  register "capo", meta: true
+  register "meta", meta: true
+
+  # Environment directives
+  %w[chorus verse bridge tab grid].each do |directive|
+    letter = directive[0]
+    register "start_of_#{directive}", aka: "so#{letter}"
+    register "end_of_#{directive}", aka: "eo#{letter}"
+  end
+
+  # Chord diagrams
+  register "define"
+  register "chord"
+  register "transpose"
+
+  register "chordfont", aka: "cf"
+  register "chordsize", aka: "cs"
+  register "chordcolour"
+  register "footerfont"
+  register "footersize"
+  register "footercolour"
+  register "gridfont"
+  register "gridsize"
+  register "gridcolour"
+  register "tabfont"
+  register "tabsize"
+  register "tabcolour"
+  register "tocfont"
+  register "tocsize"
+  register "toccolour"
+  register "textfont", aka: "tf"
+  register "textsize", aka: "ts"
+  register "textcolour"
+  register "titlefont"
+  register "titlesize"
+  register "titlecolour"
+
+  # Output related directives
+  register "new_page", aka: "np"
+  register "new_physical_page", aka: "npp"
+  register "column_break", aka: "cb"
+  register "pagetype"
+end

data/lib/chordpro/song.rb

@@ -0,0 +1,26 @@
+module Chordpro
+  class Song
+    attr_reader :elements, :metadata
+
+    def initialize(elements = [])
+      @elements = elements
+      @metadata = Metadata.new(@elements)
+    end
+
+    def accept(visitor)
+      elements.map { |element| element.accept(visitor) }
+    end
+
+    def method_missing(method, *args)
+      if respond_to_missing?(method)
+        metadata[method]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_all = false)
+      super || !!Directive.find(method)&.meta
+    end
+  end
+end

data/lib/chordpro/transform.rb

@@ -0,0 +1,17 @@
+module Chordpro
+  class Transform < Parslet::Transform
+    rule(directive: {name: simple(:name), value: simple(:value)}) do
+      directive_name = Directive.find(name) || Directive::Name.new(name.to_s)
+      Chordpro::Directive.new(directive_name, value.to_s)
+    end
+    rule(directive: {name: simple(:name)}) do
+      Chordpro::Directive.new(name.to_s)
+    end
+
+    rule(linebreak: simple(:x)) { Chordpro::Linebreak.new }
+    rule(chord: simple(:name)) { Chordpro::Chord.new(name.to_s) }
+    rule(lyric: simple(:text)) { Chordpro::Lyric.new(text.to_s) }
+    rule(line: subtree(:parts)) { Chordpro::Line.new(parts) }
+    rule(song: subtree(:elements)) { Chordpro::Song.new(elements) }
+  end
+end

data/lib/chordpro/version.rb

@@ -1,3 +1,3 @@
 module Chordpro
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/lib/chordpro.rb

@@ -1,9 +1,23 @@
-require "chordpro/version"
-require "chordpro/parser"
+require "chordpro/chord"
+require "chordpro/directive"
 require "chordpro/html"
+require "chordpro/line"
+require "chordpro/linebreak"
+require "chordpro/lyric"
+require "chordpro/metadata"
+require "chordpro/parser"
+require "chordpro/song"
+require "chordpro/transform"
+require "chordpro/version"
+
+require "chordpro/setup"
 
 module Chordpro
+  def self.parse(string)
+    Transform.new.apply(Parser.new.parse(string))
+  end
+
   def self.html(string)
-    HTML.new(Parser.new.parse(string)).to_s
+    HTML.new(parse(string)).to_s
   end
 end

data/spec/chordpro/chord_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Chordpro::Chord do
+  describe "to_s" do
+    {
+      "Bb" => "B♭",
+      "F#m" => "F♯m",
+      "Gaug7" => "G+⁷",
+      "Ddim7" => "D°⁷",
+      "Csus9" => "Cˢᵘˢ⁹",
+      "Asus2" => "Aˢᵘˢ²",
+      "Esus4" => "Eˢᵘˢ⁴",
+      "E5" => "E⁵",
+      "Cm6" => "Cm⁶",
+      "G7" => "G⁷",
+      "Asus9" => "Aˢᵘˢ⁹"
+    }.each do |input, output|
+      it "replaces #{input.inspect} with #{output.inspect}" do
+        expect(Chordpro::Chord.new(input).to_s).to eq(output)
+      end
+    end
+  end
+
+  describe "accept" do
+    let(:chord) { Chordpro::Chord.new("C") }
+    let(:visitor) { double(:visitor) }
+
+    it "calls chord with chord" do
+      expect(visitor).to receive(:chord).with(chord).and_return("result")
+      expect(chord.accept(visitor)).to eq("result")
+    end
+
+    it "does not blow up if object does not respond to chord" do
+      expect(chord.accept(visitor)).to be(chord)
+    end
+  end
+end

data/spec/chordpro/directive_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Chordpro::Directive do
+  describe "accept" do
+    let(:visitor) { double(:visitor) }
+    let(:directive) { Chordpro::Directive.new("title", "The Visitor") }
+
+    it "calls method on visitor" do
+      expect(visitor).to receive(:title).and_return("title")
+      expect(directive.accept(visitor)).to eq("title")
+    end
+
+    it "returns self when visitor does not respond to method" do
+      expect(directive.accept(visitor)).to be(directive)
+    end
+  end
+end
+
+describe Chordpro::Directive::Name do
+  describe "==" do
+    context "with alias" do
+      let(:name) { Chordpro::Directive::Name.new("title", aka: "t") }
+
+      it "equals string matching name" do
+        expect(name).to eq("title")
+      end
+
+      it "equals symbol matching name" do
+        expect(name).to eq(:title)
+      end
+
+      it "equals string matching alias" do
+        expect(name).to eq("t")
+      end
+
+      it "equals symbol matching alias" do
+        expect(name).to eq(:t)
+      end
+
+      it "equals Name matching name" do
+        expect(name).to eq(described_class.new("title"))
+      end
+
+      it "does not equal other string" do
+        expect(name).not_to eq("nope")
+      end
+
+      it "does not equal other Name" do
+        expect(name).not_to eq(described_class.new("comment"))
+      end
+    end
+  end
+end