edit_in_place 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a49b654229bb462de8d09e761fb800ef58647a8964b793e90c308e29b65589b
-  data.tar.gz: dbc63f81542231c4defe07042f10664cf0376a61f47a41abf2983175134671ba
+  metadata.gz: 98f6c29f5c933c2f0051d9199089dc41125fe9cf6bdf8d3f61e7a6718b828a40
+  data.tar.gz: 95f123e6fcacbd5b8a42489d9dea077d0b381f482d1cdb152245f61dd56071da
 SHA512:
-  metadata.gz: 615184175d7f147d9764c2a35ce3246e3114db24e33699ad02bfd422e8e6d9021653f2600ee0793245966e76538a8ccd286fd4e0c2aca361ddf29da279e5e76d
-  data.tar.gz: fef7dc43b4333a89fe8d23b3f62d92aabbca2372fffca8535899c6b089c21be8f64201621eea27c71c26f7e9aed54a7a97d4027963f69dc6519877ca6cc60218
+  metadata.gz: 50f8954118b90962787e4131feae133a5babe443a4bdb36231c0a6c3fcbadfdc0f65d71831d8c449a0d9f07afc7f026598a8119088bc9bf1100e3a2a7da7658c
+  data.tar.gz: 5a66d2fbdbbc040ef95acaaa29f61aa886d8172baf9b298e44ae5f61ab2ffed669eb0e9113bd361babbe2bf85dcec0b00729a7deb536b80a3a878bb3a30e8fef

data/README.md

@@ -1,11 +1,12 @@
 # EditInPlace
 
+[![Gem Version](https://badge.fury.io/rb/edit_in_place.svg)](https://badge.fury.io/rb/edit_in_place)
 [![Build Status](https://travis-ci.com/jacoblockard99/edit_in_place.svg?branch=master)](https://travis-ci.com/jacoblockard99/edit_in_place)
 [![Inline docs](http://inch-ci.org/github/jacoblockard99/edit_in_place.svg?branch=master)](http://inch-ci.org/github/jacoblockard99/edit_in_place)
 [![Maintainability](https://api.codeclimate.com/v1/badges/389fc591cd9cccb2ceb1/maintainability)](https://codeclimate.com/github/jacoblockard99/edit_in_place/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/389fc591cd9cccb2ceb1/test_coverage)](https://codeclimate.com/github/jacoblockard99/edit_in_place/test_coverage)
 
-`edit_in_place` is a Rails plugin that facilitates the creation of user interfaces that allow the user to edit content "in place" in a natural way. `edit_in_place` aims to be:
+`edit_in_place` is a Ruby gem that facilitates the creation of user interfaces that allow the user to edit content "in place" in a natural way. `edit_in_place` aims to be:
   - **Flexible.** Everything has been designed with extensibility in mind. The `edit_in_place` core (this repository) can be extended for a huge variety of use cases.
   - **Reliable.** Every aspect of the plugin is thoroughly tested and documented.
   - **Natural.** Coding with `edit_in_place` is just as natural as editing content with it is! We think you'll really enjoy working with the `edit_in_place` API.
@@ -34,7 +35,7 @@ Or you may install it manually with:
 $ gem install edit_in_place
 ```
 
-`edit_in_place` currently has two dependencies: `rails` and `middlegem`.
+`edit_in_place` currently has two dependencies: `activesupport` and `middlegem`. The only extension required from `activesupport` is `Hash#deep_merge`.
 
 ## Concepts
 
@@ -65,12 +66,12 @@ Here are a few examples:
 class TextFieldType < EditInPlace::FieldType
   protected
 
-  def render_viewing(options, name, value)
-    options.view.tag.p value
+  def render_viewing(mode, name, value)
+    "<p>#{value}</p>"
   end
 
-  def render_editing(options, name, value)
-    options.view.text_field_tag name, value
+  def render_editing(mode, name, value)
+    "<input type='text' value='#{value}' name='#{name]' />"
   end
 end
 ```
@@ -79,13 +80,13 @@ end
 # boolean_field_type.rb
 
 class DummyFieldtype < EditInPlace::FieldType
-  def render(options, *)
-    "You are currently #{options.mode} the webpage!"
+  def render(mode, *)
+    "You are currently #{mode} the webpage!"
   end
 end
 ```
 
-Notice that the `render` method is passed an options parameter, which is an instance of `EditInPlace::FieldOptions`, that contains the view context and the mode. Also note how `render_viewing` and `render_editing` will be called according to the current mode. If you want to define a `render_*` method for a different mode, you'll need to override the `supported_modes` method, like so:
+Notice that the `render` method is passed a mode parameter. Also note how `render_viewing` and `render_editing` will be called according to the current mode. If you want to define a `render_*` method for a different mode, you'll need to override the `supported_modes` method, like so:
 
 ```ruby
 class LockedField
@@ -109,7 +110,7 @@ class LockedField
 end
 ```
 
-Attempts to call `render` with a mode that is not is `supported_modes` will result in an `EditInPlace::UnsupportedModeError`, even if the field type has a corresponding `render_*` method.
+Attempts to call `render` with a mode that is not in `supported_modes` will result in an `EditInPlace::UnsupportedModeError`, even if the field type has a corresponding `render_*` method.
 
 As mentioned earlier, one of the aims of `edit_in_place` is to be natural for the developer. Thus, in the interests of convenience, `edit_in_place` allows you to "register" field types with a name, making them easier to use. We might register our "text" field type, for example, like this:
 
@@ -133,6 +134,25 @@ Becomes:
 
 Note that field type names must be symbols—strings are not allowed. Also note that duplicate registrations are not alowed and will raise an `EditInPlace::DuplicateRegistrationError`.
 
+Another convenient feature is that you may use or register field type _classes_ whose
+constructor has no parameters. For example:
+
+```ruby
+@builder.config.field_types.register :image, ImageFieldType
+```
+
+```ruby
+<%= @builder.field TextFieldType, 'contact_name', 'Jacob' %>
+<%= @builder.field :image, 'contact_name', 'Jacob' %>
+```
+
+Equivalent to:
+
+```ruby
+<%= @builder.field TextFieldType.new, 'contact_name', 'Jacob' %>
+<%= @builder.field ImageFieldType.new, 'contact_name', 'Jacob' %>
+```
+
 ### Configuring a Builder
 
 The next step is creating and using an `EditInPlace::Builder` instance. A builder always has an `EditInPlace::Configuration` instance that contains all its options and context. When a builder is first instantiated, its configuration is copied from the global `EditInPlace` configuration. Thus, you can set any global configuration options using `EditInPlace.config` or `EditInPlace.configure`, and all builders with use those options by default. For example:
@@ -152,27 +172,6 @@ This would make editing the *default* mode. Then, you can modify builder-specifi
 
 Both `EditInPlace.config` and `Builder#config` are `EditInPlace::Configuration` instances, so you configure them identically. You are encouraged to check out the [docs](https://rubydoc.info/github/jacoblockard99/edit_in_place/EditInPlace/Configuration) on `Configuration` to see all the available configuration options.
 
-Only two options are really critical to using the builder: the view context and the mode. The view context is necessary when the field type needs access to a view context to render the field. In our `TextFieldType` example above, for example, the `text_field_tag` method was required. Probably the easiest way to pass the view context is to simply use the `view_context` method in Rails controllers. For example:
-
-```
-class SomeController
-  def index
-    @builder = Builder.new
-    @builder.field_options.view = view_context
-  end
-end
-```
-
-Now, field types will automatically have access to the view context. This method has some pitfalls, however, most importantly that `view_context` returns a _new_ view context, not the one used in the actual view. If you must have the actual view context object, something like this could be done instead:
-
-```erb
-<% @builder.field_options.view = self %>
-
-<%= @builder.field :text, "hello, world" %>
-```
-
-Of course, you would need to put this at the top of all your views.
-
 There are a few approaches to managing builder modes. One approach is to have a seperate controller for each, like so:
 
 ```ruby
@@ -220,6 +219,12 @@ If your field type happens to expect the first input argument to be a hash, you
 <%= @builder.field :some_type, {}, { option: true }, 'etc' %>
 ```
 
+`Builder` also overrides `method_missing` to make it easier to call registered fields. If, for example, you have registered a `:text` field type, you can do the following:
+
+```erb
+<%= @builder.text_field 'phone_number', '(123) 456-7890' %>
+```
+
 ### Middlewares
 
 Perhaps the most powerful feature of `edit_in_place` are the field middlewares. `edit_in_place` uses [`middlegem`](https://github/jacoblockard99/middlegem) for middlewares, which you may want to briefly review. Field middlewares allow the inputs to a field to be transformed before actually making it to the field type's `render` method. The use cases for this are limitless.
@@ -254,6 +259,16 @@ end
 
 Now, when viewing the site, the first one would show "(5000)" and the second would show "(a string)". Note that middlewares are often too verbose to be easily used like this. They are really best used by edit_in_place extensions.
 
+Like field types, middlewares can also be registered, using `Configuration#registered_middlewares`. For example:
+
+```ruby
+@builder = Builder.new
+@builder.configure do |c|
+  c.registered_middlewares.register :parentheses, ParenthesesMiddleware
+  c.field_options.middlewares << :parentheses
+```
+
+
 ### Scoped Builders
 
 There will likely be times when you wish for many fields to have the same `FieldOptions`. This can be accomplished with the `Builder#scoped` method, which allows field options to be shared across a block. For example:
@@ -264,7 +279,15 @@ There will likely be times when you wish for many fields to have the same `Field
 <% end %>
 ```
 
-Now any fields generated with the scoped `b` builder will have an `'example'` argument appended to their input (assuming that `AppendArgumentMiddleware` has been defined).
+Now any fields generated with the scoped `b` builder will have an `'example'` argument appended to their input (assuming that `AppendArgumentMiddleware` has been defined). In fact, scoping a builder with middleware is comon enough that `Builder` also provides a `with_middlewares` convenience method:
+
+```erb
+<%= @builder.with_middlewares AppendArgumentMiddleware.new('example') |b| do %>
+  <%= b.field :text, 'name', 'value' %>
+<% end %>
+```
+
+Note that `Builder#scope` and `Builder#middleware_scope` are aliases for `Builder#scoped` and `Builder#with_middlewares`, respectively.
 
 ### Extending Builder
 

data/Rakefile

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
 
-require 'bundler/setup'
-
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
 
-require 'rake/testtask'
+require 'rubocop/rake_task'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
+RuboCop::RakeTask.new
 
-task default: :test
+task default: %i[spec rubocop]

data/lib/edit_in_place.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
-require 'edit_in_place/version'
-require 'edit_in_place/railtie'
+require 'edit_in_place/array_definition'
 require 'edit_in_place/builder'
 require 'edit_in_place/configuration'
-require 'edit_in_place/registrar'
 require 'edit_in_place/extended_builder'
 require 'edit_in_place/field_options'
 require 'edit_in_place/field_type'
 require 'edit_in_place/field_type_registrar'
+require 'edit_in_place/middleware_registrar'
+require 'edit_in_place/middleware_wrapper'
+require 'edit_in_place/registrar'
+require 'edit_in_place/version'
+
+require 'edit_in_place/error'
+require 'edit_in_place/duplicate_registration_error'
+require 'edit_in_place/invalid_field_type_error'
+require 'edit_in_place/invalid_registration_name_error'
+require 'edit_in_place/unregistered_field_type_error'
+require 'edit_in_place/unregistered_middleware_error'
+require 'edit_in_place/unsupported_mode_error'
 
 # {EditInPlace} is a namespace that contains all the modules and classes of the edit_in_place
 # Rails gemified plugin.
@@ -16,22 +26,9 @@ require 'edit_in_place/field_type_registrar'
 # @author Jacob Lockard
 # @since 0.1.0
 module EditInPlace
-  # {Error} is a subclass of {https://ruby-doc.org/core-2.5.0/StandardError.html StandardError}
-  # from which all custom errors in edit_in_place are derived. One potential use for this class
-  # is to rescue all custom errors produced by edit_in_place. For example:
-  #
-  #   begin
-  #     # Do something risky with edit_in_place here...
-  #   rescue EditInPlace::Error
-  #     # Catch any edit_in_place-specific error here...
-  #   end
-  #
-  # @see https://ruby-doc.org/core-2.0.0/Exception.html
-  class Error < StandardError; end
-
   @config = Configuration.new
 
-  # Gets the `Configuration` instance that represents the global configuration for the
+  # Gets the {Configuration} instance that contains the global configuration for the
   # edit_in_place plugin. The global configuration will be applied to all created {Builder}
   # instances.
   # @return [Configuration] the global configuration.
@@ -40,7 +37,7 @@ module EditInPlace
     @config
   end
 
-  # Sets the `Configuration` instance that represents the global configuration for the
+  # Sets the {Configuration} instance that represents the global configuration for the
   # edit_in_place plugin. A convenient use for this method is to reset the global configuration
   # by setting it to +EditInPlace::Configuration.new+.
   # @param config [Configuration] the global configuration.
@@ -65,8 +62,3 @@ module EditInPlace
     yield config if block_given?
   end
 end
-
-require 'edit_in_place/invalid_field_type_error'
-require 'edit_in_place/unregistered_field_type_error'
-require 'edit_in_place/invalid_registration_name_error'
-require 'edit_in_place/duplicate_registration_error'

data/lib/edit_in_place/array_definition.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'middlegem'
+
+module EditInPlace
+  # {ArrayDefinition} is a subclass of +Middlegem::ArrayDefinition+ that works properly with
+  # {MiddlewareWrapper} instances. The problem is that +Middlegem::ArrayDefinition+, by default,
+  # tries to use the class of the defined middlewares themselves. By overriding {matches_class?},
+  # {ArrayDefinition} is able to cause +middlegem+ to use the class of the _base_ middleware of
+  # any {MiddlewareWrapper} instances.
+  #
+  # @author Jacob Lockard
+  # @since 0.2.0
+  class ArrayDefinition < Middlegem::ArrayDefinition
+    protected
+
+    # Overrides +matches_class?+ to use the base middleware's class if the middleware is a
+    # {MiddlewareWrapper}.
+    # @param middleware [Object] the middleware to check.
+    # @param klass [Class] the class against which the middleware should be checked.
+    # @return [Boolean] whether the given middleware has the given class.
+    def matches_class?(middleware, klass)
+      middleware.is_a?(MiddlewareWrapper) ? middleware.base.instance_of?(klass) : super
+    end
+  end
+end

data/lib/edit_in_place/builder.rb

@@ -2,12 +2,13 @@
 
 module EditInPlace
   # {Builder} is the class that provides the actual functionality to build and render editable
-  # content. This class will usually be instantiated in a controller and passed somehow to a
-  # view. The view can then use its methods to generate content. Note that when a {Builder} is
-  # created, it's {Configuration} is copied from the global configuration.
+  # content. If used in a Rails setting, this class will usually be instantiated in a controller
+  # and passed somehow to a view. The view can then use its methods to generate content. Note
+  # that when a {Builder} is created, its {Configuration} is copied from the global
+  # configuration.
   #
   # This class can be extended by utilizing {ExtendedBuilder} to safely add additional
-  # functionality. This can be particularly helpful for edit_in_place extensions that would like
+  # functionality. This can be particularly helpful for edit_in_place extensions that wish
   # to add other content generation methods without requiring the user to yield another builder
   # to the view.
   #
@@ -25,15 +26,40 @@ module EditInPlace
       @config = EditInPlace.config.dup
     end
 
-    # Creates a deep copy of this {Builder}, whose configuration can be safely modified.
+    # Overrides +method_missing+ to allow methods like +*_field+ to be called for registered
+    # fields. For example, if a +:text+ field type has been registered, then calling
+    # +Builder#text_field(...)+ is equivalent to calling +Builder#field(:text, ...)+.
+    # @param method_name [Symbol, String] the name of the missing method being called.
+    # @param args [Array] the arguments passed to the missing method.
+    # @yield the block, if any, passed to the missing method.
+    # @return the result of calling {#field} with the appropriate type if possible; the result of
+    #   calling +super+ if not.
+    # @since 0.2.0
+    def method_missing(method_name, *args, &block)
+      field_type = parse_field_method(method_name)
+      field_type ? field(field_type, *args, &block) : super
+    end
+
+    # Overrides +respond_to_missing?+ to allow methods like +*_field+ to be responded to by
+    # {Builder}.
+    # @param method_name [Symbol, String] the name of the missing method being checked.
+    # @return [Boolean] +true+ if this {Builder} can respond to the given method name; +false+
+    #   otherwise.
+    # @see #method_missing
+    # @since 0.2.0
+    def respond_to_missing?(method_name, inlude_private = false)
+      parse_field_method(method_name) || super
+    end
+
+    # Creates a deep copy of this {Builder} whose configuration can be safely modified.
     # @return [Builder] a deep copy of this {Builder}.
     def dup
-      b = Builder.new
+      b = self.class.new
       b.config = config.dup
       b
     end
 
-    # Configures this {Builder} by yielding its configuration to the given block. For example,
+    # Configures this {Builder} by yielding its configuration to the given block. For example:
     #
     #   @builder = EditInPlace::Builder.new
     #   @builder.configure do |c|
@@ -41,71 +67,62 @@ module EditInPlace
     #     c.field_options.middlewares = [:one, :two]
     #   end
     #
-    # Note that this method is simply a convenience method, and the above code is exactly
+    # Note that this method is simply a convenience method and that the above code is exactly
     # equivalent to the following:
     #
     #   @builder = EditInPlace::Builder.new
     #   @builder.config.field_options.mode = :editing
     #   @builder.config.field_options.middlewares = [:one, :two]
+    #
     # @yieldparam config [Configuration] the {Configuration} instance associated with this
     #   {Builder}.
     # @yieldreturn [void]
     # @return [void]
-    # @see EditInPlace.configure
     def configure
       yield config if block_given?
     end
 
+    # Renders a single "field", that is, a single piece of editable content defined by a field
+    # type. Field options may or may not be provided and will be automatically injected if not.
+    # The input given to this method will be transformed by any middlewares added from various
+    # sources.
     # @overload field(type, options, *args)
-    #   Renders a single field of the given type with the given field option and arguments
-    #   to be passed to the field type renderer.
-    #   @param type [FieldType, Symbol] the type of field to render, either an actual instance of
-    #     {FieldType}, or the symbol name of a registered field type.
+    #   Renders a single field of the given type with the given field options and input.
+    #   @param type [FieldType, Class, Symbol] the type of field to render, either an actual
+    #     instance of {FieldType}, a field type class that can be instantiated with no arguments,
+    #     or the symbol name of a registered field type.
     #   @param options [FieldOptions, Hash] the field options to be used when rendering the
-    #     field. These options are defined in {FieldOptions}. Either an actual instance of
+    #     field. These options are as defined in {FieldOptions}. Either an actual instance of
     #     {FieldOptions} or a hash are acceptable.
-    #   @param args [Array] the arguments to be passed to the field renderer.
-    #   @return [String] the rendered field, as HTML.
+    #   @param args [Array] the input arguments to be passed to `FieldType#render`.
+    #   @return the rendered field.
     # @overload field(type, *args)
-    #   Renders a single field of the given type with the given arguments to be passed to the
-    #   field type renderer. The default field options (as defined in {FieldOptions}) will be
-    #   used.
-    #   @param type [FieldType, Symbol] the type of field to render, either an actual instance of
-    #     {FieldType}, or the symbol name of a registered field type.
-    #   @param args [Array] the arguments to be passed to the field renderer.
-    #   @return [String] the rendered field, as HTML.
+    #   Renders a single field of the given type with the default field options and the given
+    #   input.
+    #   @param type [FieldType, Class, Symbol] the type of field to render, either an actual
+    #     instance of {FieldType}, a field type class that can be instantiated with no arguments,
+    #     or the symbol name of a registered field type.
+    #   @param args [Array] the input arguments to be passed to `FieldType#render`.
+    #   @return the rendered field.
     def field(type, *args)
-      inject_field_options!(args)
-      args[0] = config.field_options.merge(args[0])
+      options = config.field_options.merge(get_field_options!(args))
+      args.unshift(options.mode)
 
-      definition = Middlegem::ArrayDefinition.new(config.defined_middlewares)
-      stack = Middlegem::Stack.new(definition, middlewares: args[0].middlewares)
-      args = stack.call(*args)
+      args = apply_middlewares(options.middlewares, *args)
 
       type = evaluate_field_type(type)
       type.render(*args)
     end
 
     # Yields a new, scoped {Builder} with the given field options. This method is helpful when
-    # many fields require the same options. One use, for example, is to easily give field types
-    # access to the current view context, like so:
-    #
-    #   <!-- some_view.html.erb -->
-    #
-    #   <%= @builder.scoped view: self do |b|
-    #     <%= b.field(:example_type, 'random scoped field') %>
-    #     <!-- ... -->
-    #   <% end %>
-    #
-    # Now all fields generated using +b+ will have access to +self+ as the view context in
-    # {FieldOptions#view}.
+    # many fields require the same options.
     # @yieldparam scoped_builder [Builder] the new, scoped {Builder} instance.
-    # @yieldreturn [string] the output generated with the scoped builder.
+    # @yieldreturn the output.
     # @param field_options [FieldOptions, Hash] the field options that the scoped builder should
     #   have. Note that these options will be merged (using {FieldOptions#merge!}) with the
     #   current ones. Either an actual {FieldOptions} instance or a hash of options are
     #   acceptable.
-    # @return [string] the output of the block.
+    # @return the output of the block.
     def scoped(field_options = {})
       field_options = FieldOptions.new(field_options) unless field_options.is_a? FieldOptions
 
@@ -114,48 +131,104 @@ module EditInPlace
 
       yield scoped_builder
     end
+    # @since 0.2.0
+    alias scope scoped
+
+    # Yields a new, scoped {Builder} with the given middlewares merged into the current ones.
+    # Note that this method is for convenience only and is exactly equivalent to calling
+    # +scoped(middlewares: ...)+.
+    # @yieldparam scoped_builder [Builder] the new, scoped {Builder} instance.
+    # @yieldreturn the output.
+    # @param middlewares [Array] the array of middlewares that the scoped builder should have
+    #   merged into it.
+    # @return the output of the block.
+    # @since 0.2.0
+    def with_middlewares(*middlewares, &block)
+      scoped(middlewares: middlewares, &block)
+    end
+    alias middleware_scope with_middlewares
 
     private
 
-    # Ensures that the first argument in the given list of arguments is a valid, appropriate
-    # {FieldOptions} instance for the list of arguments. In particular:
-    # - When the first argument is already an instance of {FieldOptions}, the argument list
-    #   is not touched.
-    # - When the first argument is a hash, then it is converted to a
-    #   {FieldOptions} instance.
-    # - Otherwise, the default {FieldOptions} instance is prepended to the argument list.
-    # @param args [Array] the raw arguments into which to inject the field options.
-    # @return [void]
-    def inject_field_options!(args)
-      options = args.first
+    # Attempts to get a field type from the given '*_field' method name.
+    # @param method_name [Symbol, String] the name of the method to parse.
+    # @return [FieldType, nil] the field type if one could be found; +nil+ if not.
+    def parse_field_method(method_name)
+      method_name = method_name.to_s
+      return nil unless method_name.end_with? '_field'
 
-      return if options.is_a? FieldOptions
+      field_type_name = method_name.delete_suffix('_field').to_sym
+      config.field_types.find(field_type_name)
+    end
 
-      if options.is_a? Hash
-        args[0] = FieldOptions.new(options)
+    # Gets an appropriate {FieldOptions} instance for the given list of field arguments and
+    # removes any present field options from the argument list.
+    # @param args [Array] the raw arguments from which to get the field options.
+    # @return [FieldOptions] the retrieved field options.
+    # @since 0.2.0
+    def get_field_options!(args)
+      case args.first
+      when FieldOptions
+        args.shift
+      when Hash
+        FieldOptions.new(args.shift)
       else
-        args.unshift(FieldOptions.new)
+        FieldOptions.new
       end
     end
 
     # Gets an appropriate {FieldType} instance for the given raw field type argument. In
     # particular:
-    # - When the input is already a FieldType instance, that instance is simply returned.
     # - When the input is a symbol, attempts to find a registered field type associated with it.
+    # - When the input is a class, instatiates it.
+    # - When the input is already a FieldType instance, that instance is simply returned.
     # - Otherwise, raises an error.
+    # @param type [Symbol, Class, FieldType] the raw field type argument to evaluate.
     # @return [FieldType] an appropriate {FieldType} instance for the given input.
     def evaluate_field_type(type)
       case type
+      when Symbol
+        evaluate_field_type(lookup_field_type(type))
+      when Class
+        evaluate_field_type(type.new)
       when FieldType
         type
-      when Symbol
-        result = config.field_types.find(type)
-        raise UnregisteredFieldTypeError, type if result.nil?
-
-        result
       else
         raise InvalidFieldTypeError, type
       end
     end
+
+    # Attempts to find a field type registered with the given name in the field type registrar.
+    # If one could not be found, raises an appropriate error.
+    # @param name [Symbol] the name to search for.
+    # @return the found field type.
+    # @since 0.2.0
+    def lookup_field_type(name)
+      result = config.field_types.find(name)
+      raise UnregisteredFieldTypeError, name if result.nil?
+
+      result
+    end
+
+    # Applies the given array of middlewares to the given input arguments and returns the result.
+    # @param middlewares [Array] the array of middlewares to apply.
+    # @param args [Array] the array of input arguments.
+    # @return [Array] the resulting argument list.
+    # @since 0.2.0
+    def apply_middlewares(middlewares, *args)
+      definition = ArrayDefinition.new(config.defined_middlewares)
+      stack = Middlegem::Stack.new(definition, middlewares: wrap_middlewares(middlewares))
+
+      stack.call(*args)
+    end
+
+    # Converts each of the given middleware instances into a {MiddlewareWrapper} and returns the
+    # result.
+    # @param middlewares [Array] the middlewares to wrap.
+    # @return [Array] the wrapped middlewares.
+    # @since 0.2.0
+    def wrap_middlewares(middlewares)
+      middlewares.map { |m| MiddlewareWrapper.new(m, config.registered_middlewares) }
+    end
   end
 end

data/lib/edit_in_place/configuration.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
+require 'active_support/core_ext/object/deep_dup'
+
 module EditInPlace
   # {Configuration} is a class that is capable of storing configuration for an edit_in_place
-  # {Builder}. Essentially all the options provided by edit_in_place reside in this class for
+  # {Builder}. Essentially all the options provided by edit_in_place reside in this class, for
   # easy reuse. This class is currently used in two locations---the global configuration in
   # {EditInPlace.config} and the builder-specific configuration in {Builder#config}.
   #
   # @author Jacob Lockard
   # @since 0.1.0
   class Configuration
-    # The default mode in which fields should be rendered if left unpspecified in the
-    # configuration.
+    # The default mode in which fields should be rendered if left unspecified in
+    # {#field_options}.
     DEFAULT_MODE = :viewing
 
     # The {FieldTypeRegistrar} used to store the list of registered field types.
@@ -27,21 +29,28 @@ module EditInPlace
     # @return [Array] the array of defined middlewares.
     attr_accessor :defined_middlewares
 
+    # The {MiddlewareRegistrar} used to store the list of registered middlewares.
+    # @return [MiddlewareRegistrar] the {MiddlewareRegistrar} that stores the list of registered
+    #   middlewares.
+    attr_accessor :registered_middlewares
+
     # Creates a new, default instance of {Configuration}.
     def initialize
       @field_types = FieldTypeRegistrar.new
       @field_options = FieldOptions.new(mode: DEFAULT_MODE)
       @defined_middlewares = []
+      @registered_middlewares = MiddlewareRegistrar.new
     end
 
     # Creates a deep copy of this {Configuration} that can be safely modified.
     # @return [Configuration] a deep copy of this configuration.
     def dup
-      c = Configuration.new
+      c = self.class.new
       c.field_types = field_types.dup
       c.field_options = field_options.dup
       # Note that this is purposely NOT a deep copy---it doesn't make sense to duplicate classes.
       c.defined_middlewares = defined_middlewares.dup
+      c.registered_middlewares = registered_middlewares.dup
       c
     end
   end

data/lib/edit_in_place/error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module EditInPlace
+  # {Error} is a subclass of {https://ruby-doc.org/core-2.5.0/StandardError.html StandardError}
+  # from which all custom errors in edit_in_place are derived. One potential use for this class
+  # is to rescue all custom errors produced by edit_in_place. For example:
+  #
+  #   begin
+  #     # Do something risky with edit_in_place here...
+  #   rescue EditInPlace::Error
+  #     # Catch any edit_in_place-specific error here...
+  #   end
+  #
+  # @see https://ruby-doc.org/core-2.0.0/Exception.html
+  class Error < StandardError; end
+end

data/lib/edit_in_place/extended_builder.rb

@@ -29,12 +29,33 @@ module EditInPlace
     #   quack like a {Builder}.
     attr_reader :base
 
-    delegate_missing_to :base
-
     # Creates a new {ExtendedBuilder} with the given base builder.
     # @param base [Object] the base builder to extend. It should quack like a {Builder}.
     def initialize(base)
       @base = base
     end
+
+    # Overrides +method_missing+ to allow the use of methods defined on the base builder. This
+    # method was added in version 0.2.0 when Rails support (and thus support for
+    # +delegate_missing_to+) was removed.
+    # @param method_name [Symbol, String] the name of the missing method.
+    # @param args [Array] the arguments given to the missing method.
+    # @yield the block passed to the missing method.
+    # @return the result of calling the method on the base builder, if it was defined, or the
+    #   result of calling +super+ if not.
+    # @since 0.2.0
+    def method_missing(method_name, *args, &block)
+      base.respond_to?(method_name) ? base.send(method_name, *args, &block) : super
+    end
+
+    # Overrides +respond_to_missing?+ to respond to methods defined on the base builder. This
+    # method was added in version 0.2.0 when Rails support (and thus support for
+    # +delegate_missing_to+) was removed.
+    # @param method_name [Symbol, String] the name of the missing method.
+    # @return [Boolean] whether this {ExtendedBuilder} can respond to the given method name.
+    # @since 0.2.0
+    def respond_to_missing?(method_name, priv = false)
+      base.respond_to?(method_name) || super
+    end
   end
 end

data/lib/edit_in_place/field_options.rb

@@ -2,6 +2,8 @@
 
 module EditInPlace
   # {FieldOptions} is a class that stores the options and context required to render a field.
+  # More specifically, it stores options given to *the {Builder#field} method itself*, not
+  # options given to the field renderer.
   #
   # @author Jacob Lockard
   # @since 0.1.0
@@ -18,11 +20,6 @@ module EditInPlace
     #   @return [void]
     attr_reader :mode
 
-    # The view context to be used when rendering the field. This view context can be derived in
-    # a number of ways, most commonly by creating a new instance of +ActionView::Base+.
-    # @return the view context to be used when rendering the field.
-    attr_accessor :view
-
     # An array of middleware instances that should be applied to the field's input.
     # @return the array of middlewares.
     attr_accessor :middlewares
@@ -31,12 +28,11 @@ module EditInPlace
     #   Creates a new instance of {FieldOptions} with the given options.
     #   @param options [Hash, #[]] a hash containing the given field options.
     #   @option options [Symbol] :mode the {#mode} in which fields should be rendered.
-    #   @option options :view the {#view} context to use when rendering the field.
+    #   @option options [Array] :middlewares the {#middlewares} for the field.
     # @overload initialize
     #   Creates a new instance of {FieldOptions} with the default options.
     def initialize(options = {})
       self.mode = options[:mode]
-      self.view = options[:view]
       self.middlewares = options[:middlewares] || []
     end
 
@@ -48,24 +44,22 @@ module EditInPlace
     # Creates a deep copy of this {FieldOptions} instance that can be safely modified.
     # @return [FieldOptions] a deep copy of this {FieldOptions} instance.
     def dup
-      f = FieldOptions.new
+      f = self.class.new
       f.mode = mode
-      f.view = view
-      f.middlewares = middlewares.deep_dup
+      f.middlewares = middlewares.map { |m| m.instance_of?(Class) ? m : m.dup }
       f
     end
 
-    # Merges the given {FieldOptions} instance into this one. Modes and view contexts from the
-    # other instance will overwrite those in this instance if present. The other instance is
-    # duplicated before being merged, so it can be safely modified after the fact. All
-    # middleware arrays will be merged.
+    # Merges the given {FieldOptions} instance into this one. A mode from the
+    # other instance will overwrite the one in this instance if present. Middleware arrays will
+    # be merged. Note that the other instance is duplicated before being merged, so it can be
+    # safely modified after the fact.
     # @param other [FieldOptions] the other field options to merge into this one.
     # @return [void]
     def merge!(other)
       other = other.dup
 
       self.mode = other.mode unless other.mode.nil?
-      self.view = other.view unless other.view.nil?
       self.middlewares += other.middlewares
     end
 

data/lib/edit_in_place/field_type.rb

@@ -3,13 +3,13 @@
 module EditInPlace
   # {FieldType} is a class that represents a single type of field. A field is a single,
   # self-contained component that displays data in various "modes", typically either "viewing" or
-  # "editing". Field types provide the templates for similar fields.
+  # "editing". Field types provide the templates for rendering fields.
   #
   # @abstract
   # @author Jacob Lockard
   # @since 0.1.0
   class FieldType
-    # Render the field, given a {FieldOptions} instance and an array of arguments passed by
+    # Render the field, given the mode and an array of arguments passed by
     # the caller.
     #
     # While subclasses may override this method as appropriate, the default
@@ -18,13 +18,12 @@ module EditInPlace
     # 2. calls a +render_*+ method.
     # For example, if the mode were +:admin_editing+, then a +render_admin_editing+ method would
     # be called. Naturally, the +render_*+ methods need to be defined by the subclass.
-    # @param options [FieldOptions] options passed by the {Builder} instance that should
-    #   be used to render the field.
+    # @param mode [Symbol] the mode with which to render the field.
     # @param args [Array<Object>] the arguments passed by the field creator.
-    # @return [String] the rendered HTML.
-    def render(options, *args)
-      validate_mode!(options.mode)
-      send("render_#{options.mode}", options, *args)
+    # @return the rendered result.
+    def render(mode, *args)
+      validate_mode!(mode)
+      send("render_#{mode}", mode, *args)
     end
 
     # Gets the modes that are supported by this field type, +:viewing+ and +:editing+ by default.

data/lib/edit_in_place/field_type_registrar.rb

@@ -1,22 +1,26 @@
 # frozen_string_literal: true
 
+require 'edit_in_place/registrar'
+
 module EditInPlace
   # {FieldTypeRegistrar} is a subcalss of {Registrar} that only allows {FieldType}
-  # instances to be registered.
+  # instances and field type classes to be registered.
   #
   # @author Jacob Lockard
   # @since 0.1.0
   class FieldTypeRegistrar < Registrar
     protected
 
-    # Adds to the default `validate_registration!` implementation by ensuring that only
-    # {FieldType} instances can be registered.
+    # Adds to the default +validate_registration!+ implementation by ensuring that only
+    # {FieldType} instances or field type classes can be registered.
     # @param name [Symbol] the name to validate.
-    # @param field_type [FieldType] the field type to validate.
+    # @param field_type [FieldType, Class] the field type to validate.
     # @return [void]
     def validate_registration!(name, field_type)
       super
-      raise InvalidFieldTypeError, field_type unless field_type.is_a? FieldType
+      unless field_type.is_a?(FieldType) || field_type.instance_of?(Class)
+        raise InvalidFieldTypeError, field_type
+      end
     end
   end
 end

data/lib/edit_in_place/middleware_registrar.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module EditInPlace
+  # {MiddlewareRegistrar} is a subclass of {Registrar} that only allows middleware objects (as
+  # defined by +Middlegem::Middleware.valid?+) or middleware classes to be registered.
+  #
+  # @author Jacob Lockard
+  # @since 0.2.0
+  class MiddlewareRegistrar < Registrar
+    protected
+
+    # Adds to the default +validate_registration!+ implementation by ensuring that only
+    # middleware objects (as defined by +Middlegem::Middleware.valid?+) or middleware classes
+    # can be registered.
+    def validate_registration!(name, middleware)
+      super
+      unless Middlegem::Middleware.valid?(middleware) || middleware.instance_of?(Class)
+        raise Middlegem::InvalidMiddlewareError
+      end
+    end
+  end
+end

data/lib/edit_in_place/middleware_wrapper.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'middlegem'
+
+module EditInPlace
+  # {MiddlewareWrapper} is a class that provides a consistent wrapper for a middleware, which
+  # currently can be one of the following:
+  #   1. an actual middleware object (i.e. an object that responds to +#call+),
+  #   2. a symbol name corresponding to a registered middleware, or
+  #   3. a parameterless middleware class that should be instantiated.
+  # {MiddlewareWrapper}, which is itself a +Middlegem::Middleware+ does all the necessary
+  # conversions, providing a simple {#call} method.
+  #
+  # @author Jacob Lockard
+  # @since 0.2.0
+  class MiddlewareWrapper < Middlegem::Middleware
+    # The base middleware, which should be a middleware object, a middleware class, or a
+    # middleware name.
+    # @return the base middleware.
+    attr_reader :base
+
+    # Creates a new instance of {MiddlewareWrapper} with the given middleware and registrar.
+    # @param base the middleware to wrap.
+    # @param registrar [MiddlewareRegistrar] the middleware registrar in which to search for
+    #   registered middlewares.
+    def initialize(base, registrar)
+      base = lookup_middleware(base, registrar) if base.is_a? Symbol
+      base = base.new if base.instance_of? Class
+
+      @base = base
+
+      super()
+    end
+
+    # Executes this {MiddlewareWrapper} with the given input by delegating appropriately to the
+    # base middleware.
+    # @param args [Array] the input arguments.
+    # @return [Array] the transformed output.
+    def call(*args)
+      base.call(*args)
+    end
+
+    private
+
+    # Attempts to find a middleware registered with the given name in the middleware registrar.
+    # If one could not be found, raises an appropriate error.
+    # @param name [Symbol] the name to search for.
+    # @return the found middleware.
+    def lookup_middleware(name, registrar)
+      result = registrar.find(name)
+      raise UnregisteredMiddlewareError, name if result.nil?
+
+      result
+    end
+  end
+end

data/lib/edit_in_place/registrar.rb

@@ -3,7 +3,7 @@
 module EditInPlace
   # {Registrar} is a class that is capable of storing a list of objects registered with symbol
   # names. Note that it makes no attempt to validate the objects registered. If such validation
-  # is required feel free to subclass {Registrar} and override the {validate_registration!}
+  # is required feel free to subclass {Registrar} and override the {#validate_registration!}
   # method.
   #
   # @author Jacob Lockard
@@ -17,7 +17,7 @@ module EditInPlace
     # Creates a deep copy of this {Registrar} that can be safely modified.
     # @return [Registrar] a deep copy of this registrar.
     def dup
-      r = Registrar.new
+      r = self.class.new
       r.register_all(all)
       r
     end
@@ -59,17 +59,15 @@ module EditInPlace
     # internal one and can be safely modified.
     # @return [Hash<(Symbol, Object)>] the hash of registered names and objects.
     def all
-      registrations.deep_dup
+      # Be sure to not duplicate classes.
+      registrations.transform_values { |r| r.instance_of?(Class) ? r : r.deep_dup }
     end
 
     protected
 
-    # @return [Hash<(Symbol, Object)>] A hash of registrations.
-    attr_reader :registrations
-
     # Should ensure that the given registration is valid. By default a registration is valid if
-    # its name is not already taken and is a symbol. Subclasses may override this method to add
-    # validation rules. Errors should be raised for any invalid registrations.
+    # its name is not already taken and it is a symbol. Subclasses may override this method to
+    # add validation rules. Errors should be raised for any invalid registrations.
     # @param name [Symbol] the name to validate.
     # @param _object [Object] the object to validate.
     # @return [void]
@@ -86,5 +84,11 @@ module EditInPlace
         ERR
       end
     end
+
+    private
+
+    # The hash of registrations contained in this {Registrar}.
+    # @return [Hash<(Symbol, Object)>] the hash of registrations.
+    attr_reader :registrations
   end
 end

data/lib/edit_in_place/unregistered_middleware_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module EditInPlace
+  # An error that occurs when no registered middlewares exist for the middleare name given.
+  class UnregisteredMiddlewareError < Error
+    # Creates a new instance of {UnregisteredMiddlewareError} with the given middleware name that
+    # caused the error.
+    # @param name [Symbol] the middleware that caused the error; used in the error message.
+    def initialize(name)
+      super("No middlewares are registered with the name '#{name}'")
+    end
+  end
+end

data/lib/edit_in_place/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EditInPlace
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: edit_in_place
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jacob
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-15 00:00:00.000000000 Z
+date: 2021-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '11.0'
 - !ruby/object:Gem::Dependency
-  name: rspec-rails
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -81,42 +81,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.17'
 - !ruby/object:Gem::Dependency
-  name: middlegem
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 6.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 6.1.3
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: middlegem
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 6.1.3
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.3.2
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 6.1.3
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.3.2
-description: 'edit_in_place is a Ruby on Rails plugin that allows the creation of
-  user interfaces that allow the user to edit content in an intuitive, natural, "in
-  place" way.
+        version: 0.2.0
+description: 'edit_in_place is a gem that allows the creation of user interfaces that
+  allow the user to edit content in an intuitive, natural, "in place" way.
 
   '
 email:
@@ -129,18 +122,22 @@ files:
 - README.md
 - Rakefile
 - lib/edit_in_place.rb
+- lib/edit_in_place/array_definition.rb
 - lib/edit_in_place/builder.rb
 - lib/edit_in_place/configuration.rb
 - lib/edit_in_place/duplicate_registration_error.rb
+- lib/edit_in_place/error.rb
 - lib/edit_in_place/extended_builder.rb
 - lib/edit_in_place/field_options.rb
 - lib/edit_in_place/field_type.rb
 - lib/edit_in_place/field_type_registrar.rb
 - lib/edit_in_place/invalid_field_type_error.rb
 - lib/edit_in_place/invalid_registration_name_error.rb
-- lib/edit_in_place/railtie.rb
+- lib/edit_in_place/middleware_registrar.rb
+- lib/edit_in_place/middleware_wrapper.rb
 - lib/edit_in_place/registrar.rb
 - lib/edit_in_place/unregistered_field_type_error.rb
+- lib/edit_in_place/unregistered_middleware_error.rb
 - lib/edit_in_place/unsupported_mode_error.rb
 - lib/edit_in_place/version.rb
 - lib/tasks/edit_in_place_tasks.rake
@@ -166,5 +163,5 @@ requirements: []
 rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
-summary: A Rails plugin that facilitates the creation of intuitive editable content.
+summary: A gem that facilitates the creation of intuitive editable content.
 test_files: []

data/lib/edit_in_place/railtie.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module EditInPlace
-  class Railtie < ::Rails::Railtie
-  end
-end