fontcustom 1.0.1 → 1.1.0.pre

data/spec/fontcustom/util_spec.rb

@@ -13,101 +13,347 @@ describe Fontcustom::Util do
   end
 
   context ".collect_options" do
-    it "should return defaults when called without arguments" do
-      options = util.collect_options
-      defaults = Fontcustom::DEFAULT_OPTIONS.dup
-
-      # ignore :templates and :output since they're generated
-      options.delete(:templates)
-      defaults.delete(:templates)
-      options.delete(:output)
-      defaults.delete(:output)
-
-      options.should == defaults
+    it "should raise error if fontcustom.yml isn't valid" do
+      options = { 
+        :project_root => fixture,
+        :input => "shared/vectors",
+        :config => "util/fontcustom-malformed.yml" 
+      }
+      expect { util.collect_options(options) }.to raise_error Fontcustom::Error, /couldn't read your configuration/
     end
 
     it "should overwrite defaults with config file" do
-      options = util.collect_options :config => fixture("fontcustom.yml")
-      options[:font_name].should == "custom-name-from-config"
+      options = { 
+        :project_root => fixture,
+        :input => "shared/vectors",
+        :config => "util/fontcustom.yml" 
+      }
+      options = util.collect_options options
+      options[:font_name].should == "Custom-Name-From-Config"
     end
 
     it "should overwrite config file and defaults with CLI options" do
-      options = util.collect_options :config => fixture("fontcustom.yml"), :font_name => "custom-name-from-cli"
+      options = { 
+        :project_root => fixture,
+        :input => "shared/vectors",
+        :font_name => "custom-name-from-cli",
+        :config => "util/fontcustom.yml" 
+      }
+      options = util.collect_options options
       options[:font_name].should == "custom-name-from-cli"
     end
 
     it "should normalize file name" do
-      options = util.collect_options :font_name => " A_stR4nG3 nAm3  "
-      options[:font_name].should == "a_str4ng3-nam3"
+      options = { 
+        :project_root => fixture,
+        :input => "shared/vectors",
+        :font_name => " A_stR4nG3  nAm3 Ø&  "
+      }
+      options = util.collect_options options
+      options[:font_name].should == "A_stR4nG3--nAm3---"
     end
   end
 
   context ".get_config_path" do
     it "should search for fontcustom.yml if options[:config] is a dir" do
-      options = { :config => fixture("") }
-      util.get_config_path(options).should == fixture("fontcustom.yml")
+      options = { 
+        :project_root => fixture,
+        :config => "util/config-is-in-dir"
+      }
+      util.get_config_path(options).should == fixture("util/config-is-in-dir/fontcustom.yml")
+    end
+
+    it "should use options[:config] if it's a file" do
+      options = { 
+        :project_root => fixture,
+        :config => "util/fontcustom.yml"
+      }
+      util.get_config_path(options).should == fixture("util/fontcustom.yml")
+    end
+
+    it "should find fontcustom.yml in :project_root/config" do
+      options = { :project_root => fixture("util/rails-like") }
+      util.get_config_path(options).should == fixture("util/rails-like/config/fontcustom.yml")
+    end
+
+    it "should follow ../../ paths" do 
+      options = { 
+        :project_root => fixture("shared"),
+        :input => "vectors",
+        :config => "../util"
+      }
+      util.get_config_path(options).should == fixture("util/fontcustom.yml")
+    end
+
+    it "should print out which fontcustom.yml it's using"
+
+    it "should raise error if fontcustom.yml was specified but doesn't exist" do
+      options = { 
+        :project_root => fixture,
+        :input => "shared/vectors",
+        :config => "does-not-exist"
+      }
+      expect { util.get_config_path(options) }.to raise_error Fontcustom::Error, /couldn't find/
+    end
+
+    it "should print a warning if fontcustom.yml was NOT specified and doesn't exist"
+  end
+
+  context ".get_input_paths" do
+    it "should raise error if input[:vectors] doesn't contain vectors" do
+      options = {
+        :project_root => fixture,
+        :input => "shared/vectors-empty"
+      }
+      expect { util.get_input_paths(options) }.to raise_error Fontcustom::Error, /doesn't contain any vectors/
+    end
+
+    it "should follow ../../ paths" do
+      options = { 
+        :project_root => fixture("util"),
+        :input => {:vectors => "../shared/vectors", :templates => "../shared/templates"}
+      }
+      paths = util.get_input_paths(options)
+      paths[:vectors].should eq(fixture("shared/vectors"))
+      paths[:templates].should eq(fixture("shared/templates"))
+    end
+
+    context "when passed a hash" do
+      it "should return a hash of input locations" do
+        options = {
+          :input => { :vectors => "shared/vectors" },
+          :project_root => fixture
+        }
+        paths = util.get_input_paths(options)
+        paths.should have_key("vectors")
+        paths.should have_key("templates")
+      end
+
+      it "should set :templates as :vectors if :templates isn't passed" do
+        options = {
+          :input => { :vectors => "shared/vectors" },
+          :project_root => fixture
+        }
+        paths = util.get_input_paths(options)
+        paths[:vectors].should equal(paths[:templates])
+      end
+
+      it "should preserve :templates if it is passed" do
+        options = {
+          :input => { :vectors => "shared/vectors", :templates => "shared/templates" },
+          :project_root => fixture
+        }
+        paths = util.get_input_paths(options)
+        paths[:templates].should_not equal(paths[:vectors])
+      end
+
+      it "should raise an error if :vectors isn't included" do
+        options = {
+          :input => { :templates => "shared/templates" },
+          :project_root => fixture
+        }
+        expect { util.get_input_paths(options) }.to raise_error Fontcustom::Error, /should be a string or a hash/
+      end
+
+      it "should raise an error if :vectors doesn't point to an existing directory" do
+        options = {
+          :input => { :vectors => "shared/not-a-dir" },
+          :project_root => fixture
+        }
+        expect { util.get_input_paths(options) }.to raise_error Fontcustom::Error, /should be a directory/
+      end
     end
 
-    it "should search use options[:config] if it's a file" do
-      options = { :config => fixture("fontcustom.yml") }
-      util.get_config_path(options).should == fixture("fontcustom.yml")
+    context "when passed a string" do
+      it "should return a hash of input locations" do
+        options = { 
+          :input => "shared/vectors",
+          :project_root => fixture
+        }
+        paths = util.get_input_paths(options)
+        paths.should have_key("vectors")
+        paths.should have_key("templates")
+      end
+
+      it "should set :templates to match :vectors" do
+        options = { 
+          :input => "shared/vectors",
+          :project_root => fixture
+        }
+        paths = util.get_input_paths(options)
+        paths[:vectors].should equal(paths[:templates])
+      end
+
+      it "should raise an error if :vectors doesn't point to a directory" do
+        options = { 
+          :input => "shared/not-a-dir",
+          :project_root => fixture
+        }
+        expect { util.collect_options options }.to raise_error Fontcustom::Error, /should be a directory/
+      end
     end
+  end
 
-    it "should search in input dir if no options[:config] is given" do
-      options = { :input => fixture("") }
-      util.get_config_path(options).should == fixture("fontcustom.yml")
+  context ".get_output_paths" do
+    it "should default to :project_root/:font_name if no output is specified" do
+      options = { :project_root => fixture, :font_name => "test" }
+      paths = util.get_output_paths(options)
+      paths[:fonts].should eq(fixture("test"))
     end
 
-    it "should return false if neither exist" do
-      options = { :input => fixture("vectors") }
-      util.get_config_path(options).should be_false
+    it "should print a warning when defaulting to :project_root/:font_name"
+
+    it "should follow ../../ paths" do
+      options = { 
+        :project_root => fixture("shared"),
+        :input => "vectors",
+        :output => {
+          :fonts => "../output/fonts",
+          :css => "../output/css",
+          :preview => "../output/views"
+        }
+      }
+      paths = util.get_output_paths(options)
+      paths[:fonts].should eq(fixture("output/fonts"))
+      paths[:css].should eq(fixture("output/css"))
+      paths[:preview].should eq(fixture("output/views"))
+    end
+
+    context "when passed a hash" do
+      it "should return a hash of output locations" do 
+        options = {
+          :output => { :fonts => "output/fonts" },
+          :project_root => fixture
+        }
+        paths = util.get_output_paths(options)
+        paths.should have_key("fonts")
+        paths.should have_key("css")
+        paths.should have_key("preview")
+      end
+
+      it "should set :css and :preview to match :fonts if either aren't passed" do
+        options = {
+          :output => { :fonts => "output/fonts" },
+          :project_root => fixture
+        }
+        paths = util.get_output_paths(options)
+        paths[:css].should equal(paths[:fonts])
+        paths[:preview].should equal(paths[:fonts])
+      end
+
+      it "should preserve :css and :preview if they do exist" do
+        options = {
+          :output => { 
+            :fonts => "output/fonts",
+            :css => "output/styles",
+            :preview => "output/preview"
+          },
+          :project_root => fixture
+        }
+        paths = util.get_output_paths(options)
+        paths[:css].should_not equal(paths[:fonts])
+        paths[:preview].should_not equal(paths[:fonts])
+      end
+
+      it "should create additional paths if they are given" do
+        options = {
+          :output => { 
+            :fonts => "output/fonts",
+            "special.js" => "assets/javascripts"
+          },
+          :project_root => fixture
+        }
+        paths = util.get_output_paths(options)
+        paths["special.js"].should eq(File.join(options[:project_root], "assets/javascripts"))
+      end
+      
+      it "should raise an error if :fonts isn't included" do
+        options = {
+          :output => { :css => "output/styles" },
+          :project_root => fixture
+        }
+        expect { util.get_output_paths(options) }.to raise_error Fontcustom::Error, /containing a "fonts" key/
+      end
+    end
+
+    context "when passed a string" do
+      it "should return a hash of output locations" do
+        options = {
+          :output => "output/fonts",
+          :project_root => fixture
+        }
+        paths = util.get_output_paths(options)
+        paths.should have_key("fonts")
+        paths.should have_key("css")
+        paths.should have_key("preview")
+      end
+
+      it "should set :css and :preview to match :fonts" do
+        options = {
+          :output => "output/fonts",
+          :project_root => fixture
+        }
+        paths = util.get_output_paths(options)
+        paths[:css].should equal(paths[:fonts])
+        paths[:preview].should equal(paths[:fonts])
+      end
+
+      it "should raise an error if :fonts exists but isn't a directory" do
+        options = {
+          :output => "shared/not-a-dir",
+          :project_root => fixture
+        }
+        expect { util.get_output_paths(options) }.to raise_error Fontcustom::Error, /directory, not a file/
+      end
     end
   end
 
-  context ".get_template_paths" do
+  context ".get_templates" do
     it "should ensure that 'css' is included with 'preview'" do
       lib = util.gem_lib_path
-      options = { :input => fixture("vectors"), :templates => %W|preview| }
-      templates = util.get_template_paths options
+      options = { :input => fixture("shared/vectors"), :templates => %W|preview| }
+      templates = util.get_templates options
       templates.should =~ [
-        File.join(lib, "templates", "fontcustom.css"), 
+        File.join(lib, "templates", "fontcustom.css"),
         File.join(lib, "templates", "fontcustom-preview.html")
       ]
     end
 
     it "should expand shorthand for packaged templates" do
       lib = util.gem_lib_path
-      options = { :input => fixture("vectors"), :templates => %W|preview css scss bootstrap bootstrap-scss bootstrap-ie7 bootstrap-ie7-scss| }
-      templates = util.get_template_paths options
+      options = { :input => fixture("shared/vectors"), :templates => %W|preview css scss bootstrap bootstrap-scss bootstrap-ie7 bootstrap-ie7-scss| }
+      templates = util.get_templates options
       templates.should =~ [
         File.join(lib, "templates", "fontcustom-preview.html"),
-        File.join(lib, "templates", "fontcustom.css"), 
+        File.join(lib, "templates", "fontcustom.css"),
         File.join(lib, "templates", "_fontcustom.scss"),
-        File.join(lib, "templates", "fontcustom-bootstrap.css"), 
-        File.join(lib, "templates", "_fontcustom-bootstrap.scss"), 
-        File.join(lib, "templates", "fontcustom-bootstrap-ie7.css"), 
-        File.join(lib, "templates", "_fontcustom-bootstrap-ie7.scss") 
+        File.join(lib, "templates", "fontcustom-bootstrap.css"),
+        File.join(lib, "templates", "_fontcustom-bootstrap.scss"),
+        File.join(lib, "templates", "fontcustom-bootstrap-ie7.css"),
+        File.join(lib, "templates", "_fontcustom-bootstrap-ie7.scss")
       ]
     end
 
-    it "should search in Dir.pwd first" do
-      Dir.chdir fixture("")
-      options = { :templates => %W|not-a-dir| }
-      templates = util.get_template_paths options
-      templates.should =~ ["not-a-dir"]
-    end
-
-    it "should search in options[:input] second" do
-      options = { :input => fixture("empty"), :templates => %W|no_vectors_here.txt| }
-      templates = util.get_template_paths options
-      templates.should =~ [fixture("empty/no_vectors_here.txt")]
+    it "should find custom templates in :template_path" do
+      options = { 
+        :project_root => fixture, 
+        :input => { 
+          :vectors => fixture("shared/vectors"), 
+          :templates => fixture("shared/templates") 
+        },
+        :templates => %W|custom.css|
+      }
+      templates = util.get_templates options
+      templates.should eq([ fixture("shared/templates/custom.css") ])
     end
 
     it "should raise an error if a template does not exist" do
-      options = { :input => fixture("vectors"), :templates => %W|css #{fixture("fake-template")}| }
-      expect { util.get_template_paths options }.to raise_error(
-        Fontcustom::Error, /couldn't find.+#{fixture("fake-template")}/
-      )
+      options = {
+        :project_root => fixture,
+        :input => { :templates => "shared/templates" },
+        :templates => %W|css fake-template|
+      }
+      expect { util.get_templates options }.to raise_error Fontcustom::Error, /couldn't find.+fake-template/
     end
   end
 end

data/spec/fontcustom/watcher_spec.rb

@@ -7,7 +7,7 @@ describe Fontcustom::Watcher do
     Fontcustom::Generator::Font.stub :start
     Fontcustom::Generator::Template.stub :start
     opts = Fontcustom::Util.collect_options options
-    opts[:blocking] = false # undocumented — non-blocking use of watcher
+    opts[:blocking] = false # undocumented — non-blocking use of watcher for testing
     Fontcustom::Watcher.new opts
   end
 
@@ -15,7 +15,11 @@ describe Fontcustom::Watcher do
     it "should call generators on init" do
       Fontcustom::Generator::Font.should_receive(:start).once
       Fontcustom::Generator::Template.should_receive(:start).once
-      w = watcher :input => fixture("vectors"), :output => fixture("watcher-test")
+      w = watcher(
+        :project_root => fixture,
+        :input => "shared/vectors",
+        :output => "output"
+      )
       # silence output
       capture(:stdout) do
         w.watch
@@ -26,7 +30,12 @@ describe Fontcustom::Watcher do
     it "should not call generators on init if options[:skip_first] is passed" do
       Fontcustom::Generator::Font.should_not_receive(:start)
       Fontcustom::Generator::Template.should_not_receive(:start)
-      w = watcher :input => fixture("vectors"), :output => fixture("watcher-test"), :skip_first => true
+      w = watcher(
+        :project_root => fixture,
+        :input => "shared/vectors",
+        :output => "output",
+        :skip_first => true
+      )
       capture(:stdout) do
         w.watch
         w.stop
@@ -36,31 +45,68 @@ describe Fontcustom::Watcher do
     it "should call generators when vectors change" do
       Fontcustom::Generator::Font.should_receive(:start).once
       Fontcustom::Generator::Template.should_receive(:start).once
-      w = watcher :input => fixture("vectors"), :output => fixture("watcher-test"), :skip_first => true
+      w = watcher(
+        :project_root => fixture,
+        :input => "shared/vectors",
+        :output => "output",
+        :skip_first => true
+      )
       capture(:stdout) do
         begin
           w.watch
-          FileUtils.cp fixture("vectors/C.svg"), fixture("vectors/test.svg")
-          sleep 2
+          FileUtils.cp fixture("shared/vectors/C.svg"), fixture("shared/vectors/test.svg")
+          sleep 1
         ensure
           w.stop
-          new = fixture("vectors/test.svg")
+          new = fixture("shared/vectors/test.svg")
           FileUtils.rm(new) if File.exists?(new)
         end
       end
     end
 
+    it "should call generators when watched templates change" do
+      Fontcustom::Generator::Font.should_receive(:start).once
+      Fontcustom::Generator::Template.should_receive(:start).once
+      w = watcher(
+        :project_root => fixture,
+        :input => {:vectors => "shared/vectors", :templates => "shared/templates"},
+        :templates => %w|css preview custom.css|,
+        :output => "output",
+        :skip_first => true
+      )
+      capture(:stdout) do
+        begin
+          template = fixture "shared/templates/custom.css"
+          content = File.read template
+          new = content + "\n.bar { color: red; }"
+
+          w.watch
+          File.open(template, "w") { |file| file.write(new) }
+          sleep 1
+        ensure
+          w.stop
+          File.open(template, "w") { |file| file.write(content) }
+        end
+      end
+
+    end
+
     it "should do nothing when non-vectors change" do
       Fontcustom::Generator::Font.should_not_receive(:start)
       Fontcustom::Generator::Template.should_not_receive(:start)
-      w = watcher :input => fixture("vectors"), :output => fixture("watcher-test"), :skip_first => true
+      w = watcher(
+        :project_root => fixture,
+        :input => "shared/vectors",
+        :output => "output",
+        :skip_first => true
+      )
       capture(:stdout) do
         begin
           w.watch
-          FileUtils.touch fixture("vectors/non-vector-file")
+          FileUtils.touch fixture("shared/vectors/non-vector-file")
         ensure
           w.stop
-          new = fixture("vectors/non-vector-file")
+          new = fixture("shared/vectors/non-vector-file")
           FileUtils.rm(new) if File.exists?(new)
         end
       end