rest_framework 0.9.2 → 0.9.4

data/docs/_includes/shared.html

@@ -0,0 +1,164 @@
+<!--
+AUTOGENERATED
+Updates must be written to `shared.{css,js}` and synced with `rake maintain_assets`.
+-->
+<style>
+:root {
+  --rrf-red: #900;
+  --rrf-red-hover: #5f0c0c;
+  --rrf-light-red: #db2525;
+  --rrf-light-red-hover: #b80404;
+}
+#rrfAccentBar {
+  background-color: var(--rrf-red);
+  height: .3em;
+}
+header nav { background-color: black; }
+
+/* Header adjustments. */
+h1 { font-size: 2rem; }
+h2 { font-size: 1.7rem; }
+h3 { font-size: 1.5rem; }
+h4 { font-size: 1.3rem; }
+h5 { font-size: 1.1rem; }
+h6 { font-size: 1rem; }
+h1, h2, h3, h4, h5, h6 {
+  color: var(--rrf-red);
+}
+html[data-bs-theme="dark"] h1,
+html[data-bs-theme="dark"] h2,
+html[data-bs-theme="dark"] h3,
+html[data-bs-theme="dark"] h4,
+html[data-bs-theme="dark"] h5,
+html[data-bs-theme="dark"] h6 {
+  color: var(--rrf-light-red);
+}
+
+/* Improve code and code blocks. */
+pre code, .trix-content pre {
+  display: block;
+  overflow-x: auto;
+  padding: .5em !important;
+}
+code, .trix-content pre {
+  --bs-code-color: black;
+  background-color: #eee !important;
+  border: 1px solid #aaa;
+  border-radius: 3px;
+  padding: .1em .3em;
+}
+html[data-bs-theme="dark"] code, html[data-bs-theme="dark"] .trix-content pre {
+  --bs-code-color: white;
+  background-color: #2b2b2b !important;
+}
+
+/* Anchors */
+a:not(.nav-link) {
+  text-decoration: none;
+  color: var(--rrf-red);
+}
+a:hover:not(.nav-link) {
+  text-decoration: underline;
+  color: var(--rrf-red-hover);
+}
+html[data-bs-theme="dark"] a:not(.nav-link) { color: var(--rrf-light-red); }
+html[data-bs-theme="dark"] a:hover:not(.nav-link) { color: var(--rrf-light-red-hover); }
+
+</style>
+<script>
+;(() => {
+  // Get the real mode from a selected mode. Anything other than "light" or "dark" is treated as
+  // "system" mode.
+  const rrfGetRealMode = (selectedMode) => {
+    if (selectedMode === "light" || selectedMode === "dark") {
+      return selectedMode
+    }
+
+    if (window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches) {
+      return "dark"
+    }
+
+    return "light"
+  }
+
+  // Set the mode, given a "selected" mode.
+  const rrfSetSelectedMode = (selectedMode) => {
+    // Anything except "light" or "dark" is casted to "system".
+    if (selectedMode !== "light" && selectedMode !== "dark") {
+      selectedMode = "system"
+    }
+
+    // Store selected mode in `localStorage`.
+    localStorage.setItem("rrfMode", selectedMode)
+
+    // Set the mode selector to the selected mode.
+    const modeComponent = document.getElementById("rrfModeComponent")
+    if (modeComponent) {
+      let labelHTML
+      modeComponent.querySelectorAll("button[data-rrf-mode-value]").forEach((el) => {
+        if (el.getAttribute("data-rrf-mode-value") === selectedMode) {
+          el.classList.add("active")
+          labelHTML = el.querySelector("i").outerHTML.replace("ms-2", "me-1")
+        } else {
+          el.classList.remove("active")
+        }
+      })
+      modeComponent.querySelector("button[data-bs-toggle]").innerHTML = labelHTML
+    }
+
+    // Get the real mode to use.
+    realMode = rrfGetRealMode(selectedMode)
+
+    // Set the `realMode` effects.
+    if (realMode === "light") {
+      document.querySelectorAll(".rrf-light-mode").forEach((el) => {
+        el.disabled = false
+      })
+      document.querySelectorAll(".rrf-dark-mode").forEach((el) => {
+        el.disabled = true
+      })
+      document.querySelectorAll(".rrf-mode").forEach((el) => {
+        el.setAttribute("data-bs-theme", "light")
+      })
+    } else if (realMode === "dark") {
+      document.querySelectorAll(".rrf-light-mode").forEach((el) => {
+        el.disabled = true
+      })
+      document.querySelectorAll(".rrf-dark-mode").forEach((el) => {
+        el.disabled = false
+      })
+      document.querySelectorAll(".rrf-mode").forEach((el) => {
+        el.setAttribute("data-bs-theme", "dark")
+      })
+    } else {
+      console.log(`RRF: Unknown mode: ${mode}`)
+    }
+  }
+
+  // Initialize dark/light mode before page fully loads to prevent flash.
+  rrfSetSelectedMode(localStorage.getItem("rrfMode"))
+
+  // Initialize dark/light mode after page load (mostly so mode component is updated).
+  document.addEventListener("DOMContentLoaded", (event) => {
+    rrfSetSelectedMode(localStorage.getItem("rrfMode"))
+
+    // Also set up mode selector.
+    document.querySelectorAll("#rrfModeComponent button[data-rrf-mode-value]").forEach((el) => {
+      el.addEventListener("click", (event) => {
+        rrfSetSelectedMode(event.target.getAttribute("data-rrf-mode-value"))
+      })
+    })
+  })
+
+  // Handle case where user changes system theme.
+  if (window.matchMedia) {
+    window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", () => {
+      const selectedMode = localStorage.getItem("rrfMode")
+      if (selectedMode !== "light" && selectedMode !== "dark") {
+        rrfSetSelectedMode("system")
+      }
+    })
+  }
+})()
+
+</script>

data/lib/rest_framework/controller_mixins/base.rb

@@ -6,28 +6,18 @@ require_relative "../utils"
 # the ability to route arbitrary actions with `extra_actions`. This is also where `api_response`
 # is defined.
 module RESTFramework::BaseControllerMixin
-  RRF_BASE_CONTROLLER_CONFIG = {
-    filter_pk_from_request_body: true,
-    exclude_body_fields: %w[
-      created_at
-      created_by
-      created_by_id
-      updated_at
-      updated_by
-      updated_by_id
-      _method
-      utf8
-      authenticity_token
-    ].freeze,
+  RRF_BASE_CONFIG = {
     extra_actions: nil,
     extra_member_actions: nil,
-    filter_backends: nil,
     singleton_controller: nil,
 
     # Options related to metadata and display.
     title: nil,
     description: nil,
     inflect_acronyms: ["ID", "IDs", "REST", "API", "APIs"].freeze,
+  }
+  RRF_BASE_INSTANCE_CONFIG = {
+    filter_backends: nil,
 
     # Options related to serialization.
     rescue_unknown_format_with: :json,
@@ -42,10 +32,6 @@ module RESTFramework::BaseControllerMixin
     page_size_query_param: "page_size",
     max_page_size: nil,
 
-    # Options related to bulk actions and batch processing.
-    bulk_guard_query_param: nil,
-    enable_batch_processing: nil,
-
     # Option to disable serializer adapters by default, mainly introduced because Active Model
     # Serializers will do things like serialize `[]` into `{"":[]}`.
     disable_adapters_by_default: true,
@@ -146,7 +132,7 @@ module RESTFramework::BaseControllerMixin
     # :nocov:
     def rrf_finalize
       if RESTFramework.config.freeze_config
-        self::RRF_BASE_CONTROLLER_CONFIG.keys.each { |k|
+        (self::RRF_BASE_CONFIG.keys + self::RRF_BASE_INSTANCE_CONFIG.keys).each { |k|
           v = self.send(k)
           v.freeze if v.is_a?(Hash) || v.is_a?(Array)
         }
@@ -161,14 +147,15 @@ module RESTFramework::BaseControllerMixin
     base.extend(ClassMethods)
 
     # Add class attributes (with defaults) unless they already exist.
-    RRF_BASE_CONTROLLER_CONFIG.each do |a, default|
+    RRF_BASE_CONFIG.each do |a, default|
       next if base.respond_to?(a)
 
-      base.class_attribute(a)
+      base.class_attribute(a, default: default, instance_accessor: false)
+    end
+    RRF_BASE_INSTANCE_CONFIG.each do |a, default|
+      next if base.respond_to?(a)
 
-      # Set default manually so we can still support Rails 4. Maybe later we can use the default
-      # parameter on `class_attribute`.
-      base.send(:"#{a}=", default)
+      base.class_attribute(a, default: default)
     end
 
     # Alias `extra_actions` to `extra_collection_actions`.
@@ -219,7 +206,7 @@ module RESTFramework::BaseControllerMixin
 
   # Get the configured serializer class.
   def get_serializer_class
-    return nil unless serializer_class = self.class.serializer_class
+    return nil unless serializer_class = self.serializer_class
 
     # Support dynamically resolving serializer given a symbol or string.
     serializer_class = serializer_class.to_s if serializer_class.is_a?(Symbol)
@@ -242,7 +229,7 @@ module RESTFramework::BaseControllerMixin
 
   # Get filtering backends, defaulting to no backends.
   def get_filter_backends
-    return self.class.filter_backends || []
+    return self.filter_backends || []
   end
 
   # Filter an arbitrary data set over all configured filter backends.
@@ -299,7 +286,7 @@ module RESTFramework::BaseControllerMixin
     end
 
     # Do not use any adapters by default, if configured.
-    if self.class.disable_adapters_by_default && !kwargs.key?(:adapter)
+    if self.disable_adapters_by_default && !kwargs.key?(:adapter)
       kwargs[:adapter] = nil
     end
 
@@ -309,27 +296,27 @@ module RESTFramework::BaseControllerMixin
     begin
       respond_to do |format|
         if payload == ""
-          format.json { head(kwargs[:status] || :no_content) } if self.class.serialize_to_json
-          format.xml { head(kwargs[:status] || :no_content) } if self.class.serialize_to_xml
+          format.json { head(kwargs[:status] || :no_content) } if self.serialize_to_json
+          format.xml { head(kwargs[:status] || :no_content) } if self.serialize_to_xml
         else
           format.json {
             jkwargs = kwargs.merge(json_kwargs)
             render(json: payload, layout: false, **jkwargs)
-          } if self.class.serialize_to_json
+          } if self.serialize_to_json
           format.xml {
             xkwargs = kwargs.merge(xml_kwargs)
             render(xml: payload, layout: false, **xkwargs)
-          } if self.class.serialize_to_xml
+          } if self.serialize_to_xml
           # TODO: possibly support more formats here if supported?
         end
         format.html {
           @payload = payload
           if payload == ""
-            @json_payload = "" if self.class.serialize_to_json
-            @xml_payload = "" if self.class.serialize_to_xml
+            @json_payload = "" if self.serialize_to_json
+            @xml_payload = "" if self.serialize_to_xml
           else
-            @json_payload = payload.to_json if self.class.serialize_to_json
-            @xml_payload = payload.to_xml if self.class.serialize_to_xml
+            @json_payload = payload.to_json if self.serialize_to_json
+            @xml_payload = payload.to_xml if self.serialize_to_xml
           end
           @title ||= self.class.get_title
           @description ||= self.class.description
@@ -347,7 +334,7 @@ module RESTFramework::BaseControllerMixin
         }
       end
     rescue ActionController::UnknownFormat
-      if !already_rescued_unknown_format && rescue_format = self.class.rescue_unknown_format_with
+      if !already_rescued_unknown_format && rescue_format = self.rescue_unknown_format_with
         request.format = rescue_format
         already_rescued_unknown_format = true
         retry

data/lib/rest_framework/controller_mixins/models.rb

@@ -14,7 +14,7 @@ module RESTFramework::BaseModelControllerMixin
   }
   include RESTFramework::BaseControllerMixin
 
-  RRF_BASE_MODEL_CONTROLLER_CONFIG = {
+  RRF_BASE_MODEL_CONFIG = {
     # Core attributes related to models.
     model: nil,
     recordset: nil,
@@ -22,20 +22,31 @@ module RESTFramework::BaseModelControllerMixin
     # Attributes for configuring record fields.
     fields: nil,
     field_config: nil,
-    action_fields: nil,
 
     # Options for what should be included/excluded from default fields.
     exclude_associations: false,
     include_active_storage: false,
     include_action_text: false,
-
+  }
+  RRF_BASE_MODEL_INSTANCE_CONFIG = {
     # Attributes for finding records.
     find_by_fields: nil,
     find_by_query_param: "find_by",
 
-    # Attributes for create/update parameters.
+    # Options for handling request body parameters.
     allowed_parameters: nil,
-    allowed_action_parameters: nil,
+    filter_pk_from_request_body: true,
+    exclude_body_fields: %w[
+      created_at
+      created_by
+      created_by_id
+      updated_at
+      updated_by
+      updated_by_id
+      _method
+      utf8
+      authenticity_token
+    ].freeze,
 
     # Attributes for the default native serializer.
     native_serializer_config: nil,
@@ -59,13 +70,18 @@ module RESTFramework::BaseModelControllerMixin
     # Options for association assignment.
     permit_id_assignment: true,
     permit_nested_attributes_assignment: true,
-    allow_all_nested_attributes: false,
 
     # Option for `recordset.create` vs `Model.create` behavior.
     create_from_recordset: true,
 
     # Control if filtering is done before find.
     filter_recordset_before_find: true,
+
+    # Options for `ransack` filtering.
+    ransack_options: nil,
+    ransack_query_param: "q",
+    ransack_distinct: true,
+    ransack_distinct_query_param: "distinct",
   }
 
   module ClassMethods
@@ -130,6 +146,7 @@ module RESTFramework::BaseModelControllerMixin
           columns = model.columns_hash
         end
         config[:sub_fields] ||= RESTFramework::Utils.sub_fields_for(ref)
+        config[:sub_fields] = config[:sub_fields].map(&:to_s)
 
         # Serialize very basic metadata about sub-fields.
         config[:sub_fields_metadata] = config[:sub_fields].map { |sf|
@@ -228,21 +245,17 @@ module RESTFramework::BaseModelControllerMixin
         if ref = reflections[f]
           metadata[:kind] = "association"
 
-          # Determine if we render id/ids fields.
-          if self.permit_id_assignment
-            if ref.collection?
-              metadata[:id_field] = "#{f.singularize}_ids"
-            elsif ref.belongs_to?
-              metadata[:id_field] = "#{f}_id"
-            end
+          # Determine if we render id/ids fields. Unfortunately, `has_one` does not provide this
+          # interface.
+          if self.permit_id_assignment && id_field = RESTFramework::Utils.get_id_field(f, ref)
+            metadata[:id_field] = id_field
           end
 
           # Determine if we render nested attributes options.
-          if self.permit_nested_attributes_assignment
-            if nested_opts = model.nested_attributes_options[f.to_sym].presence
-              nested_opts[:field] = "#{f}_attributes"
-              metadata[:nested_attributes_options] = nested_opts
-            end
+          if self.permit_nested_attributes_assignment && (
+            nested_opts = model.nested_attributes_options[f.to_sym].presence
+          )
+            metadata[:nested_attributes_options] = {field: "#{f}_attributes", **nested_opts}
           end
 
           begin
@@ -364,7 +377,7 @@ module RESTFramework::BaseModelControllerMixin
       # self.setup_channel
 
       if RESTFramework.config.freeze_config
-        self::RRF_BASE_MODEL_CONTROLLER_CONFIG.keys.each { |k|
+        (self::RRF_BASE_MODEL_CONFIG.keys + self::RRF_BASE_MODEL_INSTANCE_CONFIG.keys).each { |k|
           v = self.send(k)
           v.freeze if v.is_a?(Hash) || v.is_a?(Array)
         }
@@ -381,31 +394,21 @@ module RESTFramework::BaseModelControllerMixin
     base.extend(ClassMethods)
 
     # Add class attributes (with defaults) unless they already exist.
-    RRF_BASE_MODEL_CONTROLLER_CONFIG.each do |a, default|
+    RRF_BASE_MODEL_CONFIG.each do |a, default|
       next if base.respond_to?(a)
 
-      base.class_attribute(a)
-
-      # Set default manually so we can still support Rails 4. Maybe later we can use the default
-      # parameter on `class_attribute`.
-      base.send(:"#{a}=", default)
+      base.class_attribute(a, default: default, instance_accessor: false)
     end
-  end
-
-  def _get_specific_action_config(action_config_key, generic_config_key)
-    action_config = self.class.send(action_config_key)&.with_indifferent_access || {}
-    action = self.action_name&.to_sym
-
-    # Index action should use :list serializer if :index is not provided.
-    action = :list if action == :index && !action_config.key?(:index)
+    RRF_BASE_MODEL_INSTANCE_CONFIG.each do |a, default|
+      next if base.respond_to?(a)
 
-    return (action_config[action] if action) || self.class.send(generic_config_key)
+      base.class_attribute(a, default: default)
+    end
   end
 
-  # Get a list of fields, taking into account the current action.
+  # Get a list of fields for this controller.
   def get_fields
-    fields = self._get_specific_action_config(:action_fields, :fields)
-    return self.class.get_fields(input_fields: fields)
+    return self.class.get_fields(input_fields: self.class.fields)
   end
 
   # Pass fields to get dynamic metadata based on which fields are available.
@@ -413,19 +416,11 @@ module RESTFramework::BaseModelControllerMixin
     return self.class.get_options_metadata
   end
 
-  # Get a list of find_by fields for the current action.
-  def get_find_by_fields
-    return self.class.find_by_fields
-  end
-
   # Get a list of parameters allowed for the current action.
   def get_allowed_parameters
     return @_get_allowed_parameters if defined?(@_get_allowed_parameters)
 
-    @_get_allowed_parameters = self._get_specific_action_config(
-      :allowed_action_parameters,
-      :allowed_parameters,
-    )
+    @_get_allowed_parameters = self.allowed_parameters
     return @_get_allowed_parameters if @_get_allowed_parameters
 
     # For fields, automatically add `_id`/`_ids` and `_attributes` variations for associations.
@@ -454,20 +449,16 @@ module RESTFramework::BaseModelControllerMixin
       # Return field if it's not an association.
       next f unless ref = reflections[f]
 
-      if self.class.permit_id_assignment
-        if ref.collection?
-          hash_variations["#{f.singularize}_ids"] = []
-        elsif ref.belongs_to?
-          variations << "#{f}_id"
+      if self.permit_id_assignment && id_field = RESTFramework::Utils.get_id_field(f, ref)
+        if id_field.ends_with?("_ids")
+          hash_variations[id_field] = []
+        else
+          variations << id_field
         end
       end
 
-      if self.class.permit_nested_attributes_assignment
-        if self.class.allow_all_nested_attributes
-          hash_variations["#{f}_attributes"] = {}
-        else
-          hash_variations["#{f}_attributes"] = self.class.get_field_config(f)[:sub_fields]
-        end
+      if self.permit_nested_attributes_assignment
+        hash_variations["#{f}_attributes"] = self.class.get_field_config(f)[:sub_fields]
       end
 
       # Associations are not allowed to be submitted in their bare form.
@@ -483,37 +474,57 @@ module RESTFramework::BaseModelControllerMixin
     return super || RESTFramework::NativeSerializer
   end
 
-  # Get filtering backends, defaulting to using `ModelFilter`, `ModelOrderingFilter`, and
+  # Get filtering backends, defaulting to using `ModelQueryFilter`, `ModelOrderingFilter`, and
   # `ModelSearchFilter`.
   def get_filter_backends
-    return self.class.filter_backends || [
-      RESTFramework::ModelFilter,
+    return self.filter_backends || [
+      RESTFramework::ModelQueryFilter,
       RESTFramework::ModelOrderingFilter,
       RESTFramework::ModelSearchFilter,
     ]
   end
 
   # Use strong parameters to filter the request body using the configured allowed parameters.
-  def get_body_params(data: nil, bulk_mode: nil)
-    data ||= self.request.request_parameters
+  def get_body_params(bulk_mode: nil)
+    data = self.request.request_parameters
     pk = self.class.get_model&.primary_key
+    allowed_params = self.get_allowed_parameters
+
+    # Before we filter the data, dynamically dispatch association assignment to either the id/ids
+    # assignment ActiveRecord API or the nested assignment ActiveRecord API. Note that there is no
+    # need to check for `permit_id_assignment` or `permit_nested_attributes_assignment` here, since
+    # that is enforced by strong parameters generated by `get_allowed_parameters`.
+    self.class.get_model.reflections.each do |name, ref|
+      if payload = data[name]
+        if payload.is_a?(Hash) || (payload.is_a?(Array) && payload.all? { |x| x.is_a?(Hash) })
+          # Assume nested attributes assignment.
+          attributes_key = "#{name}_attributes"
+          data[attributes_key] = data.delete(name) unless data[attributes_key]
+        elsif id_field = RESTFramework::Utils.get_id_field(name, ref)
+          # Assume id/ids assignment.
+          data[id_field] = data.delete(name) unless data[id_field]
+        end
+      end
+    end
 
     # Filter the request body with strong params. If `bulk` is true, then we apply allowed
     # parameters to the `_json` key of the request body.
-    body_params = if bulk_mode
+    body_params = if allowed_params == true
+      ActionController::Parameters.new(data).permit!
+    elsif bulk_mode
       pk = bulk_mode == :update ? [pk] : []
-      ActionController::Parameters.new(data).permit({_json: self.get_allowed_parameters + pk})
+      ActionController::Parameters.new(data).permit({_json: allowed_params + pk})
     else
-      ActionController::Parameters.new(data).permit(*self.get_allowed_parameters)
+      ActionController::Parameters.new(data).permit(*allowed_params)
     end
 
     # Filter primary key if configured.
-    if self.class.filter_pk_from_request_body && bulk_mode != :update
+    if self.filter_pk_from_request_body && bulk_mode != :update
       body_params.delete(pk)
     end
 
     # Filter fields in `exclude_body_fields`.
-    (self.class.exclude_body_fields || []).each { |f| body_params.delete(f) }
+    (self.exclude_body_fields || []).each { |f| body_params.delete(f) }
 
     # ActiveStorage Integration: Translate base64 encoded attachments to upload objects.
     #
@@ -595,9 +606,9 @@ module RESTFramework::BaseModelControllerMixin
     is_pk = true
 
     # Find by another column if it's permitted.
-    if find_by_param = self.class.find_by_query_param.presence
+    if find_by_param = self.find_by_query_param.presence
       if find_by = params[find_by_param].presence
-        find_by_fields = self.get_find_by_fields&.map(&:to_s)
+        find_by_fields = self.find_by_fields&.map(&:to_s)
 
         if !find_by_fields || find_by.in?(find_by_fields)
           is_pk = false unless find_by_key == find_by
@@ -621,7 +632,7 @@ module RESTFramework::BaseModelControllerMixin
 
   # Determine what collection to call `create` on.
   def get_create_from
-    if self.class.create_from_recordset
+    if self.create_from_recordset
       # Create with any properties inherited from the recordset. We exclude any `select` clauses
       # in case model callbacks need to call `count` on this collection, which typically raises a
       # SQL `SyntaxError`.
@@ -660,13 +671,13 @@ module RESTFramework::ListModelMixin
     records = self.get_records
 
     # Handle pagination, if enabled.
-    if self.class.paginator_class
+    if self.paginator_class
       # If there is no `max_page_size`, `page_size_query_param` is not `nil`, and the page size is
       # set to "0", then skip pagination.
-      unless !self.class.max_page_size &&
-          self.class.page_size_query_param &&
-          params[self.class.page_size_query_param] == "0"
-        paginator = self.class.paginator_class.new(data: records, controller: self)
+      unless !self.max_page_size &&
+          self.page_size_query_param &&
+          params[self.page_size_query_param] == "0"
+        paginator = self.paginator_class.new(data: records, controller: self)
         page = paginator.get_page
         serialized_page = self.serialize(page)
         return paginator.get_paginated_response(serialized_page)

data/lib/rest_framework/controller_mixins.rb

@@ -2,5 +2,6 @@ module RESTFramework::ControllerMixins
 end
 
 require_relative "controller_mixins/base"
+
 require_relative "controller_mixins/bulk"
 require_relative "controller_mixins/models"

data/lib/rest_framework/engine.rb

@@ -1,2 +1,11 @@
 class RESTFramework::Engine < Rails::Engine
+  initializer "rest_framework.assets" do
+    config.after_initialize do |app|
+      if RESTFramework.config.use_vendored_assets
+        app.config.assets.precompile += RESTFramework::EXTERNAL_ASSETS.keys.map do |name|
+          "rest_framework/#{name}"
+        end
+      end
+    end
+  end
 end

data/lib/rest_framework/filters/base.rb

@@ -0,0 +1,9 @@
+class RESTFramework::BaseFilter
+  def initialize(controller:)
+    @controller = controller
+  end
+
+  def get_filtered_data(data)
+    raise NotImplementedError
+  end
+end