on_form 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 820b56db21bed598a2c4c4fbef8aa5c33cabc693
-  data.tar.gz: 7cd239b39707c8fefa12ba3acec8c2cbe3d733b4
+  metadata.gz: febeec1d904aefce31f0499e1a0259caff00003c
+  data.tar.gz: 0fa55ca7d0f8692479ae9ee574a1e2f03f2ed42c
 SHA512:
-  metadata.gz: 897e50e32ef49cf93fea57d5487c750b8c3ed8e65d8610dce0ffb657f6171697b329bfc7125175883223e529bb857442fc5381d34c4ad08f8568721d0194ad5d
-  data.tar.gz: eefe006c8c937acad840b960076233592eed058c4265ca5aaa8e86aa0176a047c4b57d3b962b9aa0d9368431d687a1fbec8a67a322afce90cd273f44787b23e9
+  metadata.gz: c3a32337ff68ecc0037ab9fb431b279f6897fda0f2a82c90a657add23ca0eeac43c1ce1bf517e2768fa2caa471399551fa32b5a25cc4478912632011ea679dcc
+  data.tar.gz: bb78f1d4a027fee037958b23e232c9c381efa7c9d426018e9b6723e7060a1042c2d14b0876302c75e555226c236e795a2bc49dac33709f45136b78b12dc0b90a

data/README.md

@@ -134,7 +134,7 @@ You can also define your own method over the top of the `attr_reader`.  Just rem
 
 By default the attribute names exposed on the form object are the same as the attributes on the backing models.  Sometimes this leads to unclear meanings, and sometimes you'll have duplicate attribute names in a multi-model form.
 
-To address this you can use the `prefix` and/or `suffix` options to `expose`.
+To address this you can use the `prefix` and/or `suffix` options to `expose`, or if you need to change the name completely, the `as` option.
 
 ```ruby
 class AccountHolderForm < OnForm::Form
@@ -205,6 +205,65 @@ Note that model save calls are nested inside the form save calls, which means th
     form around_save ends
     form after_save
 
+### Adding artifical attributes
+
+In addition to mapping attributes between models and the form, you can introduce new attributes which are not directly persisted anywhere.  You can use any of the "standard" (non-database-specific) ActiveRecord types, and you can add `default`, `scale`, and `precision` options.
+
+```ruby
+class ChangeEmailForm < OnForm::Form
+  expose %i(email), on: :customer, as: :new_email
+  attribute :email_confirmation, :string, :default => "(please confirm)"
+
+  validate :email_confirmation_matches
+
+  def initialize(customer)
+    @customer = customer
+  end
+
+  def email_confirmation_matches
+    errors[:email_confirmation] << "does not match" unless email_confirmation == new_email
+  end
+end
+```
+
+### Model-less forms
+
+Taking this one step further, you can define forms which have _no_ exposed model attributes.  *Be aware that forms that expose no models do not automatically start a database transaction, because they don't know which database connection to use.*
+
+To actually perform a data change in response to the form submission, you can add a `before_save` or `after_save` callback and from there call your existing model code or service objects.  It's best to keep the code in the form object to just the bits specific to the form - try not to put your business logic in your form objects!
+
+```ruby
+class ChangePasswordForm < OnForm::Form
+  attribute :current_password, :string
+  attribute :password, :string
+  attribute :password_confirmation, :string
+
+  validate :current_password_correct
+  validate :password_confirmation_matches
+  before_save :set_new_password
+
+  def initialize(customer)
+    @customer = customer
+  end
+
+  def current_password_correct
+    unless @customer.password_correct?(current_password)
+      errors[:current_password] << "is incorrect"
+    end
+  end
+
+  def password_confirmation_matches
+    unless password_confirmation == password
+      errors[:password_confirmation] << "doesn't match"
+    end
+  end
+
+  def set_new_password
+    @customer.change_password!(password)
+  end
+end
+```
+
 ### Reusing and extending forms
 
 You can descend form classes from other form classes and expose additional models or additional attributes on existing models.
@@ -267,8 +326,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/powers
 
 ## Roadmap
 
-* Currently, the author is looking into support for declaring attributes on the form.  (You can use plain old Ruby object `attr_accessor` for untyped attributes in the meantime.)
-* After that we'll need to tackle the other use cases for ActiveRecord nested attributes, such as one-to-many associations and auto-building/deleting associated records.
+* The author is currently assessing other use cases for ActiveRecord nested attributes, such as one-to-many associations and auto-building/deleting associated records.  Feedback welcome.
 
 ## License
 

data/lib/on_form.rb

@@ -5,4 +5,5 @@ require "on_form/rails_compat"
 require "on_form/attributes"
 require "on_form/errors"
 require "on_form/saving"
+require "on_form/types"
 require "on_form/form"

data/lib/on_form/attributes.rb

@@ -20,7 +20,8 @@ module OnForm
     end
 
     def attribute_names
-      self.class.exposed_attributes.values.flat_map(&:keys).collect(&:to_s)
+      self.class.exposed_attributes.values.flat_map(&:keys).collect(&:to_s) +
+        self.class.introduced_attribute_types.keys.collect(&:to_s)
     end
 
     def attributes

data/lib/on_form/form.rb

@@ -12,9 +12,14 @@ module OnForm
       @exposed_attributes ||= Hash.new { |h, k| h[k] = {} }
     end
 
+    def self.introduced_attribute_types
+      @introduced_attribute_types ||= {}
+    end
+
     class << self
       def inherited(child)
         exposed_attributes.each { |k, v| child.exposed_attributes[k].merge!(v) }
+        child.introduced_attribute_types.merge!(introduced_attribute_types)
       end
     end
 
@@ -44,5 +49,24 @@ module OnForm
       define_method("#{exposed_name}_was")              { backing_model_instance(backing_model_name).send("#{backing_name}_was") }
       define_method("#{exposed_name}=")                 { |arg| backing_model_instance(backing_model_name).send("#{backing_name}=", arg) }
     end
+
+    def self.attribute(name, type, options = {})
+      name = name.to_sym
+      introduced_attribute_types[name] = Types.lookup(type, options)
+      define_method(name)                       { introduced_attribute_values.fetch(name) { type = self.class.introduced_attribute_types[name]; type.cast(introduced_attribute_values_before_type_cast.fetch(name) { type.default }) } }
+      define_method("#{name}_before_type_cast") { introduced_attribute_values_before_type_cast[name] }
+      define_method("#{name}_changed?")         { send(name) != send("#{name}_was") }
+      define_method("#{name}_was")              { type = self.class.introduced_attribute_types[name]; type.cast(type.default) }
+      define_method("#{name}=")                 { |arg| introduced_attribute_values.delete(name); introduced_attribute_values_before_type_cast[name] = arg }
+    end
+
+  protected
+    def introduced_attribute_values
+      @introduced_attribute_values ||= {}
+    end
+
+    def introduced_attribute_values_before_type_cast
+      @introduced_attribute_values_before_type_cast ||= {}
+    end
   end
 end

data/lib/on_form/types.rb

@@ -0,0 +1,52 @@
+module OnForm
+  module Types
+    class Type
+      attr_reader :default
+
+      def initialize(type, default)
+        @type = type
+        @default = default
+      end
+    end
+
+    if ActiveRecord::Type.methods.include?(:lookup)
+      def self.lookup(type, options)
+        default = options.delete(:default)
+        Type.new(ActiveRecord::Type.lookup(type, options), default)
+      end
+
+      class Type
+        def cast(arg)
+          @type.cast(arg)
+        end
+      end
+    else
+      # for rails 4.2 and below, the type map lives on individual database adapters, but we may
+      # not have any models, so here we fall back to the map defined by the abstract adapter class.
+      def self.lookup(type, options)
+        default = options.delete(:default)
+        if precision = options.delete(:precision)
+          if scale = options.delete(:scale)
+            type = "#{type}(#{precision},#{scale})"
+          else
+            type = "#{type}(#{precision})"
+          end
+        elsif options[:scale]
+          raise ArgumentError, "Can't apply scale without precision on Rails 4.2.  The precision is used when converting Float values."
+        end
+        raise ArgumentError, "Unknown type option: #{options}" unless options.empty?
+        Type.new(_adapter.type_map.lookup(type), default)
+      end
+
+      def self._adapter
+        @_adapter ||= ActiveRecord::ConnectionAdapters::AbstractAdapter.new(nil)
+      end
+
+      class Type
+        def cast(arg)
+          @type.type_cast_from_user(arg)
+        end
+      end
+    end
+  end
+end

data/lib/on_form/version.rb

@@ -1,3 +1,3 @@
 module OnForm
-  VERSION = "2.0.1"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: on_form
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Will Bryant
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-27 00:00:00.000000000 Z
+date: 2016-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -102,6 +102,7 @@ files:
 - lib/on_form/form.rb
 - lib/on_form/rails_compat.rb
 - lib/on_form/saving.rb
+- lib/on_form/types.rb
 - lib/on_form/version.rb
 - on_form.gemspec
 homepage: https://github.com/powershop/on_form