transmuter 0.0.0.1 → 0.0.1

data/spec/transmuter/cli/thor_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe CLI do
+  describe "Thor" do
+    before(:all) do
+      @valid_initialize_options = ['README.md']
+    end
+
+    subject { CLI::Runner.new(@valid_initialize_options) }
+
+    describe "Thor group definition" do
+      subject { CLI::Runner }
+      it { should respond_to(:desc) }
+      it { should respond_to(:class_option) }
+      it { should respond_to(:argument) }
+      its (:desc) { should_not be_empty }
+      its (:arguments) { should_not be_empty }
+    end
+
+    describe "input" do
+      it "should have an arguments :input defined" do
+        CLI::Runner.arguments.any? { |arg| arg.name == 'input' }.should be_true
+      end
+
+      it "should be required" do
+        -> { CLI::Runner.new }.should raise_error Thor::RequiredArgumentMissingError,
+          "No value provided for required arguments 'input'"
+      end
+
+      it { should respond_to(:set_input_filename) }
+
+      it "should set @input_filename" do
+        subject.set_input_filename
+        subject.instance_variable_get('@input_filename').should == 'README.md'
+      end
+    end
+
+    describe "input format" do
+      it "should have a class_option input_format defined" do
+        CLI::Runner.class_options.should have_key(:input_format)
+      end
+
+      it "should not be required" do
+        -> { CLI::Runner.new @valid_initialize_options }.should_not
+          raise_error Thor::RequiredArgumentMissingError
+      end
+
+      it { should respond_to(:set_input_fileformat) }
+
+      it "should set @input_fileformat with --input_format" do
+        cli = CLI::Runner.new @valid_initialize_options, input_format: 'format1'
+        cli.set_input_fileformat
+        cli.instance_variable_get('@input_fileformat').should == "format1"
+      end
+
+      it "should be markdown if the input file extensions is .md" do
+        cli = CLI::Runner.new ['README.md']
+        cli.set_input_fileformat
+        cli.instance_variable_get('@input_fileformat').should == "markdown"
+      end
+
+      it "should be markdown if the input file extensions is .markdown" do
+        cli = CLI::Runner.new ['README.markdown']
+        cli.set_input_fileformat
+        cli.instance_variable_get('@input_fileformat').should == "markdown"
+      end
+
+      it "should be html if the input file extensions is .htm" do
+        cli = CLI::Runner.new ['README.htm']
+        cli.set_input_fileformat
+        cli.instance_variable_get('@input_fileformat').should == "html"
+      end
+
+      it "should be html if the input file extensions is .html" do
+        cli = CLI::Runner.new ['README.html']
+        cli.set_input_fileformat
+        cli.instance_variable_get('@input_fileformat').should == "html"
+      end
+    end
+
+    describe "output format" do
+
+      it "should have a class_option output_format defined" do
+        CLI::Runner.class_options.should have_key(:output_format)
+      end
+
+      it "should not be required" do
+        -> { CLI::Runner.new @valid_initialize_options }.should_not
+          raise_error Thor::RequiredArgumentMissingError
+      end
+
+      it { should respond_to(:set_output_fileformat) }
+
+      it "should set @output_fileformat with --output_format" do
+        cli = CLI::Runner.new @valid_initialize_options, output_format: 'format1'
+        cli.set_output_fileformat
+        cli.instance_variable_get('@output_fileformat').should == "format1"
+      end
+
+      it "should default to pdf" do
+        subject.set_output_fileformat
+        subject.instance_variable_get('@output_fileformat').should == "pdf"
+      end
+    end
+
+    describe "output" do
+      before(:each) do
+        subject.set_input_filename
+        subject.set_input_fileformat
+        subject.set_output_fileformat
+      end
+
+      it "should have an arguments :input defined" do
+        CLI::Runner.arguments.any? { |arg| arg.name == 'output' }.should be_true
+      end
+
+      it "should not be required" do
+        -> { CLI::Runner.new @valid_initialize_options }.should_not
+          raise_error Thor::RequiredArgumentMissingError
+      end
+
+      it { should respond_to(:set_output_filename) }
+
+      it "should raise an exception of both output_format and output are empty" do
+        cli = CLI::Runner.new @valid_initialize_options, output_format: ''
+        cli.set_input_filename
+        cli.set_input_fileformat
+        cli.set_output_fileformat
+
+        -> { cli.set_output_filename }.should raise_error ArgumentError,
+          "Either output or output_format should be given,"
+      end
+
+      it "should set @output_filename" do
+        subject.set_output_filename
+        subject.instance_variable_get('@output_filename').should == 'README.pdf'
+      end
+    end
+
+    describe "stylesheets" do
+
+      it "should have a class_option stylesheets defined" do
+        CLI::Runner.class_options.should have_key(:stylesheets)
+      end
+
+      it "should not be required" do
+        -> { CLI::Runner.new @valid_initialize_options }.should_not
+          raise_error Thor::RequiredArgumentMissingError
+      end
+
+      it { should respond_to(:set_stylesheets) }
+
+      it "should set @stylesheets with --stylesheets" do
+        cli = CLI::Runner.new @valid_initialize_options, stylesheets: 'stylesheets/test.css'
+        cli.set_stylesheets
+        cli.instance_variable_get('@stylesheets').should == 'stylesheets/test.css'
+      end
+
+      it "should default to [#{ROOT_PATH}/stylesheets/default.css]" do
+        subject.set_stylesheets
+        subject.instance_variable_get('@stylesheets').should == ["#{ROOT_PATH}/stylesheets/default.css"]
+      end
+    end
+
+    describe "#start" do
+      it "should call transmute" do
+        CLI::Runner.any_instance.expects(:transmute).returns(true).at_least(1)
+        CLI::Runner.any_instance.expects(:transmute!).returns(true).at_least(1)
+
+        CLI::Runner.start ["README.md"]
+      end
+    end
+
+  end
+end

data/spec/transmuter/cli/transmute_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'pdfkit'
+
+describe CLI do
+  describe "Transmute" do
+
+    let(:markdown_h1) { '# Heading 1' }
+    let(:html_h1) { '<h1>Heading 1</h1>' }
+
+    before(:all) do
+      @valid_arguments = ['README.md']
+      @valid_html_options = { output_format: 'html' }
+      @valid_pdf_options = { output_format: 'pdf' }
+      @valid_html_start_args = begin
+        @valid_arguments + begin
+          @valid_html_options.collect do |k, v|
+            "--#{k.to_s.gsub(/_/, '-')}=#{v}"
+          end
+        end
+      end
+      @valid_pdf_start_args = begin
+        @valid_arguments + begin
+          @valid_pdf_options.collect do |k, v|
+            "--#{k.to_s.gsub(/_/, '-')}=#{v}"
+          end
+        end
+      end
+    end
+
+    subject { CLI::Runner.new(@valid_arguments, @valid_html_options) }
+
+    before(:each) do
+      File.stubs(:read).with('README.md').returns(markdown_h1)
+      File.stubs(:read).with(::Transmuter::CLI::Runner::DEFAULT_THEME).returns('h1 { color: #000; }')
+      File.any_instance.stubs(:write).returns(true)
+    end
+
+    describe "Definitions" do
+      it { should respond_to(:transmute) }
+      it { should respond_to(:transmute!) }
+    end
+
+    describe "#transmute!" do
+      describe "Errors" do
+        it "should raise a NameError exception if input is invalid" do
+          subject.instance_variable_set("@input_fileformat", 'Invalid')
+          -> { subject.transmute! }.should raise_error NameError
+        end
+
+        it "should raise a NameError exception if output is invalid" do
+          subject.instance_variable_set("@output_fileformat", 'Invalid')
+          -> { subject.transmute! }.should raise_error NameError
+        end
+
+        it "should raise an NotImplementedError if we don't know how to transmute from input to output" do
+          subject.instance_variable_set("@output_fileformat", "invalid")
+          subject.instance_variable_set("@destination_klass", "set to bypass errors")
+          -> { subject.transmute! }.should raise_error NotImplementedError
+        end
+
+        it "should raise an NotImplementedError if we don't know how to process output" do
+          not_output = Class.new
+          subject.instance_variable_set("@output_fileformat", "invalid")
+          subject.instance_variable_set("@destination_klass", not_output)
+          -> { subject.transmute! }.should raise_error NotImplementedError
+        end
+      end
+
+      describe "Transmuting from markdown to HTML" do
+        it "should invoke #transmute!" do
+          CLI::Runner.any_instance.expects(:transmute!).at_least(1)
+
+          CLI::Runner.start @valid_html_start_args
+        end
+
+        it "should read the source file" do
+          File.expects(:read).with('README.md').returns(markdown_h1).once
+
+          CLI::Runner.start @valid_html_start_args
+        end
+
+        it "should write the source file" do
+          File.any_instance.expects(:write).once
+
+          CLI::Runner.start @valid_html_start_args
+        end
+
+      end
+
+      describe "Transmuting from markdown to PDF" do
+        before(:each) do
+          pdfkit_instance = mock()
+          pdfkit_instance.stubs(:to_pdf).returns true
+          PDFKit.stubs(:new).returns(pdfkit_instance)
+        end
+
+        it "should invoke #transmute!" do
+          CLI::Runner.any_instance.expects(:transmute!).at_least(1)
+
+          CLI::Runner.start @valid_pdf_start_args
+        end
+
+        it "should read the source file" do
+          File.expects(:read).with('README.md').returns(markdown_h1).once
+
+          CLI::Runner.start @valid_pdf_start_args
+        end
+
+        it "should write the source file" do
+          File.any_instance.expects(:write).once
+
+          CLI::Runner.start @valid_pdf_start_args
+        end
+
+      end
+
+      describe "stylesheets" do
+        it "should set a default stylesheets" # do
+         #          Format::Markdown.any_instance.expects(:parse_options).
+         #            with(stylesheets: "#{ROOT_PATH}/stylesheets/default.css")
+         #
+         #          CLI::Runner.start @valid_html_start_args
+         #        end
+      end
+    end
+
+    describe "#transmute" do
+      describe "Errors" do
+        it "should not raise a NameError exception" do
+          cli = subject.dup
+          cli.instance_variable_set("@input_fileformat", 'Invalid')
+          -> { cli.transmute }.should_not raise_error NameError
+        end
+      end
+    end
+
+  end
+end

data/spec/transmuter/cli_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe CLI do
+end

data/spec/transmuter/format/html_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+module Format
+  describe Html do
+    let(:html_h1) { '<h1>Heading 1</h1>' }
+    let(:html_ruby) { %(<pre lang=\"ruby\"><code>def say_hi\n  &quot;Hello, world!&quot;\nend\n</code></pre>\n) }
+
+    subject { Html.new(html_h1, stylesheets: "/path/to/file.css") }
+
+    before(:each) do
+      File.stubs(:read).with('/path/to/file.css').returns('h1 { color: #000; }')
+    end
+
+    describe "#new" do
+      it "should require html" do
+        -> { Html.new }.should raise_error ArgumentError, "wrong number of arguments (0 for 1)"
+      end
+
+      it "should set @html" do
+        h = Html.new(html_h1)
+        h.instance_variable_get("@html").should == html_h1
+      end
+    end
+
+    describe "#parse_options" do
+      it "should have parse_options as a protected method" do
+        Html.protected_instance_methods.should include(:parse_options)
+      end
+
+      it "should set @options" do
+        subject.instance_variable_get('@options').should_not be_empty
+      end
+    end
+
+    describe "#read_stylesheet_files" do
+      describe "as an Array" do
+        it "should have read_stylesheet_files as a protected method" do
+          Html.protected_instance_methods.should include(:read_stylesheet_files)
+        end
+
+        it "should reads the stylesheets from the specified files" do
+          File.expects(:read).with('/path/to/file.css').once
+          subject.send :read_stylesheet_files
+        end
+      end
+
+      describe "as a String" do
+        it "should have read_stylesheet_files as a protected method" do
+          Html.protected_instance_methods.should include(:read_stylesheet_files)
+        end
+
+        it "should reads the stylesheets from the specified files" do
+          File.expects(:read).with('/path/to/file.css').once
+          subject.send :read_stylesheet_files
+        end
+      end
+    end
+
+    describe "#include_inline_stylesheets" do
+      it "should render html with stylsheets" do
+        require 'nokogiri'
+        html = "<html><body>#{html_h1}</body></html>"
+        styled_html = subject.send(:include_inline_stylesheets, html)
+
+        doc = Nokogiri::HTML(styled_html)
+        doc.search('/html/head').size.should == 1
+
+        styled_html.should
+          match(%r(<html>[^<head>]*<head><style [^>]*>h1 { color: #000; }.*</style>.*</head>[^<head>]*<body>)m)
+      end
+
+      it "should render html with stylsheets even if there's already head" do
+        require 'nokogiri'
+        html = %(<html><head><link rel="stylesheet" href="styles.css" type="text/css" /></head><body>#{html_h1}</body></html>)
+        styled_html = subject.send(:include_inline_stylesheets, html)
+
+        doc = Nokogiri::HTML(styled_html)
+        doc.search('/html/head').size.should == 1
+
+        styled_html.should
+          match(%r(<html>[^<head>]*<head><style [^>]*>h1 { color: #000; }.*</style>.*</head>[^<head>]*<body>)m)
+      end
+    end
+
+    describe "#syntax_highlighter" do
+      it "should have syntax_highlighter as a protected method" do
+        Html.protected_instance_methods.should include(:syntax_highlighter)
+      end
+
+      it "should call Nokogiri::HTML" do
+        nokogiri_document = mock()
+        nokogiri_document.stubs(:search).returns([])
+        Nokogiri.expects(:HTML).with(html_h1).once.returns(nokogiri_document)
+
+        subject.send :syntax_highlighter
+      end
+
+      it "should call Albino.colorize" do
+        pre = mock
+        pre.stubs(:text).returns("some html")
+        pre.stubs(:[]).with(:lang).returns(:ruby)
+        pre.stubs(:replace).returns(true)
+        nokogiri_document = mock()
+        nokogiri_document.stubs(:search).returns([pre])
+        Nokogiri.expects(:HTML).with(html_h1).once.returns(nokogiri_document)
+
+        Albino.expects(:colorize).once.returns("")
+        subject.send(:syntax_highlighter)
+      end
+    end
+
+    describe "#process" do
+      it { should respond_to :process }
+
+      describe "call stack" do
+        it "should call syntax_highlighter" do
+          Html.any_instance.expects(:syntax_highlighter).once.returns(html_h1)
+
+          subject.process
+        end
+
+        it "should call include_inline_stylesheets" do
+          Html.any_instance.expects(:include_inline_stylesheets).once.returns(html_h1)
+
+          subject.process
+        end
+
+      end
+    end
+
+    describe "#to_pdf" do
+      before(:each) do
+        pdfkit_instance = mock()
+        pdfkit_instance.stubs(:to_pdf).returns true
+        PDFKit = mock() unless defined?(PDFKit)
+        PDFKit.stubs(:new).returns(pdfkit_instance)
+      end
+
+      it { should respond_to :to_pdf }
+
+      describe "call stack" do
+        it "should call process" do
+          Html.any_instance.expects(:process).returns(html_h1).once
+
+          subject.to_pdf
+        end
+
+        it "should create a new Pdf object" do
+          pdf = mock
+          pdf.stubs(:process).returns(true)
+          Pdf.expects(:new).returns(pdf).once
+
+          subject.to_pdf
+        end
+      end
+    end
+
+  end
+end

data/spec/transmuter/format/markdown_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+module Format
+  describe Markdown do
+
+    let(:markdown_h1) { '# Heading 1' }
+    let(:html_h1) { '<h1>Heading 1</h1>' }
+    let(:markdown_ruby) { %(```ruby\ndef say_hi\n  "Hello, world!"\nend\n```) }
+    let(:html_ruby) { %(<pre lang=\"ruby\"><code>def say_hi\n  &quot;Hello, world!&quot;\nend\n</code></pre>\n) }
+
+    subject { Markdown.new(markdown_h1, stylesheets: "/path/to/file.css") }
+
+    before(:each) do
+      File.stubs(:read).with('/path/to/file.css').returns('h1 { color: #000; }')
+    end
+
+    describe "REDCARPET_OPTIONS" do
+      it "shoudle have defined REDCARPET_OPTIONS" do
+        Markdown.constants.should include(:REDCARPET_OPTIONS)
+      end
+
+      it "should be equal to [:autolink, :no_intraemphasis, :fenced_code, :gh_blockcode]" do
+        Markdown::REDCARPET_OPTIONS.should == [:autolink, :no_intraemphasis, :fenced_code, :gh_blockcode]
+      end
+    end
+
+    describe "#new" do
+      it "should require markdown" do
+        -> { Markdown.new }.should raise_error ArgumentError, "wrong number of arguments (0 for 1)"
+      end
+
+      it "should set @markdown" do
+        m = Markdown.new(markdown_h1)
+        m.instance_variable_get("@markdown").should == markdown_h1
+      end
+    end
+
+    describe "#parse_options" do
+      it "should have parse_options as a protected method" do
+        Markdown.protected_instance_methods.should include(:parse_options)
+      end
+
+      it "should set @options" do
+        subject.instance_variable_get('@options').should_not be_empty
+      end
+
+      it "should include :redcarpet_options in the options" do
+        redcarpet_options = subject.instance_variable_get('@options')[:redcarpet_options]
+        redcarpet_options.should_not be_empty
+        redcarpet_options.should == Markdown::REDCARPET_OPTIONS
+      end
+    end
+
+    describe "#create_markdown" do
+      it "should have create_markdown as a protected method" do
+        Markdown.protected_instance_methods.should include(:create_markdown)
+      end
+
+      it "should create a new Redcarpet object" do
+        m = subject.send :create_markdown
+        m.should be_instance_of Redcarpet
+      end
+    end
+
+    describe "#parse_markdown" do
+      it "should have parse_markdown as a protected method" do
+        Markdown.protected_instance_methods.should include(:parse_markdown)
+      end
+
+      it "should call create_markdown" do
+        markdown = mock()
+        markdown.stubs(:to_html).returns(true)
+        Markdown.any_instance.expects(:create_markdown).once.returns(markdown)
+
+        subject.send(:parse_markdown)
+      end
+
+      it "should call Redcarpet.to_html" do
+        Redcarpet.any_instance.expects(:to_html).returns(true)
+
+        subject.send(:parse_markdown)
+      end
+
+      it "should render simple markdown" do
+        subject.send(:parse_markdown).should match(%r(#{html_h1}))
+      end
+    end
+
+    describe "#to_html" do
+      describe "call stach" do
+        it "should call parse_markdown" do
+          Markdown.any_instance.expects(:parse_markdown).once.returns(html_h1)
+
+          subject.to_html
+        end
+
+        it "should call process on the Html object" do
+          Html.any_instance.expects(:process).once.returns(html_h1)
+
+          subject.to_html
+        end
+      end
+
+      it { should respond_to :to_html }
+
+      it "should call Redcarpet.to_html" do
+        Redcarpet.any_instance.expects(:to_html).returns(html_h1)
+
+        subject.to_html
+      end
+
+      it "should render simple markdown" do
+        subject.to_html.should match(%r(#{html_h1}))
+      end
+
+      it "should render simple markdown and include stylesheets" do
+        subject.to_html.should
+          match(%r(<html>.*<head>.*<style [^>]*>h1 { color: #000; }.*</style>.*</head>.*<body>.*#{html_h1}.*</body>.*</html>)m)
+      end
+    end
+
+    describe "#to_pdf" do
+      before(:each) do
+        pdfkit_instance = mock()
+        pdfkit_instance.stubs(:to_pdf).returns true
+        PDFKit = mock() unless defined?(PDFKit)
+        PDFKit.stubs(:new).returns(pdfkit_instance)
+      end
+
+      it { should respond_to :to_pdf }
+
+      describe "call stack" do
+
+        it "should call to_html" do
+          Html.any_instance.expects(:process).returns(html_h1).once
+
+          subject.to_pdf
+        end
+
+        it "should create a new Pdf object" do
+          pdf = mock
+          pdf.stubs(:process).returns(true)
+          Pdf.expects(:new).returns(pdf).once
+
+          subject.to_pdf
+        end
+      end
+    end
+  end
+end

data/spec/transmuter/format/pdf_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Format
+  describe Pdf do
+    let(:html_h1) { '<h1>Heading 1</h1>' }
+    let(:html_ruby) { %(<pre lang=\"ruby\"><code>def say_hi\n  &quot;Hello, world!&quot;\nend\n</code></pre>\n) }
+
+    subject { Pdf.new(html_h1, stylesheets: "/path/to/file.css") }
+
+    before(:each) do
+      File.stubs(:read).with('/path/to/file.css').returns('h1 { color: #000; }')
+    end
+
+    describe "#new" do
+      it "should require html" do
+        -> { Pdf.new }.should raise_error ArgumentError, "wrong number of arguments (0 for 1)"
+      end
+
+      it "should set @html" do
+        h = Pdf.new(html_h1)
+        h.instance_variable_get("@html").should == html_h1
+      end
+    end
+
+    describe "#process" do
+      it { should respond_to :process }
+
+      describe "call stack" do
+        it "should create a new PDFKit object" do
+          pdf = mock
+          pdf.stubs(:to_pdf).returns(true)
+          PDFKit.expects(:new).with(html_h1, page_size: 'Letter').returns(pdf).once
+
+          subject.process
+        end
+
+        it "should call to_pdf on the created PDFKit object" do
+          pdf = mock
+          pdf.expects(:to_pdf).returns(true).once
+          PDFKit.expects(:new).with(html_h1, page_size: 'Letter').returns(pdf).once
+
+          subject.process
+        end
+
+      end
+    end
+
+  end
+end

data/spec/transmuter/format_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Format do
+end