ab_admin 0.1.0

data/lib/ab_admin/utils/csv_builder.rb

@@ -0,0 +1,52 @@
+module AbAdmin
+  module Utils
+    # CSVBuilder stores CSV configuration
+    #
+    # Usage example:
+    #
+    #   csv_builder = CSVBuilder.new
+    #   csv_builder.column :id
+    #   csv_builder.column("Name") { |resource| resource.full_name }
+    #
+    #   csv_builder = CSVBuilder.new :separator => ";"
+    #   csv_builder.column :id
+    #
+    #
+    class CSVBuilder
+
+      # Return a default CSVBuilder for a resource
+      # The CSVBuilder's columns would be Id followed by this
+      # resource's content columns
+      def self.default_for_resource(resource)
+        new.tap do |csv_builder|
+          csv_builder.column(:id)
+          resource.content_columns.each do |content_column|
+            csv_builder.column(content_column.name.to_sym)
+          end
+        end
+      end
+
+      attr_reader :columns, :column_separator
+
+      def initialize(options={}, &block)
+        @columns = []
+        @column_separator = options.delete(:separator)
+        instance_eval &block if block_given?
+      end
+
+      # Add a column
+      def column(name, &block)
+        @columns << Column.new(name, block)
+      end
+
+      class Column
+        attr_reader :name, :data
+
+        def initialize(name, block = nil)
+          @name = name.is_a?(Symbol) ? name.to_s.titleize : name
+          @data = block || name.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/ab_admin/utils/csv_document.rb

@@ -0,0 +1,66 @@
+require 'csv'
+
+module AbAdmin
+  module Utils
+    class CsvDocument
+      include AbAdmin::Utils::EvalHelpers
+
+      def initialize(source, options = {})
+        @source = source
+        @options = options
+        @klass = @options.delete(:klass) || extract_klass
+      end
+
+      def default_columns
+        @default_columns ||= @klass.column_names
+      end
+
+      def column_data
+        @columns_names ||= @options[:column_data] || default_columns
+      end
+
+      def columns_names
+        (@options[:column_names] || default_columns).map { |column| column.is_a?(Symbol) ? @klass.human_attribute_name(column) : column }
+      end
+
+      def filename
+        @filename ||= [@options[:filename] || "#{@klass.model_name.plural}-#{Time.now.strftime('%Y-%m-%d')}", '.csv'].join
+      end
+
+      def render
+        ::CSV.generate(:col_sep => @options[:column_separator] || ',') do |csv|
+          csv << columns_names
+
+          each_record do |item|
+            csv << column_data.map { |column| AbAdmin.pretty_data call_method_or_proc_on(item, column, :exec => false) }
+          end
+        end
+      end
+
+      def each_record
+        if @source.respond_to?(:find_each)
+          @source.find_each do |item|
+            yield item
+          end
+        else
+          Array(@source).each do |item|
+            yield item
+          end
+        end
+      end
+
+      protected
+
+      def extract_klass
+        if @source.respond_to?(:klass)
+          @source.klass
+        elsif @source.is_a?(Array)
+          @source.first.try(:class)
+        else
+          @source.class
+        end
+      end
+
+    end
+  end
+end

data/lib/ab_admin/utils/eval_helpers.rb

@@ -0,0 +1,103 @@
+module AbAdmin
+  module Utils
+    # Provides a set of helper methods for evaluating methods within the context
+    # of an object.
+    module EvalHelpers
+      # Evaluates one of several different types of methods within the context
+      # of the given object.  Methods can be one of the following types:
+      # * Symbol
+      # * Method / Proc
+      # * String
+      # 
+      # == Examples
+      # 
+      # Below are examples of the various ways that a method can be evaluated
+      # on an object:
+      # 
+      #   class Person
+      #     def initialize(name)
+      #       @name = name
+      #     end
+      #     
+      #     def name
+      #       @name
+      #     end
+      #   end
+      #   
+      #   class PersonCallback
+      #     def self.run(person)
+      #       person.name
+      #     end
+      #   end
+      # 
+      #   person = Person.new('John Smith')
+      #   
+      #   evaluate_method(person, :name)                            # => "John Smith"
+      #   evaluate_method(person, PersonCallback.method(:run))      # => "John Smith"
+      #   evaluate_method(person, Proc.new {|person| person.name})  # => "John Smith"
+      #   evaluate_method(person, lambda {|person| person.name})    # => "John Smith"
+      #   evaluate_method(person, '@name')                          # => "John Smith"
+      # 
+      # == Additional arguments
+      # 
+      # Additional arguments can be passed to the methods being evaluated.  If
+      # the method defines additional arguments other than the object context,
+      # then all arguments are required.
+      # 
+      # For example,
+      # 
+      #   person = Person.new('John Smith')
+      #   
+      #   evaluate_method(person, lambda {|person| person.name}, 21)                              # => "John Smith"
+      #   evaluate_method(person, lambda {|person, age| "#{person.name} is #{age}"}, 21)          # => "John Smith is 21"
+      #   evaluate_method(person, lambda {|person, age| "#{person.name} is #{age}"}, 21, 'male')  # => ArgumentError: wrong number of arguments (3 for 2)
+      def evaluate_method(object, method, *args, &block)
+        case method
+          when Symbol
+            object.method(method).arity == 0 ? object.send(method, &block) : object.send(method, *args, &block)
+          when Proc, Method
+            args.unshift(object)
+            arity = method.arity
+            limit = [0, 1].include?(arity) ? arity : args.length
+            
+            # Procs don't support blocks in < Ruby 1.8.6, so it's tacked on as an
+            # argument for consistency across versions of Ruby (even though 1.9
+            # supports yielding within blocks)
+            if block_given? && Proc === method && arity != 0
+              if [1, 2].include?(arity)
+                # Force the block to be either the only argument or the 2nd one
+                # after the object (may mean additional arguments get discarded)
+                limit = arity
+                args.insert(limit - 1, block)
+              else
+                # Tack the block to the end of the args
+                limit += 1 unless limit < 0
+                args.push(block)
+              end
+            end
+            
+            method.call(*args[0, limit], &block)
+          when String
+            eval(method, object.instance_eval {binding}, &block)
+          else
+            raise ArgumentError, 'Methods must be a symbol denoting the method to call, a block to be invoked, or a string to be evaluated'
+          end
+      end
+
+      def call_method_or_proc_on(obj, symbol_or_proc, options = {})
+        exec = options[:exec].nil? ? true : options[:exec]
+        case symbol_or_proc
+          when Symbol, String
+            obj.send(symbol_or_proc.to_sym)
+          when Proc
+            if exec
+              obj.instance_exec(&symbol_or_proc)
+            else
+              symbol_or_proc.call(obj)
+            end
+        end
+      end
+
+    end
+  end
+end

data/lib/ab_admin/utils/logger.rb

@@ -0,0 +1,21 @@
+module AbAdmin
+  module Utils
+    module Logger
+
+      class ShortFormatter < ::Logger::Formatter
+        def call(severity, time, progname, msg)
+          "[#{time.strftime("%Y-%m-%dT%H:%M:%S")}] #{msg}\n"
+        end
+      end
+
+      def self.for_file(filename)
+        logfile = File.open(Rails.root.join('log', filename), 'a+')
+        logfile.sync = true
+        logger = ::Logger.new(logfile)
+        logger.formatter = ShortFormatter.new
+        logger
+      end
+
+    end
+  end
+end

data/lib/ab_admin/utils/mysql.rb

@@ -0,0 +1,34 @@
+module AbAdmin
+  module Utils
+    module Mysql
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Deletes all rows in table very fast, but without calling +destroy+ method
+        # nor any hooks.
+        def truncate!
+          transaction { connection.execute("TRUNCATE TABLE #{quoted_table_name};") }
+        end
+
+        # Disables key updates for model table
+        def disable_keys
+          connection.execute("ALTER TABLE #{quoted_table_name} DISABLE KEYS")
+        end
+
+        # Enables key updates for model table
+        def enable_keys
+          connection.execute("ALTER TABLE #{quoted_table_name} ENABLE KEYS")
+        end
+
+        # Disables keys, yields block, enables keys.
+        def with_keys_disabled
+          disable_keys
+          yield
+          enable_keys
+        end
+      end
+    end
+  end
+end

data/lib/ab_admin/utils/xls_document.rb

@@ -0,0 +1,81 @@
+require 'ruby2xlsx'
+
+module AbAdmin
+  module Utils
+    class XlsDocument < Ruby2xlsx::Base
+      include AbAdmin::Utils::EvalHelpers
+
+      def default_columns
+        @default_columns ||= @klass.column_names
+      end
+
+      def column_data
+        @columns_names ||= @options[:column_data] || default_columns
+      end
+
+      def columns_names
+        (@options[:column_names] || default_columns).map { |column| column.is_a?(Symbol) ? @klass.human_attribute_name(column) : column }
+      end
+
+      def filename
+        @filename ||= [@options[:filename] || "#{@klass.model_name.plural}-#{Time.now.strftime('%Y-%m-%d')}", '.xls'].join
+      end
+
+      def render
+        date_format = workbook.add_format(:num_format => 'dd.mm.yyyy')
+        time_format = workbook.add_format(:num_format => 'dd.mm.yyyy HH:MM')
+
+        each_with_index do |item, index|
+          row = index + 1
+
+          column_data.each_with_index do |column, num|
+            value = call_method_or_proc_on(item, column, :exec => false)
+
+            case value
+              when Date
+                worksheet.write_string(row, num, value.strftime('%Y-%m-%dT'), date_format)
+              when DateTime, Time
+                worksheet.write_date_time(row, num, value.strftime('%Y-%m-%dT%H:%M:%S.%L'), time_format)
+              when String
+                worksheet.write_string(row, num, value)
+              else
+                worksheet.write(row, num, AbAdmin.pretty_data(value))
+            end
+          end
+        end
+
+        bold = workbook.add_format(:bold => 1)
+        worksheet.write('A1', columns_names, bold)
+
+        super
+
+      end
+
+      def worksheet_name
+        @worksheet_name ||= (@options[:worksheet_name] || @klass.model_name.human)
+      end
+
+      def each_with_index
+        count = 0
+        if @source.is_a?(::ActiveRecord::Relation)
+          @klass ||= @source.klass
+
+          @source.find_each do |item|
+            yield item, count
+            count += 1
+          end
+        else
+          items = Array.wrap(@source)
+          @klass ||= items.first.class unless items.empty?
+          @klass ||= Default
+
+          items.each do |item|
+            yield item, count
+            count += 1
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ab_admin/version.rb

@@ -0,0 +1,3 @@
+module AbAdmin
+  VERSION = '0.1.0'
+end

data/lib/ab_admin/views/admin_helpers.rb

@@ -0,0 +1,116 @@
+module AbAdmin
+  module Views
+    module AdminHelpers
+
+      def admin_form_for(object, *args, &block)
+        options = args.extract_options!
+        options[:html] ||= {}
+        options[:html][:class] ||= 'form-horizontal'
+        options[:builder] ||= ::AbAdmin::Views::FormBuilder
+        options[:html]['data-id'] = Array(object).last.id
+        if controller_name == 'manager' && resource_class == Array(object).last.class
+          options[:url] ||= object.new_record? ? collection_path : resource_path
+        end
+        if options.delete(:nested)
+          simple_nested_form_for([:admin, object].flatten, *(args << options), &block)
+        else
+          simple_form_for([:admin, object].flatten, *(args << options), &block)
+        end
+      end
+
+      def options_for_ckeditor(options = {})
+        {:width => 930, :height => 200, :toolbar => 'VeryEasy', :namespace => ''}.update(options)
+      end
+
+      def admin_tree_item(item)
+        render 'tree_item', :item => item, :child_tree => admin_tree(item.cached_children)
+      end
+
+      def admin_tree(items)
+        return if items.blank?
+        items.map { |item| admin_tree_item(item) }.join.html_safe
+      end
+
+      def layout_css
+        css = []
+        css << 'content_with_sidebar' if settings[:sidebar]
+        css << 'well' if settings[:well]
+        css << "#{settings[:index_view]}_view"
+        css
+      end
+
+      def admin_comments
+        render 'admin/admin_comments/comments'
+      end
+
+      def color_bool(val, success_class='badge-success')
+        %(<span class="badge #{success_class if val}">#{val ? '+' : '-'}</span>).html_safe
+      end
+
+      def icon(name, white=false)
+        "<i class='icon-#{name} #{'icon-white' if white}'></i> ".html_safe
+      end
+
+      def admin_pretty_data(object)
+        case object
+          when String, Integer
+            object
+          when TrueClass, FalseClass
+            color_bool(object)
+          when Date, DateTime, Time, ActiveSupport::TimeWithZone
+            I18n.l(object, :format => :long)
+          when NilClass
+            ''
+          when ActiveRecord::Base
+            admin_show_link(object)
+          else
+            AbAdmin.safe_display_name(object)
+        end
+      end
+
+      def pretty_data(object)
+        AbAdmin.pretty_data(object)
+      end
+
+      def item_image_link(item, options={})
+        options.reverse_merge!(:url => resource_path(item), :assoc => :picture)
+        image = item.send(options[:assoc])
+        return nil unless image
+        version = options[:version] || image.class.thumb_size
+        popover_data = {:content => "<img src='#{image.url}'></img>", :title => item.name}
+        link_to image_tag(image.url(version)), options[:url], :data => popover_data, :rel => 'popover'
+      end
+
+      def item_image(item, assoc=:photo, size=:thumb)
+        image_tag_if(item.send(assoc).try(:url, size))
+      end
+
+      # input_set 'title', :legend_class => 'do_sort', :label_class => 'label-info' do
+      def input_set(title, options={}, &block)
+        options.reverse_merge!(:class => "inputs well well-small #{options.delete(:legend_class) || 'do_sort'}", :id => options.delete(:legend_id))
+        html = content_tag(:label, title, :class => "input_set label #{options.delete(:label_class)}")
+        html.concat(capture(&block)) if block_given?
+        content_tag(:fieldset, html, options)
+      end
+
+      def ha(attr)
+        resource_class.han(attr)
+      end
+
+      def call_method_or_proc_on(obj, symbol_or_proc, options = {})
+        exec = options[:exec].nil? ? true : options[:exec]
+        case symbol_or_proc
+          when Symbol, String
+            obj.send(symbol_or_proc.to_sym)
+          when Proc
+            if exec
+              instance_exec(obj, &symbol_or_proc)
+            else
+              symbol_or_proc.call(obj)
+            end
+        end
+      end
+
+    end
+  end
+end