card 1.95.3 → 1.96.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6051bed4929802033973d16097fd41ae8b90b8b2
-  data.tar.gz: 1392cf213a98410aac04baa57362e73666f9dad4
+  metadata.gz: a73062a82222809672762110ca1f6892dcf22cd7
+  data.tar.gz: 5315e20f640bd0efa37e00c3f2551b18a2856160
 SHA512:
-  metadata.gz: c8028cbb5aa77a58fe9b0cdaef9aa16067591023ba25f76fca6d6d33f1a8592c8621ed8f7ad34890ea2b97b48548275f39f1ab21c62470c2641bcd53165570df
-  data.tar.gz: 3d0afe134f4cdac0c227dc51913e7b4fc134fa729f7957ed5b3e0ecbfc48313c7f012b1a326744f5647fb95484a380e0a42218368a023ba9ef58b6074cebdad0
+  metadata.gz: 03f59ad4c0428b43d47e2c81c202e630293000057e53648a702fff25401e2791d497895fe17e71ca9600b5a4d7c5182da361ef19aa9fbe0b75595be7566cc9b1
+  data.tar.gz: f9c7550d1c9ea23c1f3447bcc2c1611afe434d4bd92e778410827fc07aeb73ab2b89cf0ac3091e14905d267454fec508c14166e06ec8fda8de7fb98630b2e66b

data/VERSION

@@ -1 +1 @@
-0.5.3
+0.6.0

data/lib/card.rb

@@ -141,11 +141,19 @@ class Card < ApplicationRecord
     :silent_change,               # and this probably too
     # :remove_rule_stash,
     :last_action_id_before_edit,
-    :only_storage_phase,           # used to save subcards
+    :only_storage_phase,          # used to save subcards
     :changed_attributes,
-    :skip_event
+    :skip,                        # skip event(s) for all cards in act
+    :skip_in_action,               # skip event for just this card
+    :trigger,                     # trigger event(s) for all cards in act
+    :trigger_in_action             # trigger event for just this card
   )
 
+  alias_method :skip_event, :skip
+  alias_method :skip_event_in_action, :skip_in_action
+  alias_method :trigger_event, :trigger
+  alias_method :trigger_event_in_action, :trigger_in_action
+
   def serializable_attributes
     self.class.serializable_attributes + set_specific.keys
   end

data/lib/card/migration/import.rb

@@ -99,7 +99,7 @@ class Card
 
       def fetch_local_data name, view
         Card::Auth.as_bot do
-          Card[name].format(format: :json).render!(view || :content)
+          Card[name].format(format: :json).render!(view || :page)
         end
       end
 

data/lib/card/set.rb

@@ -36,7 +36,7 @@ class Card
   #        b) then uses Card::Set module to provide API for the most common set methods.
   #
   module Set
-    include Event
+    include Event::Api
     include Trait
     include Basket
     include Inheritance

data/lib/card/set/event.rb

@@ -8,99 +8,97 @@ class Card
     #   * __integration__ deals with any ramifications of those changes
     #
     #
-    module Event
-      include DelayedEvent
-
-      def event event, stage_or_opts={}, opts={}, &final
-        opts = event_opts stage_or_opts, opts
-        Card.define_callbacks event
-        define_event event, opts, &final
-        set_event_callbacks event, opts
+    class Event
+      module Api
+        def event event, stage_or_opts={}, opts={}, &final
+          Event.new(event, stage_or_opts, opts, self, &final).register
+        end
       end
 
-      private
+      CONDITION_OPTIONS = {
+        on: %i[create update delete save read],
+        changed: %i[name content db_content type type_id codename key],
+        skip: :allowed,
+        trigger: :required,  # the event is only executed if triggered explicitly with
+                             # trigger: [event_name]
+      }.freeze
+
+      CONDITIONS = ::Set.new(%i[on changed when skip trigger]).freeze
 
-      # EVENT OPTS
+      include DelayedEvent
+      include Options
+      include Callbacks
 
-      def event_opts stage_or_opts, opts
-        opts = normalize_opts stage_or_opts, opts
-        process_stage_opts opts
-        process_action_opts opts
-        opts
+      attr_reader :set_module, :opts
+
+      def initialize event, stage_or_opts, opts, set_module, &final
+        @event = event
+        @set_module = set_module
+        @opts = event_opts stage_or_opts, opts
+        @event_block = final
       end
 
-      def normalize_opts stage_or_opts, opts
-        if stage_or_opts.is_a? Symbol
-          opts[:in] = stage_or_opts
-        else
-          opts = stage_or_opts
-        end
-        opts
+      def register
+        validate_conditions
+        Card.define_callbacks @event
+        define_event
+        set_event_callbacks
       end
 
-      def process_action_opts opts
-        opts[:on] = [:create, :update] if opts[:on] == :save
+      # @return the name of the event
+      def name
+        @event
       end
 
-      def process_stage_opts opts
-        if opts[:after] || opts[:before]
-          # ignore :in options
-        elsif (in_opt = opts.delete :in)
-          opts[:after] = callback_name in_opt, opts.delete(:after_subcards)
-        end
+      def block
+        @event_block
+      end
+
+      # the name for the method that only executes the code
+      # defined in the event
+      def simple_method_name
+        "#{@event}_without_callbacks"
       end
 
-      def callback_name stage, after_subcards=false
-        name = after_subcards ? "#{stage}_final_stage" : "#{stage}_stage"
-        name.to_sym
+      # the name for the method that adds the event to
+      # the delayed job queue
+      def delaying_method_name
+        "#{@event}_with_delay"
       end
 
+      private
+
       # EVENT DEFINITION
 
-      def define_event event, opts, &final
-        simple_method_name = "#{event}_without_callbacks"
-        define_simple_method event, simple_method_name, &final
-        define_event_method event, simple_method_name, opts
+      def define_event
+        define_simple_method
+        define_event_method
       end
 
-      def define_simple_method _event, method_name, &method
-        class_eval do
-          define_method method_name, &method
+      def define_simple_method
+        @set_module.class_exec(self) do |event|
+          define_method event.simple_method_name, &event.block
         end
       end
 
-      def define_event_method event, method_name, opts
-        event_type = with_delay?(opts) ? :delayed : :standard
-        send "define_#{event_type}_event_method", event, method_name
+      def define_event_method
+        send "define_#{event_type}_event_method"
+      end
+
+      def event_type
+        with_delay?(@opts) ? :delayed : :standard
       end
 
-      def define_standard_event_method event, method_name
-        class_eval do
-          define_method event do
-            log_event_call event
-            run_callbacks event do
+      def define_standard_event_method method_name=simple_method_name
+        @set_module.class_exec(@event) do |event_name|
+          define_method event_name do
+            log_event_call event_name
+            run_callbacks event_name do
               send method_name
             end
           end
         end
       end
-
-      # EVENT CALLBACKS
-
-      def set_event_callbacks event, opts
-        opts[:set] ||= self
-        [:before, :after, :around].each do |kind|
-          next unless (object_method = opts.delete kind)
-          set_event_callback object_method, kind, event, opts
-        end
-      end
-
-      def set_event_callback object_method, kind, event, opts
-        Card.class_eval do
-          set_callback object_method, kind, event,
-                       prepend: true, if: proc { |c| c.event_applies?(event, opts) }
-        end
-      end
     end
   end
 

data/lib/card/set/event/callbacks.rb

@@ -0,0 +1,21 @@
+class Card
+  module Set
+    class Event
+      module Callbacks
+        def set_event_callbacks
+          %i[before after around].each do |kind|
+            next unless (object_method = @opts.delete kind)
+            set_event_callback object_method, kind
+          end
+        end
+
+        def set_event_callback object_method, kind
+          Card.class_exec(self) do |event|
+            set_callback object_method, kind, event.name,
+                         prepend: true, if: proc { |c| c.event_applies?(event) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/set/event/delayed_event.rb

@@ -1,6 +1,6 @@
 class Card
   module Set
-    module Event
+    class Event
       module DelayedEvent
         DELAY_STAGES = ::Set.new([:integrate_with_delay_stage,
                                   :integrate_with_delay_final_stage]).freeze
@@ -11,28 +11,23 @@ class Card
           DELAY_STAGES.include?(opts[:after]) || DELAY_STAGES.include?(opts[:before])
         end
 
-        def define_delayed_event_method event, simple_method_name
-          delaying_method = "#{event}_with_delay"
-          define_event_delaying_method event, delaying_method, simple_method_name
-          define_standard_event_method event, delaying_method
+        def define_delayed_event_method
+          define_event_delaying_method
+          define_standard_event_method delaying_method_name
         end
 
-        # creates an ActiveJob.
+        # creates a method that creates an ActiveJob that calls the event method.
         # The scheduled job gets the card object as argument and all serializable
         # attributes of the card.
         # (when the job is executed ActiveJob fetches the card from the database
         # so all attributes get lost)
-        # @param event [String] the event used as queue name
-        # @param method_name [String] the name of the method we define to trigger
-        #   the actjve job
-        # @param final_method_name [String] the name of the method that get called
-        #   by the active job and finally executes the event
-        def define_event_delaying_method event, method_name, final_method_name
-          class_eval do
-            define_method(method_name, proc do
-              IntegrateWithDelayJob.set(queue: event).perform_later(
+        # It uses the event as queue name
+        def define_event_delaying_method
+          @set_module.class_exec(self) do |event|
+            define_method(event.delaying_method_name, proc do
+              IntegrateWithDelayJob.set(queue: event.name).perform_later(
                 Card::ActManager.act&.id, self, serialize_for_active_job, Card::Env.serialize,
-                Card::Auth.serialize, final_method_name
+                Card::Auth.serialize, event.simple_method_name
               )
             end)
           end

data/lib/card/set/event/options.rb

@@ -0,0 +1,78 @@
+class Card
+  module Set
+    class Event
+      module Options
+        def validate_conditions
+          @opts.each do |key, val|
+            next if key.in? %i[in before after around]
+            validate_condition_name key
+            validate_condition_value key, val
+          end
+        end
+
+        def validate_condition_name condition
+          return if Card::Set::Event::CONDITIONS.include? condition
+          raise ArgumentError,
+                "invalid condition key '#{condition}' in event '#{@event}'\n" \
+                "valid conditions are #{Card::Set::Event::CONDITIONS.to_a.join ', '}"
+        end
+
+        def validate_condition_value condition, val
+          if condition == :when
+            validate_when_value val
+          else
+            invalid = Array.wrap(val) - Array.wrap(valid_values(condition))
+            return if invalid.empty?
+            raise ArgumentError,
+                  "invalid option#{'s' if invalid.size > 1} '#{invalid}' "\
+                  "for condition '#{condition}' in event '#{@event}'"
+          end
+        end
+
+        def validate_when_value val
+          return if val.is_a?(Symbol) || val.is_a?(Proc)
+          raise ArgumentError,
+                "invalid value for condition 'when' in event '#{@event}'\n" \
+                "must be a symbol or a proc"
+        end
+
+        def valid_values condition
+          Card::Set::Event::CONDITION_OPTIONS[condition]
+        end
+
+        def event_opts stage_or_opts, opts
+          opts = normalize_opts stage_or_opts, opts
+          process_stage_opts opts
+          process_action_opts opts
+          opts
+        end
+
+        def normalize_opts stage_or_opts, opts
+          if stage_or_opts.is_a? Symbol
+            opts[:in] = stage_or_opts
+          else
+            opts = stage_or_opts
+          end
+          opts
+        end
+
+        def process_action_opts opts
+          opts[:on] = [:create, :update] if opts[:on] == :save
+        end
+
+        def process_stage_opts opts
+          if opts[:after] || opts[:before]
+            # ignore :in options
+          elsif (in_opt = opts.delete :in)
+            opts[:after] = callback_name in_opt, opts.delete(:after_subcards)
+          end
+        end
+
+        def callback_name stage, after_subcards=false
+          name = after_subcards ? "#{stage}_final_stage" : "#{stage}_stage"
+          name.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/card/set/format.rb

@@ -21,6 +21,7 @@ class Card
     #
     module Format
       require_dependency "card/set/format/haml_views"
+      require_dependency "card/set/format/abstract_format"
 
       def format *format_names, &block
         format_names.compact!
@@ -39,6 +40,10 @@ class Card
         format { view(*args, &block) }
       end
 
+      def view_for_override *args, &block
+        format { view_for_override(*args, &block) }
+      end
+
       def before view, &block
         format { before view, &block }
       end
@@ -75,99 +80,6 @@ class Card
         modules[:base_format][format_class] ||= []
         modules[:base_format][format_class] << mod
       end
-
-      # All Format modules are extended with this module in order to support
-      # the basic format API (ok, view definitions.  It's just view
-      # definitions.)
-      # No longer just view definitions. Also basket definitions now.
-      module AbstractFormat
-        include Set::Basket
-        include Set::Format::HamlViews
-
-        mattr_accessor :views
-        self.views = Hash.new { |h, k| h[k] = {} }
-
-        def before view, &block
-          define_method "_before_#{view}", &block
-        end
-
-        def view view, *args, &block
-          #view = view.to_viewname.key.to_sym
-          interpret_view_opts view, args[0] if block_given?
-          view_method_block = view_block(view, args, &block)
-          if async_view? args
-            # This case makes only sense for HtmlFormat
-            # but I don't see an easy way to override class methods for a specific
-            # format. All formats are extended with this general module. So
-            # a HtmlFormat.view method would be overridden by AbstractFormat.view
-            # We need something like AbstractHtmlFormat for that.
-            define_async_view_method view, &view_method_block
-          else
-            define_standard_view_method view, &view_method_block
-          end
-        end
-
-        def define_standard_view_method view, &block
-          views[self][view] = block
-          define_method "_view_#{view}", &block
-        end
-
-        def define_async_view_method view, &block
-          view_content = "#{view}_async_content"
-          define_standard_view_method view_content, &block
-          define_standard_view_method view do
-            %(<card-view-placeholder data-url="#{path view: view_content}" />)
-          end
-        end
-
-        def interpret_view_opts view, opts
-          return unless opts.present?
-          Card::Format.interpret_view_opts view, opts
-          extract_view_cache_rules view, opts.delete(:cache)
-        end
-
-        def extract_view_cache_rules view, cache_rule
-          return unless cache_rule
-          methodname = Card::Format.view_cache_setting_method view
-          define_method(methodname) { cache_rule }
-        end
-
-        def view_block view, args, &block
-          return haml_view_block(view, wrap_with_slot?(args), &block) if haml_view?(args)
-          block_given? ? block : lookup_alias_block(view, args)
-        end
-
-        def haml_view? args
-          args.first.is_a?(Hash) && args.first[:template] == :haml
-        end
-
-        def wrap_with_slot? args
-          args.first.is_a?(Hash) && args.first[:slot]
-        end
-
-        def async_view? args
-          args.first.is_a?(Hash) && args.first[:async]
-        end
-
-        def lookup_alias_block view, args
-          opts = args[0].is_a?(Hash) ? args.shift : { view: args.shift }
-          opts[:mod] ||= self
-          opts[:view] ||= view
-          views[opts[:mod]][opts[:view]] || begin
-            raise "cannot find #{opts[:view]} view in #{opts[:mod]}; " \
-                  "failed to alias #{view} in #{self}"
-          end
-        end
-
-        def source_location
-          set_module.source_location
-        end
-
-        # remove the format part of the module name
-        def set_module
-          Card.const_get name.split("::")[0..-2].join("::")
-        end
-      end
     end
   end
 end