resque-reports 0.0.2 → 0.3.0

data/lib/resque/reports/csv_report.rb

@@ -1,60 +1,84 @@
 # coding: utf-8
+require 'csv'
+
 module Resque
   module Reports
+    # Class to inherit from for custom CSV reports
+    # To make your custom report you must define at least:
+    #   1. directory, is where to write reports to
+    #   2. source, is symbol of method that retrieves report data
+    #   3. table, report table configuration using DSL
     class CsvReport < BaseReport
       extend Forwardable
-      include Callbacks # include on_progress, on_error callbacks, and handle_progress, handle_errors handlers
 
       class << self
-        attr_accessor :csv_options
-      end 
+        attr_accessor :options
+
+        alias_method :csv_options, :options=
+      end
 
-      DEFAULT_CSV_OPTIONS = { col_sep: ';', row_sep: "\r\n" }
+      DEFAULT_CSV_OPTIONS = {col_sep: ';', row_sep: "\r\n"}
 
       extension :csv
 
-      def_delegator 'self.class', :csv_options
+      def_delegators TO_EIGENCLASS, :options, :csv_options
 
       def initialize(*args)
-        csv_options = DEFAULT_CSV_OPTIONS.merge(csv_options)
+        csv_options DEFAULT_CSV_OPTIONS.merge(options || Hash.new)
+
         super(*args)
       end
 
-      # Callbacks
-      on_progress { |progress, total| at(progress, total, progress_message(progress, total)) }
-      on_error { |error| raise error }
-
-      # You must use ancestor methods to work with data:
-      #   1) get_data => returns Enumerable of source objects
-      #   2) build_table_header => returns Array of column names
-      #   3) build_table_row(object) => returns Array of cell values (same order as header)
-      def write(io)        
+      def write(io, force = false)
+        # You must use ancestor methods to work with report data:
+        #   1) data_size => returns source data size
+        #   2) data_each => yields given block for each source data element
+        #   3) build_table_header => returns Array of report column names
+        #   4) build_table_row(object) => returns Array of report cell values
+        #                                 (same order as header)
         progress = 0
 
-        CSV(io, csv_options) do |csv|
-          data_collection = get_data
-          
-          if data_collection.size > 0
-            write_line csv, build_table_header
+        CSV(io, options) do |csv|
+          write_line csv, build_table_header
 
-            data_collection.each do |data_element|
-              begin
-                write_line csv, build_table_row(data_element)
-              rescue
-                handle_error
-              end
-
-              handle_progress(progress += 1)
+          data_each(force) do |data_element|
+            begin
+              write_line csv, build_table_row(data_element)
+            rescue
+              handle_error
             end
 
-            handle_progress(progress, true)
+            handle_progress(progress += 1, data_size)
           end
-        end       
+
+          handle_progress(progress, data_size, true)
+        end
       end
 
       def write_line(csv, row_cells)
         csv << row_cells
       end
+
+      #--
+      # Event handling #
+      #++
+
+      def error_message(error)
+        error_message = []
+        error_message << 'Выгрузка отчета невозможна. '
+        error_message << case error
+                         when Encoding::UndefinedConversionError
+                           <<-ERR_MSG.gsub(/^ {29}/, '')
+                             Символ #{error.error_char} не поддерживается
+                             заданной кодировкой
+                           ERR_MSG
+                         when EncodingError
+                           'Ошибка преобразования в заданную кодировку'
+                         else
+                           fail error
+                         end
+        error_message * ' '
+      end
     end # class CsvReport
   end # module Report
 end # module Resque

data/lib/resque/reports/extensions/const.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+module Resque
+  module Reports
+    module Extensions
+      module Const
+        TO_EIGENCLASS = 'self.class'.freeze
+        TO_SUPER = 'self.class.superclass'.freeze
+      end
+    end
+  end
+end

data/lib/resque/reports/extensions/encodings.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+module Resque
+  module Reports
+    module Extensions
+      module Encodings
+        CP1251 = 'cp1251'.freeze
+        UTF8 = 'utf-8'.freeze
+      end
+    end
+  end
+end

data/lib/resque/reports/extensions/event_callbacks.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+module Resque
+  module Reports
+    module Extensions
+      # Defines event callbacks and handlers for Resque::Reports::ReportJob
+      module EventCallbacks
+        # TODO: сделать гибкой логику колбеков и хендлеров
+        # Defines callbacks
+        module ClassMethods
+
+          attr_reader :progress_callback, :error_callback
+
+          #--
+          # Callbacks
+          #++
+
+          # Set callback for watching progress of export
+          # @yield [progress] block to be executed on progress
+          # @yieldparam progress [Integer] current progress
+          # @yieldparam total [Integer] data length
+          def on_progress(&block)
+            @progress_callback = block
+          end
+
+          # Set callback on error
+          # @yield [error] block to be executed when error occurred
+          # @yieldparam [Exception] error
+          def on_error(&block)
+            @error_callback = block
+          end
+        end
+
+        # Defines handlers
+        module InstanceMethods
+          extend Forwardable
+
+          PROGRESS_STEP = 10
+
+          def_delegators Extensions::Const::TO_EIGENCLASS,
+                         :error_callback,
+                         :progress_callback
+          #--
+          # Handlers
+          #++
+
+          def handle_progress(progress, total, force = false)
+            if progress_callback && (force || progress % PROGRESS_STEP == 0)
+              progress_callback.call progress, total
+            end
+          end
+
+          def handle_error
+            error_callback ? error_callback.call($ERROR_INFO) : fail
+          end
+        end
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+      end
+    end
+  end
+end

data/lib/resque/reports/extensions/event_templates.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+module Resque
+  module Reports
+    module Extensions
+      # Defines base event handling methods for Resque::Reports::EventCallbacks
+      module EventTemplates
+
+        # Specifies progress message generation
+        # Can be overridden in successors
+        def progress_message(p, t)
+          nil
+        end
+
+        # Specifies error message generation
+        # Can be overridden in successors
+        def error_message(e)
+          fail e
+        end
+      end
+    end
+  end
+end

data/lib/resque/reports/extensions/filename_gen.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+module Resque
+  module Reports
+    module Extensions
+      # Module that generates file name
+      # Usage:
+      #   class SomeClass
+      #     include Resque::Reports::Extensions::FilenameGen
+      #
+      #     # ...call somewhere...
+      #     fname = generate_filename(%w(a b c), 'pdf')
+      #     # 'fname' value is something like this:
+      #     #   "a60428ee50f1795819b8486c817c27829186fa40.pdf"
+      #   end
+      module FilenameGen
+
+        private
+
+        def generate_filename(args, fextension)
+          "#{ hash(self.class.to_s, *args) }.#{ fextension }"
+        end
+
+        def hash(*args)
+          Digest::SHA1.hexdigest(args.to_json)
+        end
+      end
+    end
+  end
+end

data/lib/resque/reports/extensions/table_building.rb

@@ -0,0 +1,117 @@
+# coding: utf-8
+# Resque namespace
+module Resque
+  # Resque::Reports namespace
+  module Reports
+    # Resque::Reports::Extensions namespace
+    module Extensions
+      # Defines report table building logic
+      module TableBuilding
+        # Defines table building methods
+        #   External(DSL):
+        #     - source
+        #     - table
+        #     - column
+        #   Internal:
+        #     - init_table
+        #     - build_table_header
+        #     - build_table_row(row_object)
+        #     - data_each
+        #     - data_size
+        module ClassMethods
+
+          attr_accessor :source_method
+          alias_method :source, :source_method=
+
+          def table(&block)
+            @table_block = block
+          end
+
+          def column(name, value)
+            add_column_header(name) || add_column_cell(value)
+          end
+
+          def init_table
+            @table_header = []
+            @table_row = []
+          end
+
+          def add_column_header(column_name)
+            @table_header << encoded_string(column_name) if @header_collecting
+          end
+
+          def add_column_cell(column_value)
+            return if @header_collecting
+
+            if column_value.is_a? Symbol
+              # Smells bad... changes input variable
+              column_value = @instance.send(column_value, @row_object)
+            end
+
+            @table_row << encoded_string(column_value)
+          end
+
+          def build_table_row(row_object)
+            @header_collecting = false
+
+            @row_object = row_object # for instance decorate methods calls
+            row = @table_block.call(@row_object)
+
+            finish_row
+
+            row
+          end
+
+          def build_table_header
+            @header_collecting = true
+            @table_block.call(Extensions::Dummy.new)
+          end
+
+          # you may override default string endcoding
+          def encoded_string(obj)
+            obj.to_s.encode('utf-8', invalid: :replace, undef: :replace)
+          end
+
+          def finish_row
+            @table_row = []
+          end
+
+          def data(force = false)
+            if force || @data.nil?
+              @data = @instance.send(@source_method)
+            else
+              @data
+            end
+          end
+
+          def data_each(force = false)
+            data(force).each do |element|
+              yield element
+            end
+          end
+
+          def data_size
+            @data_size ||= data.count
+          end
+        end
+
+        # Delegates class methods to instance
+        module InstanceMethods
+          extend Forwardable
+
+          def_delegators Extensions::Const::TO_EIGENCLASS,
+                         :data_each,
+                         :data_size,
+                         :build_table_header,
+                         :build_table_row,
+                         :init_table
+        end
+
+        def self.included(base)
+          base.extend ClassMethods
+          base.send :include, InstanceMethods
+        end
+      end
+    end
+  end
+end

data/lib/resque/reports/extensions.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+require 'resque/reports/extensions/const'
+require 'resque/reports/extensions/event_callbacks'
+require 'resque/reports/extensions/event_templates'
+require 'resque/reports/extensions/filename_gen'
+require 'resque/reports/extensions/table_building'
+require 'resque/reports/extensions/encodings'
+
+# Resque namespace
+module Resque
+  # Resque::Reports namespace
+  module Reports
+    # Resque::Reports::Extensions namespace
+    module Extensions
+      # Class for dummy object that respond to any method
+      # and returns 'nil' on any method call
+      class Dummy
+        def method_missing(method, *arguments, &block)
+          nil
+        end
+
+        def respond_to?(method, include_private = false)
+          true
+        end
+      end
+
+      def self.included(base)
+        base.send :include, Const # share gem constants
+        base.send :include, TableBuilding # init and build table
+        base.send :include, FilenameGen # generate_filename method
+        base.send :include, EventCallbacks # event callbacks and handlers
+        base.send :include, EventTemplates # template events handling methods
+        base.send :include, Encodings # encoding constants
+      end
+    end
+  end
+end

data/lib/resque/reports/version.rb

@@ -1,5 +1,6 @@
+# coding: utf-8
 module Resque
   module Reports
-    VERSION = "0.0.2"
+    VERSION = '0.3.0'
   end
 end

data/lib/resque/reports.rb

@@ -1,17 +1,18 @@
 # coding: utf-8
 require 'forwardable'
-require 'facets/kernel/constant'
-
 require 'resque-integration'
 
-require 'resque/reports/version'
+require 'resque/reports/extensions'
+
 require 'resque/reports/cache_file'
-require 'resque/reports/callbacks'
-require 'resque/reports/encodings'
 require 'resque/reports/base_report'
 require 'resque/reports/csv_report'
 
+require 'resque/reports/version'
+
+# Resque namespace
 module Resque
+  # Resque::Reports namespace
   module Reports
 
   end