coookies 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ed65d3647b297736118c3369a1506f7bb48bfdf2
+  data.tar.gz: 67a10192ed5f72cd0cc19e18a70eeed3265238f8
+SHA512:
+  metadata.gz: ead52c05c49e812b3a522d87c9379b2ffb1682ba36e6320163fdf975ae1115d48b76d53841ca6c4562c404838463108f397e3452288340b4391614546cfa29ec
+  data.tar.gz: c8ee28c5e8d137ee996c7c60e3539f52f2caaeac860b34ce5b53e570997643066e38b8d9d8414ee8934cdeebc22f72c0f6bdf236f62386ccdf100456e3caca58

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+pkg/*
+*.swp

data/.rvmrc

@@ -0,0 +1 @@
+rvm use default@cookie-extractor

data/CHANGES.md

@@ -0,0 +1,16 @@
+CHANGES: cookie_extractor
+-------------------------
+
+### v0.2.0  2013-07-02
+
+- Browser guessing code contributed by Ben Eills (github.com/beneills):
+ - Added --guess flag to automatically choose most recently used cookie file
+ - Added --browser flag to specify browser by name
+
+### v0.1.0  2012-02-23
+
+- Updated to include Chrome/Chromium support.
+
+### v0.0.1  2012-02-20
+
+- Initial version. Supports extracting Firefox cookies.

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cookie_extractor.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    cookie_extractor (0.0.1)
+      sqlite3-ruby
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    sqlite3 (1.3.5)
+    sqlite3-ruby (1.3.3)
+      sqlite3 (>= 1.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cookie_extractor!
+  rspec

data/README.md

@@ -0,0 +1,33 @@
+cookie_extractor
+----------------
+
+Extract cookies from Firefox, Chrome or Chromium sqlite cookie stores into a wget-compatible cookies.txt file.
+
+### Install ###
+
+    gem install cookie_extractor
+
+### Usage ###
+
+    cookie_extractor /path/to/firefox/cookies.sqlite > cookies.txt
+    
+    cookie_extractor --guess    # Guess which browser to use and open corresponding file
+    
+    cookie_extractor --browser chrome|chromium|firefox    # Open corresponding  DB
+
+
+Typical locations for the cookies file on Linux are:
+
+ * Firefox: *~/.mozilla/firefox/(profile directory)/cookies.sqlite*
+ * Chrome: *~/.config/google-chrome/Default/Cookies*
+ * Chromium: *~/.config/chromium/Default/Cookies*
+
+### License ###
+
+Copyright (c) 2012 Jeff Dallien
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/cookie_extractor

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "cookie_extractor"))
+
+
+def usage msg=nil
+  puts msg if msg
+  puts "Usage: cookie_extractor /path/to/cookies.sqlite              Open a DB file"
+  puts "       cookie_extractor --guess                              Guess which browser to use and open corresponding file"
+  puts "       cookie_extractor --browser chrome|chromium|firefox    Open DB corresponding to a particular browser"
+  exit
+end
+
+
+begin
+  extractor =
+    case ARGV.first
+    when '--guess', '-g'
+      begin
+        CookieExtractor::BrowserDetector.guess()
+      rescue CookieExtractor::NoCookieFileFoundException
+        abort "Error: we couldn't find any supported broswer's cookies"
+      end
+    when '--browser', '-b'
+      browser = ARGV[1]
+      usage "Error: Please supply a browser name" unless browser
+      begin
+        CookieExtractor::BrowserDetector.browser_extractor(browser)
+      rescue CookieExtractor::InvalidBrowserNameException
+        abort "Error: '#{browser}' is not a valid browser name"
+      rescue CookieExtractor::NoCookieFileFoundException
+        abort "Error: Could not locate cookie file for browser #{browser}"
+      end
+    when nil
+      usage
+    else
+      filename = ARGV.first
+      abort "Error: #{filename} does not exist" unless File.exists?(filename)
+      CookieExtractor::BrowserDetector.new_extractor(filename)
+    end
+  puts extractor.extract.join("\n")
+rescue SQLite3::NotADatabaseException,
+  CookieExtractor::BrowserNotDetectedException        
+  abort "Error: File '#{filename}' is not a Firefox or Chrome cookie database"
+end
+
+

data/cookie_extractor.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cookie_extractor/version"
+
+Gem::Specification.new do |s|
+  s.name        = "coookies"
+  s.version     = CookieExtractor::VERSION
+  s.authors     = ["Matias Fernandez"]
+  s.email       = ["matiasfmolinari@gmail.com"]
+  s.summary     = %q{Create cookies.txt from Firefox or Chrome/Chromium cookies}
+  s.description = %q{Extract cookies from Firefox, Chrome or Chromium sqlite databases into a wget-compatible cookies.txt file.}
+
+  s.rubyforge_project = "cookie_extractor"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", "~> 2.8"
+  s.add_runtime_dependency "sqlite3", "~> 1.3"
+end

data/lib/cookie_extractor.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "cookie_extractor/version"
+require "cookie_extractor/common"
+require "cookie_extractor/firefox_cookie_extractor"
+require "cookie_extractor/chrome_cookie_extractor"
+require "cookie_extractor/browser_detector"
+
+module CookieExtractor
+end

data/lib/cookie_extractor/browser_detector.rb

@@ -0,0 +1,78 @@
+module CookieExtractor
+  class BrowserNotDetectedException < Exception; end
+  class InvalidBrowserNameException < Exception; end
+  class NoCookieFileFoundException < Exception; end
+
+  class BrowserDetector
+    COOKIE_LOCATIONS = {
+      "chrome" => "~/.config/google-chrome/Default/Cookies",
+      "chromium" => "~/.config/chromium/Default/Cookies",
+      "firefox" => "~/.mozilla/firefox/*.default/cookies.sqlite"
+    }
+
+    # Returns the extractor of the most recently used browser's cookies
+    #   or raise NoCookieFileFoundException if there are no cookies
+    def self.guess
+      most_recently_used_detected_browsers.each { |browser, path|
+        begin
+          extractor = self.browser_extractor(browser)
+        rescue BrowserNotDetectedException, NoCookieFileFoundException
+          # better try the next one...
+        else
+          return extractor
+        end
+      }
+      # If we make it here, we've failed...
+      raise NoCookieFileFoundException, "Couldn't find any browser's cookies"
+    end
+
+    # Open a browser's cookie file using intelligent guesswork
+    def self.browser_extractor(browser)
+      raise InvalidBrowserNameException, "Browser must be one of: #{self.supported_browsers.join(', ')}" unless self.supported_browsers.include?(browser)
+      paths = Dir.glob(File.expand_path(COOKIE_LOCATIONS[browser]))
+      if paths.length < 1 or not File.exists?(paths.first)
+        raise NoCookieFileFoundException, "File #{paths.first} does not exist!"
+      end
+      self.new_extractor(paths.first)
+    end
+
+    def self.new_extractor(db_filename)
+      browser = detect_browser(db_filename)
+      if browser
+        CookieExtractor.const_get("#{browser}CookieExtractor").new(db_filename)
+      else
+        raise BrowserNotDetectedException, "Could not detect browser type."
+      end
+    end
+
+    def self.supported_browsers
+      COOKIE_LOCATIONS.keys
+    end
+
+    def self.detect_browser(db_filename)
+      db = SQLite3::Database.new(db_filename)
+      browser = 
+        if has_table?(db, 'moz_cookies')
+          'Firefox'
+        elsif has_table?(db, 'cookies')
+          'Chrome'
+        end
+      db.close
+      browser
+    end
+
+    def self.has_table?(db, table_name)
+      db.table_info(table_name).size > 0
+    end
+
+    def self.most_recently_used_detected_browsers
+      COOKIE_LOCATIONS.select { |browser, path|
+        Dir.glob(File.expand_path(path)).any?
+      }.sort_by { |browser, path|
+        File.mtime(Dir.glob(File.expand_path(path)).first)
+      }.reverse
+    end
+
+    private_class_method :most_recently_used_detected_browsers
+  end
+end

data/lib/cookie_extractor/chrome_cookie_extractor.rb

@@ -0,0 +1,29 @@
+require 'sqlite3'
+
+module CookieExtractor
+  class ChromeCookieExtractor
+    include Common
+
+    def initialize(cookie_file)
+      @cookie_file = cookie_file
+    end
+
+    def extract
+      db = SQLite3::Database.new @cookie_file
+      db.results_as_hash = true
+      result = []
+      db.execute("SELECT * FROM cookies") do |row|
+        result << [ row['host_key'],
+          true_false_word(is_domain_wide(row['host_key'])),
+          row['path'],
+          true_false_word(row['secure']),
+          row['expires_utc'],
+          row['name'],
+          row['value']
+        ].join("\t")
+      end
+      db.close
+      result
+    end
+  end
+end

data/lib/cookie_extractor/common.rb

@@ -0,0 +1,19 @@
+module CookieExtractor
+  module Common
+    private
+
+    def is_domain_wide(hostname)
+      hostname[0..0] == "."
+    end
+
+    def true_false_word(value)
+      if value == "1" || value == 1 || value == true
+        "TRUE"
+      elsif value == "0" || value == 0 || value == false
+        "FALSE"
+      else
+        raise "Invalid value passed to true_false_word: #{value.inspect}"
+      end
+    end
+  end
+end

data/lib/cookie_extractor/firefox_cookie_extractor.rb

@@ -0,0 +1,29 @@
+require 'sqlite3'
+
+module CookieExtractor
+  class FirefoxCookieExtractor
+    include Common
+
+    def initialize(cookie_file)
+      @cookie_file = cookie_file
+    end
+
+    def extract
+      db = SQLite3::Database.new @cookie_file
+      db.results_as_hash = true
+      result = []
+      db.execute("SELECT * FROM moz_cookies") do |row|
+        result << [ row['host'],
+          true_false_word(is_domain_wide(row['host'])),
+          row['path'],
+          true_false_word(row['isSecure']),
+          row['expiry'],
+          row['name'],
+          row['value']
+        ].join("\t")
+      end
+      db.close
+      result
+    end
+  end
+end

data/lib/cookie_extractor/version.rb

@@ -0,0 +1,3 @@
+module CookieExtractor
+  VERSION = "0.2.1"
+end

data/spec/browser_detector_spec.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe CookieExtractor::BrowserDetector, "determining the correct extractor to use" do
+  before :each do
+    @fake_cookie_db = double("cookie database", :close => true)
+    SQLite3::Database.should_receive(:new).
+      with('filename').
+        and_return(@fake_cookie_db)
+  end
+
+  describe "given a sqlite database with a 'moz_cookies' table" do
+    before :each do
+      @fake_cookie_db.should_receive(:table_info).
+        with("moz_cookies").
+          and_return(
+            { 'name' => 'some_field',
+              'type' => "some_type" })
+    end
+
+    it "should return a firefox extractor instance" do
+      extractor = CookieExtractor::BrowserDetector.new_extractor('filename')
+      extractor.instance_of?(CookieExtractor::FirefoxCookieExtractor).should be_true
+    end
+  end
+
+  describe "given a sqlite database with a 'cookies' table" do
+    before :each do
+      @fake_cookie_db.should_receive(:table_info).
+        with("moz_cookies").
+          and_return([])
+      @fake_cookie_db.should_receive(:table_info).
+        with("cookies").
+          and_return(
+            [{ 'name' => 'some_field',
+              'type' => "some_type" }])
+    end
+
+    it "should return a chrome extractor instance" do
+      extractor = CookieExtractor::BrowserDetector.new_extractor('filename')
+      extractor.instance_of?(CookieExtractor::ChromeCookieExtractor).should be_true
+    end
+  end
+end
+
+describe CookieExtractor::BrowserDetector, "guessing the location of the cookie file" do
+  describe "when no cookie files are found in the standard locations" do
+    before :each do
+      Dir.stub!(:glob).and_return([])
+    end
+
+    it "should raise NoCookieFileFoundException" do
+      lambda { CookieExtractor::BrowserDetector.guess }.
+        should raise_error(CookieExtractor::NoCookieFileFoundException)
+    end
+  end
+
+  describe "when multiple cookie files are found in the standard locations" do
+    before :each do
+      cookie_locations = CookieExtractor::BrowserDetector::COOKIE_LOCATIONS
+      Dir.stub!(:glob).and_return([cookie_locations['chrome']],
+                                  [],
+                                  [cookie_locations['firefox']])
+    end
+
+    describe "and chrome was the most recently used" do
+      before :each do
+        File.should_receive(:mtime).twice.and_return(
+          Time.parse("July 2 2013 00:00:00"),
+          Time.parse("July 1 2013 00:00:00"))
+      end
+
+      it "should build a ChromeCookieExtractor" do
+        CookieExtractor::BrowserDetector.
+          should_receive(:browser_extractor).
+            once.with("chrome")
+        CookieExtractor::BrowserDetector.guess
+      end
+    end
+  end 
+end

data/spec/chrome_cookie_extractor_spec.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe CookieExtractor::ChromeCookieExtractor do
+  before :each do
+    @fake_cookie_db = double("cookie database",
+      :results_as_hash= => true,
+      :close => true)
+    SQLite3::Database.should_receive(:new).
+      with('filename').
+        and_return(@fake_cookie_db)
+  end
+
+  describe "opening and closing a sqlite db" do
+    before :each do
+      @fake_cookie_db.should_receive(:execute).and_yield(
+        { 'host_key' => '.dallien.net',
+          'path' => '/',
+          'secure' => '0',
+          'expires_utc' => '1234567890',
+          'name' => 'NAME',
+          'value' => 'VALUE'})
+      @extractor = CookieExtractor::ChromeCookieExtractor.new('filename')
+    end
+
+    it "should close the db when finished" do
+      @fake_cookie_db.should_receive(:close)
+      @extractor.extract
+    end
+  end
+
+  describe "with a cookie that has a host starting with a dot" do
+    before :each do
+      @fake_cookie_db.should_receive(:execute).and_yield(
+        { 'host_key' => '.dallien.net',
+          'path' => '/',
+          'secure' => '0',
+          'expires_utc' => '1234567890',
+          'name' => 'NAME',
+          'value' => 'VALUE'})
+      @extractor = CookieExtractor::ChromeCookieExtractor.new('filename')
+      @result = @extractor.extract
+    end
+
+    it "should return one cookie string" do
+      @result.size.should == 1
+    end
+
+    it "should put TRUE in the domain wide field" do
+      cookie_string = @result.first
+      cookie_string.split("\t")[1].should == "TRUE"
+    end
+
+    it "should build the correct cookie string" do
+      cookie_string = @result.first
+      cookie_string.should ==
+        ".dallien.net\tTRUE\t/\tFALSE\t1234567890\tNAME\tVALUE"
+    end
+  end
+
+  describe "with a cookie that has a host not starting with a dot" do
+    before :each do
+      @fake_cookie_db.should_receive(:execute).and_yield(
+        { 'host_key' => 'jeff.dallien.net',
+          'path' => '/path',
+          'secure' => '1',
+          'expires_utc' => '1234567890',
+          'name' => 'NAME',
+          'value' => 'VALUE'})
+      @extractor = CookieExtractor::ChromeCookieExtractor.new('filename')
+      @result = @extractor.extract
+    end
+
+    it "should return one cookie string" do
+      @result.size.should == 1
+    end
+
+    it "should put FALSE in the domain wide field" do
+      cookie_string = @result.first
+      cookie_string.split("\t")[1].should == "FALSE"
+    end
+
+    it "should build the correct cookie string" do
+      cookie_string = @result.first
+      cookie_string.should ==
+        "jeff.dallien.net\tFALSE\t/path\tTRUE\t1234567890\tNAME\tVALUE"
+    end
+  end
+
+  describe "with a cookie that is not marked as secure" do
+    before :each do
+      @fake_cookie_db.should_receive(:execute).and_yield(
+        { 'host_key' => '.dallien.net',
+          'path' => '/',
+          'secure' => '0',
+          'expires_utc' => '1234567890',
+          'name' => 'NAME',
+          'value' => 'VALUE'})
+      @extractor = CookieExtractor::ChromeCookieExtractor.new('filename')
+      @result = @extractor.extract
+    end
+
+    it "should put FALSE in the secure field" do
+      cookie_string = @result.first
+      cookie_string.split("\t")[3].should == "FALSE"
+    end
+  end
+
+  describe "with a cookie that is marked as secure" do
+    before :each do
+      @fake_cookie_db.should_receive(:execute).and_yield(
+        { 'host_key' => '.dallien.net',
+          'path' => '/',
+          'secure' => '1',
+          'expires_utc' => '1234567890',
+          'name' => 'NAME',
+          'value' => 'VALUE'})
+      @extractor = CookieExtractor::ChromeCookieExtractor.new('filename')
+      @result = @extractor.extract
+    end
+
+    it "should put TRUE in the secure field" do
+      cookie_string = @result.first
+      cookie_string.split("\t")[3].should == "TRUE"
+    end
+  end
+end

data/spec/cookie_extractor_spec.rb

@@ -0,0 +1,6 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe CookieExtractor do
+
+
+end

data/spec/firefox_cookie_extractor_spec.rb

@@ -0,0 +1,136 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe CookieExtractor::FirefoxCookieExtractor do
+  before :each do
+    @fake_cookie_db = double("cookie database",
+      :results_as_hash= => true,
+      :close => true)
+    SQLite3::Database.should_receive(:new).
+      with('filename').
+        and_return(@fake_cookie_db)
+  end
+
+  describe "opening and closing a sqlite db" do
+    before :each do
+      @fake_cookie_db.should_receive(:execute).and_yield(
+        {'host' => '.dallien.net',
+          'path' => '/',
+          'isSecure' => '0',
+          'expiry' => '1234567890',
+          'name' => 'NAME',
+          'value' => 'VALUE'})
+      @extractor = CookieExtractor::FirefoxCookieExtractor.new('filename')
+    end
+
+    it "should close the db when finished" do
+      @fake_cookie_db.should_receive(:close)
+      @extractor.extract
+    end
+  end
+
+  describe "with a cookie that has a host starting with a dot" do
+    before :each do
+      @fake_cookie_db.should_receive(:execute).and_yield(
+        {'host' => '.dallien.net',
+          'path' => '/',
+          'isSecure' => '0',
+          'expiry' => '1234567890',
+          'name' => 'NAME',
+          'value' => 'VALUE'})
+      @extractor = CookieExtractor::FirefoxCookieExtractor.new('filename')
+      @result = @extractor.extract
+    end
+
+    it "should return one cookie string" do
+      @result.size.should == 1
+    end
+
+    it "should put TRUE in the domain wide field" do
+      cookie_string = @result.first
+      cookie_string.split("\t")[1].should == "TRUE"
+    end
+
+    it "should put FALSE in the secure field" do
+      cookie_string = @result.first
+      cookie_string.split("\t")[3].should == "FALSE"
+    end
+
+    it "should build the correct cookie string" do
+      cookie_string = @result.first
+      cookie_string.should ==
+        ".dallien.net\tTRUE\t/\tFALSE\t1234567890\tNAME\tVALUE"
+    end
+  end
+
+  describe "with a cookie that has a host not starting with a dot" do
+    before :each do
+      @fake_cookie_db.should_receive(:execute).and_yield(
+        { 'host' => 'jeff.dallien.net',
+          'path' => '/path',
+          'isSecure' => '1',
+          'expiry' => '1234567890',
+          'name' => 'NAME',
+          'value' => 'VALUE'})
+      @extractor = CookieExtractor::FirefoxCookieExtractor.new('filename')
+      @result = @extractor.extract
+    end
+
+    it "should return one cookie string" do
+      @result.size.should == 1
+    end
+
+    it "should put FALSE in the domain wide field" do
+      cookie_string = @result.first
+      cookie_string.split("\t")[1].should == "FALSE"
+    end
+
+    it "should put TRUE in the secure field" do
+      cookie_string = @result.first
+      cookie_string.split("\t")[3].should == "TRUE"
+    end
+
+    it "should build the correct cookie string" do
+      cookie_string = @result.first
+      cookie_string.should ==
+        "jeff.dallien.net\tFALSE\t/path\tTRUE\t1234567890\tNAME\tVALUE"
+    end
+  end
+
+  describe "with a cookie that is not marked as secure" do
+    before :each do
+      @fake_cookie_db.should_receive(:execute).and_yield(
+        {'host' => '.dallien.net',
+          'path' => '/',
+          'isSecure' => '0',
+          'expiry' => '1234567890',
+          'name' => 'NAME',
+          'value' => 'VALUE'})
+      @extractor = CookieExtractor::FirefoxCookieExtractor.new('filename')
+      @result = @extractor.extract
+    end
+
+    it "should put FALSE in the secure field" do
+      cookie_string = @result.first
+      cookie_string.split("\t")[3].should == "FALSE"
+    end
+  end
+
+  describe "with a cookie that is marked as secure" do
+    before :each do
+      @fake_cookie_db.should_receive(:execute).and_yield(
+        {'host' => '.dallien.net',
+          'path' => '/',
+          'isSecure' => '1',
+          'expiry' => '1234567890',
+          'name' => 'NAME',
+          'value' => 'VALUE'})
+      @extractor = CookieExtractor::FirefoxCookieExtractor.new('filename')
+      @result = @extractor.extract
+    end
+
+    it "should put TRUE in the secure field" do
+      cookie_string = @result.first
+      cookie_string.split("\t")[3].should == "TRUE"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "cookie_extractor"))
+

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: coookies
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Matias Fernandez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Extract cookies from Firefox, Chrome or Chromium sqlite databases into
+  a wget-compatible cookies.txt file.
+email:
+- matiasfmolinari@gmail.com
+executables:
+- cookie_extractor
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rvmrc"
+- CHANGES.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/cookie_extractor
+- cookie_extractor.gemspec
+- lib/cookie_extractor.rb
+- lib/cookie_extractor/browser_detector.rb
+- lib/cookie_extractor/chrome_cookie_extractor.rb
+- lib/cookie_extractor/common.rb
+- lib/cookie_extractor/firefox_cookie_extractor.rb
+- lib/cookie_extractor/version.rb
+- spec/browser_detector_spec.rb
+- spec/chrome_cookie_extractor_spec.rb
+- spec/cookie_extractor_spec.rb
+- spec/firefox_cookie_extractor_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: cookie_extractor
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: Create cookies.txt from Firefox or Chrome/Chromium cookies
+test_files:
+- spec/browser_detector_spec.rb
+- spec/chrome_cookie_extractor_spec.rb
+- spec/cookie_extractor_spec.rb
+- spec/firefox_cookie_extractor_spec.rb
+- spec/spec_helper.rb