fast_browser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5cf1f07c8cf5352d87676a1bf461dc53f7881120
+  data.tar.gz: 9d3d924ef18bfac7948dd3acc197c56d5813d457
+SHA512:
+  metadata.gz: 2f8e15193b73056ad463a242d8ff063e01971e2097ea7bcc65d243a585d409654fae0f05f3a22e184699db05808720c4666f50461d33b43acebabd9c2773e6ad
+  data.tar.gz: 13db7ca269f9f541af9bd18873d37a6627ad42b8b193648a4c7f1e3d2a42d931a250ca1ae4ae2772e8d654f1ea9307028ca572f5c8785145ab389e1db171000c

data/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+Cargo.lock
+Makefile
+mkmf.log
+ext/fast_browser
+pkg
+rust/target

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,29 @@
+language: rust
+
+rust:
+  - beta
+  - nightly
+
+matrix:
+  allow_failures:
+    - rust: nightly
+
+before_install:
+  - rvm install 2.3.0
+  - gem install bundler
+  - bundle install
+
+install:
+  - ruby ext/extconf.rb
+  - make
+
+script:
+  # Rust tests
+  - cd $TRAVIS_BUILD_DIR/rust
+  - cargo test
+  # Ruby specs
+  - cd $TRAVIS_BUILD_DIR
+  - bundle exec rspec
+  # Check that the gem builds and installs
+  - bundle exec rake install
+  - ruby -e "require 'rubygems'; require 'fast_browser'"

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    fast_browser (0.1.0)
+      ffi (~> 1.9.10)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    ffi (1.9.10)
+    rake (10.4.2)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  fast_browser!
+  rake (~> 10.4.2)
+  rspec (~> 3.4.0)
+
+BUNDLED WITH
+   1.11.2

data/Rakefile

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

data/ext/extconf.rb

@@ -0,0 +1,39 @@
+require 'mkmf'
+
+def sys(cmd, &block)
+  block = ->(f) { f.gets } if block.nil?
+
+  ret = IO.popen(cmd, &block)
+
+  if $?.to_i != 0
+    puts "=> Failed!"
+    raise "Command failed: #{cmd}"
+  else
+    ret
+  end
+end
+
+ROOT      = File.expand_path '..', File.dirname(__FILE__)
+RUST_ROOT = File.join ROOT, 'rust'
+
+puts ' - Checking Rust compiler'
+rustc = sys "cd #{RUST_ROOT}; rustc --version"
+
+if !(rustc.include?('rustc 1.6.0') || rustc.include?('rustc 1.7.0'))
+  puts "=> Bad Rust compiler version: #{rustc}"
+  puts '   Version 1.6.0 or 1.7.0 is required.'
+
+  raise "Invalid Rust compiler version"
+end
+
+# Create an empty makefile with an empty `install` task
+puts ' - Creating Makefile'
+File.open('Makefile', 'w') do |f|
+  body = [
+    "install:",
+    "\tcd #{RUST_ROOT}; cargo build --release",
+    "\tmkdir -p #{ROOT}/ext/fast_browser",
+    "\tcp #{RUST_ROOT}/target/release/libfast_browser.* #{ROOT}/ext/fast_browser"
+  ]
+  f.puts(body.join("\n") + "\n")
+end

data/fast_browser.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'fast_browser/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'fast_browser'
+  s.version     = FastBrowser::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Dirk Gadsden']
+  s.email       = ['dirk@esherido.com']
+  s.homepage    = 'https://github.com/dirk/fast_browser'
+  s.summary     = 'Blazing-fast, Rust-powered user agent detection library.'
+  s.description = s.summary
+  s.license     = ''
+
+  s.files         = `git ls-files`.split "\n"
+  s.test_files    = `git ls-files -- {test}/*`.split "\n"
+  s.require_paths = ['lib']
+  s.extensions    = ['ext/extconf.rb']
+
+  s.add_dependency 'ffi', '~> 1.9.10'
+
+  s.add_development_dependency 'bundler', '~> 1.10'
+  s.add_development_dependency 'rake', '~> 10.4.2'
+  s.add_development_dependency 'rspec', '~> 3.4.0'
+end

data/lib/fast_browser/library_extensions.rb

@@ -0,0 +1,15 @@
+class FastBrowser
+  module LibraryExtensions
+    def attach_string_returning_function(name, arg_types)
+      private_name = "_#{name}".to_sym
+
+      attach_function private_name, name, arg_types, :strptr
+
+      class_eval <<-BODY
+        def self.#{name}(*args)
+          call_and_free_string :#{private_name}, *args
+        end
+      BODY
+    end
+  end
+end

data/lib/fast_browser/version.rb

@@ -0,0 +1,3 @@
+class FastBrowser
+  VERSION = '0.1.0'
+end

data/lib/fast_browser.rb

@@ -0,0 +1,69 @@
+require 'ffi'
+
+require 'fast_browser/version'
+require 'fast_browser/library_extensions'
+
+class FastBrowser
+  module RustLib
+    extend FFI::Library
+    extend LibraryExtensions
+
+    lib_file = "libfast_browser.#{FFI::Platform::LIBSUFFIX}"
+    ffi_lib File.expand_path("../../ext/fast_browser/#{lib_file}", __FILE__)
+
+    %w(chrome edge firefox opera safari).each do |tester|
+      attach_function "is_#{tester}".to_sym, [:pointer], :bool
+    end
+
+    attach_function :get_browser_minor_version, [:pointer], :int8
+    attach_function :get_browser_major_version, [:pointer], :int8
+    attach_function :is_mobile, [:pointer], :bool
+
+    attach_string_returning_function :get_browser_family, [:pointer]
+    attach_string_returning_function :get_user_agent, [:pointer]
+    attach_string_returning_function :get_version, []
+
+    # Private Rust methods; don't call these directly!
+    attach_function :_parse_user_agent, :parse_user_agent, [:string], :pointer
+    attach_function :_free_user_agent,  :free_user_agent, [:pointer], :void
+    attach_function :_free_string,      :free_string, [:pointer], :void
+
+    # Sends the given method name (`method`) to self, copies the returned
+    # string into a Ruby string and then calls `.free_string` to deallocate
+    # the original returned string.
+    def self.call_and_free_string method, *args
+      string, ptr = send method, *args
+      _free_string ptr
+      string
+    end
+
+    def self.parse_user_agent string
+      FFI::AutoPointer.new(
+        self._parse_user_agent(string),
+        self.method(:_free_user_agent)
+      )
+    end
+  end
+
+  def initialize(string)
+    @pointer = RustLib.parse_user_agent(string)
+  end
+
+  def chrome?;  RustLib.is_chrome(@pointer)  end
+  def edge?;    RustLib.is_edge(@pointer)    end
+  def firefox?; RustLib.is_firefox(@pointer) end
+  def opera?;   RustLib.is_opera(@pointer)   end
+  def safari?;  RustLib.is_safari(@pointer)  end
+  def mobile?;  RustLib.is_mobile(@pointer)  end
+
+  def major_version; RustLib.get_browser_major_version(@pointer) end
+  def minor_version; RustLib.get_browser_minor_version(@pointer) end
+  def family;        RustLib.get_browser_family(@pointer) end
+  def user_agent;    RustLib.get_user_agent(@pointer) end
+end
+
+if FastBrowser::RustLib.get_version != FastBrowser::VERSION
+  e = FastBrowser::VERSION
+  g = FastBrowser::RustLib.get_version
+  raise "Rust library version doesn't match Ruby gem version (expected #{e}, got #{g})"
+end

data/rust/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "fast_browser"
+version = "0.0.1"
+authors = []
+
+[lib]
+name = "fast_browser"
+crate-type = ["dylib"]
+
+[dependencies]
+lazy_static = "0.1.*"
+libc = "0.2"
+regex = "0.1.47"

data/rust/build-debug.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+# Call this like `TARGET=release ./build-debug.sh` to do a release build
+
+# TODO: Make this set the right extension based on the current platform
+NATIVE_EXT=dylib
+
+if [ "$TARGET" == "release" ]; then
+  CARGO_ARGS=--release
+  TARGET=release
+else
+  CARGO_ARGS=
+  TARGET=debug
+fi
+
+set -x
+cargo build $CARGO_ARGS && cp target/$TARGET/libfast_browser.$NATIVE_EXT ../ext/fast_browser/libfast_browser.$NATIVE_EXT

data/rust/src/bot.rs

@@ -0,0 +1,66 @@
+use regex::{Regex};
+use util::map_first_captures;
+
+#[derive(Debug, PartialEq)]
+pub enum BotName {
+    Googlebot,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Bot {
+    pub name: BotName,
+}
+
+impl Bot {
+    pub fn new(name: BotName) -> Bot {
+        Bot { name: name, }
+    }
+
+    pub fn parse(ua: &str) -> Option<Bot> {
+        for matcher in MATCH_SEQUENCE.iter() {
+            if let Some(bot) = matcher(ua) {
+                return Some(bot)
+            }
+        }
+
+        None
+    }
+
+    fn match_googlebot(ua: &str) -> Option<Bot> {
+        let versions = GOOGLEBOT_REGEX
+            .captures(ua)
+            .map(map_first_captures);
+
+        if let Some(_) = versions {
+            Some(Bot::new(BotName::Googlebot))
+        } else {
+            None
+        }
+    }
+}
+
+type MatcherFn = Fn(&str) -> Option<Bot> + Sync;
+type Matcher = Box<MatcherFn>;
+
+lazy_static! {
+    static ref GOOGLEBOT_REGEX: Regex = Regex::new(r"Googlebot/(\d+)\.(\d+)").unwrap();
+
+    static ref MATCH_SEQUENCE: Vec<Matcher> = vec![
+        Box::new(Bot::match_googlebot),
+    ];
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Bot, BotName};
+
+    const GOOGLEBOT: &'static str = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+
+    #[test]
+    fn test_parse_googlebot() {
+        assert_eq!(
+            Bot::new(BotName::Googlebot),
+            Bot::parse(GOOGLEBOT).unwrap()
+        )
+    }
+}

data/rust/src/browser.rs

@@ -0,0 +1,181 @@
+use regex::{Regex};
+
+use util::map_first_captures;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum BrowserFamily {
+    Chrome,
+    Edge,
+    Firefox,
+    Opera,
+    Safari,
+    MobileSafari,
+}
+
+impl BrowserFamily {
+    pub fn is_mobile(&self) -> bool {
+        match self {
+            &BrowserFamily::MobileSafari => true,
+            _ => false,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Browser {
+    pub family: BrowserFamily,
+    pub major_version: i8,
+    pub minor_version: i8,
+}
+
+type MatcherFn = Fn(&str) -> Option<(i8, i8)> + Sync;
+type Matcher = (BrowserFamily, Box<MatcherFn>);
+
+lazy_static! {
+    // NOTE: Order of tests is significant
+    static ref MATCH_SEQUENCE: Vec<Matcher> = vec![
+        (BrowserFamily::Opera,        Box::new(Browser::match_opera)),
+        (BrowserFamily::Edge,         Box::new(Browser::match_edge)),
+        (BrowserFamily::Chrome,       Box::new(Browser::match_chrome)),
+        (BrowserFamily::Firefox,      Box::new(Browser::match_firefox)),
+        (BrowserFamily::MobileSafari, Box::new(Browser::match_mobile_safari)),
+        (BrowserFamily::Safari,       Box::new(Browser::match_safari)),
+    ];
+}
+
+impl Browser {
+    fn new(family: BrowserFamily, versions: (i8, i8)) -> Browser {
+        Browser {
+            family:        family,
+            major_version: versions.0,
+            minor_version: versions.1,
+        }
+    }
+
+    #[allow(unused_parens)]
+    pub fn parse(ua: &str) -> Option<Browser> {
+        // NOTE: Order of these tests is significant because browser vendors are terrible
+
+        for tuple in MATCH_SEQUENCE.iter() {
+            let &(ref family, ref matcher) = tuple;
+
+            if let Some(versions) = matcher(ua) {
+                let browser = Browser::new(family.clone(), versions);
+
+                return Some(browser)
+            }
+        }
+
+        return None
+    }
+
+    /// Take a regex and attempt to match it to the browser. The regex must include two capture
+    /// groups that capture the version of the matched browser.
+    fn match_versions(ua: &str, regex: &Regex) -> Option<(i8, i8)> {
+        regex
+            .captures(ua)
+            .map(map_first_captures)
+    }
+}
+
+lazy_static! {
+    static ref CHROME_REGEX: Regex         = Regex::new(r"Chrom(?:ium|e)/(\d+)\.(\d+)").unwrap();
+    static ref EDGE_REGEX: Regex           = Regex::new(r"Edge/(\d+)\.(\d+)").unwrap();
+    static ref FIREFOX_REGEX: Regex        = Regex::new(r"Firefox/(\d+)\.(\d+)").unwrap();
+    static ref OPERA_VERSION_REGEX: Regex  = Regex::new(r"Version/(\d+)\.(\d+)").unwrap();
+    static ref SAFARI_VERSION_REGEX: Regex = Regex::new(r"Version/(\d+)\.(\d+)").unwrap();
+}
+
+impl Browser {
+    pub fn match_edge(ua: &str) -> Option<(i8, i8)> {
+        Browser::match_versions(ua, &EDGE_REGEX)
+    }
+
+    /// Search for the Firefox componenet in the user agent and parse out the version if present
+    pub fn match_firefox(ua: &str) -> Option<(i8, i8)> {
+        Browser::match_versions(ua, &FIREFOX_REGEX)
+    }
+
+    pub fn match_chrome(ua: &str) -> Option<(i8, i8)> {
+        Browser::match_versions(ua, &CHROME_REGEX)
+    }
+
+    pub fn match_opera(ua: &str) -> Option<(i8, i8)> {
+        if !ua.contains("Opera") { return None }
+
+        Browser::match_versions(ua, &OPERA_VERSION_REGEX)
+    }
+
+    pub fn match_safari(ua: &str) -> Option<(i8, i8)> {
+        if !ua.contains("Safari") { return None }
+        if ua.contains("Mobile/") { return None }
+
+        Browser::match_versions(ua, &SAFARI_VERSION_REGEX)
+    }
+
+    pub fn match_mobile_safari(ua: &str) -> Option<(i8, i8)> {
+        if !ua.contains("Safari")  { return None }
+        if !ua.contains("Mobile/") { return None }
+
+        Browser::match_versions(ua, &SAFARI_VERSION_REGEX)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Browser, BrowserFamily};
+
+    type StaticStr = &'static str;
+
+    const OPERA_12: StaticStr        = "Opera/9.80 (X11; Linux i686; Ubuntu/14.10) Presto/2.12.388 Version/12.16";
+    const OPERA_11: StaticStr        = "Opera/9.80 (Windows NT 6.1; WOW64; U; pt) Presto/2.10.229 Version/11.62";
+    const SAFARI_7: StaticStr        = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_3) AppleWebKit/537.75.14 (KHTML, like Gecko) Version/7.0.3 Safari/7046A194A";
+    const SAFARI_5: StaticStr        = "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_3; en-us) AppleWebKit/534.1+ (KHTML, like Gecko) Version/5.0 Safari/533.16";
+    const MOBILE_SAFARI_6: StaticStr = "Mozilla/5.0 (iPad; CPU OS 6_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10A5355d Safari/8536.25";
+
+    #[test]
+    fn test_parse_safari() {
+        assert_eq!(
+            Browser::new(BrowserFamily::Safari, (7, 0)),
+            Browser::parse(SAFARI_7).unwrap()
+        );
+
+        assert_eq!(
+            Browser::new(BrowserFamily::MobileSafari, (6, 0)),
+            Browser::parse(MOBILE_SAFARI_6).unwrap()
+        )
+    }
+
+    #[test]
+    fn test_match_firefox() {
+        let did_match = Browser::match_firefox("Firefox/1.2");
+        assert_eq!(did_match, Some((1, 2)));
+
+        let didnt_match = Browser::match_firefox("NotFirefox/x.y");
+        assert_eq!(didnt_match, None)
+    }
+
+    #[test]
+    fn test_match_safari() {
+        let version_7 = Browser::match_safari(SAFARI_7);
+        assert_eq!(version_7, Some((7, 0)));
+
+        let version_5 = Browser::match_safari(SAFARI_5);
+        assert_eq!(version_5, Some((5, 0)));
+    }
+
+    #[test]
+    fn test_match_mobile_safari() {
+        let mobile_version_6 = Browser::match_mobile_safari(MOBILE_SAFARI_6);
+        assert_eq!(mobile_version_6, Some((6, 0)))
+    }
+
+    #[test]
+    fn test_match_opera() {
+        let opera_12 = Browser::match_opera(OPERA_12);
+        assert_eq!(opera_12, Some((12, 16)));
+
+        let opera_11 = Browser::match_opera(OPERA_11);
+        assert_eq!(opera_11, Some((11, 62)))
+    }
+}

data/rust/src/lib.rs

@@ -0,0 +1,109 @@
+#[macro_use]
+extern crate lazy_static;
+
+extern crate libc;
+extern crate regex;
+
+mod bot;
+mod browser;
+mod user_agent;
+mod util;
+
+use libc::c_char;
+use std::ffi::{CStr, CString};
+use self::browser::BrowserFamily;
+use self::user_agent::UserAgent;
+
+#[no_mangle]
+pub extern fn parse_user_agent(cstring: *const c_char) -> *const UserAgent {
+    let string  = unsafe { CStr::from_ptr(cstring) }.to_str().unwrap();
+    let browser = UserAgent::parse(string);
+
+    Box::into_raw(Box::new(browser))
+}
+
+/// Take back ownership of an externally-owned `Browser` and destructively deallocate it.
+#[no_mangle]
+pub extern fn free_user_agent(ua: *mut UserAgent) {
+    drop(unsafe { Box::from_raw(ua) })
+}
+
+macro_rules! is_family {
+    ($function:ident, $family:path) => {
+        #[no_mangle]
+        pub extern fn $function(ua: *const UserAgent) -> bool {
+            if let Some(ref browser) = UserAgent::borrow_from_c(ua).browser {
+                browser.family == $family
+            } else {
+                false
+            }
+        }
+    };
+}
+
+is_family!(is_chrome,  BrowserFamily::Chrome);
+is_family!(is_edge,    BrowserFamily::Edge);
+is_family!(is_firefox, BrowserFamily::Firefox);
+is_family!(is_opera,   BrowserFamily::Opera);
+is_family!(is_safari,  BrowserFamily::Safari);
+
+#[no_mangle]
+pub extern fn is_mobile(ua: *const UserAgent) -> bool {
+    let ua = UserAgent::borrow_from_c(ua);
+
+    match ua.browser {
+        Some(ref b) => b.family.is_mobile(),
+        _ => false
+    }
+}
+
+#[no_mangle]
+pub extern fn get_browser_major_version(ua: *const UserAgent) -> i8 {
+    UserAgent::borrow_from_c(ua).browser.clone().map_or(0, |b| b.major_version)
+}
+
+#[no_mangle]
+pub extern fn get_browser_minor_version(ua: *const UserAgent) -> i8 {
+    UserAgent::borrow_from_c(ua).browser.clone().map_or(0, |b| b.minor_version)
+}
+
+/// Returns the user agent's browser family name as a heap-allocated `CString`
+#[no_mangle]
+pub extern fn get_browser_family(ua: *const UserAgent) -> *mut c_char {
+    let browser = UserAgent::borrow_from_c(ua).browser.clone();
+
+    let family =
+        browser.map_or("Other", |browser| {
+            match browser.family {
+                BrowserFamily::Chrome       => "Chrome",
+                BrowserFamily::Edge         => "Edge",
+                BrowserFamily::Firefox      => "Firefox",
+                BrowserFamily::Opera        => "Opera",
+                BrowserFamily::Safari       => "Safari",
+                BrowserFamily::MobileSafari => "Mobile Safari",
+            }
+        });
+
+    CString::new(family).unwrap().into_raw()
+}
+
+/// Returns the original user agent that was parsed as a `CString` (must free later)
+#[no_mangle]
+pub extern fn get_user_agent(ua: *const UserAgent) -> *mut c_char {
+    let ref ua = UserAgent::borrow_from_c(ua);
+
+    CString::new(ua.source.clone()).unwrap().into_raw()
+}
+
+/// Free a `CString` pointer owned by Rust
+#[no_mangle]
+pub extern fn free_string(string: *mut c_char) {
+    drop(unsafe { CString::from_raw(string) })
+}
+
+const VERSION: &'static str = "0.0.1";
+
+#[no_mangle]
+pub extern fn get_version() -> *const c_char {
+    CString::new(VERSION).unwrap().into_raw()
+}

data/rust/src/user_agent.rs

@@ -0,0 +1,32 @@
+use std::mem;
+use bot::Bot;
+use browser::Browser;
+
+pub struct UserAgent {
+    pub browser: Option<Browser>,
+    pub bot: Option<Bot>,
+
+    /// The string that was parsed to determine the browser, bot, etc.
+    pub source: String,
+}
+
+impl UserAgent {
+    pub fn parse(ua: &str) -> UserAgent {
+        let browser = Browser::parse(ua);
+        let bot     = Bot::parse(ua);
+
+        UserAgent {
+            browser: browser,
+            bot: bot,
+            source: ua.to_owned(),
+        }
+    }
+
+    /// Take an externally-owned `Browser` and non-destructively borrow a reference to it.
+    ///
+    /// **Note**: This will *not* deallocate the instance passed in. So it is safe to call this
+    /// over and over again.
+    pub fn borrow_from_c<'a>(ua: *const UserAgent) -> &'a UserAgent {
+        unsafe { mem::transmute(ua) }
+    }
+}

data/rust/src/util.rs

@@ -0,0 +1,10 @@
+use regex::{Captures};
+use std::str::FromStr;
+
+/// Takes the first two capture groups from a regex result and turns them into a version
+/// integer 2-tuple
+pub fn map_first_captures(captures: Captures) -> (i8, i8) {
+    let major_version = i8::from_str(&captures[1]).unwrap();
+    let minor_version = i8::from_str(&captures[2]).unwrap();
+    (major_version, minor_version)
+}

data/spec/name_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe FastBrowser do
+  let(:firefox)       { 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.1' }
+  let(:mobile_safari) { 'Mozilla/5.0 (iPad; CPU OS 6_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10A5355d Safari/8536.25' }
+
+  it 'parses Firefox name' do
+    browser = FastBrowser.new firefox
+
+    expect(browser.family).to eq 'Firefox'
+  end
+
+  it 'parses Chrome name' do
+    browser = FastBrowser.new 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36'
+
+    expect(browser.family).to eq 'Chrome'
+  end
+
+  it 'returns Other if not parses matches' do
+    browser = FastBrowser.new 'Mozilla/5.0 Unknwon/1.2'
+
+    expect(browser.family).to eq 'Other'
+  end
+
+  it 'returns true if it is a mobile browser' do
+    browser = FastBrowser.new mobile_safari
+
+    expect(browser.mobile?).to eq true
+  end
+
+  it "returns false if it isn't a mobile browser" do
+    browser = FastBrowser.new firefox
+
+    expect(browser.mobile?).to eq false
+  end
+
+  describe '#user_agent' do
+    it 'returns the original user agent' do
+      nonsense = 'abc123'
+      browser  = FastBrowser.new nonsense
+
+      expect(browser.user_agent).to eq nonsense
+    end
+  end
+end

data/spec/safety_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe FastBrowser do
+  let(:firefox) { 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.1' }
+  let(:chrome)  { 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36' }
+
+  it 'seems to be memory-safe' do
+    b1 = FastBrowser.new firefox
+    expect(b1.firefox?).to eq true
+    expect(b1.chrome?).to eq false
+
+    b2 = FastBrowser.new chrome
+    expect(b2.firefox?).to eq false
+    expect(b2.chrome?).to eq true
+
+    # Then check each against to make sure they didn't overwrite each other
+    # or something
+
+    expect(b1.firefox?).to eq true
+    expect(b1.chrome?).to eq false
+
+    expect(b2.firefox?).to eq false
+    expect(b2.chrome?).to eq true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'fast_browser'

data/spec/version_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe FastBrowser do
+  it 'parses Firefox versions' do
+    browser = FastBrowser.new 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.1'
+
+    expect(browser.major_version).to eq 40
+    expect(browser.minor_version).to eq 1
+  end
+
+  it 'parses Chrome versions' do
+    browser = FastBrowser.new 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36'
+
+    expect(browser.major_version).to eq 41
+    expect(browser.minor_version).to eq 0
+  end
+end

data/test/benchmark/compare.rb

@@ -0,0 +1,72 @@
+require_relative '../test_helper'
+
+require 'benchmark'
+require 'minitest/autorun'
+
+require 'browser'
+require 'ruby-prof'
+
+class TestCompare < Minitest::Test
+  TIMES = 50_000
+
+  FIREFOX_40 = 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.1'
+
+  def test_compare_with_browser
+    ua = FIREFOX_40
+    result = nil
+
+    # Make sure the Rust lib is hot
+    _ = FastBrowser.new ua
+
+    test_browser = lambda do
+      TIMES.times do
+        b = Browser.new user_agent: ua
+        assert_equal b.firefox?, true
+        assert_equal "40", b.version
+      end
+    end
+
+    test_fast_browser = lambda do
+      TIMES.times do
+        b = FastBrowser.new ua
+        assert_equal b.firefox?, true
+        assert_equal 40, b.major_version
+      end
+    end
+
+    {
+      'browser' => test_browser,
+      'fast_browser' => test_fast_browser
+    }.each do |(name, test_block)|
+      time    = benchmark_time &test_block
+      objects = benchmark_memory &test_block
+
+      print "#{name.ljust(15)}%10.5f seconds\t%d objects\n" % [time, objects]
+    end
+  end
+
+  private
+
+  def profile(&block)
+    result = RubyProf.profile &block
+    RubyProf::FlatPrinter.new(result).print(STDOUT)
+  end
+
+  def benchmark_time &block
+    Benchmark.realtime &block
+  end
+
+  def benchmark_memory &block
+    GC.start
+
+    before_allocated = GC.stat[:total_allocated_objects]
+    GC.disable
+
+    block.call
+
+    after_allocated = GC.stat[:total_allocated_objects]
+    GC.enable
+
+    return after_allocated - before_allocated
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'fast_browser'

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: fast_browser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dirk Gadsden
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.9.10
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+description: Blazing-fast, Rust-powered user agent detection library.
+email:
+- dirk@esherido.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- ext/extconf.rb
+- fast_browser.gemspec
+- lib/fast_browser.rb
+- lib/fast_browser/library_extensions.rb
+- lib/fast_browser/version.rb
+- rust/Cargo.toml
+- rust/build-debug.sh
+- rust/src/bot.rs
+- rust/src/browser.rs
+- rust/src/lib.rs
+- rust/src/user_agent.rs
+- rust/src/util.rs
+- spec/name_spec.rb
+- spec/safety_spec.rb
+- spec/spec_helper.rb
+- spec/version_spec.rb
+- test/benchmark/compare.rb
+- test/test_helper.rb
+homepage: https://github.com/dirk/fast_browser
+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: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Blazing-fast, Rust-powered user agent detection library.
+test_files: []