color_parser 0.1.0 → 1.0.0

data/spec/page_spec.rb

@@ -2,193 +2,38 @@ require 'spec_helper'
 
 describe Page do
   before(:each) do 
-    ColorParser.request = FakeRequest.new
+    Stylesheet.request = FakeRequest.new
   end
-
-  it "should initialize url" do
-    url = "http://example.com/css/inline.html?foo=bar"
-    page = ColorParser::Page.new(url)
-    
-    expect(page.url).to eq url
-  end
-
-  it "should parse url" do
-    url = "http://example.com/css/inline.html?foo=bar"
-    page = ColorParser::Page.new(url)
-
-    expect(page.host).to eq  "example.com" 
-    expect(page.path).to eq  "/css/inline.html"
-    expect(page.query).to eq "foo=bar"
-  end
-
-  # Stylesheet sources
-  it "should build styles from inline css" do 
-    url = "http://example.com/css/inline.html"
-    page = ColorParser::Page.new(url)
-  
-    # 2 found
-    expect(page.stylesheets.length).to eq 2
-
-    # stylesheet content
-    sheet = page.stylesheets.first
-    expect(sheet.type).to eq "inline"
-    expect(sheet.text).to include "background"
-  end
-
-  it "should build styles with inine css with import" do 
-    url = "http://example.com/css/inline_import.html"
-    page = ColorParser::Page.new(url)
-
-    expect(page.stylesheets.length).to eq 1
-  
-    expect(page.stylesheets[0].name).to eq                "inline_import.html"
-    expect(page.stylesheets[0].stylesheets[0].name).to eq "print.css"
-    expect(page.stylesheets[0].stylesheets[1].name).to eq "fonts.css"
-    expect(page.stylesheets[0].stylesheets[2].name).to eq "colors.css"
-  end
-  
-  it "should build styles from external relative css" do 
-    url = "http://example.com/css/relative.html"
-    page = ColorParser::Page.new(url)
-
-    # 2 found
-    expect(page.stylesheets.length).to eq 2
-
-    # stylesheet content
-    sheet = page.stylesheets.first
-    expect(sheet.type).to eq "external"
-    expect(sheet.text).to include "background"
-  end
-
-  it "should build styles from external relative root css" do 
-    url = "http://example.com/css/relative_root.html"
-    page = ColorParser::Page.new(url)
-  
-    # 2 found
-    expect(page.stylesheets.length).to eq 2
-  
-    # stylesheet content
-    sheet = page.stylesheets.first
-    expect(sheet.type).to eq "external"
-    expect(sheet.text).to include "background"
-  end
-
-  it "should build styles from external absolute css" do 
-    url = "http://example.com/css/relative.html"
-    page = ColorParser::Page.new(url)
-  
-    # 2 found
-    expect(page.stylesheets.length).to eq 2
-  
-    # stylesheet content
-    sheet = page.stylesheets.first
-    expect(sheet.type).to eq "external"
-    expect(sheet.text).to include "background"
-  end
-  
-  it "should build styles from imported css" do 
-    url = "http://example.com/css_import/index.html"
-    page = ColorParser::Page.new(url)
-    css = page.stylesheets
-  
-    expect(css.length).to eq 2
-  
-    # 5 found 
-    expect(css[0].name).to include "screen.css"
-    expect(css[1].name).to include "print.css"
-
-    expect(css[0].stylesheets[0].name).to include "master.css"
-    expect(css[0].stylesheets[1].name).to include "fonts.css"
-    expect(css[0].stylesheets[2].name).to include "ie.css"
-    expect(css[0].stylesheets[3].name).to include "images.css"
-    expect(css[0].stylesheets[4].name).to include "borders.css"
-    expect(css[0].stylesheets[5].name).to include "colors.css"
-  end
-  
-  it "should not fail from an invalid css path" do 
-    url = "http://example.com/css/invalid.html"
-    page = ColorParser::Page.new(url)
-  
-    # 1 found
-    expect(page.stylesheets.length).to eq 1
-    expect(page.stylesheets[0].name).to include "screen.css"
-  end
-  
-  
-  # IMAGES
-  
-  it "should build images from inline images with relative paths" do 
-    url    = "http://example.com/inline_images/relative.html"
-    page   = ColorParser::Page.new(url)
-    images = page.images
-  
-    expect(images.size).to eq 2
-  
-    expect(images[0].url).to eq "http://example.com/inline_images/images/apple.png"
-    expect(images[1].url).to eq "http://example.com/inline_images/images/kiwi.jpg"
-  end
-  
-  it "should build images from inline images with relative root paths" do 
-    url    = "http://example.com/inline_images/relative_root.html"
-    page   = ColorParser::Page.new(url)
-    images = page.images
-  
-    expect(images.size).to eq 2
-  
-    expect(images[0].url).to eq "http://example.com/inline_images/images/apple.png"
-    expect(images[1].url).to eq "http://example.com/inline_images/images/kiwi.jpg"
-  end
-  
-  it "should build images from inline images with absolute paths" do 
-    url    = "http://example.com/inline_images/absolute.html"
-    page   = ColorParser::Page.new(url)
-    images = page.images
   
-    expect(images.size).to eq 2
-  
-    expect(images[0].url).to eq "http://example.com/inline_images/images/apple.png"
-    expect(images[1].url).to eq "http://example.com/inline_images/images/kiwi.jpg"
-  end
-  
-  
-  # STYLESHEET IMAGES
-  
-  it "should combine images from inline external and import styles" do 
-    url    = "http://example.com/css_images/paths.html"
-    page   = ColorParser::Page.new(url)
-    images = page.images
-  
-    expect(images.size).to eq 5
+  describe ".new" do 
+    
+    it "should initialize url" do
+      url = "http://example.com/css/inline.html?foo=bar"
+      page = ColorParser::Page.new(url)
 
-    expect(images[0].name).to eq "mango.png"
-    expect(images[1].name).to eq "apple.png"
-    expect(images[2].name).to eq "kiwi.jpg"
-    expect(images[3].name).to eq "cantaloupe.png"
-    expect(images[4].name).to eq "pineapple.png"
+      expect(page.url).to eq url
+    end
   end
 
+  describe "#colors" do 
+    let :page do 
+      ColorParser::Page.new("http://example.com/css_color/frequency.html")
+    end
 
-  # STYLESHEET COLORS 
-
-  it "should combine colors from external and import styles" do 
-    url    = "http://example.com/css_color/frequency.html"
-    page   = ColorParser::Page.new(url)
-    colors = page.colors
-  
-    expect(colors["386ec0"]).to eq 4
-    expect(colors["3a5dc4"]).to eq 3
-    expect(colors["718ad7"]).to eq 2
-    expect(colors["ff0000"]).to eq 1
-    expect(colors["357ad1"]).to eq 1
-    expect(colors["535353"]).to eq 1
-  end
-  
-  it "should solot colors by frequency" do 
-    url    = "http://example.com/css_color/frequency.html"
-    page   = ColorParser::Page.new(url)
-
-    colors = ["386ec0", "3a5dc4", "718ad7", "535353", "357ad1", "ff0000"]
-    expect(page.colors_by_frequency).to eq colors
+    it "should combine colors from external and import styles" do 
+      colors = page.colors
+    
+      expect(colors["386ec0"]).to eq 4
+      expect(colors["3a5dc4"]).to eq 3
+      expect(colors["718ad7"]).to eq 2
+      expect(colors["ff0000"]).to eq 1
+      expect(colors["357ad1"]).to eq 1
+      expect(colors["535353"]).to eq 1
+    end
+    
+    it "should solot colors by frequency" do 
+      colors = ["386ec0", "3a5dc4", "718ad7", "535353", "357ad1", "ff0000"]
+      expect(page.colors_by_frequency).to eq colors
+    end
   end
-  
 end

data/spec/stylesheet_spec.rb

@@ -2,96 +2,42 @@ require 'spec_helper'
 
 describe Stylesheet do
   before(:each) do 
-    ColorParser.request = FakeRequest.new
+    Stylesheet.request = FakeRequest.new
   end
   
-  describe "#new" do 
-    it "must initialize params" do
-      sheet = ColorParser::Stylesheet.new(text: "a { background: #fff; }", 
-                                          type: "inline",
-                                          url:  "http://example.com/css/inline.html?foo=bar")
-      expect(sheet.type).to eq  "inline"
-      expect(sheet.text).to eq  "a { background: #fff; }"
-      expect(sheet.url).to eq   "http://example.com/css/inline.html?foo=bar"
-      expect(sheet.host).to eq  "example.com"
-      expect(sheet.path).to eq  "/css/inline.html"
-      expect(sheet.query).to eq "foo=bar"
-    end
-  end
-
-  describe "import quoting" do 
+  describe "#rules" do 
     let :style do 
-      ColorParser::Stylesheet.new(text: fixture("/css_import/stylesheets/screen.css"), 
-                                  url: "http://example.com/css_import/stylesheets/screen.css")
-    end
-
-    it "should import stylesheets with double quotes" do 
-      imported = style.stylesheets[0]
-      expect(imported.name).to eq "master.css"
-      expect(imported.text).to include "a:link"
+      url = "http://example.com/css_color/stylesheets/properties.css"
+      css = ::Stylesheet::CssStyleSheet.new(url)
+  
+      stylesheet = ColorParser::Stylesheet.new(css)
     end
+  
+    it "should parse rules" do 
+      rules = style.rules
+  
+      expect(rules.size).to eq 4
     
-    it "should import stylesheets with single quotes" do     
-      imported = style.stylesheets[1]
-      expect(imported.name).to eq "fonts.css"
-      expect(imported.text).to include "font-family"
-    end
+      expect(rules["p"].size).to eq   3
+      expect(rules["div"].size).to eq 2
+      expect(rules["h1"].size).to eq  3
     
-    it "should import stylesheets with no quotes" do 
-      imported = style.stylesheets[2]
-      expect(imported.name).to eq "ie.css"
-      expect(imported.text).to include "background-color"
+      # imported 
+      expect(rules["dl"].size).to eq 1
     end
   end
-
-  describe "import paths" do 
-    let :style do 
-      ColorParser::Stylesheet.new(text: fixture("/css_import/stylesheets/screen.css"), 
-                                  url: "http://example.com/css_import/stylesheets/screen.css")
-    end
-
-    it "should import from relative path" do 
-      imported = style.stylesheets[0]
-      expect(imported.url).to eq "http://example.com/css_import/stylesheets/master.css"
-    end
-  
-    it "should import from relative root path" do   
-      imported = style.stylesheets[1]
-      expect(imported.url).to eq "http://example.com/css_import/stylesheets/fonts.css"
-    end
   
-    it "should import from absolute path" do 
-      imported = style.stylesheets[2]
-      expect(imported.url).to eq "http://example.com/css_import/stylesheets/ie.css"
-    end
-
-    it "should not fail on invalid import path" do 
-      expect(style.stylesheets[6]).to be_nil
-    end
-  end
-
-  describe "selector parsing" do 
+  describe "#properties" do 
     let :style do 
-      ColorParser::Stylesheet.new(text: fixture("/css_color/stylesheets/properties.css"), 
-                                  url: "http://example.com/css_color/stylesheets/properties.css")
+      url = "http://example.com/css_color/stylesheets/properties.css"
+      css = ::Stylesheet::CssStyleSheet.new(url)
+  
+      stylesheet = ColorParser::Stylesheet.new(css)
     end
 
-    it "should parse selectors" do 
-      selectors = style.selectors
-      
-      expect(selectors.size).to eq 4
-    
-      expect(selectors["p"].size).to eq   2
-      expect(selectors["div"].size).to eq 1
-      expect(selectors["h1"].size).to eq  2
-    
-      # imported 
-      expect(selectors["dl"].size).to eq 1
-    end
-    
     it "should parse properties" do 
       props = style.properties
-      
+  
       expect(props.size).to eq 9
       
       expect(props).to include ["background",       "#000"]
@@ -106,65 +52,69 @@ describe Stylesheet do
     end
   end
 
-  describe "color parsing" do 
+  describe "#colors" do 
     let :style do 
-      ColorParser::Stylesheet.new(text: fixture("/css_color/stylesheets/color_styles.css"), 
-                                  url: "http://example.com/css_color/stylesheets/color_styles.css")
-    end
+      url = "http://example.com/css_color/stylesheets/color_styles.css"
+      css = ::Stylesheet::CssStyleSheet.new(url)
 
+      stylesheet = ColorParser::Stylesheet.new(css)
+    end
+  
     it "should parse hex colors" do 
       expect(style.colors["386ec0"]).to be # 386ec0
     end
-
+  
     it "should parse hex short colors" do 
       expect(style.colors["cc00cc"]).to be # c0c
     end
-
+  
     it "should parse textual colors" do 
       expect(style.colors["008080"]).to be # teal
     end
-
+  
     it "should parse rgb colors" do 
       expect(style.colors["718ad7"]).to be # rgb(113,138,215)
     end
-
+  
     it "should parse rgb colors with space" do 
       expect(style.colors["3a5dc4"]).to be # rgb(58, 93, 196)
     end
-
+  
     it "should parse rgba colors" do 
       expect(style.colors["29469e"]).to be # rgba(41,70,158,0.5);
     end
-
+  
     it "should parse rgba colors with space" do 
       expect(style.colors["3f6aeb"]).to be # rgba(63, 106, 235, 0.5);
     end
   end
-
+  
   describe "color weighting" do 
     let :style do 
-      ColorParser::Stylesheet.new(text: fixture("/css_color/stylesheets/frequency.css"), 
-                                  url: "http://example.com/css_color/stylesheets/frequency.css")
-    end
+      url = "http://example.com/css_color/stylesheets/frequency.css"
+      css = ::Stylesheet::CssStyleSheet.new(url)
 
+      stylesheet = ColorParser::Stylesheet.new(css)
+    end
+  
     it "should order colors by frequency" do 
       colors = {"386ec0" => 4, "3a5dc4" => 3, 
                 "718ad7" => 2, "ff0000" => 1}
       expect(style.colors).to eq colors
     end
-
+  
     # BG colors
     it "should order background colors by frequency" do 
       colors = {"386ec0" => 2, "3a5dc4" => 1}
       expect(style.bg_colors).to eq colors
     end
-
+  
     # Text colors
     it "should order text colors by frequency" do 
       colors = {"386ec0" => 2, "718ad7" => 1}
       expect(style.text_colors).to eq colors
     end
-
+  
     # Border colors
     it "should order border colors by frequency" do 
       colors = {"3a5dc4" => 2, "ff0000" => 1, "718ad7" => 1}
@@ -172,64 +122,4 @@ describe Stylesheet do
     end
   end
 
-  describe "image parsing" do 
-    let :style do 
-      ColorParser::Stylesheet.new(text: fixture("/css_images/stylesheets/quotes.css"), 
-                                  url: "http://example.com/css_images/stylesheets/quotes.css")
-    end
-
-    it "should parse images with double quotes" do 
-      expect(style.images[0].name).to eq "apple.png"
-    end
-
-    it "should parse images with single quotes" do 
-      expect(style.images[1].name).to eq "kiwi.jpg"
-    end
-
-    it "should parse images with no quotes" do 
-      expect(style.images[2].name).to eq "cantaloupe.png"
-    end
-  end
-
-  describe "image paths" do 
-    let :style do 
-      ColorParser::Stylesheet.new(text: fixture("/css_images/stylesheets/paths.css"), 
-                                  url: "http://example.com/css_images/stylesheets/paths.css")
-    end
-
-    it "should build image from absolute path" do 
-      urls = style.images.map {|image| image.url }
-
-      expect(urls.size).to eq 4
-      expect(urls).to include "http://example.com/css_images/images/apple.png"
-    end
-
-    it "should build image from relative path" do 
-      urls = style.images.map {|image| image.url }
-
-      expect(urls.size).to eq 4
-      expect(urls).to include "http://example.com/css_images/images/kiwi.jpg"
-    end
-
-    it "should build image from relative root path" do 
-      urls = style.images.map {|image| image.url }
-
-      expect(urls.size).to eq 4
-      expect(urls).to include "http://example.com/css_images/images/cantaloupe.png"
-    end
-
-    it "should build image from imported path" do 
-      urls = style.images.map {|image| image.url }
-
-      expect(urls.size).to eq 4
-      expect(urls).to include "http://example.com/css_images/images/pineapple.png"
-    end
-  end
-end
-
-private 
-
-def fixture(path)
-  fixture = "#{File.dirname(__FILE__)}/../spec/fixtures#{path}"
-  File.read(fixture) if File.exist?(fixture)
 end