font_awesome_rails 0.0.1

data/lib/font_awesome/nokogiri.rb

@@ -0,0 +1,17 @@
+module FontAwesome
+  module Nokogiri
+    extend self
+
+    def raise_exception
+      raise LoadError, %{Nokogiri is required to use this feature -- please add "gem 'nokogiri'" to your Gemfile and run "bundle install"}
+    end
+
+    def method_missing(method, *args)
+      raise_exception
+    end
+
+    def const_missing(const)
+      raise_exception
+    end
+  end
+end

data/lib/font_awesome/sass_extensions/functions.rb

@@ -0,0 +1,26 @@
+require 'active_support/concern'
+
+module FontAwesome
+  module SassExtensions
+    module Functions
+      extend ActiveSupport::Concern
+
+      included do
+        declare :icon_image, [:name]
+        declare :icon_image, [:name, :style]
+      end
+
+      def icon_image(name, style=nil)
+        assert_type name, :String
+        icon = Icon.new(name.value)
+
+        unless style.nil?
+          assert_type style, :String
+          icon.style = style.value
+        end
+
+        Sass::Script::String.new icon.to_uri, :string
+      end
+    end
+  end
+end

data/lib/font_awesome/sass_extensions.rb

@@ -0,0 +1,6 @@
+require "sass"
+require "font_awesome/sass_extensions/functions"
+
+module Sass::Script::Functions
+  include FontAwesome::SassExtensions::Functions
+end

data/lib/font_awesome.rb

@@ -0,0 +1,10 @@
+begin
+  require "nokogiri"
+rescue LoadError
+  require "font_awesome/nokogiri"
+end
+
+require "font_awesome/font"
+require "font_awesome/hex_code"
+require "font_awesome/icon"
+require "font_awesome/sass_extensions"

data/lib/font_awesome_rails/engine.rb

@@ -0,0 +1,4 @@
+module FontAwesomeRails
+  class Engine < Rails::Engine
+  end
+end

data/lib/font_awesome_rails/version.rb

@@ -0,0 +1,3 @@
+module FontAwesomeRails
+  VERSION = "0.0.1"
+end

data/lib/font_awesome_rails.rb

@@ -0,0 +1,10 @@
+require "font_awesome_rails/version"
+require "font_awesome_rails/engine" if defined?(Rails)
+
+require "font_awesome"
+
+module FontAwesomeRails
+  def self.root
+    File.expand_path "../..", __FILE__
+  end
+end

data/spec/font_awesome/font_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+describe FontAwesome::Font do
+  subject(:font) { FontAwesome::Font.send :new }
+  before { FontAwesome::Font.stubs(:instance).returns(font) }
+
+  let(:hex_code) { stub("HexCode", to_unicode: "\uf00d") }
+
+  it "should be a singleton" do
+    expect{FontAwesome::Font.new}.to raise_error NoMethodError
+  end
+
+  describe "#svg" do
+    it "loads the webfont" do
+      Nokogiri.expects(:XML).with{|file| file.path == font.send(:path)}.returns(:parsed_xml)
+      font.send(:svg).should == :parsed_xml
+    end
+
+    it "memoizes" do
+      File.expects(:open).once.returns(:parsed_xml)
+      font.send(:svg)
+      font.send(:svg)
+    end
+  end
+
+  describe "#select" do
+    it "finds the first node in the webfont matching the given CSS selector" do
+      font.stubs(:svg).returns(mock{expects(:at_css).with("something")})
+      font.send(:select, "something")
+    end
+  end
+
+  describe "#attribute" do
+    let(:xml) { Nokogiri.XML('<pizza topping="meatlovers" />') }
+
+    before { font.stubs(:svg).returns(xml) }
+
+    context "when the attribute exists" do
+      it "returns its value" do
+        font.send(:attribute, "topping", "pizza").should == "meatlovers"
+      end
+    end
+
+    context "when the attribute does not exist" do
+      it "returns nil" do
+        font.send(:attribute, "base", "pizza").should be_nil
+      end
+    end
+  end
+
+  describe "#glyph" do
+    it "returns a selector for the specified character" do
+      font.send(:glyph, hex_code).should == "glyph[unicode=\uf00d]"
+    end
+  end
+
+  describe "#ascent" do
+    it "returns the ascent height" do
+      font.ascent.should > 0
+    end
+  end
+
+  describe "#descent" do
+    it "returns the descent height" do
+      font.descent.should < 0
+    end
+  end
+
+  describe "#em_size" do
+    it "returns the number of units per em" do
+      font.stubs(:attribute).with("units-per-em", "font-face").returns("2048")
+      font.em_size.should == 2048
+    end
+  end
+
+  describe "#character_width" do
+    before { font.stubs(:attribute).with("horiz-adv-x", "glyph[unicode=\uf00d]").returns(glyph_horiz_adv_x) }
+
+    context "when the glyph has its own horiz-adv-x" do
+      let(:glyph_horiz_adv_x) { "1542" }
+
+      it "returns it" do
+        font.character_width(hex_code).should == 1542
+      end
+    end
+
+    context "when the glyph does not have its own horiz-adv-x" do
+      let(:glyph_horiz_adv_x) { nil }
+
+      it "returns the font's horiz-adv-x" do
+        font.stubs(:attribute).with("horiz-adv-x", "font").returns("1536")
+        font.character_width(hex_code).should == 1536
+      end
+    end
+  end
+
+  describe "#character_outline" do
+    it "returns the glyph's path" do
+      font.stubs(:attribute).with("d", "glyph[unicode=\uf00d]").returns("M0 0z")
+      font.character_outline(hex_code).should == "M0 0z"
+    end
+  end
+end

data/spec/font_awesome/hex_code_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+describe FontAwesome::HexCode do
+  subject(:hex_code) { FontAwesome::HexCode.new(name) }
+  let(:name) { :pizza }
+  before { FontAwesome::HexCode.stubs(:lookup_table).returns({"pizza" => "f00d"}) }
+
+  describe ".new" do
+    it "sets the name" do
+      FontAwesome::HexCode.any_instance.expects(:name=).with(:foo)
+      FontAwesome::HexCode.new(:foo)
+    end
+  end
+
+  describe "#name=" do
+    it "stringifies and dasherizes the name" do
+      ["some-icon", "some_icon", :some_icon].each do |value|
+        hex_code.name = value
+        hex_code.name.should == "some-icon"
+      end
+    end
+  end
+
+  describe "#to_s" do
+    it "looks up the name in the lookup table" do
+      FontAwesome::HexCode.expects(:lookup_table).returns(mock{expects(:[]).with("pizza").returns("f00d")})
+      hex_code.to_s.should == "f00d"
+    end
+  end
+
+  describe "#to_unicode" do
+    it "unicode-escapes the hex code" do
+      hex_code.to_unicode.should == "\uf00d"
+    end
+  end
+
+  describe "#to_css" do
+    it "css-escapes the hex code" do
+      hex_code.to_css.should == '\f00d'
+    end
+  end
+
+  describe "#to_xml" do
+    it "xml-escapes the hex code" do
+      hex_code.to_xml.should == ""
+    end
+  end
+
+  describe ".all" do
+    it "returns an enumerator for the lookup table" do
+      FontAwesome::HexCode.all.to_a.should == FontAwesome::HexCode.lookup_table.each.to_a
+    end
+  end
+
+  describe ".lookup_table" do
+    subject(:lookup_table) { FontAwesome::HexCode.lookup_table }
+
+    before { FontAwesome::HexCode.unstub :lookup_table}
+
+    it { should be_a Hash }
+
+    it "translates icon names to hex codes" do
+      lookup_table["glass"].should == "f000"
+    end
+  end
+end

data/spec/font_awesome/icon_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+describe FontAwesome::Icon do
+  subject { icon }
+  let(:icon) { FontAwesome::Icon.new("pizza") }
+  let(:font) { FontAwesome::Font.instance }
+
+  describe ".new" do
+    it "sets the hex code" do
+      FontAwesome::Icon.new("foo").hex_code.name.should == "foo"
+    end
+
+    it "defaults the style" do
+      FontAwesome::Icon.any_instance.stubs(:default_style).returns("fill:red")
+      FontAwesome::Icon.new("foo").style.should == "fill:red"
+    end
+
+    it "sets the font" do
+      FontAwesome::Icon.new("foo").font.should == font
+    end
+  end
+
+  describe "#to_svg" do
+    subject { to_svg }
+    let(:to_svg) { icon.to_svg }
+    let(:xml) { Nokogiri.XML to_svg }
+
+    before do
+      icon.stubs(:offset_x).returns(256)
+      icon.stubs(:offset_y).returns(1792)
+      icon.stubs(:path).returns("M0 0z")
+      icon.stubs(:style).returns("fill:blue")
+      font.stubs(:em_size).returns(2048)
+    end
+
+    it { should_not include "\n" }
+    it { should_not include "<?xml" }
+
+    it "is valid XML" do
+      xml.should have(0).errors
+    end
+
+    it "contains an SVG image" do
+      xml.root.name.should == "svg"
+    end
+
+    describe "returned SVG image" do
+      subject { svg }
+      let(:svg) { xml.root }
+
+      it "has the correct xml namespace" do
+        svg.namespace.href.should == "http://www.w3.org/2000/svg"
+        svg.namespace.prefix.should be_nil
+      end
+
+      its(["version"]) { should == "1.1" }
+
+      its(["width"]) { should == "100px" }
+      its(["height"]) { should == "100px" }
+      its(["viewBox"]) { should == "-256 -1792 2048 2048" }
+
+      it { should have(1).children }
+
+      describe "path" do
+        subject { path }
+        let(:path) { svg.child }
+
+        its(:name) { should == "path" }
+        its(["d"]) { should == "M0 0z" }
+        its(["style"]) { should == "fill:blue" }
+        its(["transform"]) { should == "rotate(180) scale(-1,1)" }
+      end
+    end
+  end
+
+  describe "#to_uri" do
+    it "returns a data-uri for the SVG image" do
+      icon.expects(:to_svg).returns("a bunch of xml")
+      icon.to_uri.should == "data:image/svg+xml,a%20bunch%20of%20xml"
+    end
+  end
+
+  describe ".all" do
+    it "returns an array of all icons" do
+      FontAwesome::HexCode.stubs(:lookup_table).returns({"pizza" => "f00d", "linux" => "f055"})
+      FontAwesome::Icon.expects(:new).with("pizza").returns(:pizza)
+      FontAwesome::Icon.expects(:new).with("linux").returns(:linux)
+
+      FontAwesome::Icon.all.should == [:pizza, :linux]
+    end
+  end
+end

data/spec/font_awesome/sass_extensions/functions_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe FontAwesome::SassExtensions::Functions do
+  class EvaluationContext
+    def self.declare(*args)
+      declarations << args
+    end
+
+    def self.declarations
+      @declarations ||= []
+    end
+
+    def assert_type(*args)
+    end
+
+    include FontAwesome::SassExtensions::Functions
+  end
+
+  let(:functions) { EvaluationContext.new }
+
+  it "declares icon-image($name)" do
+    EvaluationContext.declarations.should include [:icon_image, [:name]]
+  end
+
+  it "declares icon-image($name, $style)" do
+    EvaluationContext.declarations.should include [:icon_image, [:name, :style]]
+  end
+
+  describe "icon-image($name)" do
+    subject(:icon_image) { functions.icon_image(name) }
+    let(:name) { Sass::Script::String.new("foo") }
+    let(:icon) { stub("Icon", to_uri: "uri") }
+
+    before { FontAwesome::Icon.stubs(:new).with("foo").returns(icon) }
+
+    it "requires that $name be a string" do
+      functions.expects(:assert_type).with(name, :String)
+      icon_image
+    end
+
+    it "returns a data-uri representation of the icon" do
+      icon_image.should == Sass::Script::String.new("uri")
+    end
+  end
+
+  describe "icon-image($name, $style)" do
+    subject(:icon_image) { functions.icon_image(name, style) }
+    let(:name) { Sass::Script::String.new("foo") }
+    let(:style) { Sass::Script::String.new("fill:blue") }
+    let(:icon) { stub("Icon", :style= => nil, to_uri: "uri") }
+
+    before { FontAwesome::Icon.stubs(:new).with("foo").returns(icon) }
+
+    it "requires that $name and $style be strings" do
+      functions.expects(:assert_type).with(name, :String)
+      functions.expects(:assert_type).with(style, :String)
+      icon_image
+    end
+
+    it "sets the icon style" do
+      icon.expects(:style=).with("fill:blue")
+      icon_image
+    end
+
+    it "returns a data-uri representation of the icon" do
+      icon_image.should == Sass::Script::String.new("uri")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require "bundler/setup"
+require "font_awesome_rails"
+
+Dir[File.expand_path("../tasks/**/*.rb", File.dirname(__FILE__))].each {|task| require task }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = "random"
+
+  config.mock_with :mocha
+end

data/spec/tasks/update_classic_sass_task_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe UpdateClassicSassTask do
+  subject(:task) { UpdateClassicSassTask.new }
+
+  describe "#contents" do
+    it "returns the Font Awesome scss" do
+      task.expects(:open_file).with("Font-Awesome/sass/font-awesome.scss").returns("scss code")
+      task.contents.should == "scss code"
+    end
+  end
+
+  describe "#styles" do
+    it "returns the Font Awesome styles excluding the @font-face declaration" do
+      contents = task.contents.lines.to_a
+      styles = task.styles.lines.to_a
+
+      styles.first.should == "/*  Font Awesome styles\n"
+      styles.should == contents.last(styles.length)
+    end
+  end
+
+  describe "#run" do
+    it "copies classic Font Awesome styles" do
+      task.stubs(:puts)
+      task.stubs(:styles).returns("classic styles")
+      task.expects(:open_file).with("vendor/assets/stylesheets/font-awesome/_classic.scss", "w").yields(mock{
+        expects(:write).with("classic styles")
+      })
+      task.run
+    end
+  end
+end

data/spec/tasks/update_hex_codes_task_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe UpdateHexCodesTask do
+  subject(:task) { UpdateHexCodesTask.new }
+
+  describe "#hex_code_class" do
+    it "returns the source code for FontAwesome::HexCode" do
+      task.expects(:open_file).with("lib/font_awesome/hex_code.rb").returns("source code")
+      task.hex_code_class.should == "source code"
+    end
+  end
+
+  describe "#css" do
+    it "returns the Font Awesome css styles" do
+      task.expects(:open_file).with("Font-Awesome/css/font-awesome.css").returns("css rules")
+      task.css.should == "css rules"
+    end
+  end
+
+  describe "#hex_codes" do
+    it "extracts the hex code lookup table from the css" do
+      task.hex_codes.should have_at_least(200).keys
+      task.hex_codes["glass"].should == "f000"
+    end
+  end
+
+  describe "#updated_hex_code_class" do
+    it "replaces the hex code lookup table in FontAwesome::HexCode" do
+      task.stubs(:hex_codes).returns({"pizza" => "f00d", "linux" => "f055"})
+      diff = task.updated_hex_code_class.lines.to_a - task.hex_code_class.lines.to_a
+      diff.should have(1).item
+      diff.first.should include 'HEX_CODES = {"pizza"=>"f00d", "linux"=>"f055"}'
+    end
+  end
+
+  describe "#run" do
+    it "writes the updated source code" do
+      task.stubs(:puts)
+      task.stubs(:updated_hex_code_class).returns("updated source code")
+      task.expects(:open_file).with("lib/font_awesome/hex_code.rb", "w").yields(mock{expects(:write).with("updated source code")})
+      task.run
+    end
+  end
+end

data/spec/tasks/update_metrics_task_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe UpdateMetricsTask do
+  subject(:task) { UpdateMetricsTask.new }
+
+  describe "#font_class" do
+    it "returns the source code for FontAwesome::Font" do
+      task.expects(:open_file).with("lib/font_awesome/font.rb").returns("source code")
+      task.font_class.should == "source code"
+    end
+  end
+
+  describe "#updated_font_class" do
+    it "replaces the ascent and descent constants in FontAwesome::Font" do
+      Metrics.stubs(:ascent).returns(1234)
+      Metrics.stubs(:descent).returns(-567)
+      diff = task.updated_font_class.lines.to_a - task.font_class.lines.to_a
+      diff.should have(2).items
+      diff.first.should include 'ASCENT = 1234'
+      diff.last.should include 'DESCENT = -567'
+    end
+  end
+
+  describe "#run" do
+    it "writes the updated source code" do
+      task.stubs(:puts)
+      task.stubs(:updated_font_class).returns("updated source code")
+      task.expects(:open_file).with("lib/font_awesome/font.rb", "w").yields(mock{
+        expects(:write).with("updated source code")
+      })
+      task.run
+    end
+  end
+end

data/spec/tasks/update_sass_task_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe UpdateSassTask do
+  subject(:task) { UpdateSassTask.new }
+
+  def mock_icon(name, hex_code)
+    stub(name: name, hex_code: stub(to_css: "\\#{hex_code}"))
+  end
+
+  describe "#run" do
+    it "writes scss placeholders for icon content" do
+      task.stubs(:puts)
+      FontAwesome::Icon.stubs(:all).returns([mock_icon("pizza", "f00d"), mock_icon("linux", "f055")])
+      task.expects(:open_file).with("app/assets/stylesheets/font-awesome/_icons.scss", "w").yields(mock{
+        expects(:write).with("%icon-pizza { content: '\\f00d'; }\n%icon-linux { content: '\\f055'; }\n")
+      })
+      task.run
+    end
+  end
+end

data/tasks/gem_dir.rb

@@ -0,0 +1,12 @@
+module GemDir
+  extend self
+
+  def expand_path(relative_path)
+    File.expand_path("../#{relative_path}", File.dirname(__FILE__))
+  end
+
+  def open_file(relative_path, mode="r", &block)
+    block = ->(file) { file.read } unless block_given?
+    File.open(expand_path(relative_path), mode, &block)
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,3 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)

data/tasks/task.rb

@@ -0,0 +1,5 @@
+require_relative "gem_dir"
+
+class Task
+  include GemDir
+end

data/tasks/update/classic.rake

@@ -0,0 +1,27 @@
+namespace :update do
+
+  desc "Copy classic Font Awesome styles"
+  task :classic => "classic:all"
+
+  namespace :classic do
+
+    task :all => ["font_awesome:download", :sass, :ie7]
+
+    task :sass do
+      require_relative "update_classic_sass_task"
+      UpdateClassicSassTask.new.run
+    end
+
+    task :ie7 do
+      require "fileutils"
+
+      source = "Font-Awesome/css/font-awesome-ie7.css"
+      destination = "vendor/assets/stylesheets/font-awesome/ie7.css"
+
+      puts "* Updating #{destination}"
+      FileUtils.cp GemDir.expand_path(source), GemDir.expand_path(destination)
+    end
+
+  end
+
+end

data/tasks/update/font.rake

@@ -0,0 +1,13 @@
+namespace :update do
+
+  desc "Transfer font files to vendor/assets"
+  task :font => "font_awesome:download" do
+    require "fileutils"
+
+    source = "Font-Awesome/font"
+    destination = "vendor/assets/font"
+
+    puts "* Copying fonts to #{destination}"
+    FileUtils.cp_r "#{GemDir.expand_path(source)}/.", GemDir.expand_path(destination)
+  end
+end

data/tasks/update/font_awesome.rake

@@ -0,0 +1,20 @@
+namespace :update do
+
+  desc "Update Font Awesome"
+  task :font_awesome => "font_awesome:download" do
+    puts "* Updating Font Awesome repo"
+    system("cd Font-Awesome && git pull")
+  end
+
+  namespace :font_awesome do
+
+    desc "Download Font Awesome"
+    task :download do
+      unless File.exists?(GemDir.expand_path("Font-Awesome"))
+        puts "* Cloning Font Awesome repo"
+        system("git clone git://github.com/FortAwesome/Font-Awesome.git")
+      end
+    end
+
+  end
+end

data/tasks/update/hex_codes.rake

@@ -0,0 +1,9 @@
+namespace :update do
+
+  desc "Generate FontAwesome::HexCode.HEX_CODES"
+  task :hex_codes => "font_awesome:download" do
+    require_relative "update_hex_codes_task"
+    UpdateHexCodesTask.new.run
+  end
+
+end

data/tasks/update/metrics.rake

@@ -0,0 +1,8 @@
+namespace :update do
+
+  desc "Update font metrics"
+  task :metrics do
+    require_relative "update_metrics_task"
+    UpdateMetricsTask.new.run
+  end
+end