muffin 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f444194037bfb0ce4da565e15de9365aba611a72
+  data.tar.gz: 58ab1e839e36c8070e4f4cb24bc4af5ddbc87b25
+SHA512:
+  metadata.gz: f4899b5cf39c11bf4c64561bec040877e71aa43d6a443d8fbe0eae6a1de87aa51d3c3a47df6f549793ea9be76e4ad2bf2fb7ade4d61c235daaa470ef27abd047
+  data.tar.gz: 820ec3cb4faf5e037fa565feceb28c83d3fc102de599cd2de0bf831363ef78fd6ca2b2bbeb20d5789932df5c7eee5e09cb28d59e26616766e0a717c9e6f72b26

data/.editorconfig

@@ -0,0 +1,12 @@
+; EditorConfig is awesome: http://EditorConfig.org
+
+; top-most EditorConfig file
+root = true
+
+; Unix-style newlines with a newline ending every file
+[*]
+indent_style = spaces
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_size = 2

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.byebug_history
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--no-profile

data/.rubocop.yml

@@ -0,0 +1,67 @@
+AllCops:
+  TargetRubyVersion: 2.4
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+
+require:
+  - rubocop/rspec/focused
+
+Metrics:
+  Enabled: false
+
+RSpec/Focused:
+  Enabled: true
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false
+
+Style/MethodMissing:
+  Enabled: false
+
+Style/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Style/NilComparison:
+  Enabled: false
+
+Style/NumericLiterals:
+  MinDigits: 15
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/WordArray:
+  EnforcedStyle: brackets
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Style/Lambda:
+  EnforcedStyle: literal
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/WordArray:
+  Enabled: false

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at jens@nerdgeschoss.de. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,35 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in muffin.gemspec
+gemspec
+
+group :development, :test do
+  gem "activerecord"
+  gem "bundler"
+  gem "guard-rspec"
+  gem "rails"
+  gem "rake"
+  gem "rspec", "~> 3.0"
+  gem "rubocop"
+  gem "rubocop-rspec-focused"
+  gem "sqlite3"
+
+  if RUBY_ENGINE == "ruby"
+    gem "simplecov" if RUBY_VERSION >= "2.0.0"
+
+    unless ENV["CI"]
+      gem "pry"
+
+      if RUBY_VERSION < "2.0.0"
+        gem "pry-nav"
+      else
+        gem "pry-byebug"
+      end
+
+      # yard and friends
+      gem "github-markup"
+      gem "redcarpet"
+      gem "yard"
+    end
+  end
+end

data/Guardfile

@@ -0,0 +1,10 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_files)
+
+  watch(%r{^lib/muffin/(.+)\.rb$}) { |m| "spec/models/#{m[1]}_spec.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 nerdgeschoss GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,286 @@
+# Muffin
+
+## Why form objects?
+
+Form objects encapsulate logic to modify data (similar to changesets in Elixir or Mutations in GraphQL). Every non trivial form in rails usually has some custom (and conditional) validation, specific behavior (when update `x`, then remove `y`) and complex association (e.g. `accepts_nested_attributes_for`). This is usually spread all over the model leading to hard to maintain code and tons of conditional validation that is hard to understand. Also it’s not possible to have a form for many objects without having a parent object that is doing the nested_attribute dance.
+
+Forms are living in `/app/forms`. They should work independently from controllers (for unit testing) and can (but doesn’t have to!) handle `ActiveRecord` objects.
+
+## Public API
+
+```ruby
+my_form = MyForm.new(request:, params:, scope:) # scope could be the current_user
+my_form.call # 'commits' the form: it validates and calls the internal process method. returns true on success, false when validation fails. Other errors are signaled via Exceptions.
+my_form.call! # same as call, but raises a ValidationError if validation fails
+```
+
+## Attributes
+
+Attributes specify which attribute in the form can be set via a request
+
+```ruby
+class MyForm < Muffin::Base
+  attribute :name # type String is implicit
+  attribute :age, Integer # second argument defines type if present
+  attribute :accepted?, Boolean # boolean is defined for true or false, converts strings like "on" or "off" (from forms) automatically to their boolean value
+  attribute :tags, array: true # array of strings
+  attribute :tags, [String] # same as above
+end
+```
+
+Forms can contain validations
+
+```ruby
+class MyForm < Muffin::Base
+  attribute :name
+  validates :name, presence: true
+end
+```
+
+And also give a list of required attributes (useful for html validation and marking them in the UI).
+
+```ruby
+my_form.required_attributes # [:name]
+my_form.valid? # returns true/false
+my_form.errors # returns an error object
+```
+
+Attributes are automatically assigned on init:
+
+```ruby
+my_form = MyForm.new(params: { name: "Superman" }) # assigns the name attribute
+my_form.attributes # { name: "Superman" }
+```
+
+## Performing Changes
+
+When `call` is invoked, the form performs validation steps. If those steps are successful, `perform` is called. `perform` is invoked inside of a transaction.
+
+```ruby
+class MyForm < Muffin::Base
+  attribute :name
+
+  def perform
+    Model.find(5).update! name: name
+  end
+end
+```
+
+The form does not make any assumptions about what perform does except for needing all validations to be successful.
+
+## Nesting forms
+
+Attributes can be nested (this replaces `accepts_nested_attributes_for` and is compatible with its helpers, e.g. in forms).
+
+```ruby
+class WishlistForm < Muffin::Base
+  attribute :children_name
+  attribute :wishes do
+    attribute :name
+    validates :name, presence: true
+  end
+end
+
+WishlistForm.new(params: { children_name: "Klaus", wishes: [{ name: "some cookies}])
+```
+
+## Manually assigning parameters
+
+Sometimes it's necessary to manually assign attributes after initialization. In this case `assign_attributes` can be overriden (a call to super is optional and will invoke the normal behaviour).
+
+```ruby
+class MyForm < Form
+  attribute :name
+
+  def assign_attributes
+    self.name = params[:name].downcase
+  end
+end
+
+MyForm.new(params: { name: "Klaus" }).name # "klaus"
+```
+
+## Creating / updating active record objects
+
+In the most simple case of a form mapping 1:1 to an active record object, the form object should be as simple as possible:
+
+```ruby
+class Object < ActiveRecord::Base
+  # has a :name
+end
+
+class ObjectUpdateForm < Muffin::Base
+  attribute :id
+  attribute :name
+
+  validates :name, presence: true
+
+  def model
+    @model ||= Object.find(params[:id])
+  end
+
+  private
+
+  def assign_attributes
+    self.name = model.name
+    super # assigns the params hash
+  end
+
+  def perform
+    model.update!(attributes.slice(:name))
+  end
+end
+
+Post.first.name # "My Post" from Post 1
+form = ObjectUpdateForm.new(params: { id: 1, name: "Updated Post" })
+form.call
+Post.first.name # "Updated Post"
+```
+
+## Updating nested active record objects
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :comments
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :user
+end
+
+class MyForm < Muffin::Base
+  attribute :id, Integer
+  attribute :comments do
+    attribute :id, Integer
+    attribute :_destroy, Boolean
+    attribute :text
+  end
+
+  def user
+    @user ||= User.find(params[:id])
+  end
+
+  def assign_attributes
+    self.attributes = user.attributes.merge(comments: user.comments.map(&:attributes))
+    super
+  end
+
+  def perform
+    update_nested! user.comments, comments
+  end
+end
+```
+
+`update_nested` will create new comments, update existing comments and destroy comments where `_destroy` is true. If no `:id` is present, it will create a new object always. If you don’t want to allow deleting, don’t add a `:_destroy` attribute.
+
+## Integrating with policies
+
+Policies are integrated with form objects.
+
+```ruby
+class MyForm < Muffin::Base
+  attribute :name
+  permitted? { scope.admin? }
+end
+
+form = MyForm.new(params: { name: "Klaus"}, scope: normal_user)
+form.permitted? # false
+form.call # raises NotPermitted
+```
+
+You can also permit single attributes depending on the user (which works as a replacement for strong attributes):
+
+```ruby
+class MyForm < Muffin::Base
+  attribute :name, permit: -> { scope.admin? }
+end
+
+form = MyForm.new(params: { name: "Klaus"}, scope: normal_user)
+form.name # nil
+form.permitted? # true
+form.attributes # { }, will not include non permitted attributes
+form.attribute_permitted?(:name) # false
+```
+
+If permission should happen depending on the actual value of an attribute, this is possible, too.
+
+```ruby
+class MyForm < Muffin::Base
+  attribute :role, permitted_values: -> { scope.admin? ? ["user", "admin"] : ["user"] }
+end
+
+form = MyForm.new(params: { role: "admin"}, scope: normal_user)
+# will raise NotPermitted
+form = MyForm.new(params: { role: "user"}, scope: normal_user)
+form.attribute_permitted?(:role) # true
+form.attribute_value_permitted?(:role, "admin") # false
+form.permitted_values(:role) # ["user"]
+```
+## Integration with controllers
+
+A form object should be easy to create from a controller with a special helper (inspired by Trailblazer).
+
+```ruby
+def create
+  @form = prepare MyForm
+  if @form.call
+    redirect_to @form.model
+  else
+    render :new
+  end
+end
+```
+
+This will instantiate a form object, hand over the params and the context (e.g. the currently logged in user or auth scope) and performs depending on the method, which is roughly equivalent to
+
+```ruby
+def prepare(klass)
+  scope = try(:form_auth_scope) || try(:current_user)
+  processed_params = params[klass.model_name.underscore].permit!.to_h.map {...} # extract params from hash and clean up keys, e.g. comments_attributes -> comments
+  klass.new params: processed_params, request: request, scope: scope
+end
+```
+
+## Integration with Views
+
+Form objects work with Rails' form helpers automatically.
+
+```ruby
+class SurveyForm < Form
+  attribute :email
+  attribute :answers do
+    attribute :question_id, Integer
+    attribute :answer
+
+    validates :answer, presence: true
+  end
+
+  validates :email, presence: true
+end
+
+def new
+  @survey = prepare SurveyForm
+end
+
+
+= form_for @survey do |f|
+  = f.email_field :email
+  = f.fields_for :answers do |ff|
+    = ff.hidden_field :question_id
+    = ff.text_field :answer
+  = f.submit
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nerdgeschoss/muffin. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "muffin"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/circle.yml

@@ -0,0 +1,24 @@
+version: 2
+executorType: docker
+containerInfo:
+  - image: ruby:2.3.3
+stages:
+  build:
+    working_directory: /root/muffin
+    steps:
+      - type: checkout
+      - type: cache-restore
+        key: gemfile-{{ checksum "muffin.gemspec" }}
+      - type: shell
+        name: Install Ruby Dependencies
+        command: bundle check --path=vendor/bundle || bundle install --path=vendor/bundle --jobs=4 --retry=3
+      - type: cache-save
+        key: gemfile-{{ checksum "muffin.gemspec" }}
+        paths:
+          - vendor/bundle
+      - type: shell
+        name: Run Tests
+        command: bundle exec rspec --format documentation
+      - type: shell
+        name: Lint Code
+        command: bundle exec rubocop

data/lib/muffin.rb

@@ -0,0 +1,8 @@
+require "active_support"
+require "active_support/core_ext"
+require "muffin/version"
+
+module Muffin
+  require_relative "./muffin/base"
+  require_relative "./muffin/rails/controller_additions"
+end

data/lib/muffin/attribute.rb

@@ -0,0 +1,49 @@
+module Muffin
+  class Attribute
+    def initialize(name:, type:, array:, default:, permit:, permitted_values:, block:)
+      array = true if array == nil && (type&.is_a?(Array) || block)
+      array ||= false
+      type = type.first if type&.is_a? Array
+      @name = name
+      @type = type
+      @array = array
+      @default = default
+      @permit = permit
+      @permitted_values = permitted_values
+    end
+
+    attr_reader :name, :type, :default, :permit, :permitted_values
+
+    def array?
+      @array
+    end
+
+    def coercise(value)
+      convert value
+    end
+
+    private
+
+    def convert(value, access_array: false)
+      return convert(default) if value == nil && default
+      return (value || []).map { |e| convert(e, access_array: true) } if array? && !access_array
+      if type <= Integer
+        value&.to_i
+      elsif type <= Float
+        value&.to_f
+      elsif type <= String
+        value&.to_s
+      elsif type <= Symbol
+        value.class <= Integer ? value.to_s.to_sym : value&.to_sym
+      elsif type <= BigDecimal
+        type.new(value) if value.present?
+      elsif type <= Hash
+        type.new.merge!(value&.to_h&.deep_dup) if value.present?
+      elsif type <= Muffin::Boolean
+        type.new(value).to_bool
+      else
+        type.new(value || {})
+      end
+    end
+  end
+end

data/lib/muffin/base.rb

@@ -0,0 +1,29 @@
+require_relative "frostings/attributes"
+require_relative "frostings/validation"
+require_relative "frostings/execution"
+require_relative "frostings/policy"
+require_relative "frostings/sync"
+
+module Muffin
+  class Base
+    include ActiveModel::Conversion
+    include ActiveModel::Naming
+    include Attributes
+    include Validation
+    include Execution
+    include Policy
+    include Sync
+
+    attr_reader :request, :params, :scope
+
+    validates_with Muffin::Validation::NestedAttributesValidator
+
+    def initialize(request: nil, params: nil, scope: nil)
+      @request = request
+      @params = params || {}
+      @scope = scope
+
+      assign_attributes
+    end
+  end
+end

data/lib/muffin/boolean.rb

@@ -0,0 +1,20 @@
+module Muffin
+  class Boolean
+    def initialize(value)
+      @value = value
+    end
+
+    attr_reader :value
+
+    def to_bool
+      case value
+      when nil
+        nil
+      when "0", "false"
+        false
+      else
+        !!value
+      end
+    end
+  end
+end

data/lib/muffin/error.rb

@@ -0,0 +1,4 @@
+module Muffin
+  class NotPermittedError < StandardError
+  end
+end

data/lib/muffin/frostings/attributes.rb

@@ -0,0 +1,81 @@
+require_relative "../attribute"
+require_relative "../boolean"
+require_relative "policy"
+require_relative "validation"
+
+module Muffin
+  module Attributes
+    module ClassMethods
+      def attribute(name, type = String, default: nil, array: nil, permit: nil, permitted_values: nil, &block)
+        type = define_class name, block if block
+        attributes[name] = Muffin::Attribute.new name: name, type: type, default: default, array: array, permit: permit, permitted_values: permitted_values, block: block
+        define_method name do
+          attributes && attributes[name]
+        end
+        define_method "#{name}=" do |value|
+          @attributes ||= {}
+          value = self.class.attributes[name].coercise(value)
+          attributes[name] = value if permit_attribute!(name, value)
+        end
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def introspect(name)
+        attributes[name]
+      end
+
+      private
+
+      def define_class(name, block)
+        class_name = name.to_s.split("_").map(&:capitalize).join
+        return const_get class_name if const_defined? class_name
+        klass = const_set class_name, Class.new(Muffin::NestedAttribute)
+        klass.instance_eval(&block)
+        klass
+      end
+    end
+
+    attr_reader :attributes
+
+    def attributes=(value)
+      self.class.attributes.keys.map { |e| [e, nil] }.to_h.merge(value.to_h).each do |k, v|
+        send("#{k}=", v) if self.class.attributes[k.to_sym]
+      end
+    end
+
+    def assign_attributes
+      self.attributes = params
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def persisted?
+      attributes[:id].present?
+    end
+
+    # fields_for checks wether an object responds to [foo_attributes=]
+    def respond_to_missing?(method_name, include_private = false)
+      return true if method_name.to_s[/_attributes=\Z/]
+      super
+    end
+
+    Boolean = Muffin::Boolean.freeze
+  end
+
+  class NestedAttribute
+    include Attributes
+    include Policy
+    include Validation
+
+    validates_with Muffin::Validation::NestedAttributesValidator
+
+    def initialize(attributes)
+      self.attributes = attributes
+    end
+  end
+end

data/lib/muffin/frostings/execution.rb

@@ -0,0 +1,15 @@
+module Muffin
+  module Execution
+    def call
+      return false unless valid?
+      permit!
+      perform if respond_to? :perform
+    end
+
+    def call!
+      validate!
+      permit!
+      perform if respond_to? :perform
+    end
+  end
+end

data/lib/muffin/frostings/policy.rb

@@ -0,0 +1,52 @@
+require_relative "../error"
+
+module Muffin
+  module Policy
+    module ClassMethods
+      attr_reader :permission_block
+
+      def permitted?(&block)
+        @permission_block = block
+      end
+    end
+
+    def permit!
+      raise NotPermittedError unless permitted?
+    end
+
+    def permitted?
+      return true unless self.class.permission_block
+      instance_eval(&self.class.permission_block)
+    end
+
+    def attribute_permitted?(name)
+      block = self.class.attributes[name]&.permit
+      return instance_exec(&block) if block
+      true
+    end
+
+    def permit_attribute!(name, value)
+      return false unless attribute_permitted?(name)
+      permitted = attribute_value_permitted?(name, value)
+      return false if value == nil && !permitted
+      raise NotPermittedError unless permitted
+      true
+    end
+
+    def permitted_values(name)
+      block = self.class.attributes[name]&.permitted_values
+      return instance_exec(&block) if block
+      nil
+    end
+
+    def attribute_value_permitted?(name, value)
+      block = self.class.attributes[name]&.permitted_values
+      return true unless block
+      instance_exec(&block).include? value
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/muffin/frostings/sync.rb

@@ -0,0 +1,47 @@
+module Muffin
+  module Sync
+    private
+
+    def update_nested!(relation, entities = [self])
+      entities = Array.wrap(entities)
+
+      # load all (available) records upfront to avoid fetching them one by one in the loop
+      records = (relation.is_a?(ActiveRecord::Base) ? relation.class : relation)
+        .where(id: entities.map(&:id).compact)
+        .each_with_object({}) { |record, hash| hash[record.id] = record }
+
+      entities.each do |entity|
+        association_attributes = {}
+        model_attributes = {}
+        record = nil
+
+        entity.attributes.except(:_destroy).each do |k, v|
+          if Array.wrap(v).any? { |e| e.is_a?(Muffin::NestedAttribute) }
+            association_attributes[k] = v
+          else
+            model_attributes[k] = v
+          end
+        end
+
+        if entity.try(:id).presence
+          record = records[entity.id]
+
+          if entity.try(:_destroy).presence
+            record.destroy
+          else
+            record.assign_attributes(model_attributes)
+            record.save! if record.changed?
+          end
+        else
+          record = relation.create!(model_attributes)
+        end
+
+        association_attributes.each do |k, v|
+          update_nested!(record.send(k), v)
+        end
+      end
+
+      relation.reload # avoid caching effects like "stale" attributes after updates
+    end
+  end
+end

data/lib/muffin/frostings/validation.rb

@@ -0,0 +1,29 @@
+require "active_model"
+
+module Muffin
+  module Validation
+    class NestedAttributesValidator < ActiveModel::Validator
+      def validate(entity)
+        entity.attributes.try(:each) do |k, v|
+          Array.wrap(v).each do |e|
+            if e.is_a?(Muffin::NestedAttribute)
+              e.validate
+              entity.errors[k] << :nested_validation_failed if e.errors.present?
+            end
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      base.include ActiveModel::Validations
+    end
+
+    def required_attributes
+      @required_attributes ||= self.class.validators
+        .select { |e| e.is_a? ActiveModel::Validations::PresenceValidator }
+        .flat_map(&:attributes)
+        .uniq
+    end
+  end
+end

data/lib/muffin/rails/controller_additions.rb

@@ -0,0 +1,29 @@
+module Muffin
+  module Rails
+    SCOPE_ACCESSOR = :operation_auth_scope
+
+    module ControllerAdditions
+      def prepare(operation, params: nil, request: nil, scope: nil)
+        if params.blank? && respond_to?(:params) && operation.respond_to?(:model_name)
+          if self.params.key?(operation.model_name.underscore)
+            params = self.params[operation.model_name.underscore].deep_dup.permit!.to_h
+            params.deep_transform_keys! do |key|
+              if key.to_s[/.+_attributes\Z/]
+                new_key = key.to_s.sub(/_attributes\Z/, "")
+                key.is_a?(Symbol) ? new_key.to_sym : new_key
+              else
+                key
+              end
+            end
+          end
+        end
+
+        request ||= try(:request)
+
+        scope ||= try(Muffin::Rails::SCOPE_ACCESSOR) || try(:current_user)
+
+        operation.new(params: params, request: request, scope: scope)
+      end
+    end
+  end
+end

data/lib/muffin/version.rb

@@ -0,0 +1,3 @@
+module Muffin
+  VERSION = "0.2.0".freeze
+end

data/muffin.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "muffin/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "muffin"
+  spec.version       = Muffin::VERSION
+  spec.authors       = ["Jens Ravens", "Michael Sievers"]
+  spec.email         = ["jens@nerdgeschoss.de", "michael@nerdgeschoss.de"]
+
+  spec.summary       = "Simple operations with optional icing on top."
+  spec.homepage      = "https://github.com/nerdgeschoss/muffin"
+  spec.license       = "MIT"
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activemodel"
+  spec.add_dependency "activesupport"
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: muffin
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Jens Ravens
+- Michael Sievers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- jens@nerdgeschoss.de
+- michael@nerdgeschoss.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- circle.yml
+- lib/muffin.rb
+- lib/muffin/attribute.rb
+- lib/muffin/base.rb
+- lib/muffin/boolean.rb
+- lib/muffin/error.rb
+- lib/muffin/frostings/attributes.rb
+- lib/muffin/frostings/execution.rb
+- lib/muffin/frostings/policy.rb
+- lib/muffin/frostings/sync.rb
+- lib/muffin/frostings/validation.rb
+- lib/muffin/rails/controller_additions.rb
+- lib/muffin/version.rb
+- muffin.gemspec
+homepage: https://github.com/nerdgeschoss/muffin
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Simple operations with optional icing on top.
+test_files: []