serious_business 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '02748be03ce33b0d73d118a6182ad52120cf8be9'
+  data.tar.gz: a0af8e6f7633262856ba169dd2bccc335073945e
+SHA512:
+  metadata.gz: f3b317bd1cc78843df8f10b1405af12e311d033d3d0d8cb6805c044141dcf75b6970f83ef270dc35b02e47e81ee1b211b25dd82286a56a97d5f2ec6cbc38107b
+  data.tar.gz: 50f0e42a28a2690eab2c8fdd59b31ece8a82be2e568edb803920c68715caed8bf19e5aa3103acd3fca822a48eacbf9df3fa77ddb6d4ac47254ff94abb556bc38

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Axel Tetzlaff
+
+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,179 @@
+# SeriousBusiness: Best application pratices in a handsome DSL
+
+A small library helping app developers to comply with basic usability and security pattern.
+By encapsulating business actions in separate classes good pratices are enforced and controllers and models are less likely to turn into [God objects](https://en.wikipedia.org/wiki/God_object)
+
+Using it you will get:
+
+  * a declarative DSL to specify authorization
+  * a simple way to check permissions object based in views
+  * a guided mechanism to a concise user experience
+  * a simpler way to test logic that before went into controllers
+  * transactional business actions per default
+  * automagic tracking on which users and actions affecting you models
+
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'serious_business'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install serious_business
+```
+## Usage
+
+The gem uses polymorphic associations to track the actions you specify. For that it creates some tables and a initializer you may need to modify:
+
+    rails g serious_business:install
+
+The gem expects one model class to act as *actor* for your actions. The default for this is `User`.
+
+You will need to make the following changes to you model class to be aware of the actions:
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  include SeriousBusiness::Actor
+end
+
+# this is needed for hot code replacement in dev mode to work
+# assuming you put your actions in app/models/actions
+Dir[Rails.root.join('app','models', 'actions', '*.rb')].each {|file| require_dependency file }
+```
+
+To create a 'business action' you inherit from `SeriousBusiness::Action`
+```ruby
+# app/models/actions/update_user.rb
+module Actions
+  class UpdateUser < SeriousBusiness::Action
+    # this action needs to be initialized with a user that should be updated
+    needs :user
+
+    # this actions reads the email from a hash most likely set from params
+    att :email, presence: true
+
+
+    # this action should be able to change only the user
+    # that is executing the action
+    forbid_if :not_self { |action| action.actor != action.user }
+
+    # unless it's an admin - they are allowed to do everything, right?
+    allow_if {|action| action.actor.admin? }
+
+
+    # implement this method to specify the actual logic of the action.
+    # return an array of all objects that are logically affected by the 
+    # change (the actor is persisted automatically)
+    def execute
+      user.update_attributes(email: form_model.email)
+      [user]
+    end
+  end
+end
+
+```
+
+By creating action classes you actor class (the class you included `SeriousBusiness::Actor` in) gets a method for every action.
+For the above example that means you can now call:
+
+    action = user.update_user
+
+Since we declared that this action applies to another user we can pass other user like this:
+
+```ruby
+other_user = User.find(params[:user_id])
+action = user.update_user.for_user(other_user)
+```
+
+Since we now specified everything thats 'needed' for the action, we can ask if the action can be executed. And since we created it from an user as actor it can anwser itself:
+
+
+```ruby
+action.can? # will return if user.admin? or user == other_user
+```
+And since it's an action that takes further data probably generated from a form submit we have to pass that in to actually execute the action
+
+
+```ruby
+action = user.update_user.for_user(other_user).with_params(email: 'foo@example.org')
+
+# Note the exclamation mark at the end of 'execute!'
+action.execute! # true if the action was executed successfully
+                # this is transactional - no changes are made to the db
+                # if anything prevents the action from succeeding (ie.
+                # failing guards/permissions or validations)
+```
+Actions themselves are fully fleged ActiveRecord Models that are persisted when successfully executed. With them references to the affected models you return from you implementation of the `execute` are stored.
+
+To access the list of actions that affected an object you have to include the include `SeriousBusiness::AffectedByActions` concern. Since in this model we modify the User:
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  include SeriousBusiness::Actor
+  include SeriousBusiness::AffectedByActions
+end
+``` 
+
+Afterwards you can retrieve all actions that affected this model.
+
+```ruby
+  actions = user.modifiers # [SeriousBusiness::Action]
+  actions.last.actor       # The User that executed the action
+  actions.last.description # A textual description of the action
+``` 
+
+SeriousBusiness encurages to maintain human consumable descriptions for a better
+user experience
+
+To start create the following structure in your i18n yaml file:
+
+```
+  serious_action:
+    description_with_failed_guards: '%{description} not possible because %{reasons}'
+    failed_guard_join_with: ' and '
+    update_user
+      description: Updating user data
+      cta: update
+      guards:
+        not_self: you are not this user 
+```
+
+This enables you to generate descriptive labels for those actions independent of their location of use:
+
+```
+    action = user.update_user.for_user(other_user)
+    action.cta_label # 'update' - ie for buttons
+
+    action.description # 'Updating the user' - i.e. for history
+
+    # the description is extended automatically if the action can not be executed
+    action.description # 'Updating the user not possible because you are not this user'
+```
+
+The latter is especially useful to give the user meaningful feedback to an unavailble action:
+
+```
+  <% if update_action.can? %>
+    <%= link_to 'Edit', edit_account_path(account) %>
+  <% else %>
+    <span title= "<%= update_action.description %>" >Edit</span>
+  <% end %>
+```
+
+
+## Contributing
+
+Pull-requests are welcome - with tests loved!
+
+## 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,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SeriousBusiness'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/config/serious_business_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/serious_business .js
+//= link_directory ../stylesheets/serious_business .css

data/app/assets/javascripts/serious_business/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/serious_business/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/serious_business/application_controller.rb

@@ -0,0 +1,5 @@
+module SeriousBusiness
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+  end
+end

data/app/helpers/serious_business/application_helper.rb

@@ -0,0 +1,12 @@
+module SeriousBusiness
+  module ApplicationHelper
+    def form_for_action action, path, custom_opts = {}, &blk
+      options = {
+        as: action.form_model.to_param,
+        url: path,
+        method: :post
+      }
+      form_for action.form_model, options.merge(custom_opts), &blk
+    end
+  end
+end

data/app/jobs/serious_business/application_job.rb

@@ -0,0 +1,4 @@
+module SeriousBusiness
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/serious_business/application_mailer.rb

@@ -0,0 +1,6 @@
+module SeriousBusiness
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/concerns/serious_business/actor.rb

@@ -0,0 +1,4 @@
+module SeriousBusiness::Actor
+ # this module will be dynamically filled with action methods
+ # depending on your declarations
+end

data/app/models/serious_business/action.rb

@@ -0,0 +1,249 @@
+module SeriousBusiness
+  class Action < ApplicationRecord
+    self.table_name= 'serious_actions'
+    belongs_to :actor, class_name: SeriousBusiness.actor_class_name
+    has_many :affecteds, foreign_key: :serious_action_id
+    has_many :affectables, through: :affecteds, source: :affected
+    attr_accessor :transient_affected_models
+
+    def self.att(name, options = {})
+      name = name.to_sym
+      self.form_model_class.send(:attr_accessor, name)
+      if options.any?
+        self.form_model_class.validates name, options
+      end
+      self.needed_attributes << name
+    end
+
+    def self.required_attributes
+      @_required_attributes ||= []
+    end
+
+    class MissingModelException < StandardError
+      def initialize(model_names)
+        method_names = model_names.map{|n| "for_#{n}"}.join(', ')
+        super("You have to call the following methods before setting params #{method_names}")
+      end
+    end
+
+    def with_params(params = {})
+      if params.respond_to? :require
+        params = params
+                  .require(self.class.param_name)
+                  .permit!
+        params.to_h.slice!(*self.class.needed_attributes.map(&:to_s))
+      end
+
+      # make sure 'needed' models were set before trying to apply params
+      missing_values = self.class.required_attributes.select do |needed_name|
+        self.send(needed_name).nil?
+      end
+      raise MissingModelException.new(missing_values) if missing_values.any?
+
+      reset_form_model
+      form_model.assign_attributes(params) unless params.empty?
+      self
+    end
+
+    def self.needs(name)
+      required_attributes << name.to_sym
+      self.send(:attr_reader, name)
+      self.send(:define_method, "for_#{name}") do |needed|
+        reset_form_model
+        self.instance_variable_set("@#{name}", needed)
+        self
+      end
+    end
+
+    def self.guards
+      @_guards ||= []
+    end
+
+    IfGuard = Struct.new(:prc) do
+      def pass?(action)
+        action.actor.instance_exec(action, &prc)
+      end
+    end
+
+    UnlessGuard = Struct.new(:reason, :prc) do
+      def pass?(action)
+        !action.actor.instance_exec(action, &prc)
+      end
+    end
+
+    def self.forbid_if reason, &blk
+      guards << UnlessGuard.new(reason, blk)
+    end
+
+    def self.allow_if &blk
+      guards << IfGuard.new(blk)
+    end
+
+    def failed_guards
+      if_guards, unless_guards = self.class.guards
+                                    .partition{ |guard| guard.is_a?(IfGuard) }
+      return [] if Array.wrap(if_guards).any?{|g| g.pass?(self)}
+
+      Array.wrap(unless_guards).select{ |guard| !guard.pass?(self) }
+    end
+
+    def full_guard_messages
+      failed_guards
+        .map(&:reason)
+        .map do |reason|
+          i18n = I18n.t("serious_action.#{self.class.param_name}.guards.#{reason}")
+          if i18n.starts_with? 'translation missing:'
+            global_i18n = I18n.t("serious_action.global_guards.#{reason}")
+            i18n = global_i18n unless global_i18n.starts_with? 'translation missing:'
+          end
+          i18n
+        end.join(I18n.t('serious_action.failed_guard_join_with'))
+    end
+
+    def can?
+      failed_guards.empty?
+    end
+
+    def self.form_model_class
+      @model_class ||= begin
+                        clazz = Class.new(BaseFormModel)
+                        self.const_set(:FormModel, clazz)
+                        clazz
+                       end
+    end
+
+    def self.needed_attributes
+      @_attribs ||= []
+    end
+
+    def self.param_name
+      name.demodulize.underscore
+    end
+
+    def self.build(actor_id: , for_model: [], params: {} )
+      action = self.new(actor_id: actor_id)
+      if params.respond_to? :require
+        params = params
+                  .require(param_name)
+                  .permit self.needed_attributes
+      end
+      action
+    end
+
+    def init_from_needed
+      {}
+    end
+
+    def all_attributes_from(other_model)
+      other_model.attributes.slice(*self.class.needed_attributes.map(&:to_s))
+    end
+
+    def form_model(params={})
+      @_form_model ||= begin
+                         attributes = init_from_needed.merge(params)
+                         model_instance = self.class.form_model_class.new
+                         model_instance.instance_variable_set(:@_action, self)
+                         model_instance.assign_attributes(attributes)
+                         model_instance
+                       end
+    end
+
+    def params
+      form_model
+    end
+
+    def actor_class
+      @_actor_class ||= begin
+                          raise "No actor_class specified! #TODO link to config" unless SeriousBusinessConfig.actor_class_name.present?
+                          Kernel.const_get(SeriousBusinessConfig.actor_class_name)
+                        end
+    end
+
+    def self.inherited(child_class)
+      super
+
+      method_name = child_class.name.demodulize.underscore
+      actor_class = Kernel.const_get SeriousBusiness.actor_class_name
+
+      if actor_class.respond_to? method_name
+        raise "Action with the same name already registered #{child_class.name}"
+      end
+
+      SeriousBusiness::Actor.send(:define_method, method_name) do |params: {}, for_model: nil|
+        child_class.build(actor_id: self.id, for_model: for_model, params: params)
+      end
+    end
+
+    def cta_label
+      I18n.t("serious_action.#{self.class.param_name}.cta")
+    end
+
+    def description
+      i18n_params = self.class.required_attributes.inject({}) do |sum, attr_name|
+        sum[attr_name] = self.instance_variable_get("@#{attr_name}")
+        sum
+      end
+      content = I18n.t("serious_action.#{self.class.param_name}.description", plan: i18n_params[:plan] )
+      if persisted? || can?
+        content
+      else
+        I18n.t("serious_action.description_with_failed_guards", description: content, reasons: full_guard_messages)
+      end
+    end
+
+    def success_description
+      custom_msg = I18n.t("serious_action.#{self.class.param_name}.success_description")
+      return custom_msg unless custom_msg.starts_with? 'translation missing'
+      content = I18n.t("serious_action.#{self.class.param_name}.description")
+      I18n.t("serious_action.success_description", description: content)
+    end
+
+    def execute!
+      unless can?
+        form_model.errors.add(:base, description)
+        return false
+      end
+      self.class.transaction do
+        begin
+          if self.class.needed_attributes.any? && !form_model.valid?
+            return false
+          end
+          self.transient_affected_models = self.execute
+          self.transient_affected_models.each do |model|
+            model.errors.each do |key, error|
+              error_key = if self.class.needed_attributes.include? key
+                            key
+                          else
+                            :base
+                          end
+              form_model.errors.add error_key, error
+            end
+          end
+          if form_model.errors.any?
+            return false
+          end
+          self.save!
+          self.transient_affected_models.each do |model|
+            SeriousBusiness::Affected.create!(action: self, affected: model)
+          end
+          return true
+        rescue Exception => e
+          raise e
+        end
+      end
+    end
+
+    protected
+
+    def execute
+      raise "execute should be overwritten in subclass"
+    end
+
+    private
+
+    def reset_form_model
+      @_form_model = nil
+    end
+  end
+end
+

data/app/models/serious_business/actor.rb

@@ -0,0 +1,4 @@
+module SeriousBusiness::Actor
+
+end
+

data/app/models/serious_business/affected.rb

@@ -0,0 +1,8 @@
+# stores the relation between a model and an action affecting it
+class SeriousBusiness::Affected < ApplicationRecord
+  self.table_name = 'serious_affecteds'
+  belongs_to :action, class_name: 'SeriousBusiness::Action', foreign_key: 'serious_action_id'
+  belongs_to :affected, polymorphic: true
+end
+
+

data/app/models/serious_business/affected_by_actions.rb

@@ -0,0 +1,9 @@
+module SeriousBusiness::AffectedByActions
+  extend ActiveSupport::Concern
+
+  included do |clazz|
+    clazz.has_many :serious_affecteds, as: :affected, class_name: 'SeriousBusiness::Affected'
+    clazz.has_many :modifiers, through: :serious_affecteds, source: :action
+
+  end
+end

data/app/models/serious_business/application_record.rb

@@ -0,0 +1,5 @@
+module SeriousBusiness
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/serious_business/base_form_model.rb

@@ -0,0 +1,31 @@
+module SeriousBusiness
+  class BaseFormModel
+    include ActiveModel::AttributeAssignment
+    include ActiveModel::Validations
+
+    def take_attributes_from(model, fields = nil)
+      fields ||= @_action.class.needed_attributes.map(&:to_s)
+      self.assign_attributes(model.attributes.slice(*fields))
+    end
+
+    def persisted?
+      # is set on instantiation
+      @_action.persisted?
+    end
+
+    def to_key
+      nil
+    end
+
+    def to_param
+      @_action.class.param_name
+    end
+
+    def attributes
+      @_action.class.needed_attributes.inject({}) do |sum, attr_name|
+        sum[attr_name] = self.instance_variable_get("@#{attr_name}")
+        sum
+      end
+    end
+  end
+end

data/app/views/layouts/serious_business/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Serious business</title>
+  <%= stylesheet_link_tag    "serious_business/application", media: "all" %>
+  <%= javascript_include_tag "serious_business/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+SeriousBusiness::Engine.routes.draw do
+end

data/lib/generators/serious_business/install_generator.rb

@@ -0,0 +1,53 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module SeriousBusiness
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path('../templates', __FILE__)
+
+      class_option :use_uuid, :optional => true, :type => :string, :banner => "use_uuid",
+                   :desc => "Set to true if you're using uuid as primary key type"
+
+      # Copy the initializer file to config/initializers folder.
+      def copy_initializer_file
+        template "initializer.rb", "config/initializers/serious_business.rb"
+      end
+
+      def use_uuid
+        options.key? :use_uuid
+      end
+
+      # Copy the migrations files to db/migrate folder
+      def copy_migration_files
+        # Copy core migration file in all cases except when you pass --only-submodules.
+        return unless defined?(SeriousBusiness::Generators::InstallGenerator::ActiveRecord)
+        migration_template "migration/actions.rb", "db/migrate/create_serious_business.rb", migration_class_name: migration_class_name
+
+      end
+
+      # Define the next_migration_number method (necessary for the migration_template method to work)
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          sleep 1 # make sure each time we get a different timestamp
+          Time.new.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      private
+
+      def migration_class_name
+        if Rails::VERSION::MAJOR >= 5
+          "ActiveRecord::Migration[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        else
+          "ActiveRecord::Migration"
+        end
+      end
+
+    end
+  end
+end

data/lib/generators/serious_business/templates/initializer.rb

@@ -0,0 +1,6 @@
+require 'serious_business'
+
+SeriousBusiness.config do |config|
+  config.actor_class_name = :User
+end
+

data/lib/generators/serious_business/templates/migration/actions.rb

@@ -0,0 +1,24 @@
+class CreateSeriousBusiness < <%= migration_class_name %>
+  def change
+    create_table :serious_actions<%= ', id: :uuid' if use_uuid %> do |t|
+      t.string :type, null: false
+      <% if use_uuid %>
+      t.uuid :actor_id
+      <% else %>
+      t.integer :actor_id
+      <% end %>
+      t.timestamps null: false
+    end
+
+    create_table :serious_affecteds do |t|
+      t.references :serious_action, foreign_key: true, null: false
+      <% if use_uuid %>
+      t.uuid :affected_id, null: false
+      <% else %>
+      t.integer :affected_id, null: false
+      <% end %>
+      t.string :affected_type
+    end
+
+  end
+end

data/lib/serious_business/engine.rb

@@ -0,0 +1,5 @@
+module SeriousBusiness
+  class Engine < ::Rails::Engine
+    isolate_namespace SeriousBusiness
+  end
+end

data/lib/serious_business/version.rb

@@ -0,0 +1,3 @@
+module SeriousBusiness
+  VERSION = '0.1.0'
+end

data/lib/serious_business.rb

@@ -0,0 +1,18 @@
+require "serious_business/engine"
+require "generators/serious_business/install_generator"
+#require "i18n-dot_lookup"
+
+module SeriousBusiness
+
+  SeriousBusinessConfig = Struct.new(:actor_class_name)
+
+  def self.config &blk
+    @config ||= SeriousBusinessConfig.new
+    blk.call(@config)
+  end
+
+  def self.actor_class_name
+    @config.actor_class_name
+  end
+
+end

data/lib/tasks/serious_business_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :serious_business do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: serious_business
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Axel Tetzlaff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Secure your app by using our structured data model to specify the data
+  flow between views and semnatic actions
+email:
+- axel.tetzlaff@gmx.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/serious_business_manifest.js
+- app/assets/javascripts/serious_business/application.js
+- app/assets/stylesheets/serious_business/application.css
+- app/controllers/serious_business/application_controller.rb
+- app/helpers/serious_business/application_helper.rb
+- app/jobs/serious_business/application_job.rb
+- app/mailers/serious_business/application_mailer.rb
+- app/models/concerns/serious_business/actor.rb
+- app/models/serious_business/action.rb
+- app/models/serious_business/actor.rb
+- app/models/serious_business/affected.rb
+- app/models/serious_business/affected_by_actions.rb
+- app/models/serious_business/application_record.rb
+- app/models/serious_business/base_form_model.rb
+- app/views/layouts/serious_business/application.html.erb
+- config/routes.rb
+- lib/generators/serious_business/install_generator.rb
+- lib/generators/serious_business/templates/initializer.rb
+- lib/generators/serious_business/templates/migration/actions.rb
+- lib/serious_business.rb
+- lib/serious_business/engine.rb
+- lib/serious_business/version.rb
+- lib/tasks/serious_business_tasks.rake
+homepage: https://github.com/axelerator
+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: A gem to formalize application flow of views and actions
+test_files: []