rear 0.2.0

data/lib/rear/helpers.rb

@@ -0,0 +1,17 @@
+module RearHelpers
+  module ClassMixin
+    include RearConstants
+  end
+
+  module InstanceMixin
+    include RearConstants
+  end
+end
+
+require 'rear/helpers/class'
+require 'rear/helpers/columns'
+require 'rear/helpers/filters'
+require 'rear/helpers/generic'
+require 'rear/helpers/order'
+require 'rear/helpers/pager'
+require 'rear/helpers/render'

data/lib/rear/helpers/class.rb

@@ -0,0 +1,46 @@
+module RearHelpers
+  module ClassMixin
+
+    def default_label
+      @__rear__default_label ||= self.name.gsub(/\W/, '_').freeze
+    end
+
+    def menu_group?; @__rear__menu_group end
+    def readonly?;   @__rear__readonly   end
+
+    def orm
+      @__rear__orm
+    end
+
+    def assocs
+      @__rear__managed_assocs ||= (@__rear__assocs || {}).inject({}) do |map,(type,assocs)|
+        map.merge type => assocs.reject {|assoc,*| ignored_assocs.include? assoc}
+      end
+    end
+
+    # keeps the list of "real" columns as well as "virtual" ones.
+    # virtual refers to columns displayed on pane/editor pages 
+    # but does exists in db
+    def columns
+      @__rear__columns ||= []
+    end
+
+    # keeps the list of columns that "physically" exists in db
+    def real_columns
+      @__rear__real_columns || []
+    end
+
+    def filters
+      mounted? ? @__rear__filters || {} : @__rear__filters ||= {}
+    end
+
+    def quick_filters
+      mounted? ? @__rear__quick_filters || {} : @__rear__quick_filters ||= {}
+    end
+    
+    def internal_filters
+      mounted? ? @__rear__internal_filters || [] : @__rear__internal_filters ||= []
+    end
+    
+  end
+end

data/lib/rear/helpers/columns.rb

@@ -0,0 +1,68 @@
+module RearHelpers
+  module InstanceMixin
+
+    def pane_columns
+      @__rear__pane_columns ||= begin
+        pane_columns = columns.select {|c| c.pane?}
+        [RearInput.new(pkey)] + case action_name
+        when :reverse_assoc
+          (assoc_columns = __rear__.assoc_columns) ?
+            pane_columns.select {|c| assoc_columns.include? c.name} :
+            pane_columns[0..1]
+        when :quickview
+          pane_columns[0..0]
+        else
+          pane_columns
+        end
+      end
+    end
+
+    def editor_columns
+      @__rear__editor_columns ||= columns.select {|c| c.editor?}
+    end
+
+    def columns
+      @__rear__columns ||= __rear__.columns.inject([]) do |columns,(name, type, attrs, proc)|
+        columns << RearInput.new(name, type, attrs, @brand_new_item, &proc)
+      end
+    end
+
+    def attrs column, scope
+      meth = '%s_attrs' % scope
+      column_attrs = column.send(meth)
+      return column_attrs if column_attrs.any?
+      __rear__.send(meth)
+    end
+
+    def render_pane_column column
+      render_column column, :pane
+    end
+
+    def render_editor_column column
+      render_column column, :editor
+    end
+
+    def render_column column, scope
+      template, value = %w[template value].map {|m| column.send('%s_%s' % [scope, m])}
+      locals = if column.optioned?
+        options = column.options
+        options = Hash[options.zip(options)] if options.is_a?(Array)
+        active_options = self.instance_exec(&column.active_options)
+        active_options = [active_options] unless active_options.is_a?(Array)
+        {options: options, active_options: active_options}
+      else
+        {value: self.instance_exec(&value)}
+      end
+      template.is_a?(Proc) ?
+        self.instance_exec(&template) :
+        render_slim_p(locals) { template_cache(path_to_rear_templates template) }
+    end
+
+    def sortable_column? column
+      if column.name == pkey || column.order_by? ||
+        __rear__.real_columns.any? {|(n,t)| n == column.name}
+        sortable_vector column
+      end
+    end
+  end
+end

data/lib/rear/helpers/filters.rb

@@ -0,0 +1,147 @@
+module RearHelpers
+  module InstanceMixin
+
+    def filters
+      __rear__.filters
+    end
+
+    def quick_filters
+      __rear__.quick_filters
+    end
+
+    def opted_quick_filters
+      @__rear__opted_quick_filters ||= begin
+        given_filters = params[:quick_filters] || {}
+        quick_filters.inject({}) do |map,(column,*)|
+          (v = given_filters[column.to_s]) && v.size > 0 ? map.merge(column => v) : map
+        end
+      end
+    end
+
+    def quick_filter? column
+      opted_quick_filters[column]
+    end
+
+    # turn
+    # {'date' => {'gte' => 'foo', 'lte' => 'bar'}}
+    # into
+    # {
+    #   :date => {
+    #             :gte => ['foo', ['%s >= ?', '%s'] ],
+    #             :lte => ['bar', ['%s <= ?', '%s'] ],
+    #            }
+    # }
+    def opted_filters
+      @__rear__opted_filters ||= (params[:filters]||{}).inject({}) do |map,s|
+        (column = s.first) && (filter = filters[(column = column.to_sym)]).is_a?(Hash) &&
+          (setup = s.last).is_a?(Hash) && setup.each_pair do |cmp,v|
+            v && v.size > 0 && (query_formats = filters_query_map[(cmp=cmp.to_sym)]) &&
+              (filter_setup = filter[cmp]) && (map[column] ||= {})[cmp] = [
+                v, # do not typecast to Fixnum cause this will break Hash to query_string conversion
+                query_formats,
+                filter_setup,
+              ]
+          end
+        map
+      end
+    end
+
+    def filters_query_map
+      @@__rear__filters__query_map ||= FILTERS__QUERY_MAP.call(__rear__.orm)
+    end
+
+    def filter name, comparison_function = FILTERS__DECORATIVE_CMP
+      ((opted_filters[name] || {})[comparison_function] || []).first
+    end
+    alias filter? filter
+    alias decorative_filter? filter
+
+    def filters_to_sql
+      conditions, sql_chunks, values = {}, [], []
+      
+      quick_filters.each_pair do |column,filters|
+        next unless label = opted_quick_filters[column]
+        filters.each_pair do |filter,(query_formats,value)|
+          next unless label == filter
+          sql_chunks  << query_formats.first % RearUtils.quote_column(model, column)
+          values << ([TrueClass, FalseClass, Regexp].include?(value.class) ? value : query_formats.last % value)
+        end
+      end
+
+      opted_filters.each_pair do |column, setups|
+        setups.each_pair do |cmp, (value, query_formats, filter_setup)|
+          next if filter_setup[:decorative?]
+          
+          sql_chunk = query_formats.first % RearUtils.quote_column(model, column)
+          custom_sql_chunk  = nil
+
+          if filter_setup[:type] == :boolean && FILTERS__STR_TO_BOOLEAN.has_key?(value)
+            values << FILTERS__STR_TO_BOOLEAN[value]
+          else
+            case cmp
+            when :in
+              values << value
+            when :csl # comma separated list
+              values << value.to_s.split(',')
+            else
+              if value.is_a?(Array)
+                custom_sql_chunk = []
+                value.each do |v|
+                  custom_sql_chunk << sql_chunk
+                  values << query_formats.last % v
+                end
+                custom_sql_chunk = '(' + custom_sql_chunk.join(' OR ') + ')'
+              else
+                values << query_formats.last % value
+              end
+            end
+          end
+          sql_chunks << (custom_sql_chunk || sql_chunk)
+        end
+      end
+
+      __rear__.internal_filters.each do |m|
+        next unless items = self.send(m)
+        sql_chunks << filters_query_map[:in].first % pkey
+        values     << items.map {|i| i[pkey]}
+      end
+
+      sql_chunks.any? ?
+        conditions.merge(conditions: [sql_chunks.join(' AND '), *values]) :
+        conditions
+    end
+
+    def render_filters
+      html = assets_mapper(route(:assets), suffix: '-rear').js_tag('xhr')
+      main_filters = filters.inject(html) do |html,(column,setups)|
+        setups.each_pair do |comparison_function, setup|
+          context = {
+              name: 'filters[%s][%s]' % [column, comparison_function],
+            column: column,
+             value: filter(column, comparison_function),
+             setup: setup,
+             attrs: Hash[setup[:attrs]]
+          }
+          template = template_cache(path_to_rear_templates(setup[:template]))
+          html << render_slim_p(context) { template }
+        end
+        html << '&nbsp;'
+      end
+    end
+
+    def filter_setup_to_options(setup)
+      options = setup[:proc] ? self.instance_exec(&setup[:proc]) : {}
+      if options.is_a?(Array)
+        options.flatten!
+        options = Hash[options.zip(options)]
+      end
+      return options if options.is_a?(Hash)
+      warn "
+      %s#%s filter expects options to be provided as a Hash or Array or via a block.
+      If block given, it should return a Hash or Array
+      " % [self.class, setup[:label]]
+      {}
+    end
+    
+  end
+end

data/lib/rear/helpers/generic.rb

@@ -0,0 +1,73 @@
+module RearHelpers
+  module InstanceMixin
+    
+    attr_reader   :items
+    attr_accessor :item, :item_id, :column
+
+    def orm
+      @__rear__orm ||= RearORM.new(__rear__.model, __rear__.pkey)
+    end
+
+    def dom_id
+      @__rear__dom_id ||= (params[:dom_id] || # params[:dom_id] are used by decorative filters
+        (@reverse_assoc ? @reverse_assoc.dom_id : 'rear_element_%s' % self.__id__)).freeze
+    end
+
+    def model
+      __rear__.model
+    end
+
+    def sequel?
+      @@__rear__is_sequel ||= RearUtils.orm(model) == :sq
+    end
+
+    def pkey
+      __rear__.pkey
+    end
+
+    def assocs *types
+      return __rear__.assocs if types.empty?
+      types.inject({}) do |assocs,type|
+        assocs.merge(__rear__.assocs[type.to_sym] || {})
+      end
+    end
+
+    def template_cache template
+      ((@__rear__template_cache ||= {})[template] ||= {})[File.mtime(template)] ||= File.read(template)
+    end
+
+    # used for cosmetic compatibility between filters and columns.
+    # columns block are executed inside Column instance,
+    # and using `options` method to define options for :select/:radio/:checkbox columns.
+    # filters of these types also uses a block and it is executed in controller's context.
+    # so adding this method here will allow to use `options` method inside filter's block.
+    #
+    # @example
+    #   filter :colors do
+    #     options 'Red', 'Green', 'Blue'
+    #   end
+    #   # this is equivalent to 
+    #   filter :colors do
+    #     ['Red', 'Green', 'Blue']
+    #   end
+    #   # but looks cosmetically better cause uses same syntax as columns
+    #
+    def options *args
+      args
+    end
+
+    def associated_model_controller model
+      (@__rear__associated_model_controllers ||= {})[model] ||=
+        RearUtils.associated_model_controller(model, :ensure_mounted)
+    end
+
+    def __rear__
+      self.class
+    end
+
+    def readonly?
+      self.class.readonly?
+    end
+
+  end
+end

data/lib/rear/helpers/order.rb

@@ -0,0 +1,47 @@
+module RearHelpers
+  module InstanceMixin
+
+    # flip-flopping vectors, that's it, if current vector set to asc
+    # this method will return desc, and vice-versa.
+    # also it will return UI arrow direction - when vector is asc
+    # arrow is down and arrow is up when vector is desc
+    def sortable_vector column
+      vector = ['asc', nil].include?(order_params[column.string_name]) ? 'desc' : 'asc'
+      [vector, vector == 'asc' ? 'down' : 'up']
+    end
+
+    # checks whether ordering is happening by given column
+    # and if it is, check whether a valid vector used
+    def sortable_vector? column
+      if vector = (params[:order] || {})[column.string_name]
+        valid_sortable_vector? vector
+      end
+    end
+
+    def valid_sortable_vector? vector
+      vector if vector == 'asc' || vector == 'desc'
+    end
+
+    def order_params
+      @__rear__order_params ||= pane_columns.inject({}) do |map,column|
+        (vector = sortable_vector?(column)) ?
+          map.update(column.string_name => vector) : map
+      end.freeze
+    end
+
+    def order_params_to_sql
+      order = []
+      order_params.each_pair do |column_name, vector|
+        next unless column = columns.find {|c| c.string_name == column_name}
+        case __rear__.orm
+        when :dm
+          column.order_by.each {|c| order << c.send(vector)}
+        when :ar
+          columns = column.order_by.map {|c| RearUtils.quote_ar_column(model, c)}
+          order  << [columns.join(', '), vector].join(' ')
+        end
+      end
+      order.any? ? order : nil
+    end
+  end
+end

data/lib/rear/helpers/pager.rb

@@ -0,0 +1,35 @@
+module RearHelpers
+  module InstanceMixin
+
+    def pager_linker page, label = nil
+      label ||= page
+      url = route(action, *action_params__array, pager_params(page))
+      return link_to(url, label) unless xhr?
+      
+      onclick = "Rear.switch_page('#%s', '%s');" % [dom_id, url]
+      link_to nil, label, onclick: onclick
+    end
+
+    def pager_params page = nil, filters = nil
+      page.is_a?(Hash) && (filters = page) && (page = nil)
+      page ||= params[:page]
+      {
+                 page: page.to_s,
+              filters: filters || pager_filters,
+        quick_filters: opted_quick_filters,
+                order: order_params
+      }.reject {|k,v| v.nil? || v.empty?}
+    end
+
+    def pager_filters
+      @__rear__pager_filters ||= filters.inject({}) do |map,(column, setups)|
+        setups.each do |comparison_function, setup|
+          (value = filter?(column, comparison_function)) &&
+            (map[column] ||= {})[comparison_function] = value
+        end
+        map
+      end
+    end
+    
+  end
+end

data/lib/rear/helpers/render.rb

@@ -0,0 +1,37 @@
+module RearHelpers
+  module InstanceMixin
+
+    def reander *args, &proc
+      reander_layout(:layout) { render_slim args, &proc }
+    end
+
+    def reander_partial path, *rest
+      render_slim_p path_to_rear_templates('%s.slim' % path), *rest
+    end
+    alias reander_p reander_partial
+    
+    def reander_layout path, *rest, &proc
+      render_slim_l path_to_rear_templates('%s.slim' % path), *rest, &proc
+    end
+    alias reander_l reander_layout
+
+    def path_to_rear_templates *chunks
+      template  = File.join *chunks.map(&:to_s)
+      locations = []
+      {
+        @__rear__templates_path => File.join(app.root, @__rear__templates_path.to_s),
+        @__rear__templates_fullpath => @__rear__templates_fullpath,
+      }.select {|k,v| k}.each_value do |prefix|
+        locations << File.join(prefix, EUtils.class_to_route(self.class.model)) if self.class.respond_to?(:model)
+        locations << File.join(prefix, 'shared-templates')
+      end
+      locations << PATH__TEMPLATES
+      locations.each do |p|
+        fp = File.join(p, template)
+        return explicit_view_path(fp) if File.file?(fp)
+      end
+      raise ArgumentError, '%s template not found in any of %s paths' % [template,locations*', ']
+    end
+    
+  end
+end