dossier 2.0.0

data/lib/dossier/configuration.rb

@@ -0,0 +1,28 @@
+require 'yaml'
+
+module Dossier
+  class Configuration
+
+    attr_accessor :config_path, :connection_options, :client
+
+    def initialize
+      @config_path = Rails.root.join('config', 'dossier.yml')
+      setup_client!
+    end
+
+    private
+
+    def setup_client!
+      @connection_options = YAML.load_file(@config_path)[Rails.env].symbolize_keys
+      @client = Dossier::Client.new(@connection_options)
+
+    rescue Errno::ENOENT => e
+      raise ConfigurationMissingError.new(
+        "#{e.message}. #{@config_path} must exist for Dossier to connect to the database."
+      )
+    end
+
+  end
+
+  class ConfigurationMissingError < StandardError ; end
+end

data/lib/dossier/engine.rb

@@ -0,0 +1,7 @@
+require 'rails'
+require 'haml'
+
+module Dossier
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/dossier/formatter.rb

@@ -0,0 +1,33 @@
+module Dossier
+  module Formatter
+    extend self
+    extend ActiveSupport::Inflector
+    extend ActionView::Helpers::NumberHelper
+
+    def number_to_currency_from_cents(value)
+      number_to_currency(value /= 100.0)
+    end
+
+    def url_formatter
+      @url_formatter ||= UrlFormatter.new
+    end
+
+    delegate :url_for, :link_to, :url_helpers, to: :url_formatter
+
+    class UrlFormatter
+      include ActionView::Helpers::UrlHelper
+
+      def _routes
+        Rails.application.routes
+      end
+
+      # No controller in current context, must be specified when generating routes
+      def controller
+      end
+
+      def url_helpers
+        _routes.url_helpers
+      end
+    end
+  end
+end

data/lib/dossier/query.rb

@@ -0,0 +1,30 @@
+module Dossier
+  class Query
+
+    attr_reader :string, :report
+
+    def initialize(report)
+      @report = report
+      @string = report.sql.dup
+    end
+
+    def to_s
+      compile
+    end
+
+    private
+
+    def compile
+      string.gsub(/\w*\:\w+/) { |match| escape(report.public_send(match[1..-1])) }
+    end
+
+    def escape(value)
+      if value.respond_to?(:map)
+        "(#{value.map { |v| escape(v) }.join(', ')})"
+      else
+        report.dossier_client.escape(value)
+      end
+    end
+
+  end
+end

data/lib/dossier/report.rb

@@ -0,0 +1,69 @@
+module Dossier
+  class Report
+    include ActiveSupport::Callbacks
+    extend ActiveModel::Naming
+
+    define_callbacks :build_query, :execute
+
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options.dup.with_indifferent_access
+    end
+
+    def sql
+      raise NotImplementedError, "`sql` method must be defined by each report"
+    end
+
+    def query
+      build_query unless defined?(@query)
+      @query.to_s
+    end
+
+    def results
+      execute unless defined?(@results)
+      @results
+    end
+
+    def raw_results
+      execute unless defined?(@raw_results)
+      @raw_results
+    end
+
+    def run
+      tap { execute }
+    end
+
+    def view
+      self.class.name.sub(/Report\Z/, '').underscore
+    end
+
+    def formatter
+      Dossier::Formatter
+    end
+
+    def dossier_client
+      Dossier.client
+    end
+
+    private
+
+    def build_query
+      run_callbacks(:build_query) { @query = Dossier::Query.new(self) }
+    end
+
+    def execute
+      build_query
+      run_callbacks :execute do
+        self.results = dossier_client.execute(query, self.class.name)
+      end
+    end
+
+    def results=(results)
+      results.freeze
+      @raw_results = Result::Unformatted.new(results, self)
+      @results     = Result::Formatted.new(results, self)
+    end
+
+  end
+end

data/lib/dossier/result.rb

@@ -0,0 +1,67 @@
+module Dossier
+  class Result
+    include Enumerable
+
+    attr_accessor :report, :adapter_results
+
+    def initialize(adapter_results, report)
+      self.adapter_results = adapter_results
+      self.report          = report
+    end
+
+    def headers
+      adapter_results.headers
+    end
+
+    def body
+      rows.first(rows.length - report.options[:footer].to_i)
+    end
+
+    def footers
+      rows.last(report.options[:footer].to_i)
+    end
+
+    def rows
+      @rows ||= to_a
+    end
+
+    def arrays
+      @arrays ||= [headers] + rows
+    end
+
+    def hashes
+      return @hashes if defined?(@hashes)
+      @hashes = rows.map { |row| Hash[headers.zip(row)] }
+    end
+
+    def each
+      raise NotImplementedError, "Every result class must define `each`"
+    end
+
+    class Formatted < Result
+      def each
+        adapter_results.rows.each do |row|
+          yield format(row)
+        end
+      end
+
+      def format(result_row)
+        unless result_row.kind_of?(Enumerable)
+          raise ArgumentError.new("#{result_row.inspect} must be a kind of Enumerable") 
+        end
+
+        result_row.each_with_index.map do |field, i|
+          method = "format_#{headers[i]}"
+          report.respond_to?(method) ? report.public_send(method, field) : field
+        end
+      end
+    end
+
+    class Unformatted < Result
+      def each
+        adapter_results.rows.each { |row| yield row }
+      end
+    end
+
+  end
+end

data/lib/dossier/stream_csv.rb

@@ -0,0 +1,24 @@
+require 'csv'
+
+module Dossier
+  class StreamCSV
+
+    def initialize(collection, headers = nil)
+      @headers    = headers || collection.shift
+      @collection = collection
+    end
+
+    def each
+      yield @headers.map { |header| Dossier::Formatter.titleize(header) }.to_csv
+      @collection.each do |record|
+        yield record.to_csv
+      end
+    rescue => e
+      yield e.message
+      e.backtrace.each do |line|
+        yield "#{line}\n"
+      end
+    end
+
+  end
+end

data/lib/dossier/version.rb

@@ -0,0 +1,3 @@
+module Dossier
+  VERSION = "2.0.0"
+end

data/lib/tasks/dossier_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :dossier do
+#   # Task goes here
+# end

data/spec/dossier/adapter/active_record/result_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Dossier::Adapter::ActiveRecord::Result do
+
+  let(:ar_connection_results) { double(:results, columns: %w[name age], rows: [['bob', 20], ['sue', 30]]) }
+  let(:result)                { described_class.new(ar_connection_results) }
+
+  describe "headers" do
+
+    let(:fake_columns) { %[foo bar] }
+
+    it "calls `columns` on its connection_results" do
+      ar_connection_results.should_receive(:columns)
+      result.headers
+    end
+
+    it "returns the columns from the connection_results" do
+      expect(result.headers).to eq(ar_connection_results.columns)
+    end
+
+  end
+
+  describe "rows" do
+
+    it "returns the connection_results" do
+      expect(result.rows).to eq(ar_connection_results.rows)
+    end
+
+  end
+end
+

data/spec/dossier/adapter/active_record_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Dossier::Adapter::ActiveRecord do
+
+  let(:ar_connection) { double(:activerecord_connection) }
+  let(:adapter)       { described_class.new({connection: ar_connection}) }
+
+  describe "escaping" do
+
+    let(:dirty_value) { "Robert'); DROP TABLE Students;--" }
+    let(:clean_value) { "'Robert\\'); DROP TABLE Students;--'" }
+
+    it "delegates to the connection" do
+      ar_connection.should_receive(:quote).with(dirty_value)
+      adapter.escape(dirty_value)
+    end
+
+    it "returns the connection's escaped value" do
+      ar_connection.stub(:quote).and_return(clean_value)
+      expect(adapter.escape(dirty_value)).to eq(clean_value)
+    end
+
+  end
+
+  describe "execution" do
+
+    let(:query)                { 'SELECT * FROM `people_who_resemble_vladimir_putin`' }
+    let(:connection_results)   { [] }
+    let(:adapter_result_class) { Dossier::Adapter::ActiveRecord::Result}
+
+    it "delegates to the connection" do
+      ar_connection.should_receive(:exec_query).with(query)
+      adapter.execute(query)
+    end
+
+    it "builds an adapter result" do
+      ar_connection.stub(:exec_query).and_return(connection_results)
+      adapter_result_class.should_receive(:new).with(connection_results)
+      adapter.execute(:query)
+    end
+
+    it "returns the adapter result" do
+      ar_connection.stub(:exec_query).and_return(connection_results)
+      expect(adapter.execute(:query)).to be_a(adapter_result_class)
+    end
+
+    it "rescues any errors and raises a Dossier::ExecuteError" do
+      ar_connection.stub(:exec_query).and_raise(StandardError.new('wat'))
+      expect{ adapter.execute(:query) }.to raise_error(Dossier::ExecuteError)
+    end
+
+  end
+
+end

data/spec/dossier/client_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Dossier::Client do
+
+  let(:connection) { 
+    double(:connection, class: double(:class, name: 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')) 
+  }
+
+  describe "initialization" do
+
+    describe "finding the correct adapter" do
+
+      context "when given a connection object" do
+
+        let(:client) { described_class.new(connection: connection) }
+
+        it "determines the adapter from the connection's class" do
+          expect(client.adapter).to be_a(Dossier::Adapter::ActiveRecord)
+        end
+
+      end
+
+      context "when given a dossier_adapter option" do
+
+        before :each do
+          Dossier::Adapter::SpecAdapter = Struct.new(:options)
+        end
+
+        after :each do
+          Dossier::Adapter.send(:remove_const, :SpecAdapter)
+        end
+
+        it "uses an adapter by that name" do
+          Dossier::Adapter::SpecAdapter.should_receive(:new).with(username: 'Timmy')
+          described_class.new(dossier_adapter: 'spec_adapter', username: 'Timmy')
+        end
+
+      end
+
+      context "when not given a connection or a dossier_adapter option" do
+
+        let(:client)   { described_class.new(username: 'Jimmy') }
+
+        describe "if there is one known ORM loaded" do
+          
+          before :each do
+            described_class.any_instance.stub(:loaded_orms).and_return([double(:class, name: 'ActiveRecord::Base')])
+          end
+
+          it "uses that ORM's adapter" do
+            Dossier::Adapter::ActiveRecord.should_receive(:new).with(username: 'Jimmy')
+            described_class.new(username: 'Jimmy')
+          end
+
+        end
+
+        context "if there are no known ORMs loaded" do
+
+          before :each do
+            described_class.any_instance.stub(:loaded_orms).and_return([])
+          end
+
+          it "raises an error" do
+            expect{described_class.new(username: 'Jimmy')}.to raise_error(Dossier::Client::IndeterminableAdapter)
+          end
+
+        end
+
+        describe "if there are multiple known ORMs loaded" do
+
+          before :each do
+            described_class.any_instance.stub(:loaded_orms).and_return([:orm1, :orm2])
+          end
+
+          it "raises an error" do
+            expect{described_class.new(username: 'Jimmy')}.to raise_error(Dossier::Client::IndeterminableAdapter)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "instances" do
+
+    let(:client)  { described_class.new(connection: connection) }
+    let(:adapter) { double(:adapter) }
+
+    before :each do
+      client.stub(:adapter).and_return(adapter)
+    end
+
+    it "delegates `escape` to its adapter" do
+      adapter.should_receive(:escape).with('Bobby Tables')
+      client.escape('Bobby Tables')
+    end
+
+    it "delegates `execute` to its adapter" do
+      adapter.should_receive(:execute).with('SELECT * FROM `primes`') # It's OK, it's in the cloud!
+      client.execute('SELECT * FROM `primes`')
+    end
+
+
+  end
+
+end