reports_kit 0.0.1

data/config/routes.rb

@@ -0,0 +1,10 @@
+ReportsKit::Engine.routes.draw do
+  namespace :reports_kit do
+    resources :reports, only: [:index]
+    resources :resources, only: [] do
+      collection do
+        get 'measures/:measure_key/filters/:filter_key/autocomplete' => :autocomplete
+      end
+    end
+  end
+end

data/gists/doc.txt

@@ -0,0 +1,58 @@
+1. Add ReportsKit
+
+Gemfile
+
+source 'https://my-api-key@gems.reportskit.co' do
+  gem 'reportskit'
+end
+
+
+2. Configure Models
+
+Configure the filters and dimensions that can be used in your reports:
+
+app/models/task.rb
+
+class Task < ActiveRecord::Base
+  belongs_to :assignee
+  belongs_to :project
+
+  reportskit do
+    filter :assignee
+    filter :project
+    filter :completed_at
+    filter :is_completed, :boolean, conditions: -> { where.not(completed_at: nil) }
+
+    dimension :assignee
+    dimension :project
+    dimension :completed_at
+  end
+end
+
+
+3. Configure Reports
+
+config/reportskit/reports/completed_tasks.yml
+
+name: Completed tasks
+measures:
+- tasks
+dimensions:
+- completed_at
+display_format: area
+
+
+4. Add Report to a View
+
+app/views/reports/my_view.html.haml
+
+= render_report 'completed_tasks'
+
+
+5. Add Routes:
+
+config/routes.rb
+
+mount ReportsKit::Engine, at: '/reports'
+
+That's it! You can now visit the view in step 4. to see the report that you've configured.

data/lib/reports_kit.rb

@@ -0,0 +1,17 @@
+require 'rails/all'
+
+directory = File.dirname(File.absolute_path(__FILE__))
+Dir.glob("#{directory}/reports_kit/*.rb") { |file| require file }
+Dir.glob("#{directory}/reports_kit/reports/data/*.rb") { |file| require file }
+Dir.glob("#{directory}/reports_kit/reports/filter_types/*.rb") { |file| require file }
+Dir.glob("#{directory}/reports_kit/reports/*.rb") { |file| require file }
+
+module ReportsKit
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+end

data/lib/reports_kit/base_controller.rb

@@ -0,0 +1,11 @@
+module ReportsKit
+  class BaseController < ActionController::Base
+    private
+
+    def context_record
+      context_record_method = ReportsKit.configuration.context_record_method
+      return unless context_record_method
+      instance_eval(&context_record_method)
+    end
+  end
+end

data/lib/reports_kit/configuration.rb

@@ -0,0 +1,10 @@
+module ReportsKit
+  class Configuration
+    attr_accessor :context_record_method, :first_day_of_week
+
+    def initialize
+      self.context_record_method = nil
+      self.first_day_of_week = :sunday
+    end
+  end
+end

data/lib/reports_kit/engine.rb

@@ -0,0 +1,21 @@
+module ReportsKit
+  class Engine < ::Rails::Engine
+    engine_name 'reports_kit'
+
+    initializer 'helper' do
+      ActiveSupport.on_load(:action_view) do
+        include Helper
+      end
+    end
+
+    initializer 'precompile', group: :all do |app|
+      if app.config.respond_to?(:assets)
+        if defined?(Sprockets) && Gem::Version.new(Sprockets::VERSION) >= Gem::Version.new('4.0.0.beta1')
+          app.config.assets.precompile += %w(reports_kit.js reports_kit.css)
+        else
+          app.config.assets.precompile << proc { |path| path.start_with?('reports_kit.') }
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/helper.rb

@@ -0,0 +1,19 @@
+module ReportsKit
+  module Helper
+    def render_report(properties, &block)
+      raise ArgumentError.new('`properties` must be a Hash or String') if properties.blank?
+      if properties.is_a?(String)
+        path = Rails.root.join('config', 'reports_kit', 'reports', "#{properties}.yml")
+        properties = YAML.load_file(path)
+      end
+      builder = ReportsKit::ReportBuilder.new(properties)
+      content_tag :div, nil, class: 'reports_kit_report', data: { properties: builder.properties, path: reports_kit_path } do
+        if block_given?
+          form_tag reports_kit_path, method: 'get', class: 'reports_kit_report_form form-inline' do
+            capture(builder, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reports_kit/model.rb

@@ -0,0 +1,16 @@
+module ReportsKit
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :reports_kit_configuration
+      end
+
+      def self.reports_kit(&block)
+        self.reports_kit_configuration = ModelConfiguration.new
+        reports_kit_configuration.instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/reports_kit/model_configuration.rb

@@ -0,0 +1,23 @@
+module ReportsKit
+  class ModelConfiguration
+    attr_accessor :dimensions, :filters, :autocomplete_scopes
+
+    def initialize
+      self.dimensions = []
+      self.filters = []
+      self.autocomplete_scopes = []
+    end
+
+    def dimension(key, properties)
+      dimensions << { key: key.to_s }.merge(properties).symbolize_keys
+    end
+
+    def filter(key, type_key, properties)
+      filters << { key: key.to_s, type_key: type_key }.merge(properties).symbolize_keys
+    end
+
+    def autocomplete_scope(*scopes)
+      self.autocomplete_scopes += scopes.map(&:to_s)
+    end
+  end
+end

data/lib/reports_kit/rails.rb

@@ -0,0 +1,5 @@
+if Rails.version >= '3.1'
+  require 'reports_kit/engine'
+else
+  ActionView::Base.send :include, Chartkick::Helper
+end

data/lib/reports_kit/report_builder.rb

@@ -0,0 +1,76 @@
+module ReportsKit
+  class ReportBuilder
+    include ActionView::Helpers
+
+    attr_accessor :properties
+
+    def initialize(properties)
+      self.properties = normalize_properties(properties)
+    end
+
+    def check_box(filter_key, options={})
+      filter = validate_filter!(filter_key)
+      checked = filter.properties[:criteria][:operator] == 'true'
+      check_box_tag(filter_key, '1', checked, options)
+    end
+
+    def date_range(filter_key, options={})
+      filter = validate_filter!(filter_key)
+      defaults = { class: 'form-control input-sm date_range_picker' }
+      options = defaults.deep_merge(options)
+      text_field_tag(filter_key, filter.properties[:criteria][:value], options)
+    end
+
+    def multi_autocomplete(filter_key, options={})
+      validate_filter!(filter_key)
+      reports_kit_path = Rails.application.routes.url_helpers.reports_kit_path
+      path = "#{reports_kit_path}reports_kit/resources/measures/#{measure.key}/filters/#{filter_key}/autocomplete"
+      scope = options.delete(:scope)
+      params = {}
+      params[:scope] = scope if scope.present?
+
+      defaults = {
+        class: 'form-control input-sm select2',
+        multiple: 'multiple',
+        data: {
+          placeholder: options[:placeholder],
+          path: path,
+          params: params
+        }
+      }
+      options = defaults.deep_merge(options)
+      select_tag(filter_key, nil, options)
+    end
+
+    def string_filter(filter_key, options={})
+      filter = validate_filter!(filter_key)
+      defaults = { class: 'form-control input-sm' }
+      options = defaults.deep_merge(options)
+      text_field_tag(filter_key, filter.properties[:criteria][:value], options)
+    end
+
+    private
+
+    def validate_filter!(filter_key)
+      filter_key = filter_key.to_s
+      filter = filters.find { |f| f.key == filter_key }
+      raise ArgumentError.new("A filter with key '#{filter_key}' is not configured in this report") unless filter
+      filter
+    end
+
+    def filters
+      measure.filters
+    end
+
+    def measure
+      Reports::Measure.new(properties[:measure])
+    end
+
+    def normalize_properties(properties)
+      properties = properties.deep_symbolize_keys
+      measure = Reports::Measure.new(properties[:measure])
+      properties[:measure] = measure.properties_with_filters
+      properties
+    end
+  end
+end

data/lib/reports_kit/reports/data/chart_options.rb

@@ -0,0 +1,132 @@
+module ReportsKit
+  module Reports
+    module Data
+      class ChartOptions
+        DEFAULT_COLORS = %w(
+          #1f77b4
+          #aec7e8
+          #ff7f0e
+          #ffbb78
+          #2ca02c
+          #98df8a
+          #d62728
+          #ff9896
+          #9467bd
+          #c5b0d5
+          #8c564b
+          #c49c94
+          #e377c2
+          #f7b6d2
+          #7f7f7f
+          #c7c7c7
+          #bcbd22
+          #dbdb8d
+          #17becf
+          #9edae5
+        ).freeze
+        DEFAULT_OPTIONS = {
+          scales: {
+            xAxes: [{
+              gridLines: {
+                display: false
+              },
+              barPercentage: 0.9,
+              categoryPercentage: 0.9
+            }],
+            yAxes: [{
+              ticks: {
+                beginAtZero: true
+              }
+            }]
+          },
+          legend: {
+            labels: {
+              usePointStyle: true
+            }
+          },
+          tooltips: {
+            xPadding: 8,
+            yPadding: 7
+          }
+        }.freeze
+
+        attr_accessor :data, :options, :chart_options, :inferred_options, :dataset_options, :type
+
+        def initialize(data, options:, inferred_options: {})
+          self.data = data
+          self.options = options.try(:except, :options) || {}
+          self.chart_options = options.try(:[], :options) || {}
+          self.dataset_options = options.try(:[], :datasets)
+          self.type = options.try(:[], :type) || 'bar'
+
+          self.options = inferred_options.deep_merge(self.options) if inferred_options.present?
+        end
+
+        def perform
+          set_colors
+          set_chart_options
+          set_dataset_options
+          set_type
+          data
+        end
+
+        private
+
+        def set_colors
+          self.data[:chart_data][:datasets] = data[:chart_data][:datasets].map.with_index do |dataset, index|
+            color = DEFAULT_COLORS[index % DEFAULT_COLORS.length]
+            dataset[:backgroundColor] = color
+            dataset[:borderColor] = color
+            dataset
+          end
+        end
+
+        def default_options
+          @default_options ||= begin
+            default_options = DEFAULT_OPTIONS.deep_dup
+
+            x_axis_label = options[:x_axis_label]
+            if x_axis_label
+              default_options[:scales] ||= {}
+              default_options[:scales][:xAxes] ||= []
+              default_options[:scales][:xAxes][0] ||= {}
+              default_options[:scales][:xAxes][0][:scaleLabel] ||= {}
+              default_options[:scales][:xAxes][0][:scaleLabel][:display] ||= true
+              default_options[:scales][:xAxes][0][:scaleLabel][:labelString] ||= x_axis_label
+            end
+
+            y_axis_label = options[:y_axis_label]
+            if y_axis_label
+              default_options[:scales] ||= {}
+              default_options[:scales][:yAxes] ||= []
+              default_options[:scales][:yAxes][0] ||= {}
+              default_options[:scales][:yAxes][0][:scaleLabel] ||= {}
+              default_options[:scales][:yAxes][0][:scaleLabel][:display] ||= true
+              default_options[:scales][:yAxes][0][:scaleLabel][:labelString] ||= y_axis_label
+            end
+
+            default_options
+          end
+        end
+
+        def set_chart_options
+          merged_options = default_options
+          merged_options = merged_options.deep_merge(chart_options) if chart_options
+          self.data[:chart_data][:options] = merged_options
+        end
+
+        def set_dataset_options
+          return if self.data[:chart_data][:datasets].blank? || dataset_options.blank?
+          self.data[:chart_data][:datasets] = self.data[:chart_data][:datasets].map do |dataset|
+            dataset.merge(dataset_options)
+          end
+        end
+
+        def set_type
+          return if type.blank?
+          self.data[:type] = type
+        end
+      end
+    end
+  end
+end