active_scaffold-sequel 0.3.0

data/lib/active_scaffold/bridges/paperclip.rb

@@ -0,0 +1,12 @@
+class ActiveScaffold::Bridges::Paperclip < ActiveScaffold::DataStructures::Bridge
+  def self.install
+    if ActiveScaffold::Config::Core.instance_methods.include?("initialize_with_paperclip")
+      raise RuntimeError, "We've detected that you have active_scaffold_paperclip_bridge installed. This plugin has been moved to core. Please remove active_scaffold_paperclip_bridge to prevent any conflicts"
+    end
+    require File.join(File.dirname(__FILE__), "paperclip/form_ui")
+    require File.join(File.dirname(__FILE__), "paperclip/list_ui")
+    require File.join(File.dirname(__FILE__), "paperclip/paperclip_bridge_helpers")
+    require File.join(File.dirname(__FILE__), "paperclip/paperclip_bridge")
+    ActiveScaffold::Config::Core.send :include, ActiveScaffold::Bridges::Paperclip::PaperclipBridge
+  end
+end

data/lib/active_scaffold/bridges/record_select/helpers.rb

@@ -0,0 +1,86 @@
+class ActiveScaffold::Bridges::RecordSelect
+  module Helpers
+    def self.included(base)
+      base.class_eval do
+        include FormColumnHelpers
+        include SearchColumnHelpers
+      end
+    end
+
+    module FormColumnHelpers
+      # requires RecordSelect plugin to be installed and configured.
+      def active_scaffold_input_record_select(column, options)
+        if column.singular_association?
+          multiple = false
+          multiple = column.options[:html_options][:multiple] if column.options[:html_options] &&  column.options[:html_options][:multiple]
+          active_scaffold_record_select(column, options, @record.send(column.name), multiple)
+        elsif column.plural_association?
+          active_scaffold_record_select(column, options, @record.send(column.name), true)
+        else
+          active_scaffold_record_select_autocomplete(column, options)
+        end
+      end
+
+      def active_scaffold_record_select(column, options, value, multiple)
+        unless column.association
+          raise ArgumentError, "record_select can only work against associations (and #{column.name} is not).  A common mistake is to specify the foreign key field (like :user_id), instead of the association (:user)."
+        end
+        remote_controller = active_scaffold_controller_for(column.association.associated_class).controller_path
+
+        # if the opposite association is a :belongs_to (in that case association in this class must be has_one or has_many)
+        # then only show records that have not been associated yet
+        if [:has_one, :has_many].include?(column.association.macro)
+          params.merge!({column.association.primary_key_name => ''})
+        end
+ 
+        record_select_options = active_scaffold_input_text_options(options).merge(
+          :controller => remote_controller
+        )
+        record_select_options.merge!(column.options)
+ 
+        html = if multiple
+          record_multi_select_field(options[:name], value || [], record_select_options)
+        else
+          record_select_field(options[:name], value || column.association.associated_class.new, record_select_options)
+        end
+        html = self.class.field_error_proc.call(html, self) if @record.errors[column.name].any?
+        html
+      end
+      
+      def active_scaffold_record_select_autocomplete(column, options)
+        record_select_options = active_scaffold_input_text_options(options).merge(
+          :controller => active_scaffold_controller_for(@record.class).controller_path
+        )
+        html = record_select_autocomplete(options[:name], @record, record_select_options)
+        html = self.class.field_error_proc.call(html, self) if @record.errors[column.name].any?
+        html
+      end
+    end
+
+    module SearchColumnHelpers
+      def active_scaffold_search_record_select(column, options)
+        value = field_search_record_select_value(column)
+        active_scaffold_record_select(column, options, value, column.options[:multiple])
+      end
+      
+      def field_search_record_select_value(column)
+        begin
+          value = field_search_params[column.name]
+          unless value.blank?
+            klass = column.association.associated_class
+            if column.options[:multiple]
+              klass.filter(klass.primary_key => value.collect!(&:to_i))
+            else
+              klass[value.to_i]
+            end
+          end
+        rescue Exception => e
+          logger.error Time.now.to_s + "Sorry, we are not that smart yet. Attempted to restore search values to search fields but instead got -- #{e.inspect} -- on the ActiveScaffold column = :#{column.name} in #{@controller.class}"
+          raise e
+        end
+      end
+    end
+  end
+end
+
+ActionView::Base.class_eval { include ActiveScaffold::Bridges::RecordSelect::Helpers }

data/lib/active_scaffold/bridges/record_select.rb

@@ -0,0 +1,11 @@
+class ActiveScaffold::Bridges::RecordSelect < ActiveScaffold::DataStructures::Bridge
+  def self.install
+    require File.join(File.dirname(__FILE__), "record_select/helpers.rb")
+  end
+  def self.stylesheets
+    'record_select'
+  end
+  def self.javascripts
+    'record_select'
+  end
+end

data/lib/active_scaffold/bridges/semantic_attributes/column.rb

@@ -0,0 +1,20 @@
+class ActiveScaffold::Bridges::SemanticAttributes
+  module Column
+    def self.included(base)
+      base.class_eval { alias_method_chain :initialize, :semantic_attributes }
+    end
+
+    def initialize_with_semantic_attributes(name, active_record_class)
+      initialize_without_semantic_attributes(name, active_record_class)
+      self.required = !active_record_class.semantic_attributes[self.name].predicates.find {|p| p.allow_empty? == false }.nil?
+      active_record_class.semantic_attributes[self.name].predicates.find do |p|
+        sem_type = p.class.to_s.split('::')[1].underscore.to_sym
+        next if [:required, :association].include?(sem_type)
+        @form_ui = sem_type
+      end
+    end
+  end
+end
+ActiveScaffold::DataStructures::Column.class_eval do
+  include ActiveScaffold::Bridges::SemanticAttributes::Column
+end

data/lib/active_scaffold/bridges/semantic_attributes.rb

@@ -0,0 +1,5 @@
+class ActiveScaffold::Bridges::SemanticAttributes < ActiveScaffold::DataStructures::Bridge
+  def self.install
+    require File.join(File.dirname(__FILE__), "semantic_attributes/column.rb")
+  end
+end

data/lib/active_scaffold/bridges/shared/date_bridge.rb

@@ -0,0 +1,209 @@
+module ActiveScaffold
+  module Bridges
+    module Shared
+      module DateBridge
+        module SearchColumnHelpers
+          def active_scaffold_search_date_bridge(column, options)
+            current_search = {'from' => nil, 'to' => nil, 'opt' => 'BETWEEN',
+                              'number' => 1, 'unit' => 'DAYS', 'range' => nil}
+            current_search.merge!(options[:value]) unless options[:value].nil?
+            tags = []
+            tags << active_scaffold_search_date_bridge_comparator_tag(column, options, current_search)
+            tags << active_scaffold_search_date_bridge_trend_tag(column, options, current_search)
+            tags << active_scaffold_search_date_bridge_numeric_tag(column, options, current_search)
+            tags << active_scaffold_search_date_bridge_range_tag(column, options, current_search)
+            tags.join("&nbsp;").html_safe
+          end
+          
+          def active_scaffold_search_date_bridge_comparator_options(column)
+            select_options = ActiveScaffold::Finder::DateComparators.collect {|comp| [as_(comp.downcase.to_sym), comp]}
+            select_options + ActiveScaffold::Finder::NumericComparators.collect {|comp| [as_(comp.downcase.to_sym), comp]}
+          end
+          
+          def active_scaffold_search_date_bridge_comparator_tag(column, options, current_search)
+            select_tag("#{options[:name]}[opt]", options_for_select(active_scaffold_search_date_bridge_comparator_options(column),current_search['opt']), :id => "#{options[:id]}_opt", :class => "as_search_range_option as_search_date_time_option")
+          end
+          
+          def active_scaffold_search_date_bridge_numeric_tag(column, options, current_search)
+            numeric_controls = "" << 
+            active_scaffold_search_date_bridge_calendar_control(column, options, current_search, 'from') <<
+            content_tag(:span, (" - " + active_scaffold_search_date_bridge_calendar_control(column, options, current_search, 'to')).html_safe,
+              :id => "#{options[:id]}_between", :class => "as_search_range_between", :style => "display:#{current_search['opt'] == 'BETWEEN' ? '' : 'none'}")  
+            content_tag("span", numeric_controls.html_safe, :id => "#{options[:id]}_numeric", :style => "display:#{ActiveScaffold::Finder::NumericComparators.include?(current_search['opt']) ? '' : 'none'}")
+          end
+  
+          def active_scaffold_search_date_bridge_trend_tag(column, options, current_search)
+            active_scaffold_date_bridge_trend_tag(column, options, 
+                                                 {:name_prefix => 'search',
+                                                  :number_value => current_search['number'],
+                                                  :unit_value => current_search["unit"],
+                                                  :show => (current_search['opt'] == 'PAST' || current_search['opt'] == 'FUTURE')})
+          end
+
+          def active_scaffold_date_bridge_trend_tag(column, options, trend_options)
+            trend_controls = text_field_tag("#{trend_options[:name_prefix]}[#{column.name}][number]", trend_options[:number_value], :class => 'text-input', :size => 10, :autocomplete => 'off') << " " <<
+            select_tag("#{trend_options[:name_prefix]}[#{column.name}][unit]",
+             options_for_select(active_scaffold_search_date_bridge_trend_units(column), trend_options[:unit_value]),
+             :class => 'text-input')
+            content_tag("span", trend_controls.html_safe, :id => "#{options[:id]}_trend", :style => "display:#{trend_options[:show] ? '' : 'none'}")
+          end
+
+          def active_scaffold_search_date_bridge_trend_units(column)
+             options = ActiveScaffold::Finder::DateUnits.collect{|unit| [as_(unit.downcase.to_sym), unit]}
+             options = ActiveScaffold::Finder::TimeUnits.collect{|unit| [as_(unit.downcase.to_sym), unit]} + options if column_datetime?(column)
+             options
+          end
+          
+          def active_scaffold_search_date_bridge_range_tag(column, options, current_search)
+            range_controls = select_tag("search[#{column.name}][range]", 
+              options_for_select( ActiveScaffold::Finder::DateRanges.collect{|range| [as_(range.downcase.to_sym), range]}, current_search["range"]), 
+             :class => 'text-input')
+            content_tag("span", range_controls.html_safe, :id => "#{options[:id]}_range", :style => "display:#{(current_search['opt'] == 'RANGE') ? '' : 'none'}")
+          end
+          
+          def column_datetime?(column)
+            (!column.column.nil? && [:datetime, :time].include?(column.column[:type]))
+          end
+        end
+
+        module HumanConditionHelpers
+          def active_scaffold_human_condition_date_bridge(column, value)
+            case value[:opt]
+            when 'RANGE'
+              range_type, range = value[:range].downcase.split('_')
+              format = active_scaffold_human_condition_date_bridge_range_format(range_type, range)
+              from, to = controller.class.date_bridge_from_to(column, value)
+              "#{column.active_record_class.human_attribute_name(column.name)} = #{as_(value[:range].downcase).downcase} (#{I18n.l(from, :format => format)})"
+            when 'PAST', 'FUTURE'
+              from, to = controller.class.date_bridge_from_to(column, value)
+              "#{column.active_record_class.human_attribute_name(column.name)} #{as_('BETWEEN'.downcase).downcase} #{I18n.l(from)} - #{I18n.l(to)}"
+            else
+              from, to = controller.class.date_bridge_from_to(column, value)
+              "#{column.active_record_class.human_attribute_name(column.name)} #{as_(value[:opt].downcase).downcase} #{I18n.l(from)} #{value[:opt] == 'BETWEEN' ? '- ' + I18n.l(to) : ''}"
+            end
+          end
+
+          def active_scaffold_human_condition_date_bridge_range_format(range_type, range)
+            case range
+            when 'week'
+              first_day_of_week = I18n.translate 'active_scaffold.date_picker_options.firstDay'
+              if first_day_of_week == 1
+                '%W %Y'
+              else
+                '%U %Y'
+              end
+            when 'month'
+              '%b %Y'
+            when 'year'
+              '%Y'
+            else
+              I18n.translate 'date.formats.default'
+            end
+          end
+        end
+        
+        module Finder
+          module ClassMethods
+            def condition_for_date_bridge_type(column, value, like_pattern)
+              operator = ActiveScaffold::Finder::NumericComparators.include?(value[:opt]) && value[:opt] != 'BETWEEN' ? value[:opt] : nil
+              from_value, to_value = date_bridge_from_to(column, value)
+              
+              if column.search_sql.is_a? Proc
+                column.search_sql.call(from_value, to_value, operator)
+              else
+                unless operator.nil?
+                  ["#{column.search_sql} #{value[:opt]} ?", from_value.to_s(:db)] unless from_value.nil?
+                else
+                  ["#{column.search_sql} BETWEEN ? AND ?", from_value.to_s(:db), to_value.to_s(:db)] unless from_value.nil? && to_value.nil?  
+                end
+              end
+            end
+            
+            def date_bridge_from_to(column, value)
+              conversion = column.column[:type] == :date ? :to_date : :to_time
+              case value[:opt]
+              when 'RANGE'
+                date_bridge_from_to_for_range(column, value).collect(&conversion)
+              when 'PAST', 'FUTURE'
+                date_bridge_from_to_for_trend(column, value).collect(&conversion)
+              else
+                ['from', 'to'].collect { |field| condition_value_for_datetime(value[field], conversion)}
+              end
+            end
+
+            def date_bridge_now
+              Time.zone.now
+            end
+            
+            def date_bridge_from_to_for_trend(column, value)
+              case value['opt']
+              when "PAST"
+                trend_number = [value['number'].to_i,  1].max
+                now = date_bridge_now
+                if date_bridge_column_date?(column)
+                  from = now.beginning_of_day.ago((trend_number).send(value['unit'].downcase.singularize.to_sym))
+                  to = now.end_of_day
+                else
+                  from = now.ago((trend_number).send(value['unit'].downcase.singularize.to_sym))
+                  to = now
+                end
+                return from, to
+              when "FUTURE"
+                trend_number = [value['number'].to_i,  1].max
+                now = date_bridge_now
+                if date_bridge_column_date?(column)
+                  from = now.beginning_of_day
+                  to = now.end_of_day.in((trend_number).send(value['unit'].downcase.singularize.to_sym))
+                else
+                  from = now
+                  to = now.in((trend_number).send(value['unit'].downcase.singularize.to_sym))
+                end
+                return from, to
+              end
+            end
+            
+            def date_bridge_from_to_for_range(column, value)
+              case value[:range]
+              when 'TODAY'
+                return date_bridge_now.beginning_of_day, date_bridge_now.end_of_day
+              when 'YESTERDAY'
+                return date_bridge_now.ago(1.day).beginning_of_day, date_bridge_now.ago(1.day).end_of_day
+              when 'TOMORROW'
+                return date_bridge_now.in(1.day).beginning_of_day, date_bridge_now.in(1.day).end_of_day
+              else
+                range_type, range = value[:range].downcase.split('_')
+                raise ArgumentError unless ['week', 'month', 'year'].include?(range)
+                case range_type
+                when 'this'
+                  return date_bridge_now.send("beginning_of_#{range}".to_sym), date_bridge_now.send("end_of_#{range}")
+                when 'prev'
+                  return date_bridge_now.ago(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), date_bridge_now.ago(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
+                when 'next'
+                  return date_bridge_now.in(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), date_bridge_now.in(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
+                else
+                  return nil, nil    
+                end
+              end
+            end
+
+            def date_bridge_column_date?(column)
+              if [:date_picker, :datetime_picker].include? column.form_ui
+                column.form_ui == :date_picker
+              else
+                (!column.column.nil? && [:date].include?(column.column[:type]))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveScaffold::Finder.const_set('DateComparators', ["PAST", "FUTURE", "RANGE"])
+ActiveScaffold::Finder.const_set('DateUnits', ["DAYS", "WEEKS", "MONTHS", "YEARS"])
+ActiveScaffold::Finder.const_set('TimeUnits', ["SECONDS", "MINUTES", "HOURS"])
+ActiveScaffold::Finder.const_set('DateRanges', ["TODAY", "YESTERDAY", "TOMORROW",
+                                                "THIS_WEEK", "PREV_WEEK", "NEXT_WEEK",
+                                                "THIS_MONTH", "PREV_MONTH", "NEXT_MONTH",
+                                                "THIS_YEAR", "PREV_YEAR", "NEXT_YEAR"])

data/lib/active_scaffold/bridges/tiny_mce/helpers.rb

@@ -0,0 +1,46 @@
+class ActiveScaffold::Bridges::TinyMce
+  module Helpers
+    def self.included(base)
+      base.class_eval do
+        include FormColumnHelpers
+        include SearchColumnHelpers
+      end
+    end
+
+    module FormColumnHelpers
+      def self.included(base)
+        base.alias_method_chain :onsubmit, :tiny_mce
+      end
+
+      def active_scaffold_input_text_editor(column, options)
+        options[:class] = "#{options[:class]} mceEditor #{column.options[:class]}".strip
+				
+				settings = { :theme => 'simple' }.merge(column.options[:tinymce] || {})
+				settings = settings.to_s.gsub(/:(.+?)\=\>/, '\1:')
+				settings = "tinyMCE.settings = #{settings};"
+
+        html = []
+        html << send(override_input(:textarea), column, options)
+        html << javascript_tag(settings + "tinyMCE.execCommand('mceAddControl', false, '#{options[:id]}');") if request.xhr? || params[:iframe]
+        html.join "\n"
+      end
+
+      def onsubmit_with_tiny_mce
+        if ActiveScaffold.js_framework == :jquery
+          submit_js = 'tinyMCE.triggerSave();$(\'textarea.mceEditor\').each(function(index, elem) { tinyMCE.execCommand(\'mceRemoveControl\', false, $(elem).attr(\'id\')); });'
+        else
+          submit_js = 'tinyMCE.triggerSave();this.select(\'textarea.mceEditor\').each(function(elem) { tinyMCE.execCommand(\'mceRemoveControl\', false, elem.id); });'
+        end
+        [onsubmit_without_tiny_mce, submit_js].compact.join ';'
+      end
+    end
+
+    module SearchColumnHelpers
+      def self.included(base)
+        base.class_eval { alias_method :active_scaffold_search_text_editor, :active_scaffold_search_text }
+      end
+    end
+  end
+end
+
+ActionView::Base.class_eval { include ActiveScaffold::Bridges::TinyMce::Helpers }

data/lib/active_scaffold/bridges/tiny_mce.rb

@@ -0,0 +1,17 @@
+class ActiveScaffold::Bridges::TinyMce < ActiveScaffold::DataStructures::Bridge
+  def self.install
+    require File.join(File.dirname(__FILE__), "tiny_mce/helpers.rb")
+  end
+
+  def self.install?
+    Object.const_defined? "TinyMCE"
+  end
+ 
+  def self.javascripts
+    if ActiveScaffold.js_framework == :jquery
+      ['tinymce-jquery', 'jquery/tiny_mce_bridge']
+    else
+      ['tinymce', 'prototype/tiny_mce_bridge']
+    end
+  end
+end

data/lib/active_scaffold/bridges.rb

@@ -0,0 +1,61 @@
+module ActiveScaffold
+  module Bridges
+    ActiveScaffold.autoload_subdir('bridges', self)
+    module Shared
+      autoload :DateBridge, 'active_scaffold/bridges/shared/date_bridge'
+    end
+
+    mattr_accessor :bridges
+    mattr_accessor :bridges_run
+    self.bridges = {}
+
+    def self.register(file)
+      match = file.match(/(active_scaffold\/bridges\/(.*))\.rb\Z/)
+      self.bridges[match[2].to_sym] = match[1] if match
+    end
+
+    def self.load(bridge_name)
+      bridge = self.bridges[bridge_name.to_sym]
+      if bridge.is_a? String
+        if ActiveScaffold.exclude_bridges.exclude? bridge_name.to_sym
+          bridge = bridge.camelize.constantize
+          self.bridges[bridge_name.to_sym] = bridge
+        else
+          self.bridges.delete bridge_name
+          bridge = nil
+        end
+      end
+      bridge
+    end
+    class << self
+      alias_method :[], :load
+    end
+      
+    def self.run_all
+      return false if self.bridges_run
+      self.bridges.keys.each do |bridge_name|
+        bridge = self[bridge_name]
+        bridge.run if bridge
+      end
+      self.bridges_run = true
+    end
+
+    def self.all_stylesheets
+      self.bridges.keys.collect do |bridge_name|
+        bridge = self[bridge_name]
+        bridge.stylesheets if bridge and bridge.install?
+      end.compact.flatten
+    end
+
+    def self.all_javascripts
+      self.bridges.keys.collect do |bridge_name|
+        bridge = self[bridge_name]
+        bridge.javascripts if bridge and bridge.install?
+      end.compact.flatten
+    end
+  end
+end
+
+(Dir[File.join(File.dirname(__FILE__), "bridges/*.rb")] - [__FILE__]).each{|bridge_require|
+  ActiveScaffold::Bridges.register bridge_require
+} 

data/lib/active_scaffold/config/base.rb

@@ -0,0 +1,71 @@
+module ActiveScaffold::Config
+  class Base
+    include ActiveScaffold::Configurable
+    extend ActiveScaffold::Configurable
+
+    def initialize(core_config)
+      @core = core_config
+    end
+
+    def self.inherited(subclass)
+      class << subclass
+        # the crud type of the action. possible values are :create, :read, :update, :delete, and nil.
+        # this is not a setting for the developer. it's self-description for the actions.
+        def crud_type; @crud_type; end
+
+        protected
+
+        def crud_type=(val)
+          raise ArgumentError, "unknown CRUD type #{val}" unless [:create, :read, :update, :delete].include?(val.to_sym)
+          @crud_type = val.to_sym
+        end
+      end
+    end
+
+    # delegate
+    def crud_type; self.class.crud_type end
+
+    def label(model = nil)
+      model ||= @core.label(:count => 1)
+      @label.nil? ? model : as_(@label, :model => model)
+    end
+    
+    # the user property gets set to the instantiation of the local UserSettings class during the automatic instantiation of this class.
+    attr_accessor :user
+
+    # define a default action_group for this action
+    # e.g. 'members.crud'
+    class_attribute :action_group
+
+    # action_group this action should belong to
+    attr_accessor :action_group
+
+    class UserSettings
+      def initialize(conf, storage, params)
+        # the session hash relevant to this action
+        @session = storage
+        # all the request params
+        @params = params
+        # the configuration object for this action
+        @conf = conf
+      end
+    end
+    
+    def formats
+      @formats ||= []
+    end
+    
+    def formats=(val)
+      @formats=val
+    end
+    
+    private
+    
+    def columns=(val)
+      @columns = ActiveScaffold::DataStructures::ActionColumns.new(*val)
+      @columns.action = self
+      @columns.set_columns(@core.columns) if @columns.respond_to?(:set_columns)
+      @columns
+    end
+  end
+end