jekyll-lilypond 0.1.1

data/spec/tag_processor_spec.rb

@@ -0,0 +1,135 @@
+require "jekyll-lilypond"
+require "spec_helper"
+require "tmpdir"
+include Liquid
+
+RSpec.describe(Jekyll::Lilypond::TagProcessor) do
+  let(:site) { double("source" => "/some/directory", "static_files" => []) }
+  let(:tag) { double("Tag", template_names: { source: "NiftyTemplateName", include: nil},
+                            template_code: { source: nil, include: "{{ filename }} abcde" },
+                            attrs: {}) }
+  let(:subject) { described_class.new(site, tag) }
+
+  context "generating source code" do
+    it "creates a Template using the tag data when you ask for a source template" do
+      expect(Jekyll::Lilypond::Template).to receive(:new).with(site, tag, :source)
+      subject.source_template_obj
+    end
+  end
+
+  context "generating include code" do
+    it "creates a Template using the tag data when you ask for an include template" do
+      expect(Jekyll::Lilypond::Template).to receive(:new).with(site, tag, :include)
+      subject.include_template_obj
+    end
+  end
+
+  context "generating filename" do
+    let(:source) { "abcde" }
+    let(:hash) { "ab56b4d92b40713acc5af89985d4b786" }
+
+    it "generates a filename as the hash of the source" do
+      allow(subject).to receive(:source).and_return(source)
+      expect(subject.hash).to eq(hash)
+    end
+    it "makes the filename available to the include template" do
+      allow(subject).to receive(:source).and_return(source)
+      expect(subject.include).to eq("#{hash} abcde")
+    end
+    it "provides the filename to the file processor" do
+      allow(subject).to receive(:source).and_return(source)
+      expect(Jekyll::Lilypond::FileProcessor).to \
+        receive(:new).with("/some/directory/lilypond_files", hash, source)
+      subject.file_processor
+    end
+  end
+
+  context "running" do
+    let(:source) { "abcde" }
+    let(:hash) { "ab56b4d92b40713acc5af89985d4b786" }
+    before do
+      allow(subject).to receive(:source).and_return(source)
+      allow_any_instance_of(Jekyll::Lilypond::FileProcessor).to receive(:write)
+      allow_any_instance_of(Jekyll::Lilypond::FileProcessor).to receive(:compile)
+      allow_any_instance_of(Jekyll::Lilypond::FileProcessor).to receive(:trim_svg)
+    end
+
+    it "calls write" do
+      expect_any_instance_of(Jekyll::Lilypond::FileProcessor).to receive(:write)
+      subject.run!
+    end
+    it "calls compile" do
+      expect_any_instance_of(Jekyll::Lilypond::FileProcessor).to receive(:compile)
+      subject.run!
+    end
+    it "doesn't call trim_svg by default" do
+      expect_any_instance_of(Jekyll::Lilypond::FileProcessor).not_to receive(:trim_svg)
+      subject.run!
+    end
+    it "calls trim_svg if the tag asks it to" do
+      tag.attrs["trim"] = "true"
+      expect_any_instance_of(Jekyll::Lilypond::FileProcessor).to receive(:trim_svg)
+      subject.run!
+    end
+    it "doesn't call make_mp3 by default" do
+      expect_any_instance_of(Jekyll::Lilypond::FileProcessor).not_to receive(:make_mp3)
+      subject.run!
+    end
+    it "calls make_mp3 if the tag asks it to" do
+      tag.attrs["mp3"] = "true"
+      expect_any_instance_of(Jekyll::Lilypond::FileProcessor).to receive(:make_mp3)
+      subject.run!
+    end
+  end
+end
+
+RSpec.describe(Jekyll::Lilypond::TagProcessor) do
+  let(:overrides) { {} }
+  let(:config) do
+    Jekyll.configuration(Jekyll::Utils.deep_merge_hashes({
+      "full_rebuild" => true,
+      "source"       => source_dir,
+      "destination"  => dest_dir,
+      "show_drafts"  => false,
+      "url"          => "http://example.org",
+      "name"         => "My awesome site",
+      "author"       => {
+        "name" => "Dr. Jekyll",
+      },
+      "collections"  => {
+        "my_collection" => { "output" => true },
+        "other_things"  => { "output" => false },
+      },
+    }, overrides))
+  end
+  let(:site)     { Jekyll::Site.new(config) }
+  let(:context)  { make_context(:site => site) }
+  before(:each) do
+    FileUtils.rm_r Dir.glob(dest_dir("*"))
+    site.process
+  end
+  after(:each) do
+    FileUtils.rm_r Dir.glob(source_dir("lilypond_files/*"))
+  end
+
+  context "integration tests" do
+    let(:code_tag) { Jekyll::Lilypond::Tag.new({ "source_template_code" => '\version "2.20.0" { {{ content }} }',
+                                                 "include_template_code" => '<img src="{{ filename }}.svg" />' },
+                                               "a b c d e") }
+    let(:subject) { described_class.new(site, code_tag) }
+    let(:target_hash) { "bfcae429ec31cea750c3ab8167526c7c" }
+    let(:target_include) { '<img src="bfcae429ec31cea750c3ab8167526c7c.svg" />' }
+    let(:target_path) { "#{source_dir}/lilypond_files/bfcae429ec31cea750c3ab8167526c7c.svg" }
+
+    it "Generates the correct hash from a real tag with explicit code" do
+      expect(subject.hash).to eq(target_hash)
+    end
+    it "Produces an SVG file at the expected location in the source tree" do
+      subject.run!
+      expect(File).to exist(target_path)
+    end
+    it "Includes the filename in the include code" do
+      expect(subject.include).to eq(target_include)
+    end
+  end
+end

data/spec/tag_spec.rb

@@ -0,0 +1,51 @@
+require "jekyll-lilypond"
+require "spec_helper"
+include Liquid
+
+RSpec.describe(Jekyll::Lilypond::Tag) do
+  context "initialization" do
+    it "stores attribute values" do
+      t = described_class.new({"foo" => "bar"}, "text")
+      expect(t.attrs["foo"]).to eq("bar")
+    end
+    it "stores content" do
+      t = described_class.new({"foo" => "bar"}, "text")
+      expect(t.attrs["content"]).to eq("text")
+    end
+    it "stores source template addresses separately" do
+      t = described_class.new({"foo" => "bar", "source_template" => "filename.ly"}, "text")
+      expect(t.attrs["source_template"]).to eq(nil)
+    end
+    it "stores source template addresses in template_names" do
+      t = described_class.new({"foo" => "bar", "source_template" => "filename.ly"}, "text")
+      expect(t.template_names[:source]).to eq("filename.ly")
+    end
+    it "stores source template code in template_code" do
+      t = described_class.new({"foo" => "bar", "source_template_code" => "foo"}, "text")
+      expect(t.template_code[:source]).to eq("foo")
+    end
+    it "stores include template addresses separately" do
+      t = described_class.new({"foo" => "bar", "include_template" => "filename.ly"}, "text")
+      expect(t.attrs["include_template"]).to eq(nil)
+    end
+    it "stores include template addresses in template_names" do
+      t = described_class.new({"foo" => "bar", "include_template" => "filename.ly"}, "text")
+      expect(t.template_names[:include]).to eq("filename.ly")
+    end
+    it "stores include template code in template_code" do
+      t = described_class.new({"foo" => "bar", "include_template_code" => "foo"}, "text")
+      expect(t.template_code[:include]).to eq("foo")
+    end
+    it "copes with missing text" do
+      expect { described_class.new({"foo" => "bar"}, "") }.to_not raise_error()
+    end
+    it "creates template_names and template_code even when no values are provided" do
+      t = described_class.new({"foo" => "bar"}, "")
+      expect(t.template_names).to eq({source: nil, include: nil})
+      expect(t.template_code).to eq({source: nil, include: nil})
+    end
+    it "copes with empty attrs" do
+      expect { described_class.new({}, "text") }.to_not raise_error()
+    end
+  end
+end

data/spec/templates_spec.rb

@@ -0,0 +1,175 @@
+require "jekyll-lilypond"
+require "spec_helper"
+include Liquid
+
+long_content =<<-CONTENT 
+thing thing thing
+stuff stuff stuff
+(╯°□°）╯︵ ┻━┻)
+❤️ 💔 💌 💕 💞 💓 💗 💖 💘 💝 💟 💜 💛 💚 💙
+stuff stuff stuff
+thing 
+CONTENT
+
+RSpec.describe(Jekyll::Lilypond::Template) do
+  let(:site) { double("Site", layouts: { "name_a" => layout_a,
+                                         "name_b" => layout_b },
+                              lilypond: double(template_names: 
+                                                 { source: "name_a",
+                                                   include: "name_b" } )) } 
+  let(:site_without_defaults) { double("Site", layouts: { "name_a" => layout_a,
+                                                          "name_b" => layout_b }) }
+  let(:template_a) { "{{ content }}" }
+  let(:template_b) { "{{ content }}{{ a }}{{ b }}" }
+  let(:template_c) { "{{ content }}{{ a }}{{ b }}{{ c }}{{ d }}" }
+  let(:layout_a) { double(content: template_a) }
+  let(:layout_b) { double(content: template_b) }
+  let(:layout_c) { double(content: template_c) }
+
+  context "getting template names" do
+    context "when they are given by the tag" do
+      let(:tag) { double("Tag", attrs: {},
+                         template_code: {source: nil, include: nil },
+                         template_names: { source: "foo", include: "bar" }) }
+      it "returns the given source template name" do
+        subject = described_class.new(site, tag, :source)
+        expect(subject.template_name).to eq("foo")
+      end
+      it "returns the given include template name" do
+        subject = described_class.new(site, tag, :include)
+        expect(subject.template_name).to eq("bar")
+      end
+    end
+    context "when they are not given by the tag" do
+      let(:tag) { double("Tag", attrs: {},
+                         template_code: {source: nil, include: nil },
+                         template_names: { source: nil, include: nil }) }
+      it "returns the sitewide source template name" do
+        subject = described_class.new(site, tag, :source)
+        expect(subject.template_name).to eq("name_a")
+      end
+      it "returns the sitewide include template name" do
+        subject = described_class.new(site, tag, :include)
+        expect(subject.template_name).to eq("name_b")
+      end
+      it "won't error when there is no sitewide template name" do
+        subject = described_class.new(site_without_defaults, tag, :source)
+        expect { subject.template_name }.not_to raise_exception 
+      end
+    end
+    context "when they are not given by the tag or the site" do
+      let(:tag) { double("Tag", attrs: {},
+                         template_code: {source: nil, include: nil },
+                         template_names: { source: nil, include: nil }) }
+      it "returns the pluginwide source template name" do
+        subject = described_class.new(site_without_defaults, tag, :source)
+        expect(subject.template_name).to eq("basic")
+      end
+      it "returns the pluginwide include template name" do
+        subject = described_class.new(site_without_defaults, tag, :include)
+        expect(subject.template_name).to eq("img")
+      end
+    end
+  end
+
+  context "when fetching templates" do
+    context "literal template code" do
+      let(:tag) { double("Tag", attrs: {},
+                         template_names: { source: nil, include: nil },
+                         template_code: { source: "foo", include: "bar" }) }
+      it "is used verbatim for source" do
+        subject = described_class.new(site, tag, :source)
+        expect(subject.template_code).to eq("foo")
+      end
+      it "is used verbatim for includes" do
+        subject = described_class.new(site, tag, :include)
+        expect(subject.template_code).to eq("bar")
+      end
+    end
+    context "a valid template name" do
+      let(:tag) { double("Tag", 
+                         attrs: {},
+                         template_names: { source: "name_a", include: "name_b" },
+                         template_code: { source: nil, include: nil }) }
+      it "loads the corresponding source template" do
+        subject = described_class.new(site, tag, :source)
+        expect(subject.template_code).to eq(template_a)
+      end
+      it "loads the corresponding include template" do
+        subject = described_class.new(site, tag, :include)
+        expect(subject.template_code).to eq(template_b)
+      end
+    end
+    context "a template name that the plugin defines but the site doesn't" do
+      let(:tag) { double("Tag", 
+                         attrs: {},
+                         template_names: { source: "raw", include: "raw" },
+                         template_code: { source: nil, include: nil }) }
+      it "loads the corresponding plugin source template" do
+        subject = described_class.new(site, tag, :source)
+        expect(subject.template_code).to eq("{{ content }}")
+      end
+      it "loads the corresponding plugin include template" do
+        subject = described_class.new(site, tag, :include)
+        expect(subject.template_code).to eq("{{ content }}")
+      end
+    end
+    context "a template name that the plugin and the site both define" do
+      let(:differentsite) { double("Site", layouts: { "raw" => layout_a }) }
+      let(:tag) { double("Tag",
+                         attrs: {},
+                         template_names: { source: "raw", include: "raw" },
+                         template_code: { source: nil, include: nil }) }
+      it "gives the site version of the source template precedence" do
+        subject = described_class.new(differentsite, tag, :source)
+        expect(subject.template_code).to eq(template_a)
+      end
+      it "gives the site version of the include template precedence" do
+        subject = described_class.new(differentsite, tag, :include)
+        expect(subject.template_code).to eq(template_a)
+      end
+    end
+    context "an invalid template name" do
+      let(:tag) { double("Tag",
+                         attrs: {},
+                         template_names: { source: "i_do_not_exist", include: "i_do_not_exist" },
+                         template_code: { source: nil, include: nil }) }
+      it "raises an error when it's a source template name" do
+        subject = described_class.new(site, tag, :source)
+        expect { subject.template_code }.to raise_exception(LoadError)
+      end
+      it "raises an error when it's an include template name" do
+        subject = described_class.new(site, tag, :include)
+        expect { subject.template_code }.to raise_exception(LoadError)
+      end
+    end
+  end
+
+  context "rendering" do
+    let(:tag) { double("Tag", 
+                       attrs: {"content" => "text",
+                               "a" => "1",
+                               "b" => "2"},
+                       template_code: { source: template_a, include: template_b },
+                       template_names: { source: nil, include: nil }) }
+    let(:long_tag) { double("Tag", 
+                       attrs: {"content" => long_content,
+                               "a" => "1",
+                               "b" => "2"},
+                       template_code: { source: template_a, include: template_b },
+                       template_names: { source: nil, include: nil }) }
+    it "renders a template without variables" do
+      subject = described_class.new(site, tag, :source)
+      expect(subject.render(tag)).to eq("text")
+    end
+    it "renders a template with variables" do
+      subject = described_class.new(site, tag, :include)
+      expect(subject.render(tag)).to eq("text12")
+    end
+    it "handles multiline content" do
+      subject = described_class.new(site, long_tag, :include)
+      expect(subject.render(long_tag)).to eq("#{long_content}12")
+    end
+  end
+end
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-lilypond
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Leah Velleman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- files/rite.png
+- jekyll-lilypond.gemspec
+- lib/jekyll-lilypond.rb
+- lib/jekyll-lilypond/file_processor.rb
+- lib/jekyll-lilypond/lilypond_tag.rb
+- lib/jekyll-lilypond/tag.rb
+- lib/jekyll-lilypond/tag_processor.rb
+- lib/jekyll-lilypond/templates.rb
+- lib/jekyll-lilypond/templates/basic.ly
+- lib/jekyll-lilypond/templates/empty.ly
+- lib/jekyll-lilypond/templates/figure.html
+- lib/jekyll-lilypond/templates/img.html
+- lib/jekyll-lilypond/templates/raw.html
+- lib/jekyll-lilypond/templates/raw.ly
+- lib/jekyll-lilypond/templates/showsource.html
+- lib/jekyll-lilypond/version.rb
+- spec/file_processor_spec.rb
+- spec/fixtures/.gitignore
+- spec/fixtures/404.html
+- spec/fixtures/Gemfile
+- spec/fixtures/_config.yml
+- spec/fixtures/_layouts/basic_html.html
+- spec/fixtures/_layouts/vacuous_html.html
+- spec/fixtures/_layouts/vacuous_ly.ly
+- spec/fixtures/_layouts/variables_html.html
+- spec/fixtures/_layouts/variables_ly.ly
+- spec/fixtures/_posts/2021-01-16-welcome-to-jekyll.markdown
+- spec/fixtures/about.markdown
+- spec/fixtures/index.markdown
+- spec/fixtures/page.md
+- spec/integration_spec.rb
+- spec/spec_helper.rb
+- spec/tag_processor_spec.rb
+- spec/tag_spec.rb
+- spec/templates_spec.rb
+homepage: https://www.velleman.org/jekyll-lilypond.html
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://www.velleman.org/jekyll-lilypond.html
+  source_code_uri: https://github.com/leahvelleman/jekyll-lilypond
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Lilypond music snippets in Jekyll
+test_files: []