RubyGems - guess_html_encoding - Versions diffs - 0.0.9 → 0.0.10 - Mend

guess_html_encoding 0.0.9 → 0.0.10

Files changed (9) hide show

checksums.yaml +7 -0
data/.ruby-gemset +1 -0
data/.ruby-version +1 -0
data/Gemfile.lock +14 -10
data/lib/guess_html_encoding.rb +2 -2
data/lib/guess_html_encoding/version.rb +1 -1
data/spec/guess_html_encoding_spec.rb +48 -44
metadata +12 -15
data/.rvmrc +0 -1

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f24b82e186d3e1a58cd2061c7cb1eef2f5b5d1b0
+  data.tar.gz: cbfd0284000e074ef621763a36ca2be60cbed218
+SHA512:
+  metadata.gz: 4d68030d7c0af216faa1e1dc029c65b6557287a8349aa89ec2a7a98833de4178a838693d2bf3e866b966edd597951e0d31c26f3a4c33daab30c7afa93692b7a5
+  data.tar.gz: e2ddc685bae62c4cc6e962dd79a4f69863aef512b556957b2ab91113b492c3b07d7315f880c57179c8a9aea30d0279823983a21bbdcc6cbbc697cfc9ef2ada30

data/.ruby-gemset ADDED Viewed

	@@ -0,0 +1 @@
1	+ guess_html_encoding

data/.ruby-version ADDED Viewed

	@@ -0,0 +1 @@
1	+ 2.1.5

data/Gemfile.lock CHANGED Viewed

@@ -1,20 +1,24 @@
 PATH
   remote: .
   specs:
-    guess_html_encoding (0.0.8)
+    guess_html_encoding (0.0.9)
 GEM
   remote: http://rubygems.org/
   specs:
-    diff-lcs (1.1.3)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.4)
-    rspec-expectations (2.6.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
+    diff-lcs (1.2.5)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
 PLATFORMS
   ruby

data/lib/guess_html_encoding.rb CHANGED Viewed

@@ -10,7 +10,7 @@ module GuessHtmlEncoding
     if headers
       headers = headers.map {|k, v| "#{k}: #{v}" }.join("\n") if headers.is_a?(Hash)
       headers = headers.dup.force_encoding("ASCII-8BIT")
-      headers.split("\n").map {|i| i.split(":")}.each do |k,v|
+      headers.gsub(/[\r\n]+/, "\n").split("\n").map {|i| i.split(":")}.each do |k,v|
         if k =~ /Content-Type/i && v =~ /charset=([\w\d-]+);?/i
           out = $1.upcase
           break
@@ -42,7 +42,7 @@ module GuessHtmlEncoding
   # Force an HTML string into a guessed encoding.
   def self.encode(html, headers = nil)
     html_copy = html.to_s.dup
-    encoding = guess(html_copy, (headers || '').gsub(/[\r\n]+/, "\n"))
+    encoding = guess(html_copy, headers)
     html_copy.force_encoding(encoding_loaded?(encoding) ? encoding : "UTF-8")
     if html_copy.valid_encoding?
       html_copy

data/lib/guess_html_encoding/version.rb CHANGED Viewed

@@ -1,3 +1,3 @@
 module GuessHtmlEncoding
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

data/spec/guess_html_encoding_spec.rb CHANGED Viewed

@@ -6,59 +6,59 @@ describe "GuessHtmlEncoding" do
     it "can use headers" do
       guess = GuessHtmlEncoding.guess("<html><body><div>hi!</div></body></html>",
                                       "Hello: world\nContent-Type: text/html; charset=LATIN1\nFoo: bar")
-      guess.should == "ISO-8859-1"
+      expect(guess).to eq("ISO-8859-1")
     end
     it "accepts headers as a hash as well" do
       guess = GuessHtmlEncoding.guess("<html><body><div>hi!</div></body></html>",
           {"Hello" => "world", "Content-Type" => "text/html; charset=LATIN1", "Foo" => "bar"})
-      guess.should == "ISO-8859-1"
+      expect(guess).to eq("ISO-8859-1")
     end
     it "accepts meta tags" do
       guess = GuessHtmlEncoding.guess('<html><head><meta http-equiv="content-type" content="text/html; charset=LATIN1"></head><body><div>hi!</div></body></html>')
-      guess.should == "ISO-8859-1"
+      expect(guess).to eq("ISO-8859-1")
     end
     it "works okay when there is a semi-colon after the encoding with headers" do
       guess = GuessHtmlEncoding.guess("<html><body><div>hi!</div></body></html>",
                                       "Hello: world\nContent-Type: text/html; charset=utf-8;\nFoo: bar")
-      guess.should == "UTF-8"
+      expect(guess).to eq("UTF-8")
     end
     it "works okay when there is a semi-colon after the encoding with meta-tags" do
       guess = GuessHtmlEncoding.guess('<html><head><meta http-equiv="content-type" content="text/html; charset=utf-8;"></head><body><div>hi!</div></body></html>')
-      guess.should == "UTF-8"
+      expect(guess).to eq("UTF-8")
     end
     it "converts UTF8 to UTF-8" do
       guess = GuessHtmlEncoding.guess('<html><head><meta http-equiv="content-type" content="text/html; charset=utf8;"></head><body><div>hi!</div></body></html>')
-      guess.should == "UTF-8"
+      expect(guess).to eq("UTF-8")
     end
     it "converts CP-1251 to CP1251" do
       guess = GuessHtmlEncoding.guess('<html><head><meta http-equiv="content-type" content="text/html; charset=cp-1251;"></head><body><div>hi!</div></body></html>')
-      guess.should == "CP1251"
+      expect(guess).to eq("CP1251")
     end
     it "skips the header content type if it's invalid" do
       guess = GuessHtmlEncoding.guess('<html><head><meta http-equiv="content-type" content="text/html; charset=utf8;"></head><body><div>hi!</div></body></html>',
                                       "Hello: world\nContent-Type: text/html; charset=RU;\nFoo: bar")
-      guess.should == "UTF-8"
+      expect(guess).to eq("UTF-8")
     end
     it "translates WIN1251 to WINDOWS-1250" do
       guess = GuessHtmlEncoding.guess('<html><head><meta http-equiv="content-type" content="text/html; charset=WIN1251;"></head><body><div>hi!</div></body></html>')
-      guess.should == "WINDOWS-1250"
+      expect(guess).to eq("WINDOWS-1250")
     end
     it "translates GB2312 to GB18030" do
       guess = GuessHtmlEncoding.guess('<html><head><meta http-equiv="content-type" content="text/html; charset=GB2312;"></head><body><div>hi!</div></body></html>')
-      guess.should == "GB18030"
+      expect(guess).to eq("GB18030")
     end
     it "should not raise an exception if data is nil" do
-      GuessHtmlEncoding.guess(nil).should_not raise_error(TypeError)
+      expect { GuessHtmlEncoding.guess(nil) }.not_to raise_error
     end
   end
@@ -66,97 +66,101 @@ describe "GuessHtmlEncoding" do
     it "should work on correctly encoded pages" do
       data = "<html><head><meta http-equiv='content-type' content='text/html; charset=utf8;'></head><body><div>hi!♥</div></body></html>"
       data.force_encoding("ASCII-8BIT")
-      data.should be_valid_encoding # everything is valid in binary
+      expect(data).to be_valid_encoding # everything is valid in binary
-      GuessHtmlEncoding.guess(data).should == "UTF-8" # because the page says so!
-      data.force_encoding("UTF-8").should be_valid_encoding # because it really is utf-8
+      expect(GuessHtmlEncoding.guess(data)).to eq("UTF-8") # because the page says so!
+      expect(data.force_encoding("UTF-8")).to be_valid_encoding # because it really is utf-8
       encoded = GuessHtmlEncoding.encode(data)
-      encoded.encoding.to_s.should == "UTF-8"
-      encoded.should be_valid_encoding
+      expect(encoded.encoding.to_s).to eq("UTF-8")
+      expect(encoded).to be_valid_encoding
     end
     it "should work on incorrectly encoded pages" do
       data = "<html><head><meta http-equiv='content-type' content='text/html; charset=utf8;'></head><body><div>hi!\xc2</div></body></html>"
       data.force_encoding("ASCII-8BIT")
-      data.should be_valid_encoding # everything is valid in binary
+      expect(data).to be_valid_encoding # everything is valid in binary
-      GuessHtmlEncoding.guess(data).should == "UTF-8" # because the page says so!
-      data.force_encoding("UTF-8").should_not be_valid_encoding # because of the bad byte sequence \xc2 which is not valid UTF-8
+      expect(GuessHtmlEncoding.guess(data)).to eq("UTF-8") # because the page says so!
+      expect(data.force_encoding("UTF-8")).not_to be_valid_encoding # because of the bad byte sequence \xc2 which is not valid UTF-8
       encoded = GuessHtmlEncoding.encode(data)
-      encoded.encoding.to_s.should == "UTF-8"
-      encoded.should be_valid_encoding
+      expect(encoded.encoding.to_s).to eq("UTF-8")
+      expect(encoded).to be_valid_encoding
     end
     it "should work on pages encoded with an unknown encoding by forcing them to utf8" do
       data = "<html><head><meta http-equiv='content-type' content='text/html; charset=x-mac-roman;'></head><body><div>hi!</div></body></html>"
       data.force_encoding("ASCII-8BIT")
-      data.should be_valid_encoding # everything is valid in binary
+      expect(data).to be_valid_encoding # everything is valid in binary
-      GuessHtmlEncoding.guess(data).should == "X-MAC-ROMAN" # because the page says so!
+      expect(GuessHtmlEncoding.guess(data)).to eq("X-MAC-ROMAN") # because the page says so!
       encoded = GuessHtmlEncoding.encode(data)
-      encoded.encoding.to_s.should == "UTF-8"
-      encoded.should be_valid_encoding
+      expect(encoded.encoding.to_s).to eq("UTF-8")
+      expect(encoded).to be_valid_encoding
-      data.encoding.to_s.should == "ASCII-8BIT"
+      expect(data.encoding.to_s).to eq("ASCII-8BIT")
     end
     it "should not raise an exception if data is nil" do
-      GuessHtmlEncoding.encode(nil).should_not raise_error(TypeError)
+      expect { GuessHtmlEncoding.encode(nil) }.not_to raise_error
     end
     it "should work on GB18030 (and translate GB2312 into GB18030)" do
       data = File.read(File.join(File.dirname(__FILE__), "fixtures/gb18030.html"), :encoding => "binary")
-      GuessHtmlEncoding.encoding_loaded?("GB18030").should be_true
-      GuessHtmlEncoding.guess(data).should == "GB18030"
-      GuessHtmlEncoding.encode(data).encoding.to_s.should == "GB18030"
+      expect(GuessHtmlEncoding.encoding_loaded?("GB18030")).to be_truthy
+      expect(GuessHtmlEncoding.guess(data)).to eq("GB18030")
+      expect(GuessHtmlEncoding.encode(data).encoding.to_s).to eq("GB18030")
+    end
+    it "should work with headers as a hash" do
+      data = File.read(File.join(File.dirname(__FILE__), "fixtures/gb18030.html"), :encoding => "binary")
+      expect(lambda { GuessHtmlEncoding.encode(data, {}) }).not_to raise_error
     end
   end
   describe "#encoding_loaded?" do
     it 'returns true for all loaded encodings' do
       (Encoding.name_list - ["internal"]).each do |name|
-        GuessHtmlEncoding.encoding_loaded?(name).should be_true
-        lambda { Encoding.find(name) }.should_not raise_error
+        expect(GuessHtmlEncoding.encoding_loaded?(name)).to be_truthy
+        expect { Encoding.find(name) }.not_to raise_error
       end
     end
     it 'returns true for uppercase encodings' do
-      GuessHtmlEncoding.encoding_loaded?("WINDOWS-1250").should be_true
-      lambda { Encoding.find("WINDOWS-1250") }.should_not raise_error
+      expect(GuessHtmlEncoding.encoding_loaded?("WINDOWS-1250")).to be_truthy
+      expect { Encoding.find("WINDOWS-1250") }.not_to raise_error
     end
     it 'returns true for lowercase encodings' do
-      GuessHtmlEncoding.encoding_loaded?("windows-1250").should be_true
-      lambda { Encoding.find("windows-1250") }.should_not raise_error
+      expect(GuessHtmlEncoding.encoding_loaded?("windows-1250")).to be_truthy
+      expect { Encoding.find("windows-1250") }.not_to raise_error
     end
     it 'returns true for encoding aliases' do
       Encoding.aliases.keys.each do |key|
-        GuessHtmlEncoding.encoding_loaded?(key).should be_true
-        GuessHtmlEncoding.encoding_loaded?(key.upcase).should be_true
-        lambda { Encoding.find(key) }.should_not raise_error
-        lambda { Encoding.find(key.upcase) }.should_not raise_error
+        expect(GuessHtmlEncoding.encoding_loaded?(key)).to be_truthy
+        expect(GuessHtmlEncoding.encoding_loaded?(key.upcase)).to be_truthy
+        expect { Encoding.find(key) }.not_to raise_error
+        expect { Encoding.find(key.upcase) }.not_to raise_error
       end
     end
     it 'returns false for irregular or unloaded encoding' do
-      GuessHtmlEncoding.encoding_loaded?('_WHY').should be_false
+      expect(GuessHtmlEncoding.encoding_loaded?('_WHY')).to be_falsy
     end
     it "accepts a simple meta tag" do
       # Like http://www.taobao.com
       guess = GuessHtmlEncoding.guess('<html><head><meta charset="gbk" /></head><body><div>hi!</div></body></html>')
-      guess.should == "GBK"
+      expect(guess).to eq("GBK")
     end
     it "works as well when there is no double quotation marks with http-equiv in meta-tags" do
       # Like http://www.frozentux.net/iptables-tutorial/cn/iptables-tutorial-cn-1.1.19.html
       guess = GuessHtmlEncoding.guess('<html><head><META http-equiv=Content-Type content="text/html; charset=utf-8"></head><body><div>hi!</div></body></html>')
-      guess.should == "UTF-8"
+      expect(guess).to eq("UTF-8")
     end
   end
 end

metadata CHANGED Viewed

@@ -1,30 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: guess_html_encoding
 version: !ruby/object:Gem::Version
-  version: 0.0.9
-  prerelease:
+  version: 0.0.10
 platform: ruby
 authors:
 - Andrew Cantino (Iteration Labs, LLC)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-01-13 00:00:00.000000000 Z
+date: 2014-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: ''
@@ -34,8 +31,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rvmrc
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -50,27 +48,26 @@ files:
 - spec/spec_helper.rb
 homepage: http://github.com/cantino/guess_html_encoding
 licenses: []
+metadata: {}
 post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: guess_html_encoding
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key:
-specification_version: 3
+specification_version: 4
 summary: A small gem that attempts to guess and then force encoding of HTML documents
   for Ruby 1.9
 test_files:

data/.rvmrc DELETED Viewed

	@@ -1 +0,0 @@
1	- rvm use 1.9.3@guess_html_encoding --create