card 1.96.8 → 1.97.0

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

@@ -5,6 +5,7 @@ class Card
         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
@@ -12,6 +13,7 @@ class Card
 
         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 ', '}"
@@ -23,6 +25,7 @@ class Card
           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}'"
@@ -31,6 +34,7 @@ class Card
 
         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"
@@ -57,7 +61,7 @@ class Card
         end
 
         def process_action_opts opts
-          opts[:on] = [:create, :update] if opts[:on] == :save
+          opts[:on] = %i[create update] if opts[:on] == :save
         end
 
         def process_stage_opts opts

data/lib/card/set/format.rb

@@ -19,6 +19,13 @@ class Card
     #   The external api with checks:
     #     render(:viewname, args)
     #
+    #  TODO:
+    #  introduce view settings
+    #    modal: { size: :large},
+    #    cache
+    #    perms
+    #    tags: :unknown_ok
+    #    bridge
     module Format
       require_dependency "card/set/format/haml_views"
       require_dependency "card/set/format/abstract_format"
@@ -80,6 +87,20 @@ class Card
         modules[:base_format][format_class] ||= []
         modules[:base_format][format_class] << mod
       end
+
+      class << self
+        def layout_method_name layout
+          "_layout_#{layout.to_name.key}"
+        end
+
+        def wrapper_method_name wrapper
+          "_wrapper_#{wrapper}"
+        end
+
+        def view_method_name view
+          "_view_#{view}"
+        end
+      end
     end
   end
 end

data/lib/card/set/format/abstract_format.rb

@@ -8,6 +8,9 @@ class Card
       module AbstractFormat
         include Set::Basket
         include Set::Format::HamlViews
+        include Set::Format::Wrapper
+
+        VIEW_SETTINGS = %i[cache modal bridge wrap].freeze
 
         mattr_accessor :views
         self.views = Hash.new { |h, k| h[k] = {} }
@@ -17,6 +20,7 @@ class Card
         end
 
         def view view, *args, &block
+          # binding.pry
           # view = view.to_viewname.key.to_sym
           interpret_view_opts view, args[0] if block_given?
           view_method_block = view_block(view, args, &block)
@@ -40,7 +44,7 @@ class Card
 
         def define_standard_view_method view, &block
           views[self][view] = block
-          define_method "_view_#{view}", &block
+          define_method Card::Set::Format.view_method_name(view), &block
         end
 
         def define_async_view_method view, &block
@@ -53,18 +57,23 @@ class Card
 
         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)
+          VIEW_SETTINGS.each do |setting_name|
+            define_view_setting_method view, setting_name, opts.delete(setting_name)
+          end
         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 }
+        def define_view_setting_method view, setting_name, setting_value
+          return unless setting_value
+
+          method_name = Card::Format.view_setting_method_name view, setting_name
+          define_method(method_name) { setting_value }
         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
 

data/lib/card/set/format/haml_views.rb

@@ -75,7 +75,6 @@ class Card
         end
 
         def haml_to_html haml, locals={}, a_binding=nil, debug_info={}
-          # binding.pry unless haml.include? ".panel.panel-primary"
           a_binding ||= binding
           ::Haml::Engine.new(haml).render a_binding, locals || {}
         rescue Haml::SyntaxError => e
@@ -85,6 +84,7 @@ class Card
 
         def template_location debug_info
           return "" unless debug_info[:path]
+
           Pathname.new(debug_info[:path])
                   .relative_path_from(Pathname.new(Dir.pwd))
         end

data/lib/card/set/format/wrapper.rb

@@ -0,0 +1,89 @@
+class Card
+  module Set
+    module Format
+      # The Wrapper module provides an API to define wrap methods.
+      # It is available in all formats.
+      module Wrapper
+        # Defines a wrapper method with the name "wrap_with_<wrapper_name>".
+        # @param wrapper_name [Symbol, String] the name for the wrap method
+        # @param *args
+        # Inside the wrap_block the variable "interior" is always available
+        # to refer to the content that is supposed to be wrapped by the wrapper.
+        #
+        # Example:
+        #   wrapper :burger do |opts|
+        #     ["#{opts[:bun]}-bun", interior, "bun"].join "|"
+        #   end
+        #
+        # It can be used like this:
+        #   wrap_with_burger bun: "sesame" do
+        #     "meat"
+        #   end  # => "sesame-bun|meat|bun"
+        #
+        # It's also possible to wrap a whole view with a wrapper
+        #   view :whopper, wrap: :burger do
+        #     "meat"
+        #   end
+        #
+        # Options for view wrappers can be provided using a hash or, if not all wrappers
+        # need options, an array of symbols and hashes.
+        # Example
+        #   view :big_mac, wrap: { burger: { bun: "sesame" }, paper: { color: :red } }
+        #   view :cheese_burger, wrap: [:burger, paper: { color: :yellow }]
+        #
+        # If you want to define a wrapper that wraps only with a single html tag
+        # then use the following syntax:
+        #   wrapper :burger, :div, class: "medium"
+        #
+        #   wrap_with_burger "meat"  # => "<div class='medium'>meat</div>"
+        def wrapper wrapper_name, *args, &wrap_block
+          method_name = Card::Set::Format.wrapper_method_name(wrapper_name)
+          if block_given?
+            define_method method_name, &wrap_block
+          else
+            define_tag_wrapper method_name, *args
+          end
+          define_wrap_with_method wrapper_name, method_name
+        end
+
+        def layout layout, &block
+          Card::Layout.register_built_in_layout layout
+          method_name = Card::Set::Format.layout_method_name(layout)
+          define_method method_name, &block
+          wrapper layout do
+            send method_name
+          end
+        end
+
+        attr_accessor :interior
+
+        private
+
+        # expects a tag with options that defines the wrap
+        def define_tag_wrapper method_name, tag_name, default_opts={}
+          class_eval do
+            define_method method_name do |opts={}|
+              add_class opts, default_opts[:class]
+              wrap_with(tag_name, interior, opts.reverse_merge(default_opts))
+            end
+          end
+        end
+
+        # defines the wrap_with_... method that you call to use the wrapper
+        def define_wrap_with_method wrapper_name, wrapper_method_name
+          class_exec(self) do |_format|
+            define_method "wrap_with_#{wrapper_name}" do |*args, &interior|
+              @interior, opts = interior ? [interior.call, args.first] : args
+
+              if method(wrapper_method_name).arity.zero?
+                send wrapper_method_name
+              else
+                send wrapper_method_name, (opts || {})
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/set/helpers.rb

@@ -9,9 +9,14 @@ class Card
         parts[first..last].join "::"
       end
 
+      def underscore
+        shortname.tr(":", "_").underscore
+      end
+
       # move to Set::Pattern?
       def num_set_parts pattern_code
         return 1 if pattern_code == :abstract
+
         Pattern.find(pattern_code).anchor_parts_count
       end
 

data/lib/card/set/i18n_scanner.rb

@@ -1,5 +1,5 @@
 # lib/my_custom_scanner.rb
-require 'i18n/tasks/scanners/file_scanner'
+require "i18n/tasks/scanners/file_scanner"
 class Card
   module Set
     class I18nScanner < ::I18n::Tasks::Scanners::FileScanner
@@ -7,16 +7,17 @@ class Card
       include ::I18n::Tasks::Scanners::OccurrenceFromPosition
 
       # @return [Array<[absolute key, Results::Occurrence]>]
-      def scan_file(path)
+      def scan_file path
         text = read_file(path)
 
         text.scan(/[^\w._-]tr[( ]\s*["':](\w+)/).map do |_match|
           occurrence = occurrence_from_position(
-              path, text, Regexp.last_match.offset(0).first)
+            path, text, Regexp.last_match.offset(0).first
+          )
           [absolute_key(".#{_match[0]}", path), occurrence]
         end
       end
     end
-    ::I18n::Tasks.add_scanner 'Card::Set::I18nScanner'
+    ::I18n::Tasks.add_scanner "Card::Set::I18nScanner"
   end
 end

data/lib/card/set/i18n_scope.rb

@@ -44,27 +44,26 @@ class Card
       end
 
       def find_tmp_set_path backtrace
-        path = backtrace.find {|line| line.include? "tmp/set/"}
-        unless path
-          raise Error, "couldn't find set path in backtrace: #{backtrace}"
-        end
+        path = backtrace.find { |line| line.include? "tmp/set/" }
+        raise Error, "couldn't find set path in backtrace: #{backtrace}" unless path
+
         path
       end
 
       def find_set_path backtrace
-        path = backtrace.find {|line| line =~ %r{(?<!card)/set/}}
-        unless path
-          raise Error, "couldn't find set path in backtrace: #{backtrace}"
-        end
+        path = backtrace.find { |line| line =~ %r{(?<!card)/set/} }
+        raise Error, "couldn't find set path in backtrace: #{backtrace}" unless path
+
         path
       end
 
       # index of the mod part in the tmp path
       def tmp_path_mod_index parts
         unless (set_index = parts.index("set")) &&
-          parts.size >= set_index + 2
+               parts.size >= set_index + 2
           raise Error, "not a valid set path: #{path}"
         end
+
         set_index + 1
       end
 
@@ -76,9 +75,10 @@ class Card
       # index of the mod part in the path
       def path_mod_index parts
         unless (set_index = parts.index("set")) &&
-          parts.size >= set_index + 2
+               parts.size >= set_index + 2
           raise Error, "not a valid set path: #{path}"
         end
+
         set_index - 1
       end
     end

data/lib/card/set/inheritance.rb

@@ -51,6 +51,7 @@ class Card
         each_format set do |format, format_mods|
           format_sym = Card::Format.format_sym format
           next unless applicable_format?(format_sym, opts[:except], opts[:only])
+
           format_mods.each do |format_mod|
             define_on_format format_sym do
               include format_mod
@@ -67,6 +68,7 @@ class Card
         format_type = "#{set_type}_format".to_sym
         modules[format_type].each_pair do |format, set_format_mod_hash|
           next unless (format_mods = set_format_mod_hash[set.shortname])
+
           yield format, format_mods
         end
       end
@@ -75,6 +77,7 @@ class Card
         format_sym = Card::Format.format_sym format
         return false if except && Array(except).include?(format_sym)
         return false if only && !Array(only).include?(format_sym)
+
         true
       end
     end

data/lib/card/set/loader.rb

@@ -45,6 +45,7 @@ class Card
       # 'nonbase modules' are included dynamically on singleton_classes
       def process_base_modules
         return unless modules[:base].present?
+
         Card.add_set_modules modules[:base]
         modules[:base_format].each do |format_class, modules_list|
           format_class.add_set_modules modules_list

data/lib/card/set/required_field.rb

@@ -0,0 +1,74 @@
+class Card
+  module Set
+    class RequiredField
+      attr_reader :parent_set, :field_set, :field
+
+      def initialize parent_set, field
+        @parent_set = parent_set
+        @field_set = ensure_field_set parent_set, field
+        @field = field
+      end
+
+      def add
+        create_parent_event
+        create_field_events
+      end
+
+      def parent_event_name
+        [parent_set.underscore, "requires_field", field_set.underscore].join("__").to_sym
+      end
+
+      def field_event_name action
+        [field_set.underscore, "required_by", parent_set.underscore, "on", action].join("__").to_sym
+      end
+
+      private
+
+      def create_field_events
+        create_field_delete_event
+        create_field_rename_event
+      end
+
+      def create_field_delete_event
+        field_set.class_exec(self) do |required|
+          event required.field_event_name(:delete), :validate, on: :delete do
+            return if left&.singleton_class&.include?(required.parent_set)
+
+            errors.add required.field, "can't be deleted; required field of #{left.name}" # LOCALIZE
+          end
+        end
+      end
+
+      def create_field_rename_event
+        field_set.class_exec(self) do |required|
+          event required.field_event_name(:update), :validate,
+                on: :update, changing: :name do
+            parent = Card.fetch(name_before_act.to_name.left)
+            return if !parent || parent&.singleton_class&.include?(required.parent_set)
+
+            errors.add :name, "can't be renamed; required field of #{parent.name}" # LOCALIZE
+          end
+        end
+      end
+
+      def create_parent_event
+        parent_set.class_exec(self) do |required|
+          event required.parent_event_name, :validate, on: :save do
+            return if field? required.field
+
+            errors.add required.field, "required" # LOCALIZE
+          end
+        end
+      end
+
+      def ensure_field_set some_set, field
+        field_set = some_set.ensure_set { "Right::#{field.to_s.capitalize}" }
+        Card::Set.register_set field_set
+        field_set
+      end
+    end
+  end
+end
+
+
+

data/lib/card/set/trait.rb

@@ -17,6 +17,12 @@ class Card
         add_traits args, options.merge(writer: true)
       end
 
+      def require_field *fields
+        fields.each do |field|
+          Card::Set::RequiredField.new(self, field).add
+        end
+      end
+
       private
 
       def add_attributes *args