noventius 1.0.0

data/app/helpers/nuntius/columns_helper.rb

@@ -0,0 +1,47 @@
+module Nuntius
+
+  module ColumnsHelper
+
+    def column_table_header_tag(column)
+      options = column.html_options.deep_merge(colspan: column.html_options.fetch(:colspan, 1),
+                                               rowspan: column.html_options.fetch(:rowspan, 1),
+                                               class:   class_for_column_header(column),
+                                               data:    data_for_column_header(column))
+
+      content_tag(:th, column.label, options)
+    end
+
+    def number_of_header_levels(columns)
+      columns.map(&:depth).max
+    end
+
+    def header_columns_for_level(columns, level)
+      if level == 0
+        columns
+      else
+        columns.select { |column| column.is_a?(ColumnsGroup) }
+          .flat_map { |column| column.columns_for_level(level) }
+      end
+    end
+
+    def class_for_column_header(column)
+      css_class = if column.is_a?(Column)
+                    'column-header'
+                  elsif column.is_a?(ColumnsGroup)
+                    'column-group-header'
+                  end
+
+      [column.html_options[:class], css_class].compact.join(' ')
+    end
+
+    def data_for_column_header(column)
+      if column.is_a?(Column)
+        { type: column.type }
+      elsif column.is_a?(ColumnsGroup)
+        {}
+      end
+    end
+
+  end
+
+end

data/app/helpers/nuntius/filters_helper.rb

@@ -0,0 +1,147 @@
+# rubocop:disable all
+module Nuntius
+
+  module FiltersHelper
+
+    include Nuntius::FilterWrappers
+
+    RESERVED_OPTIONS = [:dependent]
+
+    def filter_tag(filter, report, options = {})
+      tag_options = set_current_filter_value(filter, report)
+      tag_options = merge_filter_options(filter, options, tag_options)
+      tag_options = add_filter_options(filter, report, tag_options)
+
+      send(:"#{filter.type}_filter_tag", scope_name(filter.name), tag_options)
+    end
+
+    def class_for_filter_wrapper(filter)
+      classes = ['form-group']
+
+      if filter.type == :select
+        classes << 'select-filter-wrapper'
+      end
+
+      classes.join(' ')
+    end
+
+    def class_for_filter(filter)
+      classes = ['nuntius-filter']
+
+      unless filter.type == :select
+        classes << 'form-control'
+      end
+
+      classes.join(' ')
+    end
+
+    def set_current_filter_value(filter, report)
+      tag_options = filter.args.dup
+      current_value = report.filter_params[filter.name]
+
+      case filter.type
+      when :select
+        tag_options[:option_tags] = compile_select_option_tags(filter, report)
+      when :check_box
+        tag_options[:checked] = current_value == (tag_options[:value] || DEFAULT_CHECK_BOX_VALUE)
+      when :radio_button
+        tag_options[:checked] = current_value == (tag_options[:value] || DEFAULT_RADIO_BUTTON_VALUE)
+      when :text_area
+        tag_options[:content] = current_value || tag_options[:content]
+      else
+        tag_options[:value] = current_value || tag_options[:value]
+      end
+
+      tag_options
+    end
+
+    def compile_select_option_tags(filter, report)
+      option_tags = filter.args[:option_tags]
+      option_tags = option_tags.is_a?(Symbol) ? report.send(option_tags) : option_tags
+      current_value = report.filter_params[filter.name]
+
+      if filter.args[:dependent].present? && option_tags.is_a?(Hash)
+        return ''
+      elsif filter.args[:dependent].present?
+        fail ArgumentError, 'when a dependent select option_tags can only be a Hash.'
+      end
+
+      if option_tags.is_a?(String)
+        option_tags.html_safe
+      elsif option_tags.is_a?(Array)
+        if option_tags.size == 1 || option_tags.size == 2
+          if option_tags.size == 2
+            option_tags[1] = current_value || option_tags[1]
+          else
+            option_tags << current_value
+          end
+          options_for_select(*option_tags)
+        elsif option_tags.size == 3 || option_tags.size == 4
+          if option_tags.size == 4
+            option_tags[3] = current_value || option_tags[3]
+          else
+            option_tags << current_value
+          end
+          options_from_collection_for_select(*option_tags)
+        else
+          fail ArgumentError, 'option_tags can only be a String, an Array(max size 4) or a Symbol.'
+        end
+      else
+        fail ArgumentError, 'option_tags can only be a String, an Array(max size 4) or a Symbol.'
+      end
+    end
+
+    protected
+
+    def merge_filter_options(filter, options, tag_options)
+      tag_options.delete_if { |k, _| RESERVED_OPTIONS.include?(k) }
+
+      (tag_options[:options] ||= {}).each do |k, v|
+        opt = options.delete(k)
+        next unless opt
+
+        case v.class.to_s
+        when String.to_s
+          v << ' ' << opt
+        when Array.to_s
+          v.concat(opt)
+        when Hash.to_s
+          v.merge!(opt)
+        end
+      end
+      tag_options[:options].merge!(options)
+
+      tag_options
+    end
+
+    def add_filter_options(filter, report, tag_options)
+      tag_options = (tag_options || {}).dup
+      tag_options[:options] ||= {}
+
+      if filter.type == :select
+        include_blank = (filter.args[:options] || {})[:include_blank]
+
+        tag_options[:options].deep_merge!(data: { include_blank: include_blank })
+      end
+
+      if filter.type == :select && filter.args[:dependent].present?
+        options = filter.args[:option_tags]
+        options = options.is_a?(Symbol) ? report.send(options) : options
+        current_value = report.filter_params[filter.name]
+
+        options = options.inject({}) do |result, (key, value)|
+          result.merge(Array(key).join('_!_') => value)
+        end
+
+        tag_options[:options].deep_merge!(disabled: true,
+                                          data: { dependent: filter.args[:dependent],
+                                                  options: options, current_value: current_value })
+      end
+
+      tag_options
+    end
+
+  end
+
+end
+# rubocop:enable all

data/app/helpers/nuntius/forms_helper.rb

@@ -0,0 +1,18 @@
+module Nuntius
+
+  module FormsHelper
+
+    def compile_filters(filters)
+      filters.each_with_object({}) { |filter, memo| memo.merge!(scope_keys(filter.to_js)) }
+    end
+
+    def compile_validations(validations)
+      validations.each_with_object(rules: {}, messages: {}) do |validation, memo|
+        memo[:rules].merge!(scope_keys(validation.to_js[:rules]))
+        memo[:messages].merge!(scope_keys(validation.to_js[:messages]))
+      end
+    end
+
+  end
+
+end

data/app/helpers/nuntius/rows_helper.rb

@@ -0,0 +1,21 @@
+module Nuntius
+
+  module RowsHelper
+
+    def row_tag(row, report, &block)
+      options = { data: data_for_row(row, report) }
+
+      content_tag(:tr, options, &block)
+    end
+
+    def data_for_row(row, report)
+      return unless report.enable_nested?
+
+      { nested: { url: nested_report_path(name: report.class.name),
+                  row: row,
+                  filters: { q: report.filter_params } } }
+    end
+
+  end
+
+end

data/app/views/layouts/nuntius/application.html.erb

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Nuntius</title>
+  <%= stylesheet_link_tag "nuntius/application", media: "all" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+  <header>
+    <%= render partial: 'shared/nuntius/header' %>
+  </header>
+  <main>
+    <div class='container-fluid'>
+      <%= flash_alert %>
+      <%= yield %>
+    </div>
+  </main>
+  <footer></footer>
+  <%= javascript_include_tag 'nuntius/application' %>
+</body>
+</html>

data/app/views/nuntius/reports/_filter.erb

@@ -0,0 +1,10 @@
+<% if filter.options[:icon].present? %>
+  <div class="input-group">
+    <%= filter_tag filter, report, class: class_for_filter(filter) %>
+    <span class="input-group-addon">
+        <span class="glyphicon glyphicon-<%= filter.options[:icon] %>"></span>
+    </span>
+  </div>
+<% else %>
+  <%= filter_tag filter, report, class: class_for_filter(filter) %>
+<% end %>

data/app/views/nuntius/reports/_form.erb

@@ -0,0 +1,26 @@
+<script>
+  var FILTERS = <%= raw compile_filters(report.filters).to_json %>;
+  var FILTER_PARAMS = <%= raw scope_keys(filter_params).to_json %>;
+  var VALIDATIONS = <%= raw compile_validations(report.validations).to_json %>
+</script>
+
+<%= form_tag report_path(name: report.class.name), id: 'filter-form', method: :get, class: 'form-inline' do %>
+  <%= hidden_field_tag :format, :html %>
+
+  <% report.filters.each do |filter| %>
+    <div class='<%= class_for_filter_wrapper(filter) %>'>
+      <%= label_tag filter.name, nil, class: 'control-label'  %>
+      <%= render partial: 'filter', locals: { filter: filter, report: report } %>
+    </div>
+  <% end %>
+  <div>
+    <div class='form-group pull-right'>
+      <%= submit_tag 'Filter', class: 'btn btn-success' %>
+      <%= link_to '#', class: 'btn btn-default download' do %>
+        <i class='glyphicon glyphicon-download-alt'></i>
+        Download
+      <% end %>
+    </div>
+    <div class='clearfix'></div>
+  </div>
+<% end %>

data/app/views/nuntius/reports/_table.erb

@@ -0,0 +1,21 @@
+<% nested = local_assigns.fetch(:nested, false) %>
+<table class='table table-hover <%= 'nested' if nested %>'>
+  <thead>
+    <% number_of_header_levels(report.columns).times do |level| %>
+      <tr>
+        <% header_columns_for_level(report.columns, level).each do |column| %>
+          <%= column_table_header_tag(column) %>
+        <% end %>
+      </tr>
+    <% end %>
+  </thead>
+  <tbody>
+    <% report.processed_rows.each do |row| %>
+      <%= row_tag(row, report) do %>
+        <% report.columns_without_groups.each do |column|%>
+          <%= cell_tag(cell_for_row_column(report, row, column)) %>
+        <% end %>
+      <% end %>
+    <% end %>
+  </tbody>
+</table>

data/app/views/nuntius/reports/nested.erb

@@ -0,0 +1 @@
+<%= render partial: 'table', locals: { report: @nested_report, nested: true } %>

data/app/views/nuntius/reports/show.erb

@@ -0,0 +1,8 @@
+<div>
+  <section class='well well-sm'>
+    <%= render partial: 'form', locals: { report: @report } %>
+  </section>
+  <section class='panel'>
+    <%= render partial: 'table', locals: { report: @report, nest: true } %>
+  </section>
+</div>

data/app/views/shared/nuntius/_header.erb

@@ -0,0 +1,16 @@
+<nav class="navbar navbar-default">
+  <div class="container-fluid">
+    <div class="navbar-header">
+      <a class="navbar-brand" href='#'>
+        Reports
+      </a>
+    </div>
+  </div>
+  <ul class="nav nav-tabs">
+    <%- reports.each do |report| %>
+      <li class="<%= report == @report.class ? 'active' : '' %>">
+        <%= link_to report.tab_title, report_path(name: report.name) %>
+      </li>
+    <%- end %>
+  </ul>
+</nav>

data/config/initializers/assets.rb

@@ -0,0 +1 @@
+Nuntius::Engine.config.assets.paths << Nuntius::Engine.root.join('vendor', 'assets', 'bower_components')

data/config/routes.rb

@@ -0,0 +1,5 @@
+Nuntius::Engine.routes.draw do
+  resources :reports, param: :name, only: [:index, :show] do
+    get :nested, on: :member
+  end
+end

data/lib/nuntius/column.rb

@@ -0,0 +1,64 @@
+module Nuntius
+
+  class Column
+
+    TYPES = %i(string integer float datetime date)
+
+    attr_reader :name, :type, :label
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def initialize(name, type, options = {})
+      fail ArgumentError, "ColumnType: [#{type}] not yet implemented." unless TYPES.include?(type.to_sym)
+
+      @name = name.to_sym
+      @type = type.to_sym
+      @label = options.delete(:label) || @name.to_s
+      @label = instance_exec(&@label) if @label.is_a?(Proc)
+      @default_value = options[:default_value] || default_value_for_type
+      @value = options[:value] || default_value_block(@name, @default_value)
+      @options = options
+      @children = options[:children] || []
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    def html_options
+      @options[:html_options] || {}
+    end
+
+    def value(report, row)
+      if @value.is_a?(Proc)
+        report.instance_exec(row, &@value)
+      elsif @value.is_a?(Symbol)
+        report.public_send(@value, row)
+      else
+        @value
+      end
+    end
+
+    def depth
+      1
+    end
+
+    private
+
+    def default_value_block(name, default_value)
+      lambda do |row|
+        if row.is_a?(Hash)
+          row[name.to_s] || row[name.to_sym]
+        else
+          row[column_index(name.to_sym)]
+        end || default_value
+      end
+    end
+
+    def default_value_for_type
+      case @type
+      when :integer         then 0
+      when :float           then 0.0
+      else ''
+      end
+    end
+
+  end
+
+end

data/lib/nuntius/columns_group.rb

@@ -0,0 +1,38 @@
+module Nuntius
+
+  class ColumnsGroup
+
+    attr_reader :name, :columns, :label
+
+    def initialize(name, columns, options = {})
+      @name = name.to_sym
+      @columns = columns
+      @label = options.delete(:label) || @name.to_s
+      @label = instance_exec(&@label) if @label.is_a?(Proc)
+      @options = options
+    end
+
+    def html_options
+      @options[:html_options] || {}
+    end
+
+    def deep_dup
+      Marshal.load(Marshal.dump(self))
+    end
+
+    def depth
+      1 + (@columns.map(&:depth).max || 0)
+    end
+
+    def columns_for_level(level)
+      if level == 1
+        @columns
+      else
+        @columns.select { |column| column.is_a?(ColumnsGroup) }
+          .flat_map { |child| child.columns_for_level(level - 1) }
+      end
+    end
+
+  end
+
+end

data/lib/nuntius/engine.rb

@@ -0,0 +1,15 @@
+module Nuntius
+
+  class Engine < ::Rails::Engine
+
+    isolate_namespace Nuntius
+
+    config.autoload_paths << root.join('app/helpers/concerns/')
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+  end
+
+end

data/lib/nuntius/extensions/date_query.rb

@@ -0,0 +1,62 @@
+module Nuntius
+
+  module Extension
+
+    module DateQuery
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+
+      end
+
+      module InstanceMethods
+
+        SQL_FUNCTIONS = {
+          'month' => "DATE_TRUNC('month', <%column%>::timestamptz AT TIME ZONE {time_zone})",
+          'day' => "DATE_TRUNC('day', <%column%>::timestamptz AT TIME ZONE {time_zone})",
+          'dow' => 'EXTRACT(DOW from <%column%>::timestamptz AT TIME ZONE {time_zone})::integer',
+          'hour' => 'EXTRACT(HOUR from <%column%>::timestamptz AT TIME ZONE {time_zone})::integer',
+          'moy' => 'EXTRACT(MONTH from <%column%>::timestamptz AT TIME ZONE {time_zone})::integer'
+        }
+
+        # The different component that can be extracted from a timestamp
+        #
+        # @return [Hash] The components
+        def date_extract_options
+          [
+            {
+              'Day' => 'day',
+              'Month' => 'month',
+              'Day of week' => 'dow',
+              'Hour of day' => 'hour',
+              'Month of year' => 'moy'
+            }
+          ]
+        end
+
+        # SQL function for the extraction of the desired timestamp component
+        #
+        # @param [String] component The Date component to extract
+        # @param [String] column The column that has the timestamp
+        # @param [String] time_zone The time_zone of the timestamp. Default: 'America/Montevideo'
+        #
+        # @return [String] The SQL function
+        def date_extract(component:, column:, time_zone: 'America/Montevideo')
+          sql_function = SQL_FUNCTIONS[component].dup
+
+          Class.new(OpenStruct) {
+            include Nuntius::Report::Interpolator
+          }.new(column: column, time_zone: time_zone).interpolate(sql_function)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/nuntius/filter.rb

@@ -0,0 +1,46 @@
+module Nuntius
+
+  class Filter
+
+    RESERVED_ARGS = %i(icon priority)
+    DEFAULT_RESERVED_ARGS = { priority: 0 }
+    TYPES = %i(check_box color date datetime email month number phone radio_button range search select
+               telephone text_area text url week)
+
+    attr_reader :name, :type, :args, :options
+
+    def initialize(name, type, dirty_args = {})
+      fail ArgumentError, "FilterType: [#{type}] not yet implemented." unless TYPES.include?(type.to_sym)
+
+      @name = name.to_sym
+      @type = type.to_sym
+      @args = clean_args(dirty_args)
+      @options = DEFAULT_RESERVED_ARGS.merge(reserved_args(dirty_args))
+    end
+
+    def to_js
+      {
+        "#{name}" => {
+          type: type,
+          options: options
+        }
+      }
+    end
+
+    def deep_dup
+      Marshal.load(Marshal.dump(self))
+    end
+
+    protected
+
+    def reserved_args(args)
+      args.except(*clean_args(args).keys) || {}
+    end
+
+    def clean_args(args)
+      args.except(*RESERVED_ARGS) || {}
+    end
+
+  end
+
+end