oculus 0.5.0

data/lib/oculus/storage/file_store.rb

@@ -0,0 +1,129 @@
+require 'yaml'
+require 'csv'
+
+module Oculus
+  module Storage
+    class FileStore
+      def initialize(root)
+        @root = root
+      end
+
+      def all_queries
+        Dir["#{root}/*.query"].map do |path|
+          File.parse(path)
+        end.sort { |a,b| b.id <=> a.id }
+      end
+
+      def save_query(query)
+        query.id = next_id if query.id.nil?
+
+        File.open(filename_for_id(query.id), 'w') do |file|
+          file.write_prelude(query.attributes)
+          file.write_results(query.results) if query.results
+        end
+      end
+
+      def load_query(id)
+        path = filename_for_id(id)
+
+        if File.exist?(path)
+          File.parse(path)
+        else
+          raise QueryNotFound, id
+        end
+      end
+
+      def delete_query(id)
+        path = filename_for_id(id)
+
+        if File.exist?(path)
+          File.unlink(path)
+        else
+          raise QueryNotFound, id
+        end
+      end
+
+      private
+
+      class File < ::File
+        def self.parse(path)
+          file = File.open(path)
+          attributes = file.attributes
+          attributes[:results] = file.results
+          Oculus::Query.new(attributes).tap do |query|
+            query.id = File.basename(path).split('.').first.to_i
+          end
+        end
+
+        def write_prelude(attributes)
+          write(YAML.dump(attributes))
+          puts("---")
+        end
+
+        def write_results(results)
+          csv_data = CSV.generate do |csv|
+            csv << results.first
+            results[1..-1].each do |result|
+              csv << result
+            end
+          end
+
+          write csv_data
+        end
+
+        def attributes
+          rewind
+
+          raw = gets
+
+          until (line = gets) == "---\n"
+            raw += line
+          end
+
+          YAML.load(raw)
+        end
+
+        def results
+          rewind
+
+          section  = 0
+          section += 1 if gets.rstrip == "---" until section == 2 || eof?
+
+          CSV.new(read).to_a
+        end
+      end
+
+      def filename_for_id(id)
+        raise ArgumentError unless id.is_a?(Integer) || id =~ /^[0-9]+/
+        File.join(root, "#{id}.query")
+      end
+
+      def next_id
+        reset_primary_key unless File.exist?(primary_key_path)
+        id_file = File.open(primary_key_path, 'r+')
+        id_file.flock(File::LOCK_EX)
+
+        id = id_file.read.to_i
+
+        id_file.rewind
+        id_file.write(id + 1)
+        id_file.flock(File::LOCK_UN)
+        id_file.close
+
+        id
+      end
+
+      def reset_primary_key
+        File.open(primary_key_path, 'w') do |file|
+          file.puts '0'
+        end
+      end
+
+      def primary_key_path
+        File.join(root, 'NEXT_ID')
+      end
+
+      attr_reader :root
+    end
+  end
+end

data/lib/oculus/storage.rb

@@ -0,0 +1,7 @@
+require 'oculus/storage/file_store'
+
+module Oculus
+  module Storage
+    class QueryNotFound < RuntimeError; end
+  end
+end

data/lib/oculus/version.rb

@@ -0,0 +1,3 @@
+module Oculus
+  VERSION = "0.5.0"
+end

data/lib/oculus.rb

@@ -0,0 +1,29 @@
+require "oculus/version"
+require "oculus/storage"
+require "oculus/connection"
+require "oculus/query"
+
+module Oculus
+  extend self
+
+  DEFAULT_CONNECTION_OPTIONS = { :host => 'localhost', :username => 'root' }
+
+  attr_writer :cache_path
+
+  def cache_path
+    @cache_path ||= 'tmp/data'
+  end
+
+  attr_writer :data_store
+
+  def data_store
+    @data_store ||= Oculus::Storage::FileStore.new(Oculus.cache_path)
+  end
+
+  attr_writer :connection_options
+
+  def connection_options
+    @connection_options ||= DEFAULT_CONNECTION_OPTIONS
+  end
+end
+

data/oculus.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/oculus/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Paul Rosania"]
+  gem.email         = ["paul.rosania@gmail.com"]
+  gem.description   = %q{Oculus is a web-based logging SQL client.  It keeps a history of your queries and the results they returned, so your research is always at hand, easy to share and easy to repeat or reproduce in the future.}
+  gem.summary       = %q{Oculus is a web-based logging SQL client.}
+  gem.homepage      = "https://github.com/paulrosania/oculus"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "oculus"
+  gem.require_paths = ["lib"]
+  gem.version       = Oculus::VERSION
+
+  gem.add_runtime_dependency "sinatra", [">= 1.3.0"]
+  gem.add_runtime_dependency "mysql2",  [">= 0.3.11"]
+  gem.add_runtime_dependency "vegas",   [">= 0.1.4"]
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "cucumber", [">= 1"]
+  gem.add_development_dependency "rspec",    [">= 2"]
+  gem.add_development_dependency "capybara", [">= 1"]
+end

data/spec/connection_spec.rb

@@ -0,0 +1,61 @@
+require 'oculus'
+
+describe Oculus::Connection do
+  before(:all) do
+    client = Mysql2::Client.new(:host => "localhost", :username => "root")
+    client.query "CREATE DATABASE IF NOT EXISTS test"
+    client.query "USE test"
+    client.query %[
+      CREATE TABLE IF NOT EXISTS oculus_users (
+        id MEDIUMINT NOT NULL AUTO_INCREMENT,
+        name VARCHAR(255),
+        PRIMARY KEY (id)
+      );
+  ]
+
+    client.query 'TRUNCATE oculus_users'
+
+    client.query %[
+      INSERT INTO oculus_users (name) VALUES ('Paul'), ('Amy'), ('Peter')
+    ]
+  end
+
+  subject { Oculus::Connection::Mysql2.new(:database => 'test') }
+
+  it "fetches a result set" do
+    subject.execute("SELECT * FROM oculus_users").should == [['id', 'name'], [1, 'Paul'], [2, 'Amy'], [3, 'Peter']]
+  end
+
+  it "returns nil for queries that don't return result sets" do
+    query_connection = Mysql2::Client.new(:host => "localhost", :database => "test")
+    thread_id = query_connection.thread_id
+    Thread.new {
+      query_connection.execute("SELECT * FROM oculus_users WHERE SLEEP(2)")
+    }
+
+    sleep 0.1
+    subject.execute("KILL QUERY #{thread_id}").should be_nil
+  end
+
+  it "raises a Connection::Error on syntax errors" do
+    lambda {
+      subject.execute("FOO BAZ QUUX")
+    }.should raise_error(Oculus::Connection::Error)
+  end
+
+  it "raises a Connection::Error when the query is interrupted" do
+    thread_id = subject.thread_id
+    Thread.new {
+      sleep 0.1
+      Mysql2::Client.new(:host => "localhost", :username => "root").query("KILL QUERY #{thread_id}")
+    }
+
+    lambda {
+      subject.execute("SELECT * FROM oculus_users WHERE SLEEP(2)")
+    }.should raise_error(Oculus::Connection::Error)
+  end
+
+  it "provides the connection's thread_id" do
+    subject.thread_id.should be_an Integer
+  end
+end

data/spec/file_store_spec.rb

@@ -0,0 +1,111 @@
+require 'oculus'
+
+describe Oculus::Storage::FileStore do
+  subject { Oculus::Storage::FileStore.new('tmp/test_cache') }
+
+  let(:query) do
+    Oculus::Query.new(:name      => "All users",
+                      :query     => "SELECT * FROM oculus_users",
+                      :author    => "Paul",
+                      :thread_id => 42,
+                      :results   => [['id', 'users'], ['1', 'Paul'], ['2', 'Amy']])
+  end
+
+  let(:other_query) do
+    Oculus::Query.new(:name      => "Admin users",
+                      :query     => "SELECT * FROM oculus_users WHERE is_admin = 1",
+                      :author    => "Paul",
+                      :thread_id => 42,
+                      :results   => [['id', 'users'], ['2', 'Amy']])
+  end
+
+  let(:broken_query) do
+    Oculus::Query.new(:name      => "Admin users",
+                      :query     => "FOO BAZ QUUX",
+                      :author    => "Paul",
+                      :thread_id => 42,
+                      :error     => "You have an error in your SQL syntax")
+  end
+
+  before do
+    FileUtils.mkdir_p('tmp/test_cache')
+  end
+
+  after do
+    FileUtils.rm_r('tmp/test_cache')
+  end
+
+  it "round-trips a query with no results to disk" do
+    query = Oculus::Query.new(:name => "Unfinished query", :author => "Me")
+    subject.save_query(query)
+    subject.load_query(query.id).results.should == []
+    subject.load_query(query.id).query.should == query.query
+    subject.load_query(query.id).date.should == query.date
+    subject.load_query(query.id).author.should == query.author
+    subject.load_query(query.id).id.should == query.id
+    subject.load_query(query.id).thread_id.should == query.thread_id
+  end
+
+  it "round-trips a query with an error to disk" do
+    subject.save_query(broken_query)
+    subject.load_query(broken_query.id).results.should == []
+    subject.load_query(broken_query.id).error.should == broken_query.error
+    subject.load_query(broken_query.id).query.should == broken_query.query
+    subject.load_query(broken_query.id).date.should == broken_query.date
+    subject.load_query(broken_query.id).author.should == broken_query.author
+    subject.load_query(broken_query.id).id.should == broken_query.id
+    subject.load_query(broken_query.id).thread_id.should == broken_query.thread_id
+  end
+
+  it "round-trips a query to disk" do
+    subject.save_query(query)
+    subject.load_query(query.id).results.should == query.results
+    subject.load_query(query.id).query.should == query.query
+    subject.load_query(query.id).date.should == query.date
+    subject.load_query(query.id).author.should == query.author
+    subject.load_query(query.id).id.should == query.id
+    subject.load_query(query.id).thread_id.should == query.thread_id
+  end
+
+  it "doesn't overwrite an existing query id when saving" do
+    subject.save_query(query)
+    original_id = query.id
+    subject.save_query(query)
+    query.id.should == original_id
+  end
+
+  it "raises QueryNotFound for missing queries" do
+    lambda {
+      subject.load_query(39827493)
+    }.should raise_error(Oculus::Storage::QueryNotFound)
+  end
+
+  it "fetches all queries in reverse chronological order" do
+    subject.save_query(query)
+    subject.save_query(other_query)
+
+    subject.all_queries.map(&:results).should == [other_query.results, query.results]
+  end
+
+  it "deletes queries" do
+    subject.save_query(query)
+    subject.load_query(query.id).name.should == query.name
+    subject.delete_query(query.id)
+
+    lambda {
+      subject.load_query(query.id)
+    }.should raise_error(Oculus::Storage::QueryNotFound)
+  end
+
+  it "raises QueryNotFound when deleting a nonexistent query" do
+    lambda {
+      subject.delete_query(10983645)
+    }.should raise_error(Oculus::Storage::QueryNotFound)
+  end
+
+  it "sanitizes query IDs" do
+    lambda {
+      subject.delete_query('..')
+    }.should raise_error(ArgumentError)
+  end
+end

data/spec/query_presenter_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../lib/oculus/query'
+require_relative '../lib/oculus/presenters/query_presenter'
+
+describe Oculus::Presenters::QueryPresenter do
+  let(:query) { Oculus::Query.new }
+  let(:presenter) { Oculus::Presenters::QueryPresenter.new(query) }
+
+  it "should delegate to the underlying query" do
+    query.name = 'foo'
+    presenter.description.should == 'foo'
+  end
+
+  it "has a formatted date" do
+    query.date = Time.mktime(2010, 1, 1, 12, 34)
+    presenter.formatted_date.should == '2010-01-01 12:34'
+  end
+
+  it "reports successful queries" do
+    query.stub(:complete?).and_return(true)
+    presenter.status.should == 'done'
+  end
+
+  it "reports failed queries" do
+    query.stub(:complete?).and_return(true)
+    query.stub(:error).and_return("you fail")
+    presenter.status.should == 'error'
+  end
+
+  it "reports loading queries" do
+    query.stub(:complete?).and_return(false)
+    presenter.status.should == 'loading'
+  end
+
+  it "uses name for a description when there is one" do
+    query.name = "foo"
+    presenter.description.should == "foo"
+  end
+
+  it "uses SQL for a description when there isn't a name" do
+    query.name = nil
+    query.query = "SELECT * FROM foo"
+    presenter.description.should == "SELECT * FROM foo"
+  end
+
+  it "reports that the query has been named" do
+    query.name = "Select all the things"
+    presenter.should be_named
+  end
+
+  it "reports that the query has not been named" do
+    query.name = nil
+    presenter.should_not be_named
+  end
+end

data/spec/query_spec.rb

@@ -0,0 +1,107 @@
+require 'oculus'
+
+describe Oculus::Query do
+  before do
+    Oculus.data_store = stub
+  end
+
+  it "runs the query against the supplied connection" do
+    connection = stub
+    query = Oculus::Query.new(:query => 'SELECT * FROM users')
+    connection.should_receive(:execute).with('SELECT * FROM users')
+    query.execute(connection)
+  end
+
+  it "stores the results of running the query" do
+    connection = stub(:execute => [['id', 'name'], [1, 'Paul']])
+    query = Oculus::Query.new(:query => 'SELECT * FROM users')
+    query.execute(connection)
+    query.results.should == [['id', 'name'], [1, 'Paul']]
+  end
+
+  it "stores errors when queries fail" do
+    connection = stub
+    query = Oculus::Query.new(:query => 'SELECT * FROM users')
+    connection.stub(:execute).and_raise(Oculus::Connection::Error.new('You have an error in your SQL syntax'))
+    query.execute(connection)
+    query.error.should == 'You have an error in your SQL syntax'
+  end
+
+  it "stores the query itself" do
+    query = Oculus::Query.new(:query => 'SELECT * FROM users')
+    query.query.should == 'SELECT * FROM users'
+  end
+
+  it "stores the querying connection's thread ID" do
+    query = Oculus::Query.new(:thread_id => 42)
+    query.thread_id.should == 42
+  end
+
+  it "has a date" do
+    query = Oculus::Query.new
+    query.date.should be nil
+  end
+
+  it "updates date on save" do
+    Oculus.data_store.stub(:save_query)
+    Time.stub(:now).and_return(now = stub)
+    query = Oculus::Query.create(:results => [['id', 'name'], [1, 'Paul']])
+    query.date.should == now
+  end
+
+  it "has a name" do
+    query = Oculus::Query.new(:name => 'foo')
+    query.name.should == 'foo'
+  end
+
+  it "has an author" do
+    query = Oculus::Query.new(:author => 'Paul')
+    query.author.should == 'Paul'
+  end
+
+  it "stores new queries in the data store on creation" do
+    Oculus.data_store.should_receive(:save_query)
+    query = Oculus::Query.create(:results => [['id', 'name'], [1, 'Paul']])
+  end
+
+  it "stores new queries in the data store on save" do
+    Oculus.data_store.should_receive(:save_query)
+    query = Oculus::Query.new(:results => [['id', 'name'], [1, 'Paul']])
+    query.save
+  end
+
+  it "retrieves cached queries from the data store" do
+    Oculus.data_store.should_receive(:load_query).with(1)
+    Oculus::Query.find(1)
+  end
+
+  it "is not complete when no results are present" do
+    query = Oculus::Query.new(:query => 'SELECT * FROM users')
+    query.should_not be_complete
+  end
+
+  it "is complete when results are present" do
+    query = Oculus::Query.new(:results => [['id', 'name'], [1, 'Paul']])
+    query.should be_complete
+  end
+
+  it "is complete when there is an error" do
+    query = Oculus::Query.new(:error => "That's not how to write SQL")
+    query.should be_complete
+  end
+
+  it "is not successful when it's not complete" do
+    query = Oculus::Query.new(:query => 'SELECT * FROM users')
+    query.succeeded?.should be false
+  end
+
+  it "is successful when results are present" do
+    query = Oculus::Query.new(:results => [['id', 'name'], [1, 'Paul']])
+    query.succeeded?.should be true
+  end
+
+  it "is not successful when there is an error" do
+    query = Oculus::Query.new(:error => "That's not how to write SQL")
+    query.succeeded?.should be false
+  end
+end