rails_rbs 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 068d7378cafb40bcb836cd7858078ef5da1d6eb5
+  data.tar.gz: 7cf3527c974efefeee3c668d6793b43a9bbf680e
+SHA512:
+  metadata.gz: 882d6a91dedbbfc79ed14db7b16cf47ae92248927f72e04990daf436020f5c7799b0b298e0f153a13b5929d6e1f899b5fff992e722936556cd8eeb98712b456d
+  data.tar.gz: e1bc6b497233a18ac43239c95fe3dd7db9d99940f8c876310d3c230c06171bfce2ab8b2a46784999668bc9d653853fa61fac2777a516327f9c138de8f6712a0d

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 Rob
+
+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.rdoc

@@ -0,0 +1,3 @@
+= RailsRbs
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,23 @@
+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    = 'RailsRbs'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+

data/app/controllers/rails_rbs/rule_sets_controller.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RailsRbs
+  # This controller class is the C.R.U.D. interface for rule-sets.  Whenever the RailsRbs configuration
+  # uses rule_owners (@see RailsRbs Config) rule_sets will only be displayed and modified that belong
+  # to that owner.  This controller will attempt to render views under a rule_sets/ directory if view
+  # rendering is enabled (again @see RailsRbs Config)
+  #
+  # @note When locating a rule_set by ID this controller will use the config setting - request_id_field
+  #   like all other configuration @see RailsRbs Config
+  class RuleSetsController < RailsRbs.parent_controller.constantize
+    include RailsRbs::Controllers::Helpers
+    # If owner access is enabled validate that an owner is present
+    before_action :validate_owner_access
+    before_action :create_rule_set, only: :create
+    before_action :load_rule_set, only: [:show, :update, :destroy]
+
+    # #index displays all rule_sets either for the owner or from the entire table if owner_access is
+    # disabled (@see RailsRbs Config).  The rule_sets will always include any associated rules.
+    def index
+      if RailsRbs.owner_access
+        @rule_sets = rule_owner.rule_sets.includes(:rules, :rule_actions)
+      else
+        @rule_sets = RuleSet.all.includes(:rules, :rule_actions)
+      end
+      render_view_fallback('rule_sets/index') do
+        render json: @rule_sets
+      end
+    end
+    # #show displays a single rule_set depending on the provided id.  The method uses a
+    # protected load method that will raise an ActiveRecord::RecordNotFound error if a rule_set is
+    # not located.  This includes providing an existing ID for a rule_set not owned by the
+    # requesting owner (only if owner access is enabled - @see RailsRbs Config).
+    def show
+      render_view_fallback('rule_sets/show') do
+        render json: @rule_set
+      end
+    end
+    # #update updates a single rule_set, including any associated rules by first using the
+    # protected load_rule_set method (@see #show).  If an update fails the action will raise
+    # an ActiveRecord::RecordInvalid error.  Similar to #show this method will only operate on
+    # rule_sets that belong to the rule_set owner (if owner access is enabled).
+    def update
+      update_with_nested(key: :rules_attributes, klass: Rule)
+      update_with_nested(key: :rule_actions_attributes, klass: RuleAction)
+      @rule_set.update!(rule_set_params) unless rule_set_params.empty? # This can be empty after update_with_nested
+      # Force a reload in case the above update never ran
+      @rule_set.reload
+      render_view_fallback('rule_sets/show') do
+        render json: @rule_set
+      end
+    end
+    # #create will attempt to create a new rule_set and like all other actions in this
+    # controller it will do so for the requesting owner if owner access is enabled
+    # (@see RailsRbs Config).  If owner access is enabled but no requesting owner can be found
+    # an ActiveRecord::RecordNotFound error will be raised.
+    def create
+      render_view_fallback('rule_sets/show') do
+        render json: @rule_set
+      end
+    end
+    # #destroy will attempt to destroy a rule_set loading it using the same protected load rule_set
+    # used by #show and #update.  If destroy causes any issues an ActiveRecord error will be raised,
+    # otherwise the action renders the index view or nothing at all if view rendering is disabled
+    # (@see RailsRbs Config)
+    def destroy
+      @rule_set.destroy!
+      render_view_fallback('rule_sets/index') do
+        render nothing: true, status: 200
+      end
+    end
+
+    protected
+    # #load_rule_set is meant to be used as a before action to ensure the appropriate resource is
+    # located for whatever crud operation is interested.  In this case the method will raise an
+    # ActiveRecord::RecordNotFound error when no record is found.
+    def load_rule_set
+      if RailsRbs.owner_access
+        rule_sets_association = rule_owner.rule_sets
+      else
+        rule_sets_association = RuleSet
+      end
+      @rule_set = rule_sets_association.includes(:rules, :rule_actions).find_by!(RailsRbs.request_id_field => params[:id])
+    end
+
+    # create_rule_set is meant to be used as a before action that needs to instantiate a new
+    # rule_set resource.  This method like all others operates on the rule_owners rule_sets if
+    # owner access is enabled.
+    def create_rule_set
+      if RailsRbs.owner_access
+        @rule_set = rule_owner.rule_sets.create!(rule_set_params)
+      else
+        @rule_set = RuleSet.create!(rule_set_params)
+      end
+      raise ActiveRecord::InvalidRecord.new(@rule_set) if @rule_set.invalid?
+      @rule_set
+    end
+
+    def rule_set_params
+      return @rule_set_params if @rule_set_params.present?
+      rule_fields = RailsRbs.base_rule_fields.concat(RailsRbs.rule_fields).concat([:id, :_destroy]).uniq.reject(&:nil?)
+      rule_set_fields = [:scope, {rules_attributes: rule_fields, rule_actions_attributes: [RailsRbs.request_id_field.to_sym, :id, :_destroy, :enforced_value, :enforced_field]}].reject(&:nil?)
+      rule_set_fields << "#{RailsRbs.owned_by}_id".to_sym if RailsRbs.owner_access
+      @rule_set_params = params.require(RailsRbs.rule_set_params_root.to_sym).permit(rule_set_fields)
+    end
+
+    def validate_owner_access
+      if RailsRbs.owner_access && rule_owner.nil?
+        raise ActiveRecord::RecordNotFound.new("Unable to find owner required to create rule_set")
+      end
+    end
+
+    def update_with_nested(key: ,klass:)
+      # If using id as the rule set identifier let accepts_nested_attributes do it's job
+      if RailsRbs.request_id_field.to_sym != :id && rule_set_params[key].present?
+        id_field = RailsRbs.request_id_field.to_sym
+        updates, deletes, creates = [], [], []
+        rule_set_params[key].each do |attrs|
+          attrs[:rule_set_id] ||= @rule_set.try(:id)
+          if attrs[:id].present?
+            if attrs[:_destroy]
+              deletes << attrs
+            else
+              updates << attrs
+            end
+          else
+            creates << attrs
+          end
+        end
+        updates.each { |attrs| klass.find_by!(id_field => attrs.delete('id')).update(attrs) }
+        klass.where(id_field => deletes.map { |attrs| attrs['id'] }).delete_all
+        creates.each { |attrs| klass.create!(attrs) }
+        rule_set_params[key] = {}
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:rule_sets_controller, self)
+  end
+end

data/app/controllers/rails_rbs/rules_controller.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RailsRbs
+  # This controller class is the C.R.UD. interface for rules.  Whenever the RailsRbs configuration
+  # uses rule_owners (@see RailsRbs Config) rules will only be displayed and modified that belong
+  # to that owner.  This controller will attempt to render views under a rules/ directory if view
+  # rendering is enabled ( again @see RailsRbs Config)
+  #
+  # @note when locationg a rule by ID this contoller will use the config settings - request_id_field
+  # like all other configuations @see RailsRbs Config
+  class RulesController < RailsRbs.parent_controller.constantize
+    include RailsRbs::Controllers::Helpers
+    # If owner access is enabled validate that an owner is present
+    before_action :validate_owner_access
+    before_action :load_rule, only: [:show, :update, :destroy]
+    before_action :create_rule, only: :create
+
+    # #index displays all rules either for the owner or from the entire table if owner_access is
+    # disabled (@see RailsRbs Config).
+    def index
+      if RailsRbs.owner_access
+        @rules = rule_owner.try(:rules)
+      else
+        @rules = Rule.all
+      end
+      render_view_fallback('rules/index') do
+        render json: @rules
+      end
+    end
+    # #show displays a single rule depending on the provided id.  The method uses a protected
+    # load method that will rails an ActiveSupport::RecordNotFound error if the rule is not
+    # located.  This includes providing an ID for an existing rule not owned by the requesting
+    # owner (if owner access is enabled - @see RailsRbs Config).
+    def show
+      render_view_fallback('rules/show') do
+        render json: @rule
+      end
+    end
+    #update updates a single rule by first using a protected load method to locate the rule
+    # (@see #show).  If an update fails the action will rails an ActiveRecord::RecordInvalid
+    # error.  Similar to #show this method will only operate on rules that belong to the rule
+    # owner if owner access is enabled.
+    def update
+      @rule.update!(rule_params)
+      render_view_fallback('rules/show') do
+        render json: @rule
+      end
+    end
+    # #create will attempt to create a new rule and like the other actions in this controller
+    # it will do so for the requesting owner if owner access is enabled (@see RailsRbs Config).
+    # If owner_access is enabled but no requesting owner can be found an
+    # ActiveRecord::RecordNotFound error will be raised.
+    def create
+      render_view_fallback('rules/show') do
+        render json: @rule
+      end
+    end
+    # #destroy will attempt to destroy a rule loading it using the same protected load rule method
+    # used by #show and #update.  If destroy causes any issues an ActiveRecord error will be raised,
+    # otherwise the action renders the index view or nothing at lal if view rendering is disabled
+    # (@see RailsRbs Config).
+    def destroy
+      @rule.destroy!
+      render_view_fallback('rules/index') do
+        render nothing: true, status: 200
+      end
+    end
+
+    protected
+    # #load_rule is meant to be used as a before action to ensure the appropriate resource is
+    # located for whatever crud operation is interested.  In this case the method will raise an
+    # ActiveRecord::RecordNotFound error when no record is found.
+    def load_rule
+      if RailsRbs.owner_access
+        rules_association = rule_owner.rules
+      else
+        rules_association = Rule
+      end
+      @rule = rules_association.find_by!(RailsRbs.request_id_field => params[:id])
+    end
+
+    # Attempt to fetch the rule_set for the provided parameters and fall back to any rule object
+    # that may be in context for this request.
+    def rule_set
+      if RailsRbs.owner_access
+        @rule_set ||= rule_owner.rule_sets.find_by!(id: rule_params[:rule_set_id])
+      else
+        @rule_set ||= RuleSet.find_by!(id: rule_params[:rule_set_id])
+      end
+      @rule_set ||= @rule.try(:rule_set)
+    end
+
+    def create_rule
+      if RailsRbs.owner_access
+        @rule = rule_owner.rules.create!(rule_params)
+      else
+        @rule = Rule.create!(rule_params)
+      end
+    end
+
+    def rule_params
+      rule_fields = RailsRbs.base_rule_fields.concat(RailsRbs.rule_fields).uniq.reject(&:nil?)
+      params.require(RailsRbs.rule_params_root.to_sym).permit(rule_fields)
+    end
+
+    def validate_owner_access
+      if RailsRbs.owner_access && rule_owner.nil?
+        raise ActiveRecord::RecordNotFound.new("Unable to find owner required to create rule")
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:rules_controller, self)
+  end
+end

data/lib/generators/rails_rbs/migration_helpers.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RailsRbs
+  # This module of helpers is utilized by the RailsRbs generators to detect model and migration files
+  # at their correct path
+  module MigrationHelpers
+
+    # Detect if the rules and rule_sets table migrations exist.
+    # @return true if the rules and rule_sets migration files exist
+    def rule_migrations_exist?
+      %w[add_rules add_rule_sets add_rule_actions].any? do |name|
+        Dir.glob("#{File.join(destination_root, migration_path)}/[0-9]*_*.rb").grep(/\d+_#{name}.rb$/).first
+      end
+    end
+
+    # Detect if the migrations for the default rule types exist.
+    # @return true if date_range and location rule migration files exist
+    def default_rule_migrations_exist?
+      %w[add_date_range add_location].all? do |name|
+        Dir.glob("#{File.join(destination_root, migration_path)}/[0-9]*_*.rb").grep(/\d+_#{name}_rule.rb$/).first
+      end
+    end
+
+    # Detect if a specific model exists by singular name
+    # @return true if the a file is found in app/models that matches the name provided
+    def model_exists?(name: )
+      File.exists?(File.join(destination_root, model_path(name: name)))
+    end
+
+    # Return the file path for a model using the name as the singular file name
+    # @return [String] The relative path of the model file (app/models/rule.rb for name: rule)
+    def model_path(name: )
+      File.join("app", "models", "#{name}.rb")
+    end
+
+    # @return [String] The relative path to the directory where migration files are stored
+    def migration_path
+      if self.respond_to?(:db_migrate_path) # Rails 5.0.3 and up
+        db_migrate_path
+      else
+        File.join("db", "migrate")
+      end
+    end
+  end
+end

data/lib/generators/rails_rbs/rails_rbs_generator.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'rails/generators/active_record/migration'
+require 'generators/rails_rbs/migration_helpers'
+require 'active_support/all'
+
+module RailsRbs
+  module Generators
+    class RailsRbsGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+      include RailsRbs::MigrationHelpers
+
+      namespace "rails_rbs"
+      desc "Generates the rule and rule set models as well as their migrations.  This " \
+            "generator will also create the default rule models and crud routes, both can be skipped"
+
+      class_option :skip_defaults, type: :boolean, default: false, desc: "Skip the default rule models being generated"
+      class_option :skip_routes, desc: "Generate routes", type: :boolean, default: false
+      class_option :owned_by, desc: "What entity owns or creates the rule", type: :string, default: 'user'
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def copy_migrations
+        return if rule_migrations_exist?
+        migration_template 'rule_migration.rb', "#{migration_path}/add_rules.rb"
+        migration_template 'rule_set_migration.rb', "#{migration_path}/add_rule_sets.rb"
+        migration_template 'rule_action_migration.rb', "#{migration_path}/add_rule_actions.rb"
+      end
+
+      def generate_models
+        generate "active_record:model rule --no-migration" unless model_exists?(name: 'rule')
+        generate "active_record:model rule_set --no-migration" unless model_exists?(name: 'rule_set')
+        generate "active_record:model rule_action --no-migration" unless model_exists?(name: 'rule_action')
+      end
+
+      def inject_model_content
+        inject_into_class(model_path(name: 'rule'), 'Rule', rule_model_content)
+        inject_into_class(model_path(name: 'rule_set'), 'RuleSet', rule_set_model_content)
+        inject_into_class(model_path(name: 'rule_action'), 'RuleAction', rule_action_model_content)
+        if options.owned_by && model_exists?(name: options.owned_by)
+          inject_into_class(model_path(name: options.owned_by), options.owned_by.to_s.camelcase, owner_model_content)
+        end
+      end
+
+      def generate_default_rule_models
+        generate 'rails_rbs:rule equality' unless model_exists?(name: 'equality_rule')
+        generate 'rails_rbs:rule date_range' unless model_exists?(name: 'date_range_rule')
+        generate 'rails_rbs:rule location' unless model_exists?(name: 'location_rule')
+      end
+
+      def add_rbs_routes
+        return if options.skip_routes
+        %i[equality date_time location].each do |rule_name|
+          new_route = "resources :#{rule_name}_rules, controller: 'rails_rbs/rules', only: [:create, :update, :show, :destroy]"
+          new_route = new_route + ' skip: :all' if options.skip_defaults
+          route new_route
+        end
+        route 'resources :rules, controller: "rails_rbs/rules", only: [:index, :create, :update, :show, :destroy]'
+        route 'resources :rule_sets, controller: "rails_rbs/rule_sets", only: [:index, :create, :update, :show, :destroy]'
+        route "# RBS Generated routes"
+      end
+
+      def generate_initializer
+        template "initializer.rb", "config/initializers/rails_rbs.rb"
+      end
+
+      private
+      def rule_model_content
+        <<-CONTENT
+  include RailsRbs::FollowsRule
+        CONTENT
+      end
+
+      def rule_set_model_content
+        <<-CONTENT
+  include RailsRbs::FollowsRuleSet
+        CONTENT
+      end
+
+      def owner_model_content
+        <<-CONTENT
+  # RailsRbs rule associations
+  has_many :rules, dependent: :destroy
+  has_many :rule_sets, dependent: :destroy
+        CONTENT
+      end
+
+      def rule_action_model_content
+        <<-CONTENT
+  include RailsRbs::RunsAction
+        CONTENT
+      end
+    end
+  end
+end

data/lib/generators/rails_rbs/rule_generator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'rails/generators/active_record'
+require 'generators/rails_rbs/migration_helpers'
+require 'active_support/all'
+
+module RailsRbs
+  module Generators
+    class RuleGenerator < Rails::Generators::NamedBase
+      include ActiveRecord::Generators::Migration
+      include RailsRbs::MigrationHelpers
+
+      namespace 'rails_rbs:rule'
+
+      source_root(File.expand_path('../templates', __FILE__))
+
+      def generate_rule_model
+        invoke("active_record:model", [model_name], migration: false, parent: 'Rule') unless model_exists?(name: model_name)
+      end
+
+      def generate_migrations
+        unless default_rule_migrations_exist?
+          if name == 'date_range'
+            migration_template 'date_range_rule_migration.rb', "#{migration_path}/add_date_range_rule.rb"
+          elsif name == 'location'
+            migration_template 'location_rule_migration.rb', "#{migration_path}/add_location_rule.rb"
+          end
+        end
+      end
+
+      def inject_rule
+        default_rules = %w[equality date_range location] # The built in rules of the gem
+        if default_rules.include?(name)
+          content = default_rule_content
+        else
+          content = empty_rule_content
+        end
+        inject_into_class(model_path(name: model_name), "#{name.to_s.camelize}Rule", content)
+      end
+
+      private
+      def empty_rule_content
+        <<-CONTENT
+  def follows_rule?(*objects)
+    # Your rule logic here!
+    false
+  end
+        CONTENT
+      end
+
+      def default_rule_content
+        <<-CONTENT
+  default_rule :#{name}
+        CONTENT
+      end
+
+      def model_name
+        "#{name}_rule"
+      end
+    end
+  end
+end

data/lib/generators/rails_rbs/templates/date_range_rule_migration.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+class AddDateRangeRule < ActiveRecord::Migration
+  def change
+    change_table :rules do |table|
+      table.datetime :start_date
+      table.datetime :end_date
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+RailsRbs.setup do |config|
+  # Configure RailsRBS here
+  config.owned_by = :<%= options.owned_by %>
+  config.owner_access = :<%= "current_#{options.owned_by}" %>
+  config.render_views = true
+  config.request_id_field = :id
+  config.parent_controller = 'ApplicationController'
+  config.rule_params_root = :rule
+  config.rule_set_params_root = :rule_set
+  config.rule_set_view_dir = 'rule_sets'
+  config.rule_view_dir = 'rules'
+=begin
+  * Specialized rule fields *
+  The following list is used to support strong parameters for rules that leverage single table inheritance
+  - The default strong parameters method uses this set of allowed parameters
+  - This list can be expanded or specialized for different rule types
+  - When a specialized rule requires a new table column, add that field to this list to ensure access at the
+    controller level
+  - Specialized controllers can utilize or ignore this list of fields
+  - Some fields are required by the rule system and should always be allowed, these will never be listed in the
+    rule_fields list and can be accessed at RailsRbs.base_rule_fields
+    - Fields always included in default controllers - [:type, :enforced_type, :enforced_value, :observed_field,
+      :<owned_by>_id]
+  - The <owned_by>_id field is always added in the default strong parameters method
+=end
+  config.rule_fields = %i[value start_date end_date longitude latitude]
+end

data/lib/generators/rails_rbs/templates/location_rule_migration.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+class AddLocationRule < ActiveRecord::Migration
+  def change
+    change_table :rules do |table|
+      table.float :latitude
+      table.float :longitude
+    end
+  end
+end

data/lib/generators/rails_rbs/templates/rule_action_migration.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+class AddRuleActions < ActiveRecord::Migration
+  def change
+    create_table :rule_actions do |table|
+      table.integer :rule_set_id, null: false, index: true
+      table.string :enforced_field, null: false
+      table.string :enforced_value
+    end
+  end
+end

data/lib/generators/rails_rbs/templates/rule_migration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+class AddRules < ActiveRecord::Migration
+  def change
+    create_table :rules do |table|
+      table.string :type, null: false
+      table.string :enforced_type, null: false, default: :string
+      table.string :enforced_value
+      table.string :observed_field, null: false
+      table.string :comparison_operator, null: false, default: '='
+      table.integer :<%= options.owned_by %>_id, index: true
+      table.integer :rule_set_id, null: false, index: true
+    end
+  end
+end

data/lib/generators/rails_rbs/templates/rule_set_migration.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+class AddRuleSets < ActiveRecord::Migration
+  def change
+    create_table :rule_sets do |table|
+      table.integer :<%= options.owned_by %>_id, index: true
+      table.string :scope, index: true
+    end
+  end
+end

data/lib/rails_rbs.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+module RailsRbs
+  autoload :FollowsRule, 'rails_rbs/follows_rule'
+  autoload :FollowsRuleSet, 'rails_rbs/follows_rule_set'
+  autoload :RunsAction, 'rails_rbs/runs_action'
+
+  module Rules
+    autoload :Equality, 'rails_rbs/rules/equality'
+    autoload :DateRange, 'rails_rbs/rules/date_range'
+    autoload :Location, 'rails_rbs/rules/location'
+  end
+
+  module Controllers
+    autoload :Helpers, 'rails_rbs/controllers/helpers'
+  end
+
+  module Models
+    autoload :FollowsScope, 'rails_rbs/models/follows_scope'
+  end
+
+  # Default way to set up RailsRbs. Run rails generate rails_rbs to create
+  # a fresh initializer with all configuration values.
+  def self.setup
+    yield self
+  end
+
+  mattr_accessor :owned_by
+  @@owned_by = :user
+
+  mattr_accessor :owner_access
+  @@owner_access = :current_user
+
+  mattr_accessor :render_views
+  @@render_views = true
+
+  mattr_accessor :request_id_field
+  @@request_id_field = :id
+
+  mattr_accessor :base_rule_fields
+  @@base_rule_fields = %i[type enforced_type enforced_value observed_field rule_set_id comparison_operator]
+
+  mattr_accessor :rule_fields
+  @@rule_fields = %i[value start_date end_date longitude latitude]
+
+  mattr_accessor :parent_controller
+  @@parent_controller = 'ApplicationController'
+
+  mattr_accessor :rule_params_root
+  @@rule_params_root = :rule
+
+  mattr_accessor :rule_set_params_root
+  @@rule_set_params_root = :rule_set
+
+  mattr_accessor :rule_set_view_dir
+  @@rule_set_view_dir = 'rule_sets'
+
+  mattr_accessor :rule_view_dir
+  @@rule_view_dir = 'rules'
+end
+
+require 'rails_rbs/engine'

data/lib/rails_rbs/controllers/helpers.rb

@@ -0,0 +1,33 @@
+require 'rails'
+
+module RailsRbs
+  module Controllers
+    # Helpers that are used across RailsRbs default controllers
+    module Helpers
+      # Attempts to call the owner_access method stored by the RailsRbs configuration, only
+      # if owner_access is not falsey.  @see RailsRbs Config
+      # @return Rule/RuleSet owner if owner_access is not false
+      def rule_owner
+        self.send(RailsRbs.owner_access.to_sym) if RailsRbs.owner_access
+      end
+      # Based on the RailsRbs configuration returns the id field of the owner.  This is
+      # simply derived using the owned_by configuration (@see RailsRbs Config).
+      # @return [String] name of the owner id field used in rules and rule_sets (e.g. user_id)
+      def owner_id_field
+        "#{RailsRbs.owned_by.to_s.camelize}_id"
+      end
+      # Helper method that will render the view_path provided only if render_views is enabled
+      # (@see RailsRbs Config).  If this configuration setting is false then simply yield the
+      # provided fallback block.
+      # @param view_path [String] the path to the view to be rendered
+      # @param fallback A block to yield if render_views is disabled
+      def render_view_fallback(view_path, &fallback)
+        if RailsRbs.render_views
+          render view_path.gsub(/\Arule_sets/, RailsRbs.rule_set_view_dir).gsub(/\Arules/, RailsRbs.rule_view_dir)
+        else
+          yield fallback
+        end
+      end
+    end
+  end
+end

data/lib/rails_rbs/engine.rb

@@ -0,0 +1,4 @@
+module Rbs
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/rails_rbs/follows_rule.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module RailsRbs
+  module FollowsRule
+    extend ActiveSupport::Concern
+
+    included do
+      # RailsRBS Associations
+      belongs_to :rule_set
+      # Simply for easier owner-rule look-ups
+      belongs_to "#{RailsRbs.owned_by.to_s.underscore}".to_sym
+      # Require enforced type and field, as well as STI type
+      validates_presence_of :type
+      validates_presence_of :enforced_type
+      validates_presence_of :observed_field
+      validates_inclusion_of :comparison_operator, in: %w(= != =~ > >= < <=)
+
+      before_create :default_owner if RailsRbs.owner_access
+    end
+
+    # Defined for documentation, and prevents user from not defining a rule class correctly somehow...
+    def follows_rule?(*objects)
+      raise NotImplementedError.new("This instance of #{self.class.to_s} fails to define a follows_rule? method though it claims to be a rule...")
+    end
+    def filter_objects(association)
+      # association.where for example
+      raise NotImplementedError.new("This instance of #{self.class.to_s} fails to define a find_objects method though it claims to be a rule...")
+    end
+    # Coerce the provided object to the rule's enforced_type.  If the enforced type is a string
+    # integer or float then to_s, to_i or to_f are used, otherwise we attempt to call
+    # to_<enforced_type> on the provided object.
+    # @param object The object to coerce
+    def force_type(object)
+      return unless self.respond_to?(:enforced_type)
+      enforced_type_string = self.enforced_type.to_s.downcase
+      if enforced_type_string.to_s.downcase.to_sym == :string
+        object.to_s
+      elsif enforced_type_string.to_s.downcase =~ /\Aint(?!iger)\z/
+        object.to_i
+      elsif enforced_type_string.to_s.downcase.to_sym == :float
+        object.to_f
+      else
+        object.send("to_#{enforced_type_string}")
+      end
+    end
+    def default_owner
+      owner_field = "#{RailsRbs.owned_by.to_s.underscore}".to_sym
+      owned_by = self.send(owner_field)
+      self.send("#{owner_field}=", self.rule_set.send(owner_field)) if owned_by.nil? && self.rule_set.present?
+    end
+
+    class_methods do
+      def supported_defaults
+        %i[equality date_range location]
+      end
+      def default_rule(type)
+        return unless supported_defaults.include?(type)
+        class_eval { include("RailsRbs::Rules::#{type.to_s.camelize}".constantize) }
+      end
+    end
+
+  end
+end

data/lib/rails_rbs/follows_rule_set.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module RailsRbs
+  module FollowsRuleSet
+    extend ActiveSupport::Concern
+
+    included do
+      # Container of rules and actions that are destroyed on set destruction
+      has_many :rules, dependent: :destroy
+      has_many :rule_actions, dependent: :destroy
+      # Belongs to the owned_by configuration value unless it is nil
+      belongs_to "#{RailsRbs.owned_by.to_s.underscore}".to_sym unless RailsRbs.owned_by.nil?
+      # Allow API CRUD of nested rules and actions
+      accepts_nested_attributes_for :rules, allow_destroy: true
+      accepts_nested_attributes_for :rule_actions, allow_destroy: true
+      scope :for, -> (scope) { where(scope: scope) }
+    end
+    # Check if an object or collection of objects follows all rules in this rule_set
+    # @param objects [Array<ActiveRecord::Base> | ActiveRecord::Base] a single or collection of active
+    # record objects to check this rule_set against.
+    # @return true if the object or objects follows all rules in the rule_set
+    def follows_rule_set?(*objects)
+      self.rules.all? { |rule| rule.follows_rule?(*objects.flatten) }
+    end
+    # Apply the rule_set to all matching objects in the provided collection.  Application simply means
+    # the enforced_field will be set to the enforced_value for any objects that follow all rules
+    # in the set.
+    # @param objects [Array<ActiveRecord::BAse> | ActiveRecord::Base] a single collection of active
+    # record objects to check this apply this rule_set to.  Only objects that follow all rules in the
+    # set will have the rule_set applied.
+    def apply_rule_set(*objects)
+      follows_rules = filter_objects(objects)
+      return if follows_rules.empty?
+      self.rule_actions.map { |rule_action| rule_action.apply(follows_rules.flatten) }
+    end
+    # Return a collection of active record objects that follow all rules in the rule_set using the
+    # provided collection or association as a base to query from.
+    # @param objects collection of objects or an association object that supports the where interface
+    # @return Array collection of objects that follow all rules in the rule_set
+    def filter_objects(*objects)
+      if objects.count == 1 && objects.first.respond_to?(:where)
+        follows_rules = objects.first
+        self.rules.each { |rule| follows_rules = rule.filter_objects(follows_rules) }
+      else
+        follows_rules = objects.select { |obj| self.follows_rule_set?(obj) }
+      end
+      follows_rules
+    end
+  end
+end

data/lib/rails_rbs/models/follows_scope.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/array'
+
+module RailsRbs
+  module Models
+    # This model concern adds convenience methods to active record objects that utilize 
+    # rule_sets and rules.  This concern is included in the ActiveRecord::Base object.
+    module FollowsScope
+      extend ActiveSupport::Concern
+
+      # Check if a model instance follows a rule or rule_set.  When using a rule_set 
+      # the model must pass every rule in the set.
+      # @param rule_or_set [Rule | RuleSet] The rule or rule_set to check this instance 
+      # follows.
+      # @return true if this model instance follows the provided rule or all rules in 
+      # the provided rule_set
+      def follows?(rule_or_set)
+        if rule_or_set.is_a?(RuleSet)
+          rule_or_set.follows_rule_set?(self)
+        else
+          rule_or_set.follows_rule?(self)
+        end
+      end
+      # Apply the provided rule_set to the current model instance.  The rule_set will
+      # only be applied if the the instance follows all the rules in associated with
+      # the set.
+      # @param rule_set [RuleSet] The rule_set to check and apply the instance to
+      def apply_rule_set(rule_set)
+        rule_set.apply_rule_set(self)
+      end
+
+      class_methods do
+        # Query the active record class for objects that follow the rule(s) or set(s)
+        # provided.
+        # @param rules_or_sets [Array<Rule> | Array<RuleSet> | Rule | Set] The rule(s)
+        # or rule_set(s) to query objects with.
+        # @return Array<ActiveRecord::Object> Collection of active record objects that
+        # follow the rule(s) or set(s)
+        def following(*rules_or_sets)
+          rules_or_sets.reduce(self) { |followers, rule_or_set| rule_or_set.filter_objects(followers) }
+        end
+        # Apply the provided rule_set to any objects that follow the rule(s) or set(s)
+        # provided.  This allows users to provide rule_sets to existing data.
+        # @param rule_set [RuleSet] The rule_set to query with and apply to resulting
+        # objects.
+        def apply_rule_set(rule_set)
+          rule_set.apply_rule_set(self)
+        end
+      end
+    end
+  end
+  ActiveRecord::Base.send(:include, Models::FollowsScope)
+end

data/lib/rails_rbs/rules/date_range.rb

@@ -0,0 +1,41 @@
+module RailsRbs
+  module Rules
+    # Used by the date_range default rule type to ensure an object's observed_field
+    # falls in a certain range of two dates.  Assumes the rule model supports a
+    # start_date and end_date field
+    module DateRange
+      # Check one or more object's observed_field to ensure it falls between a
+      # start_date and end_date
+      # @param objects [Array<ActiveRecord::Base>] active record objects, or objects
+      # that respond to the observed_field value of the including rule.
+      # @return true if the provided object(s) follow the current rule
+      def follows_rule?(*objects)
+        objects.all? do |object|
+          source_date = object.send(self.observed_field.to_sym)
+          range_start, range_end = self.start_date, self.end_date
+          # Attempt to coerce the types if we can
+          if self.respond_to?(:enforced_type) && self.respond_to?(:force_type)
+            source_date = force_type(source_date)
+            range_start = force_type(range_start)
+            range_end = force_type(range_end)
+          end
+          # Was having mixed results with .between method
+          source_date >= range_start && source_date <= range_end
+        end
+      end
+      # Return an association of active record objects that fall in the date range
+      # of the rule using the provided association as a base to query from.
+      # @param association Active record association, relation or collection proxy
+      # that supports the where interface.
+      def filter_objects(association)
+        start_date, end_date = self.start_date, self.end_date
+        # Attempt to coerce the types if we can
+        if self.respond_to?(:enforced_type) && self.respond_to?(:force_type)
+          start_date = force_type(start_date)
+          end_date = force_type(end_date)
+        end
+        association.where("#{self.observed_field} >= ? AND #{self.observed_field} <= ?", start_date, end_date)
+      end
+    end
+  end
+end

data/lib/rails_rbs/rules/equality.rb

@@ -0,0 +1,40 @@
+module RailsRbs
+  module Rules
+    # Used by the equality default rule type to ensure an objects observed_field equals a specified value.
+    module Equality
+      # Check one or more object's observed_Field to ensure it equals a specified value contained in the
+      # rule's enforced_value field.
+      # @param objects [Array<ActiveRecord::Base>] active record object, or  objects that respond to the
+      # observed_field value of the including rule.
+      def follows_rule?(*objects)
+        objects.all? do |object|
+          source_value, dest_value = object.send(self.observed_field.to_sym), self.enforced_value
+          # Attempt to coerce the types if we can
+          if self.respond_to?(:enforced_type) && self.respond_to?(:force_type)
+            source_value, dest_value = force_type(source_value), force_type(dest_value)
+          end
+          # Check the comparison operator we use is correct
+          return source_value == dest_value if self.try(:comparison_operator).nil? || self.comparison_operator.to_s == '='
+          if comparison_operator.to_sym == :=~
+            dest_value = Regexp.new(Regexp.escape(dest_value), Regexp::IGNORECASE)
+            dest_value = /#{dest_value}/
+          end
+          source_value.send(self.try(:comparison_operator.to_sym), dest_value)
+        end
+      end
+      # Return an association of active record objects that have an observed_field value that matches
+      # the rules enforced_value.  The association is made from the provided association using it as
+      # a base to query from.
+      # @param association Active record association, relation or collection proxy that supports the
+      # where interface
+      def filter_objects(association)
+        matching_value = self.enforced_value
+        # Attempt to coerce the types if we can
+        if self.respond_to?(:enforced_type) && self.respond_to?(:force_type)
+          matching_value = self.force_type(matching_value)
+        end
+        association.where("#{self.observed_field} = ?", matching_value)
+      end
+    end
+  end
+end

data/lib/rails_rbs/rules/location.rb

@@ -0,0 +1,40 @@
+module RailsRbs
+  module Rules
+    # Used by the location default rule to ensure an object's observed field matches a set
+    # latitude and longitude for the rule.  Assumes the rule supports a latitude and longitude
+    # method
+    module Location
+      # Check one or more object's observed_field to ensure it matches the rule's latitude and
+      # longitude values.  This method assumes the provided object(s) observed_field will return
+      # an array of [latitude, longitude]
+      # @param objects [Array<ActiveRecord::Base>] active record objects, or objects that respond
+      # to the observed_field and return an array of [latitude, longitude] from it.
+      #
+      def follows_rule?(*objects)
+        objects.all? do |object|
+          # We expect the observed field to return an array of [latitude, longitude]
+          source_lat, source_long   =  *object.send(self.observed_field.to_sym)
+          dest_lat,   dest_long     =  *[self.latitude, self.longitude]
+          # Attempt to coerce the types if we can
+          if self.respond_to?(:enforced_type) && self.respond_to?(:force_type)
+            [source_lat, source_long, dest_lat, dest_long].each { |val| force_type(val) }
+          end
+          # TODO: Use geocoding and distance of some sort here...
+          source_lat == dest_lat && source_long == dest_long
+        end
+      end
+      # Return an association of active record objects that match the latitude and longitude of
+      # the rule.  This is done using the provided association as a base to query from.
+      # @param association Active record association, relation or collection proxy that supports
+      # the where interface.
+      def filter_objects(association)
+        matching_lat, matching_long = self.latitude, self.longitude
+        # Attempt to coerce the types if we can
+        if self.respond_to?(:enforced_type) && self.respond_to?(:force_type)
+          matching_lat, matching_long = force_type(matching_lat), force_type(matching_long)
+        end
+        association.where("latitude = ? AND longitude = ?", matching_lat, matching_long)
+      end
+    end
+  end
+end

data/lib/rails_rbs/runs_action.rb

@@ -0,0 +1,26 @@
+module RailsRbs
+  module RunsAction
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :rule_set
+      validates_presence_of :enforced_field
+      validates_presence_of :enforced_value
+    end
+
+    # Apply the action to all objects in the provided collection.  Application simply means
+    # the enforced_field will be set to the enforced_value.
+    # @param objects [Array<ActiveRecord::BAse> | ActiveRecord::Base] a single collection of active
+    # record objects to have this rule_action applied to.
+    def apply(*objects)
+      objects.flatten.map do |object|
+        if object.persisted?
+          response = object.update_column(self.enforced_field.to_sym, self.enforced_value)
+        else
+          response = object.send("#{self.enforced_field.to_sym}=", self.enforced_value)
+        end
+        [response, object.try(:errors)]
+      end
+    end
+  end
+end

data/lib/rails_rbs/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsRbs
+  VERSION = "0.2.2"
+end

data/lib/tasks/rails_rbs_tasks.rake

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

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: rails_rbs
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Rob
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.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: rspec-rails
+  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: Simple rule base system for ruby on rails that utilizes DB tables through
+  active record
+email:
+- rob@everlance.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- app/controllers/rails_rbs/rule_sets_controller.rb
+- app/controllers/rails_rbs/rules_controller.rb
+- lib/generators/rails_rbs/migration_helpers.rb
+- lib/generators/rails_rbs/rails_rbs_generator.rb
+- lib/generators/rails_rbs/rule_generator.rb
+- lib/generators/rails_rbs/templates/date_range_rule_migration.rb
+- lib/generators/rails_rbs/templates/initializer.rb
+- lib/generators/rails_rbs/templates/location_rule_migration.rb
+- lib/generators/rails_rbs/templates/rule_action_migration.rb
+- lib/generators/rails_rbs/templates/rule_migration.rb
+- lib/generators/rails_rbs/templates/rule_set_migration.rb
+- lib/rails_rbs.rb
+- lib/rails_rbs/controllers/helpers.rb
+- lib/rails_rbs/engine.rb
+- lib/rails_rbs/follows_rule.rb
+- lib/rails_rbs/follows_rule_set.rb
+- lib/rails_rbs/models/follows_scope.rb
+- lib/rails_rbs/rules/date_range.rb
+- lib/rails_rbs/rules/equality.rb
+- lib/rails_rbs/rules/location.rb
+- lib/rails_rbs/runs_action.rb
+- lib/rails_rbs/version.rb
+- lib/tasks/rails_rbs_tasks.rake
+homepage: https://github.com/Everlance/rails_rbs
+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.14
+signing_key: 
+specification_version: 4
+summary: Simple rule base system for ruby on rails that utilizes DB tables through
+  active record
+test_files: []