gitara 0.0.1 → 0.1.0

data/examples/tab-with-bar.rb

@@ -0,0 +1,7 @@
+Gitara.define do
+  bar "Intro" do
+    notes "<g'/1>8 <a/3>8 <g'/1>8 <a/3>16 <g'/1>8 <g/3>16 <e'/1>4 <g/3>8"
+    notes "<f/4>4 <f/4>4 <c/5>4 <e/4>4"
+  end
+end
+

data/examples/tab-with-reused-bar.rb

@@ -0,0 +1,9 @@
+Gitara.define do
+  bar "Intro" do
+    notes "<g'/1>8 <a/3>8 <g'/1>8 <a/3>16 <g'/1>8 <g/3>16 <e'/1>4 <g/3>8"
+    notes "<f/4>4 <f/4>4 <c/5>4 <e/4>4"
+  end
+
+  bar "Intro"
+end
+

data/examples/tab.ly

@@ -0,0 +1,117 @@
+\version "2.12.3"
+\include "english.ly"
+
+%-----------------------------------------------------------------------
+% Bars
+
+vOneBarBeganIt = { \skip 4 <a\3 c'\2 >8 <g\3>8 \skip 4 <g\3 c'\2 >8 <g\3>8 }
+vTwoBarBeganIt = { <f\4>4 <f\4>4 <c\5>4 <e\4>4 }
+
+vOneBarItsNot = { r8 <g'\1>4 <a\3>16 <g'\1>8 <g\3>16 <e'\1>4 <g\3>16( <a\3>16) }
+vTwoBarItsNot = { <f\4>4 <f\4>4 <c\5>4 <e\4>4 }
+
+vOneBarItThough = { r8 <d'\2>16( <c'\2>16) r8 <a\3>16 <c'\2>16 r8 <d'\2>16( <c'\2>16) r8 <a\3>8 }
+vTwoBarItThough = { <f\4>4 <f\4>4 <d\4>4 <d\4>4 }
+
+vOneBarWhatYouThought = { r8 <g'\1>4 <a\3>16 <g'\1>8 <g\3>16 <e'\1>4 <g\3>8 }
+vTwoBarWhatYouThought = { <f\4>4 <f\4>4 <c\5>4 <e\4>4 }
+
+vOneBarWhenYouFirst = { <e'\1>8 <d'\2>16( <c'\2>8) <a\3>8. <c'\2>4 <a\3>8 <c'\2>8 }
+vTwoBarWhenYouFirst = { <a,\5>4 <a,\5>8 <e\4>4 <a,\5>4 \skip 8 }
+
+vOneBarYouGot = { <g'\1>8 <a\3>8 <g'\1>8 <a\3>16 <g'\1>8 <g\3>16 <e'\1>4 <g\3>16( <a\3>16) }
+vTwoBarYouGot = { <f\4>4 <f\4>4 <c\5>4 <e\4>4 }
+
+
+%-----------------------------------------------------------------------
+% Lines
+
+vOneLineVerseOneLineTwo = { \vOneBarYouGot \vOneBarWhatYouThought \vOneBarWhenYouFirst \vOneBarItThough \break }
+vTwoLineVerseOneLineTwo = { \vTwoBarYouGot \vTwoBarWhatYouThought \vTwoBarWhenYouFirst \vTwoBarItThough \break }
+
+vOneLineTabOneScoreEightLineOne = { \vOneBarItsNot \vOneBarWhatYouThought \vOneBarWhenYouFirst \vOneBarBeganIt \break }
+vTwoLineTabOneScoreEightLineOne = { \vTwoBarItsNot \vTwoBarWhatYouThought \vTwoBarWhenYouFirst \vTwoBarBeganIt \break }
+
+
+%-----------------------------------------------------------------------
+% Scores
+
+vOneScoreTabOneScoreEight = { \vOneLineTabOneScoreEightLineOne \vOneLineVerseOneLineTwo }
+vTwoScoreTabOneScoreEight = { \vTwoLineTabOneScoreEightLineOne \vTwoLineVerseOneLineTwo }
+
+
+%-----------------------------------------------------------------------
+% Voices
+
+vOne = { \vOneScoreTabOneScoreEight }
+
+vTwo = { \vTwoScoreTabOneScoreEight }
+
+
+\score {
+  \new StaffGroup <<
+    \new Staff <<
+      \tempo 4 = 75
+      \clef "treble_8"
+
+      \new Voice {
+        \voiceOne
+        \vOne
+      }
+      \new Voice {
+        \voiceTwo
+        \vTwo
+      }
+    >>
+
+    \new TabStaff <<
+      \new TabVoice {
+        \slurUp
+        \vOne
+      }
+      \new TabVoice {
+        \slurUp
+        \vTwo
+      }
+    >>
+  >>
+
+  \layout {
+    \context { \Staff
+      \override TimeSignature #'style = #'numbered
+      \override StringNumber #'transparent = ##t
+    }
+    \context { \TabStaff
+      \override TimeSignature #'style = #'numbered
+    }
+    \context { \Voice
+      \remove Slur_engraver
+    }
+    \context { \TabVoice
+      \remove Dots_engraver
+      \remove Stem_engraver
+      \remove Rest_engraver
+    }
+  }
+}
+
+% showLastLength = R1*4
+\score {
+  \new Staff \with {midiInstrument = #"acoustic guitar (nylon)"} <<
+    \tempo 4 = 75
+    \clef "treble_8"
+
+    \new Voice {
+      \unfoldRepeats {
+        \vOne
+      }
+    }
+    \new Voice {
+      \unfoldRepeats {
+        \vTwo
+      }
+    }
+  >>
+
+  \midi {}
+}

data/examples/tab.rb

@@ -0,0 +1,43 @@
+Gitara.define do
+  bar :BeganIt do
+    notes "/skip 4 <a/3 c'/2 >8 <g/3>8 /skip 4 <g/3 c'/2 >8 <g/3>8"
+    notes "<f/4>4 <f/4>4 <c/5>4 <e/4>4"
+  end
+
+  bar :ItsNot do
+    notes "r8 <g'/1>4 <a/3>16 <g'/1>8 <g/3>16 <e'/1>4 <g/3>16( <a/3>16)"
+    notes "<f/4>4 <f/4>4 <c/5>4 <e/4>4"
+  end
+
+  bar :ItThough do
+    notes "r8 <d'/2>16( <c'/2>16) r8 <a/3>16 <c'/2>16 r8 <d'/2>16( <c'/2>16) r8 <a/3>8"
+    notes "<f/4>4 <f/4>4 <d/4>4 <d/4>4"
+  end
+
+  bar :WhatYouThought do
+    notes "r8 <g'/1>4 <a/3>16 <g'/1>8 <g/3>16 <e'/1>4 <g/3>8"
+    notes "<f/4>4 <f/4>4 <c/5>4 <e/4>4"
+  end
+
+  bar :WhenYouFirst do
+    notes "<e'/1>8 <d'/2>16( <c'/2>8) <a/3>8. <c'/2>4 <a/3>8 <c'/2>8"
+    notes "<a,/5>4 <a,/5>8 <e/4>4 <a,/5>4 /skip 8"
+  end
+
+  bar :YouGot do
+    notes "<g'/1>8 <a/3>8 <g'/1>8 <a/3>16 <g'/1>8 <g/3>16 <e'/1>4 <g/3>16( <a/3>16)"
+    notes "<f/4>4 <f/4>4 <c/5>4 <e/4>4"
+  end
+
+  line :VerseOneLineTwo do
+    bar :YouGot, :WhatYouThought, :WhenYouFirst, :ItThough
+  end
+
+  score do
+    line do
+      bar :ItsNot, :WhatYouThought, :WhenYouFirst, :BeganIt
+    end
+
+    line :VerseOneLineTwo
+  end
+end

data/gitara.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ["George Mendoza"]
   s.email       = ["gsmendoza@gmail.com"]
   s.homepage    = ""
-  s.summary     = "A Ruby DSL for tablatures"
-  s.description = "This will be a work in progress. Ultimately the goal is to have a good basic tablature DSL that is easily convertible to lilypond."
+  s.summary     = "Ruby + Lilypond = pretty guitar tablatures."
+  s.description = "A Ruby DSL for generating Lilypond guitar tablatures."
 
   s.rubyforge_project = "gitara"
 
@@ -18,7 +18,17 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency "active_support"
+  s.add_runtime_dependency "erubis"
+  s.add_runtime_dependency "linguistics"
+  s.add_runtime_dependency "parslet"
+  s.add_runtime_dependency "pow"
+  s.add_runtime_dependency "thor"
+  s.add_runtime_dependency "valuable"
+
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "rb-inotify"
+  s.add_development_dependency "rspec"
 end

data/lib/gitara.rb

@@ -1,5 +1,42 @@
+require "active_support/inflector"
+require "erubis"
+require "linguistics"
+require "parslet"
+require "pow"
+require "thor"
+require "valuable"
+
+require "gitara/app"
+require "gitara/dsl"
+require "gitara/id_as_word"
+require "gitara/node/base"
+require "gitara/node/base/voiced_node"
+require "gitara/node/bar"
+require "gitara/node/bar/voiced_node"
+require "gitara/node/line"
+require "gitara/node/note_set"
+require "gitara/node/score"
+require "gitara/node/tab"
+require "gitara/pow/base"
 require "gitara/version"
+require "gitara/voice"
+
+Linguistics::use :en
 
 module Gitara
-  # Your code goes here...
+  def self.define(&block)
+    @tab = Dsl.new(:node => Node::Tab.new).tap {|dsl|
+      dsl.instance_eval(&block) if block_given?
+    }.node
+  end
+
+  def self.render(path, object)
+    template = (Pow!('gitara/template') / "#{path}.erb")
+    erb = Erubis::Eruby.new(template.read!)
+    erb.evaluate(object)
+  end
+
+  def self.tab
+    @tab
+  end
 end

data/lib/gitara/app.rb

@@ -0,0 +1,29 @@
+module Gitara
+  class App < Thor
+    desc "export PATH [OPTIONS]...", "Export PATH to lilypond and friends."
+
+    method_option "target-directory",
+      :aliases => "-t",
+      :default => '.',
+      :desc => "Export files to TARGET-DIRECTORY",
+      :type => :string
+
+    method_option "run-lilypond",
+      :aliases => "-l",
+      :default => true,
+      :desc => "Run lilypond program after generating lilypond file", :default => true,
+      :type => :boolean
+
+    def export(source_path)
+      load source_path
+      tab = Gitara.tab
+      lilypond_name = Pow(source_path).name(false) + '.ly'
+      lilypond_path = Pow(options['target-directory']) / lilypond_name
+      lilypond_path.write(Gitara.render('tab', tab))
+
+      if options['run-lilypond']
+        `lilypond -o #{lilypond_path.parent / lilypond_path.name(false)} #{lilypond_path}`
+      end
+    end
+  end
+end

data/lib/gitara/dsl.rb

@@ -0,0 +1,35 @@
+module Gitara
+  class Dsl < Valuable
+    has_value :node
+
+    def add(child, &block)
+      self.node.add child
+      Dsl.new(:node => child).instance_eval(&block) if block_given?
+    end
+
+    def add_names(options = {}, &block)
+      names = options[:names].empty? ? [nil] : options[:names]
+      node_class = options[:node_class]
+
+      names.map{|name| node_class.new(:name => name) }.each do |child|
+        add child, &block
+      end
+    end
+
+    def bar(*names, &block)
+      add_names :names => names, :node_class => Node::Bar, &block
+    end
+
+    def line(*names, &block)
+      add_names :names => names, :node_class => Node::Line, &block
+    end
+
+    def notes(value)
+      add Node::NoteSet.new(:value => value)
+    end
+
+    def score(*names, &block)
+      add_names :names => names, :node_class => Node::Score, &block
+    end
+  end
+end

data/lib/gitara/id_as_word.rb

@@ -0,0 +1,8 @@
+module Gitara
+  module IdAsWord
+    def id_as_word
+      id.en.numwords.gsub('-', '_').camelize
+    end
+  end
+end
+

data/lib/gitara/node/bar.rb

@@ -0,0 +1,9 @@
+module Gitara
+  module Node
+    class Bar < Base
+      def note_sets
+        children.select{|child| child.is_a?(Node::NoteSet)}
+      end
+    end
+  end
+end

data/lib/gitara/node/bar/voiced_node.rb

@@ -0,0 +1,13 @@
+module Gitara
+  module Node
+    class Bar
+      class VoicedNode < Base::VoicedNode
+        alias_method :bar, :node
+
+        def matching_note_set
+          bar.note_sets[voice.id - 1]
+        end
+      end
+    end
+  end
+end

data/lib/gitara/node/base.rb

@@ -0,0 +1,82 @@
+module Gitara
+  module Node
+    class Base < Valuable
+      include IdAsWord
+
+      has_value :name
+      has_value :id, :default => 1
+      has_value :parent
+      has_value :value
+
+      def add(child)
+        own_children << child
+        child.id = own_children.size
+        child.parent = self
+      end
+
+      def children
+        if own_children.empty?
+          definition ? definition.own_children : []
+        else
+          own_children
+        end
+      end
+
+      def children=(values)
+        values.each do |child|
+          add child
+        end
+      end
+
+      def definition?
+        ! own_children.empty?
+      end
+
+      def definition_of?(target)
+        self.definition? && self.name == target.name && self.class == target.class
+      end
+
+      def definitions(klass)
+        self.is_a?(klass) && self.definition? ? [self] : self.own_children.map{|child| child.definitions(klass) }.flatten
+      end
+
+      def name
+        attributes[:name] || "#{parent && parent.name}#{self.class.to_s.split('::').last}#{self.id_as_word}"
+      end
+
+      def own_children
+        @children ||= []
+      end
+
+      def root
+        parent.nil? ? self : parent.root
+      end
+
+      def value
+        attributes[:value].gsub('/', "\\")
+      end
+
+      def voiced_as(arg)
+        if arg.is_a?(Voice)
+          self.class::VoicedNode.new(:node => self, :voice => arg)
+        elsif arg.is_a?(Array)
+          arg.map{|voice| self.voiced_as(voice) }
+        else
+          raise ArgumentError
+        end
+      end
+
+      private
+
+        def definition(target = self)
+          if self.definition_of?(target)
+            self
+          else
+            result = parent.own_children.detect{|node| node.definition_of?(target) }
+            result ? result : parent.definition(target)
+          end
+        end
+    end
+  end
+end
+