dossier-segmenter 0.9.0

data/lib/dossier/segmenter.rb

@@ -0,0 +1,104 @@
+require 'dossier'
+require 'dossier/segmenter/engine'
+require 'dossier/segmenter/version'
+
+module Dossier
+  class Segmenter
+    attr_accessor :report
+
+    class << self
+      attr_accessor :report_class
+    end
+
+    def self.segments
+      @segment_chain ||= Segment::Chain.new
+    end
+
+    def self.segment(name, options = {}, &block)
+      segments << Segment::Definition.new(self, name, options)
+      instance_eval(&block) if block_given?
+    end
+
+    def self.skip_headers
+      segments.map(&:columns).flatten
+    end
+
+    delegate :skip_headers, to: "self.class"
+    
+    def initialize(report)
+      self.report = report
+      extend(segment_chain.first.segment_module) if report.segmented?
+    end
+
+    def headers
+      @headers ||= report_results.headers.reject { |header| header.in?(skip_headers) }
+    end
+
+    def data
+      @data ||= report_results.rows.inject(Hash.new { [] }) { |acc, row|
+        acc.tap { |hash| hash[key_path_for(row)] += [row] }
+      }
+    end
+
+    def segment_chain
+      self.class.segments
+    end
+
+    def segmenter
+      self
+    end
+
+    def segment_options_for(segment)
+      position = segment.key_path.split('.').count
+      data.keys.map { |key| 
+        key.split('.') 
+      }.inject({}) { |acc, key| 
+        acc.tap { |hash| 
+          hash[key.first(position + 1)] ||= data[key.join('.')].first
+        }
+      }.select { |key, value| 
+        key.first(position) == segment.key_path.split('.')
+      }.values.map { |row|
+        Hash[report_results.headers.zip(row)]
+      }
+    end
+
+    def key_path
+      String.new
+    end
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+    
+    def header_index_map
+      @header_index_map ||= Hash[skip_headers.map { |h| [h, report_results.headers.index(h)] }]
+    end
+
+    private
+
+    def report_results
+      report.raw_results
+    end
+
+    def key_path_for(row)
+      group_by_indexes.map { |i| row.at(i) }.join('.')
+    end
+
+    def segment_options
+      data unless defined?(@data)
+      @segment_options
+    end
+
+    def group_by_indexes
+      @group_by_indexes ||= header_index_map.values_at(*segment_chain.map(&:group_by).map(&:to_s))
+    end
+  end
+end
+
+require "dossier/segment"
+require "dossier/segment/chain"
+require "dossier/segment/definition"
+require "dossier/segment/rows"
+require "dossier/segment/summary"
+require "dossier/segmenter/report"

data/lib/dossier/segmenter/engine.rb

@@ -0,0 +1,6 @@
+module Dossier
+  class Segmenter
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/dossier/segmenter/report.rb

@@ -0,0 +1,34 @@
+module Dossier
+  class Segmenter
+    module Report
+      extend ActiveSupport::Concern
+
+      def segment_parent
+        nil
+      end
+
+      def segmenter
+        @segmenter ||= self.class.segmenter_class.new(self)
+      end
+
+      def segmented?
+        self.class.segmenter_class.segments.any?
+      end
+
+      module ClassMethods
+        def segmenter_class
+          const_get(:Segmenter)
+        end
+
+        def inherited(base)
+          segmenter_class = Class.new(Dossier::Segmenter)
+          segmenter_class.report_class = base
+          base.const_set(:Segmenter, segmenter_class)
+          super
+        end
+      end
+
+      Dossier::Report.send :include, self
+    end
+  end
+end

data/lib/dossier/segmenter/version.rb

@@ -0,0 +1,5 @@
+module Dossier
+  class Segmenter
+    VERSION = "0.9.0"
+  end
+end

data/script/rails

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+APP_PATH = File.expand_path('../../spec/dummy/config/application',  __FILE__)
+require APP_PATH
+require 'rails/commands'

data/spec/dossier/segment/chain_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Dossier::Segment::Chain do
+  let(:report_class)    { Class.new(Dossier::Report) }
+  let(:segmenter_class) { report_class.segmenter_class }
+  let(:definition)      { Dossier::Segment::Definition.new(segmenter_class, :foo) }
+  let(:next)            { Dossier::Segment::Definition.new(segmenter_class, :bar) }
+  let(:chain)           { described_class.new.tap { |c| c << definition } }
+
+  it "allows #at access of definitions" do
+    expect(chain.at 0).to eq definition
+  end
+
+  it "aliases [] to at" do
+    expect(chain[0]).to eq definition
+  end
+
+  it "conforms to enumerable" do
+    chain.each { |d| expect(d).to eq definition }
+  end
+
+  describe "appending to the chain" do
+    before :each do
+      chain << self.next
+    end
+
+    it "uses <<" do
+      expect(chain.at 1).to eq self.next
+    end
+
+    it "allows accessing the end" do
+      expect(chain.last).to eq self.next
+    end
+
+    it "assigns the previous segment the given segment as next" do
+      expect(chain.first.next).to eq self.next
+    end
+
+    it "assigns the next segment the previous segment as prev" do
+      expect(chain.last.prev).to eq chain.first
+    end
+  end
+end

data/spec/dossier/segment/definition_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Dossier::Segment::Definition do
+  let(:report_class)    { Class.new(Dossier::Report) }
+  let(:segmenter_class) { report_class.segmenter_class }
+  let(:definition)      { described_class.new(segmenter_class, :foo) }
+
+  describe "attributes" do
+    it "has a segmenter_class" do
+      expect(definition.segmenter_class).to eq segmenter_class
+    end
+    it "has a name" do
+      expect(definition.name).to eq :foo
+    end
+
+    it "uses the name as the group by if one isn't provided" do
+      expect(definition.group_by).to eq :foo
+    end
+
+    it "uses the name as the display name if one isn't provided" do
+      expect(definition.display_name).to eq :foo
+    end
+
+    it "has a group_by" do
+      definition = described_class.new(segmenter_class, :foo, group_by: :bar)
+      expect(definition.group_by).to eq :bar
+    end
+
+    it "has a display_name" do
+      definition = described_class.new(segmenter_class, :foo, display_name: :baz)
+      expect(definition.display_name).to eq :baz
+    end
+
+    it "has a segment class name" do
+      expect(definition.segment_class_name).to eq 'Foo'
+    end
+
+    it "has a plural name" do
+      expect(definition.plural_name).to eq 'foos'
+    end
+
+    describe "for columns" do
+      it "knows to use the name" do
+        definition = described_class.new(segmenter_class, :foo)
+        expect(definition.columns).to eq %w[foo]
+      end
+
+      it "knows to use group_by if provided" do
+        definition = described_class.new(segmenter_class, :foo, group_by: :bar)
+        expect(definition.columns).to eq %w[bar foo]
+      end
+
+      it "knows to use display_name if not a proc" do
+        definition = described_class.new(segmenter_class, :foo, display_name: :baz)
+        expect(definition.columns).to eq %w[foo baz]
+      end
+
+      it "knows not to use display_name if not a proc" do
+        definition = described_class.new(segmenter_class, :foo, display_name: ->(row) {})
+        expect(definition.columns).to eq %w[foo]
+      end
+
+      it "knows not to use the name if group_by and display_name are set" do
+        definition = described_class.new(segmenter_class, :foo, group_by: :bar, display_name: :baz)
+        expect(definition.columns).to eq %w[bar baz]
+      end
+
+      it "knows not to use the display_name if group_by is present and display_name is a proc" do
+        definition = described_class.new(segmenter_class, :foo, group_by: :foo_id, display_name: ->(row) {})
+        expect(definition.columns).to eq %w[foo_id]
+      end
+    end
+  end
+
+  describe "segment subclass" do
+    it "is defined in the report class namespace as a subclass of Dossier::Segment" do
+      expect(definition.segment_subclass.superclass).to eq Dossier::Segment
+    end
+
+    it "sets up the segment subclasses name constant properly" do
+      expect(CuteAnimalsReport::Family).to be_a Class
+    end
+  end
+end

data/spec/dossier/segment/rows_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Dossier::Segment::Rows do
+
+  it "can determine the key path"
+
+  it "has the rows relevant to its parent segment"
+
+end
+

data/spec/dossier/segment/summary_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Dossier::Segment::Summary do
+
+  let(:summary) { described_class.new(headers) }
+  let(:headers) { %w[animal weight cuteness fanciness] }
+  let(:rows)    { [
+    ['Cats', 15.0, 97, true],
+    ['Dogs', 88.2, 45, false] # dogs aren't very fancy animals...
+  ] }
+  
+  before(:each) {
+    rows.each { |row| summary << row }
+  }
+
+  it "counts all the objects it has summarized" do
+    expect(summary.count).to eq 2
+  end
+
+  it "allows appending multiple rows" do
+    summary << rows[0] << rows[1]
+    expect(summary.count).to eq 4
+  end
+
+  describe "summing" do
+    it "handles whole numbers" do
+      expect(summary.sum :cuteness).to eq 142
+    end
+
+    it "handles decimal places" do
+      expect(summary.sum :weight).to eq 103.2
+    end
+  end
+
+  describe "averaging" do
+    it "handles whole numbers" do
+      expect(summary.average :cuteness).to eq 71
+    end
+
+    it "handles decimal places" do
+      expect(summary.average :weight).to eq 51.6
+    end
+  end
+
+  describe "operating on a header that doesn't exist" do
+    it "raises an helpful error" do
+      expect { summary.sum :fluffikins }.to raise_error(Dossier::Segment::Summary::HeaderError, /no such header 'fluffikins'/i)
+    end
+  end
+
+end

data/spec/dossier/segment_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Dossier::Segment do
+  let(:report_class)     { Class.new(Dossier::Report) }
+  let!(:segmenter_class) { 
+    report_class.segmenter_class.tap { |sc|
+      sc.segment :foo
+    }
+  }
+  let(:definition)      { segmenter_class.segments.first }
+  let(:report)          { report_class.new }
+  let(:segmenter)       { report.segmenter }
+  let(:segment)         { described_class.new(segmenter, definition) }
+
+  describe "attributes" do
+    it "takes the segment instance" do
+      expect(segment.segmenter).to eq segmenter
+    end
+
+    it "takes its definition" do
+      expect(segment.definition).to eq definition
+    end
+
+    it "has access to the report" do
+      expect(segment.report).to eq report
+    end
+
+    it "delegates headers to its segmenter" do
+      segment.segmenter.should_receive(:headers)
+      segment.headers
+    end
+  end
+
+
+  describe CuteAnimalsReport do
+    describe "key paths" do
+      let(:report)     { CuteAnimalsReport.new }
+      let!(:segmenter) { report.segmenter }
+      let(:families)   { segmenter.families }
+      let(:domestics)  { families.map(&:domestics).flatten }
+      let(:groups)     { domestics.map(&:groups).flatten }
+      let(:rows)       { groups.map(&:rows).map(&:to_a) }
+      let(:rows)       { groups.inject([]) { |a,g| a += g.rows.to_a } } 
+
+      describe "select the correct amount of segments" do
+
+        it "has the right amount of families" do
+          expect(families.count).to eq 2
+        end
+
+        it "has the right amount of domestics" do
+          expect(domestics.count).to eq 4
+        end
+
+        it "has the right amount of groups" do
+          expect(groups.count).to eq 6
+        end
+
+        it "has the right amount of rows" do
+          expect(rows.count).to eq CuteAnimalsReport::ROWS.call.count
+        end
+      end
+
+      describe "summarizing" do
+        before(:each) { rows }
+
+        it "properly sums all rows under family" do
+          expect(families.first.summary.sum(:gifs).to_s).to eq '4154.0'
+        end
+
+        it "properly sums all rows under domestic" do
+          expect(domestics.first.summary.sum(:gifs).to_s).to eq '2755.0'
+        end
+
+        it "property sums all the rows under group" do
+          expect(groups.first.summary.sum(:gifs).to_s).to eq '1364.0'
+        end
+
+        describe "segment chains" do
+          let(:family_definition)    { segmenter.segment_chain[0] }
+          let(:domestic_definition)  { segmenter.segment_chain[1] }
+          let(:group_definition)     { segmenter.segment_chain[2] }
+          let(:family)   { described_class.new(segmenter, family_definition,   {family: 'feline'}) }
+          let(:domestic) { described_class.new(segmenter, domestic_definition, {domestic: true}  ).tap { |s| s.parent = family   } }
+          let(:group)    { described_class.new(segmenter, group_definition,    {group_id: 25}    ).tap { |s| s.parent = domestic } }
+
+          it "has all three elements in the chain from the bottom" do
+            expect(group.chain).to eq [group, domestic, family]
+          end
+
+          it "has two elements in the chain from the middle" do
+            expect(domestic.chain).to eq [domestic, family]
+          end
+
+          it "has one element in the chain from the top" do
+            expect(family.chain).to eq [family]
+          end
+
+          it "does not replicate elements in the chain when accessed again" do
+            family.chain
+            expect(family.chain.length).to eq 1
+          end
+
+          describe "key paths" do
+            it "works from the bottom" do
+              expect(group.key_path).to eq 'feline.true.25'
+            end
+
+            it "works from the middle" do
+              expect(domestic.key_path).to eq 'feline.true'
+            end
+
+            it "works from the top" do
+              expect(family.key_path).to eq 'feline'
+            end
+          end
+        end
+      end
+    end
+  end
+end