dossier-segmenter 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 98e767c99db2057ca87c78226335c4800433514b
+  data.tar.gz: ae308223c209cac474b83bdcb3b94dfb1ee27ace
+SHA512:
+  metadata.gz: b569f16bd64f42f669d9962859a1a5995c71a5d8529e540f4e3d03e84ad621e376a904b8be4a12ce11a1a14142ec8250dd3d4f36422613073193be86380ab378
+  data.tar.gz: 381586de07e4e0c898300c1e4f41eca9a1beec68223e1c6af0213f5bb8ac150d7127bb84c813f10ef4539e4f00a1201b0925a455ceed15eb65a09bde35abc9a4

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.ruby-gemset
+.ruby-version
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+spec/dummy/log
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dossier-segmenter.gemspec
+gemspec
+
+# gem 'dossier', git: 'git@github.com:adamhunter/dossier'
+# gem 'dossier', path: '/usr/local/gems/dossier'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Adam Hunter
+
+MIT License
+
+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/README.md

@@ -0,0 +1,29 @@
+# Dossier::Segmenter
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dossier-segmenter'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dossier-segmenter
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+
+require "bundler/gem_tasks"
+
+require File.expand_path('../spec/dummy/config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/app/views/dossier/reports/cute_animals.html.haml

@@ -0,0 +1,57 @@
+-# TODO this should be working but ApplicationHelper 
+-# doesn't get included into the view context either...
+-# = render_options(report)
+
+.row-fluid
+  .span12
+    - report.segmenter.families.each do |family|
+      %h2= family.display_name
+      - family.domestics.each do |domestic|
+        %h3= domestic.display_name
+        - domestic.groups.each do |group|
+          %table
+            %thead
+              %tr
+                %th{colspan: group.headers.count}
+                  = group.display_name
+              %tr
+                - group.headers.each do |header|
+                  %th= report.format_header(header)
+            %tbody
+              - group.rows.each do |row|
+                %tr
+                  - row.each do |value|
+                    %td= value
+            %tfoot
+              %tr
+                %th Count #{commafy_number group.summary.count}
+                %th
+                %th= commafy_number group.summary.average(:cuteness), 2
+                %th= commafy_number group.summary.sum(:gifs)
+                %th
+                %th= number_to_dollars group.summary.average(:cost_new)
+      %table
+        %thead
+          %tr
+            %th Count
+            %th
+            %th Average
+            %th Sum
+            %th
+        %tbody
+          - family.domestics.each do |domestic|
+            %tr
+              %td= commafy_number domestic.summary.count
+              %td
+              %td= commafy_number domestic.summary.average(:cuteness), 2
+              %td= commafy_number domestic.summary.sum(:gifs)
+              %td
+              %td= number_to_dollars domestic.summary.average(:cost_new)
+        %tfoot
+          %tr
+            %th= commafy_number family.summary.count
+            %th
+            %th= commafy_number family.summary.average(:cuteness), 2
+            %th= commafy_number family.summary.sum(:gifs)
+            %th
+            %th= number_to_dollars family.summary.average(:cost_new)

data/dossier-segmenter.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dossier/segmenter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dossier-segmenter"
+  spec.version       = Dossier::Segmenter::VERSION
+  spec.authors       = ["Adam Hunter"]
+  spec.email         = ["adamhunter@me.com"]
+  spec.description   = %q[Adds control breaks to dossier reports by defined segments based on query results.]
+  spec.summary       = %q[Extends Dossier to have segmented report functionality.]
+  spec.homepage      = "https://github.com/adamhunter/dossier-segmenter"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "dossier", "~> 2.8"
+
+  spec.add_development_dependency "bundler",     "~> 1.3"
+  spec.add_development_dependency "rspec-rails", "~> 2.13"
+  spec.add_development_dependency "rails",       "~> 3.2.13"
+  spec.add_development_dependency "capybara",    "~> 2.1"
+  spec.add_development_dependency "simplecov",   "~> 0.7"
+  spec.add_development_dependency "pry",         ">= 0.9.10"
+  spec.add_development_dependency "rake"
+end

data/lib/dossier/segment.rb

@@ -0,0 +1,54 @@
+module Dossier
+  class Segment
+    attr_accessor :segmenter, :report, :definition, :parent, :options
+
+    def initialize(segmenter, definition, options = {})
+      self.segmenter  = segmenter
+      self.report     = segmenter.report
+      self.definition = definition
+      self.options    = options.symbolize_keys
+      extend(definition.chain_module)
+    end
+
+    def display_name
+      if definition.display_name.respond_to?(:call)
+        definition.display_name.call(options)
+      else
+        options.fetch(definition.display_name)
+      end
+    end
+    
+    def group_by
+      options.fetch(definition.group_by)
+    end
+
+    def chain
+      @chain ||= [].tap { |collector| parent_chain(self, collector) }
+    end
+
+    def key_path
+      chain.map(&:group_by).reverse.join('.')
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{key_path}>"
+    end
+
+    def summarize(row)
+      row.tap { summary << row }
+    end
+
+    def summary
+      @summary ||= Summary.new(headers)
+    end
+
+    delegate :headers, to: :segmenter
+
+    private
+
+    def parent_chain(segment, collector)
+      collector << segment
+      parent_chain(segment.parent, collector) if segment.parent
+    end
+  end
+end

data/lib/dossier/segment/chain.rb

@@ -0,0 +1,31 @@
+module Dossier
+  class Segment
+    class Chain
+      include Enumerable
+
+      def initialize
+        @segment_chain = []
+      end
+
+      def at(index)
+        segment_chain.at(index)
+      end
+      alias :[] :at
+
+      def <<(segment)
+        last.next    = segment unless last.nil?
+        segment.prev = last    unless last.nil?
+        segment_chain << segment
+      end
+
+      def each
+        segment_chain.each { |segment| yield segment }
+      end
+
+      delegate :first, :last, :length, :empty?, to: "@segment_chain"
+
+      private
+      attr_reader :segment_chain
+    end
+  end
+end

data/lib/dossier/segment/definition.rb

@@ -0,0 +1,73 @@
+module Dossier
+  class Segment
+    class Definition
+      attr_accessor :segmenter_class, :report_class, :name, :group_by, :display_name, :next, :prev
+      attr_reader :segment_subclass
+
+      def initialize(segmenter_class, name, options = {})
+        self.segmenter_class = segmenter_class
+        self.report_class    = segmenter_class.report_class
+        self.name            = name
+        self.group_by        = options.fetch(:group_by, name)
+        self.display_name    = options.fetch(:display_name, name)
+        define_segment_subclass
+      end
+
+      def segment_class_name
+        name.to_s.classify
+      end
+
+      def plural_name
+        name.to_s.pluralize
+      end
+
+      def columns
+        [group_by, display_name_for_column].map(&:to_s).uniq
+      end
+
+      def next?
+        !!self.next
+      end
+
+      def prev?
+        !!prev
+      end
+
+      def chain_module
+        next? ? self.next.segment_module : rows_module
+      end
+
+      def segment_module
+        definition = self
+        Module.new do
+          define_method definition.plural_name do
+            @segments ||= segmenter.segment_options_for(self).map { |options| 
+              definition.segment_subclass.new(segmenter, definition, options).tap do |instance|
+                instance.parent = self if is_a?(Dossier::Segment)
+              end
+            }
+          end
+        end
+      end
+
+      private
+
+      def define_segment_subclass
+        @segment_subclass = report_class.const_set(segment_class_name, Class.new(Dossier::Segment))
+      end
+
+      def display_name_for_column
+        display_name.respond_to?(:call) ? group_by : display_name
+      end
+
+      def rows_module
+        definition = self
+        Module.new do
+          define_method :rows do
+            @rows ||= Rows.new(segmenter, self, definition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dossier/segment/rows.rb

@@ -0,0 +1,39 @@
+module Dossier
+  class Segment
+    class Rows < Dossier::Result::Formatted
+      attr_accessor :segmenter, :segment, :report, :definition
+
+      def initialize(segmenter, segment, definition)
+        self.segmenter  = segmenter
+        self.report     = segmenter.report
+        self.segment    = segment
+        self.definition = definition
+      end
+
+      delegate :headers, to: :segmenter
+      delegate :length, :count, :empty?, to: :rows
+
+      def each
+        segmenter_data.each { |row| yield format(summarize(truncate(row))) }
+      end
+
+      def inspect
+        "#<#{self.class.name}:@rows.count=#{rows.count}>"
+      end
+
+      private
+
+      def segmenter_data
+        @segmenter_data ||= segmenter.data.fetch(segment.key_path)
+      end
+
+      def truncate(row)
+        row.dup.tap { |r| segmenter.header_index_map.values.sort.each_with_index { |i, j| r.delete_at(i - j) } }
+      end
+
+      def summarize(row)
+        row.tap { |r| segment.chain.each { |s| s.summarize row } }
+      end
+    end
+  end
+end

data/lib/dossier/segment/summary.rb

@@ -0,0 +1,50 @@
+module Dossier
+  class Segment
+    class Summary
+
+      attr_reader :count, :average, :sum
+
+      def initialize(headers)
+        @headers = headers.map(&:to_s)
+        @count   = 0
+        @sums    = headers.map { 0 }
+      end
+
+      def <<(row)
+        @count += 1
+        row.each_with_index { |v, i| sums[i] += parse(v) }
+        self
+      end
+
+      def sum(key)
+        sums.at(index_of key)
+      end
+
+      def average(key)
+        sum(key) / count
+      end
+
+      private
+
+      attr_reader :headers, :sums
+
+      def index_of(key)
+        indexes[key.to_s] ||= headers.index(key.to_s) or raise_missing_header(key)
+      end
+
+      def indexes
+        @indexes ||= {}
+      end
+
+      def parse(value)
+        BigDecimal.new(value.to_s)
+      end
+
+      def raise_missing_header(key)
+        raise HeaderError.new %Q[No such header '#{key}' in headers: #{headers.join(', ')}]
+      end
+
+      HeaderError = Class.new(StandardError)
+    end
+  end
+end