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

guess_html_encoding 0.0.9 → 0.0.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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