active_scaffold-sequel 0.3.0

data/lib/active_scaffold/active_record_permissions.rb

@@ -0,0 +1,136 @@
+# This module attempts to create permissions conventions for your ActiveRecord models. It supports english-based
+# methods that let you restrict access per-model, per-record, per-column, per-action, and per-user. All at once.
+#
+# You may define instance methods in the following formats:
+#  def #{column}_authorized_for_#{action}?
+#  def #{column}_authorized?
+#  def authorized_for_#{action}?
+#
+# Your methods should allow for the following special cases:
+#   * cron scripts
+#   * guest users (or nil current_user objects)
+module ActiveScaffold
+  module ModelPermissions
+    # ModelPermissions needs to know what method on your ApplicationController will return the current user,
+    # if available. This defaults to the :current_user method. You may configure this in your environment.rb if you
+    # have a different setup.
+    def self.current_user_method=(v); @@current_user_method = v; end
+    def self.current_user_method; @@current_user_method; end
+    @@current_user_method = :current_user
+
+    # Whether the default permission is permissive or not
+    # If set to true, then everything's allowed until configured otherwise
+    def self.default_permission=(v); @@default_permission = v; end
+    def self.default_permission; @@default_permission; end
+    @@default_permission = true
+
+    # This is a module aimed at making the current_user available to ActiveRecord models for permissions.
+    module ModelUserAccess
+      module Controller
+        def self.included(base)
+          base.prepend_before_filter :assign_current_user_to_models
+        end
+
+        # We need to give the ActiveRecord classes a handle to the current user. We don't want to just pass the object,
+        # because the object may change (someone may log in or out). So we give ActiveRecord a proc that ties to the
+        # current_user_method on this ApplicationController.
+        def assign_current_user_to_models
+          Sequel::Model.current_user_proc = proc {send(ModelPermissions.current_user_method)}
+        end
+      end
+
+      module Model
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          # The proc to call that retrieves the current_user from the ApplicationController.
+          attr_accessor :current_user_proc
+
+          # Class-level access to the current user
+          def current_user
+            Sequel::Model.current_user_proc.call if Sequel::Model.current_user_proc
+          end
+        end
+
+        # Instance-level access to the current user
+        def current_user
+          self.class.current_user
+        end
+      end
+    end
+
+    module Permissions
+      def self.included(base)
+        base.extend SecurityMethods
+        base.send :include, SecurityMethods
+      end
+
+      # Because any class-level queries get delegated to the instance level via a new record,
+      # it's useful to know when the authorization query is meant for a specific record or not.
+      # But using new? is confusing, even though accurate. So this is basically just a wrapper.
+      def existing_record_check?
+        !new?
+      end
+
+      module SecurityMethods
+        # A generic authorization query. This is what will be called programatically, since
+        # the actual permission methods can't be guaranteed to exist. And because we want to
+        # intelligently combine multiple applicable methods.
+        #
+        # options[:crud_type] should be a CRUD verb (:create, :read, :update, :destroy)
+        # options[:column] should be the name of a model attribute
+        # options[:action] is the name of a method
+        def authorized_for?(options = {})
+          raise ArgumentError, "unknown crud type #{options[:crud_type]}" if options[:crud_type] and ![:create, :read, :update, :delete].include?(options[:crud_type])
+
+          # column_authorized_for_crud_type? has the highest priority over other methods,
+          # you can disable a crud verb and enable that verb for a column
+          # (for example, disable update and enable inplace_edit in a column)
+          method = column_and_crud_type_security_method(options[:column], options[:crud_type])
+          return send(method) if method and respond_to?(method)
+
+          # authorized_for_action? has higher priority than other methods,
+          # you can disable a crud verb and enable an action with that crud verb
+          # (for example, disable update and enable an action with update as crud type)
+          method = action_security_method(options[:action])
+          return send(method) if method and respond_to?(method)
+
+          # collect other possibly-related methods that actually exist
+          methods = [
+            column_security_method(options[:column]),
+            crud_type_security_method(options[:crud_type]),
+          ].compact.select {|m| respond_to?(m)}
+
+          # if any method returns false, then return false
+          return false if methods.any? {|m| !send(m)}
+
+          # if any method actually exists then it must've returned true, so return true
+          return true unless methods.empty?
+
+          # if no method exists, return the default permission
+          return ModelPermissions.default_permission
+        end
+
+        private
+
+        def column_security_method(column)
+          "#{column}_authorized?" if column
+        end
+
+        def crud_type_security_method(crud_type)
+          "authorized_for_#{crud_type}?" if crud_type
+        end
+
+        def action_security_method(action)
+          "authorized_for_#{action}?" if action
+        end
+
+        def column_and_crud_type_security_method(column, crud_type)
+          "#{column}_authorized_for_#{crud_type}?" if column and crud_type
+        end
+      end
+    end
+  end
+end

data/lib/active_scaffold/attribute_params.rb

@@ -0,0 +1,208 @@
+module ActiveScaffold
+  # Provides support for param hashes assumed to be model attributes.
+  # Support is primarily needed for creating/editing associated records using a nested hash structure.
+  #
+  # Paradigm Params Hash (should write unit tests on this):
+  #   params[:record] = {
+  #     # a simple record attribute
+  #     'name' => 'John',
+  #     # a plural association hash
+  #     'roles' => {
+  #       # associate with an existing role
+  #       '5' => {'id' => 5}
+  #       # associate with an existing role and edit it
+  #       '6' => {'id' => 6, 'name' => 'designer'}
+  #       # create and associate a new role
+  #       '124521' => {'name' => 'marketer'}
+  #     }
+  #     # a singular association hash
+  #     'location' => {'id' => 12, 'city' => 'New York'}
+  #   }
+  #
+  # Simpler association structures are also supported, like:
+  #   params[:record] = {
+  #     # a simple record attribute
+  #     'name' => 'John',
+  #     # a plural association ... all ids refer to existing records
+  #     'roles' => ['5', '6'],
+  #     # a singular association ... all ids refer to existing records
+  #     'location' => '12'
+  # }
+  module AttributeParams
+    protected
+    # Takes attributes (as from params[:record]) and applies them to the parent_record. Also looks for
+    # association attributes and attempts to instantiate them as associated objects.
+    #
+    # This is a secure way to apply params to a record, because it's based on a loop over the columns
+    # set. The columns set will not yield unauthorized columns, and it will not yield unregistered columns.
+    def update_record_from_params(parent_record, columns, attributes)
+      crud_type = parent_record.new? ? :create : :update
+      return parent_record unless parent_record.authorized_for?(:crud_type => crud_type)
+
+      multi_parameter_attributes = {}
+      attributes.each do |k, v|
+        next unless k.include? '('
+        column_name = k.split('(').first.to_sym
+        multi_parameter_attributes[column_name] ||= []
+        multi_parameter_attributes[column_name] << [k, v]
+      end
+
+      columns.each :for => parent_record, :crud_type => crud_type, :flatten => true do |column|
+        # Set any passthrough parameters that may be associated with this column (ie, file column "keep" and "temp" attributes)
+        unless column.params.empty?
+          column.params.each{|p| parent_record.send("#{p}=", attributes[p]) if attributes.has_key? p}
+        end
+
+        if multi_parameter_attributes.has_key? column.name
+          parent_record.send(:assign_multiparameter_attributes, multi_parameter_attributes[column.name])
+        elsif attributes.has_key? column.name
+          value = column_value_from_param_value(parent_record, column, attributes[column.name]) 
+
+          # we avoid assigning a value that already exists because otherwise has_one associations will break (AR bug in has_one_association.rb#replace)
+          parent_record.send("#{column.name}=", value) unless parent_record.send(column.name) == value
+          
+        elsif column.plural_association? and not parent_record.new?
+          parent_record.send("remove_all_#{column.name}")
+        end
+      end
+
+      if parent_record.new?
+        parent_record.class.association_reflections.each do |name, props|
+          next unless [:one_to_one, :one_to_many].include?(props[:type]) and props[:join_table].nil?
+          next unless association_proxy = parent_record.send(name)
+
+          raise ActiveScaffold::ReverseAssociationRequired, "Association #{name} in class #{parent_record.class.name}: In order to support :one_to_one and :one_to_many where the parent record is new and the child record(s) validate the presence of the parent, ActiveScaffold requires the reverse association (the many_to_one)." unless props.reciprocal
+
+          association_proxy = [association_proxy] if props[:type] == :one_to_one
+          association_proxy.each {|record| record.send("#{props.reciprocal}=", parent_record)}
+        end
+      end
+
+      parent_record
+    end
+    
+    def manage_nested_record_from_params(parent_record, column, attributes)
+      record = find_or_create_for_params(attributes, column, parent_record)
+      if record
+        record_columns = active_scaffold_config_for(column.association.associated_class).subform.columns
+        record_columns.constraint_columns = [column.association.reciprocal]
+        update_record_from_params(record, record_columns, attributes)
+        record.unsaved = true
+      end
+      record
+    end
+    
+    def column_value_from_param_value(parent_record, column, value)
+      # convert the value, possibly by instantiating associated objects
+      if value.is_a?(Hash)
+        column_value_from_param_hash_value(parent_record, column, value)
+      else
+        column_value_from_param_simple_value(parent_record, column, value)
+      end
+    end
+
+    def column_value_from_param_simple_value(parent_record, column, value)
+      if column.singular_association?
+        # it's a single id
+        column.association.associated_class[value] if value and not value.empty?
+      elsif column.plural_association?
+        column_plural_assocation_value_from_value(column, value)
+      elsif column.number? && [:i18n_number, :currency].include?(column.options[:format])
+        self.class.i18n_number_to_native_format(value)
+      else
+        # convert empty strings into nil. this works better with 'null => true' columns (and validations),
+        # and 'null => false' columns should just convert back to an empty string.
+        # ... but we can at least check the ConnectionAdapter::Column object to see if nulls are allowed
+        value = nil if value.is_a? String and value.empty? and !column.column.nil? and column.column[:allow_null]
+        value
+      end
+    end
+
+    def column_plural_assocation_value_from_value(column, value)
+      # it's an array of ids
+      if value and not value.empty?
+        ids = value.select {|id| id.respond_to?(:empty?) ? !id.empty? : true}
+        if ids.empty?
+          []
+        else
+          klass = column.association.associated_class
+          klass.filter(klass.primary_key => ids)
+        end
+      end
+    end
+
+    def column_value_from_param_hash_value(parent_record, column, value)
+      # this is just for backwards compatibility. we should clean this up in 2.0.
+      if column.form_ui == :select
+        klass = column.association.associated_class
+        if column.singular_association?
+          value[:id]
+          value[:id].blank? ? nil : klass[value[:id]]
+        else
+          ids = (value.values.collect {|hash| hash[:id]})
+          ids.blank? ? nil : klass.filter(klass.primary_key => ids)
+        end
+      elsif column.singular_association?
+        manage_nested_record_from_params(parent_record, column, value)
+      elsif column.plural_association?
+        value.collect {|key_value_pair| manage_nested_record_from_params(parent_record, column, key_value_pair[1])}.compact
+      else
+        value
+      end
+    end
+
+   # Attempts to create or find an instance of klass (which must be an ActiveRecord object) from the
+    # request parameters given. If params[:id] exists it will attempt to find an existing object
+    # otherwise it will build a new one.
+    def find_or_create_for_params(params, parent_column, parent_record)
+      current = parent_record.send(parent_column.name)
+      klass = parent_column.association.associated_class
+      pk = klass.primary_key.to_sym
+      return nil if parent_column.show_blank_record?(current) and attributes_hash_is_empty?(params, klass)
+
+      if params.has_key? pk
+        # modifying the current object of a singular association
+        pk_val = params[pk] 
+        if current and current.is_a? Sequel::Model and current.id.to_s == pk_val
+          current
+        # modifying one of the current objects in a plural association
+        elsif current and current.respond_to?(:any?) and current.any? {|o| o.id.to_s == pk_val}
+          current.detect {|o| o.id.to_s == pk_val}
+        # attaching an existing but not-current object
+        else
+          klass[pk_val]
+        end
+      else
+        build_associated(parent_column, parent_record) if klass.authorized_for?(:crud_type => :create)
+      end
+    end
+    # Determines whether the given attributes hash is "empty".
+    # This isn't a literal emptiness - it's an attempt to discern whether the user intended it to be empty or not.
+    def attributes_hash_is_empty?(hash, klass)
+      ignore_column_types = [:boolean]
+      hash.all? do |key,value|
+        # convert any possible multi-parameter attributes like 'created_at(5i)' to simply 'created_at'
+        parts = key.to_s.split('(')
+        #old style date form management... ignore them too
+        ignore_column_types = [:boolean, :datetime, :date, :time] if parts.length > 1
+        column_name = parts.first.to_sym
+        column = klass.db_schema[column_name]
+
+        # booleans and datetimes will always have a value. so we ignore them when checking whether the hash is empty.
+        # this could be a bad idea. but the current situation (excess record entry) seems worse.
+        next true if column and ignore_column_types.include?(column[:type])
+
+        # defaults are pre-filled on the form. we can't use them to determine if the user intends a new row.
+        next true if column and value == column[:ruby_default].to_s
+
+        if value.is_a?(Hash)
+          attributes_hash_is_empty?(value, klass)
+        elsif value.is_a?(Array)
+          value.any? {|id| id.respond_to?(:empty?) ? !id.empty? : true}
+        else
+          value.respond_to?(:empty?) ? value.empty? : false
+        end
+      end
+    end
+  end
+end

data/lib/active_scaffold/bridges/ancestry/ancestry_bridge.rb

@@ -0,0 +1,39 @@
+ActiveScaffold::Config::Core.class_eval do
+  def initialize_with_ancestry(model_id)
+    initialize_without_ancestry(model_id)
+
+    return unless self.model.respond_to? :ancestry_column
+    
+    self.columns << :parent_id
+    self.columns[:parent_id].form_ui = :ancestry
+    update.columns.exclude :ancestry
+    create.columns.exclude :ancestry, :parent_id
+    list.columns.exclude :ancestry, :parent_id
+  end
+
+  alias_method_chain :initialize, :ancestry
+end
+
+module ActiveScaffold::Bridges
+  class Ancestry
+    module FormColumnHelpers
+      def active_scaffold_input_ancestry(column, options)
+        select_options = []
+        select_control_options = {:selected => @record.parent_id}
+        select_control_options[:include_blank] = as_(:_select_) if @record.parent_id.nil?
+        traverse_ancestry = proc do|key, value|
+          unless key == @record
+            select_options << ["#{'__' * key.depth}#{key.to_label}", key.id]
+            value.each(&traverse_ancestry) if value.is_a?(Hash) && !value.empty?
+          end
+        end
+        @record.class.arrange.each(&traverse_ancestry)
+        select(:record, :ancestry, select_options, select_control_options, options)
+      end
+    end
+  end
+end
+
+ActionView::Base.class_eval do
+  include ActiveScaffold::Bridges::Ancestry::FormColumnHelpers
+end

data/lib/active_scaffold/bridges/ancestry.rb

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

data/lib/active_scaffold/bridges/calendar_date_select/as_cds_bridge.rb

@@ -0,0 +1,67 @@
+module ActiveScaffold::Config
+  class Core < Base
+
+    def initialize_with_calendar_date_select(model_id)
+      initialize_without_calendar_date_select(model_id)
+      
+      calendar_date_select_fields = self.model.db_schema.collect {|name,properties| name if [:date, :datetime].include?(properties[:type])}.compact
+      # check to see if file column was used on the model
+      return if calendar_date_select_fields.empty?
+      
+      # automatically set the forum_ui to a file column
+      calendar_date_select_fields.each{|field|
+        self.columns[field].form_ui = :calendar_date_select
+      }
+    end
+    
+    alias_method_chain :initialize, :calendar_date_select
+    
+  end
+end
+
+
+module ActiveScaffold
+  module Bridges
+    class CalendarDateSelect
+      # Helpers that assist with the rendering of a Form Column
+      module FormColumnHelpers
+        def active_scaffold_input_calendar_date_select(column, options)
+          options[:class] = "#{options[:class]} text-input".strip
+          calendar_date_select("record", column.name, options.merge(column.options))
+        end      
+      end
+      
+      module SearchColumnHelpers
+        def active_scaffold_search_date_bridge_calendar_control(column, options, current_search, name)
+          if current_search.is_a? Hash
+            value = controller.class.condition_value_for_datetime(current_search[name], column.column[:type] == :date ? :to_date : :to_time)
+          else
+            value = current_search
+          end
+          calendar_date_select("record", column.name, 
+            {:name => "#{options[:name]}[#{name}]",
+             :value => (value ? l(value) : nil),
+             :class => 'text-input',
+             :id => "#{options[:id]}_#{name}",
+             :time => column_datetime?(column) ? true : false,
+             :style => "display:#{(options[:show].nil? || options[:show]) ? '' : 'none'}"})
+        end
+      end
+    end
+  end
+end
+
+ActionView::Base.class_eval do
+  include ActiveScaffold::Bridges::CalendarDateSelect::FormColumnHelpers
+  include ActiveScaffold::Bridges::Shared::DateBridge::SearchColumnHelpers
+  alias_method :active_scaffold_search_calendar_date_select, :active_scaffold_search_date_bridge
+  include ActiveScaffold::Bridges::Shared::DateBridge::HumanConditionHelpers
+  alias_method :active_scaffold_human_condition_calendar_date_select, :active_scaffold_human_condition_date_bridge
+  include ActiveScaffold::Bridges::CalendarDateSelect::SearchColumnHelpers
+  include ActiveScaffold::Bridges::CalendarDateSelect::ViewHelpers
+end
+
+ActiveScaffold::Finder::ClassMethods.module_eval do
+  include ActiveScaffold::Bridges::Shared::DateBridge::Finder::ClassMethods
+  alias_method :condition_for_calendar_date_select_type, :condition_for_date_bridge_type
+end

data/lib/active_scaffold/bridges/calendar_date_select.rb

@@ -0,0 +1,24 @@
+class ActiveScaffold::Bridges::CalendarDateSelect < ActiveScaffold::DataStructures::Bridge
+  def self.install
+    # check to see if the old bridge was installed.  If so, warn them
+    # we can detect this by checking to see if the bridge was installed before calling this code
+       
+    if ActiveScaffold::Config::Core.instance_methods.include?("initialize_with_calendar_date_select")
+      raise RuntimeError, "We've detected that you have active_scaffold_calendar_date_select_bridge installed.  This plugin has been moved to core.  Please remove active_scaffold_calendar_date_select_bridge to prevent any conflicts"
+    end
+    
+    require File.join(File.dirname(__FILE__), "calendar_date_select/as_cds_bridge.rb")
+  end
+  
+  def self.install?
+    super && ActiveScaffold.js_framework == :prototype
+  end
+
+  def self.stylesheets
+    calendar_date_select_stylesheets
+  end
+
+  def self.javascripts
+    calendar_date_select_javascripts
+  end
+end

data/lib/active_scaffold/bridges/cancan/cancan_bridge.rb

@@ -0,0 +1,107 @@
+module ActiveScaffold::Bridges
+  class Cancan
+
+    # controller level authorization
+    # As already has callbacks to ensure authorization at controller method via "authorization_method"
+    # but let's include this too, just in case, no sure how performance is affected tough :TODO benchmark
+    module ClassMethods
+      extend ActiveSupport::Concern
+      included do
+        alias_method_chain :active_scaffold, :cancan
+      end
+
+      def active_scaffold_with_cancan(model_id = nil, &block)
+        active_scaffold_without_cancan(model_id, &block)
+        authorize_resource(
+          :class => active_scaffold_config.model,
+          :instance => :record
+        )
+      end
+    end
+
+    # beginning of chain integration
+    module Actions
+      module Core
+        extend ActiveSupport::Concern
+        included do
+          alias_method_chain :beginning_of_chain, :cancan
+        end
+        # :TODO can this be expanded more ?
+        def beginning_of_chain_with_cancan
+          beginning_of_chain_without_cancan.accessible_by(current_ability)
+        end
+      end
+    end
+
+    # This is a module aimed at making the current_ability available to ActiveRecord models for permissions.
+    module ModelUserAccess
+      module Controller
+        extend ActiveSupport::Concern
+        included do
+          prepend_before_filter :assign_current_ability_to_models
+        end
+
+        # We need to give the ActiveRecord classes a handle to the current ability. We don't want to just pass the object,
+        # because the object may change (someone may log in or out). So we give ActiveRecord a proc that ties to the
+        # current_ability_method on this ApplicationController.
+        def assign_current_ability_to_models
+          ::Sequel::Model.current_ability_proc = proc {send(:current_ability)}
+        end
+      end
+
+      module Model
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          # The proc to call that retrieves the current_ability from the ApplicationController.
+          attr_accessor :current_ability_proc
+
+          # Class-level access to the current ability
+          def current_ability
+            ::Sequel::Model.current_ability_proc.call if ::Sequel::Model.current_ability_proc
+          end
+        end
+
+        # Instance-level access to the current ability
+        def current_ability; self.class.current_ability end
+      end
+    end
+
+
+    # plug into AS#authorized_for calls
+    module ActiveRecord
+      extend ActiveSupport::Concern
+      included do
+        extend SecurityMethods
+        include SecurityMethods
+        alias_method_chain :authorized_for?, :cancan
+        class << self
+          alias_method_chain :authorized_for?, :cancan
+        end
+      end
+
+      module SecurityMethods
+        class InvalidArgument < StandardError; end
+
+        # is usually called with :crud_type and :column, or :action
+        #     {:crud_type=>:update, :column=>"some_colum_name"}
+        #     {:action=>"edit"}
+        # to allow access cancan must allow both :crud_type and :action
+        # if cancan says "no", it delegates to default AS behavior
+        def authorized_for_with_cancan?(options = {})
+          raise InvalidArgument if options[:crud_type].blank? and options[:action].blank?
+          if current_ability.present?
+            crud_type_result = options[:crud_type].nil? ? true : current_ability.can?(options[:crud_type], self)
+            action_result = options[:action].nil? ? true : current_ability.can?(options[:action].to_sym, self)
+          else
+            crud_type_result, action_result = false, false
+          end
+          default_result = authorized_for_without_cancan?(options)
+          result = (crud_type_result && action_result) || default_result
+          return result
+        end
+      end
+    end
+
+  end
+end

data/lib/active_scaffold/bridges/cancan.rb

@@ -0,0 +1,15 @@
+class ActiveScaffold::Bridges::Cancan < ActiveScaffold::DataStructures::Bridge
+  def self.install
+    require File.join(File.dirname(__FILE__), "cancan", "cancan_bridge.rb")
+
+    ActiveScaffold::ClassMethods.send :include, ActiveScaffold::Bridges::Cancan::ClassMethods
+    ActiveScaffold::Actions::Core.send :include, ActiveScaffold::Bridges::Cancan::Actions::Core
+    ActiveScaffold::Actions::Nested.send :include, ActiveScaffold::Bridges::Cancan::Actions::Core
+    ActionController::Base.send :include, ActiveScaffold::Bridges::Cancan::ModelUserAccess::Controller
+    ::Sequel::Model.send :include, ActiveScaffold::Bridges::Cancan::ModelUserAccess::Model
+    ::Sequel::Model.send :include, ActiveScaffold::Bridges::Cancan::ActiveRecord
+  end
+  def self.install?
+    Object.const_defined? 'CanCan'
+  end
+end

data/lib/active_scaffold/bridges/carrierwave/carrierwave_bridge.rb

@@ -0,0 +1,31 @@
+module ActiveScaffold
+  module Bridges
+    class Carrierwave
+      module CarrierwaveBridge
+        def initialize_with_carrierwave(model_id)
+          initialize_without_carrierwave(model_id)
+          return unless self.model.respond_to?(:uploaders) && self.model.uploaders.present?
+
+          self.update.multipart = true
+          self.create.multipart = true
+
+          self.model.uploaders.keys.each do |field|
+            configure_carrierwave_field(field.to_sym)
+          end
+        end
+
+        def self.included(base)
+          base.alias_method_chain :initialize, :carrierwave
+        end
+
+        private
+        def configure_carrierwave_field(field)
+          self.columns << field
+          self.columns[field].form_ui ||= :carrierwave # :TODO thumbnail
+          self.columns[field].params.add "#{field}_cache"
+          self.columns[field].params.add "remove_#{field}"
+        end
+      end
+    end
+  end
+end

data/lib/active_scaffold/bridges/carrierwave/carrierwave_bridge_helpers.rb

@@ -0,0 +1,10 @@
+module ActiveScaffold
+  module Bridges
+    class Carrierwave
+      module CarrierwaveBridgeHelpers
+        mattr_accessor :thumbnail_style
+        self.thumbnail_style = :thumbnail
+      end
+    end
+  end
+end