card 1.101.0 → 1.101.1

data/lib/card/model/save_helper/save_arguments.rb

@@ -0,0 +1,94 @@
+class Card
+  module Model
+    module SaveHelper
+      # private helper methods for public SaveHelper api
+      module SaveArguments
+        private
+
+        # @return args
+        def standardize_args name_or_args, content_or_args=nil, _ignore=nil
+          if name_or_args.is_a?(Hash)
+            name_or_args
+          else
+            add_name name_or_args, content_or_args || {}
+          end
+        end
+
+        def standardize_ensure_args name_or_args, content_or_args
+          name = name_or_args.is_a?(Hash) ? name_or_args[:name] : name_or_args
+          args = if name_or_args.is_a?(Hash)
+                   name_or_args
+                 else
+                   hashify content_or_args, :content
+                 end
+          [name, args]
+        end
+
+        def standardize_update_args name_or_args, content_or_args
+          return name_or_args if name_or_args.is_a?(Hash)
+
+          hashify content_or_args, :content
+        end
+
+        def hashify value_or_hash, key
+          if value_or_hash.is_a?(Hash)
+            value_or_hash
+          elsif value_or_hash.nil?
+            {}
+          else
+            { key => value_or_hash }
+          end
+        end
+
+        def create_args name_or_args, content_or_args=nil
+          args = standardize_args name_or_args, content_or_args
+          resolve_name_conflict args
+          args
+        end
+
+        def name_from_args name_or_args
+          name_or_args.is_a?(Hash) ? name_or_args[:name] : name_or_args
+        end
+
+        def resolve_name_conflict args
+          rename = args.delete :rename_if_conflict
+          return unless args[:name] && rename
+
+          args[:name] = Card.uniquify_name args[:name], rename
+        end
+
+        def ensure_attributes card, args
+          subcards = card.extract_subcard_args! args.symbolize_keys!
+          update_args = changing_args card, args
+
+          return if update_args.empty? && subcards.empty?
+
+          # FIXME: use ensure_attributes for subcards
+          card.update! update_args.merge(subcards: subcards, skip: :validate_renaming)
+        end
+
+        def changing_args card, args
+          args.select do |key, value|
+            case key.to_s
+            when /^\+/
+              changing_field_arg key, value
+            when "name"
+              card.name.to_s != value
+            else
+              standard_changing_arg card, key, value
+            end
+          end
+        end
+
+        def changing_field_arg key, value
+          subfields[key] = value
+          false
+        end
+
+        def standard_changing_arg card, key, value
+          card.send(key) != value unless value.is_a? ::File
+        end
+      end
+    end
+  end
+end

data/lib/card/model/save_helper/save_helper_helper.rb

@@ -0,0 +1,93 @@
+class Card
+  module Model
+    module SaveHelper
+      # private helper methods for public SaveHelper api
+      module SaveHelperHelper
+        CARDTYPE_METHOD_REGEXP = /^(?<method_name>create|ensure)_(?<type>.+?)(?:_card)?$/
+
+        private
+
+        def codename_from_name name
+          name.downcase.tr(" ", "_").tr(":*", "")
+        end
+
+        def delete_code_card? name
+          return false if name.is_a?(Symbol) && !Codename.exist?(name)
+
+          Card.exist? name
+        end
+
+        def add_coderule_item name, prefix, type_id, to
+          codename = "#{prefix}_#{name.tr(' ', '_').underscore}"
+          name = "#{prefix}: #{name}"
+
+          ensure_card name, type_id: type_id, codename: codename
+          Card[to].add_item! name
+        end
+
+        def method_missing method, *args
+          method_name, cardtype_card = extract_cardtype_from_method_name method
+          return super unless method_name
+
+          sargs = standardize_args(*args)
+          send "#{method_name}_card", sargs.merge(type_id: cardtype_card.id)
+        end
+
+        def respond_to_missing? method, _include_private=false
+          extract_cardtype_from_method_name(method) || super
+        end
+
+        def extract_cardtype_from_method_name method
+          return unless (match = method.match CARDTYPE_METHOD_REGEXP)
+
+          cardtype_card = cardtype_card_from_string match[:type]
+
+          return unless cardtype_card&.type_id == CardtypeID || cardtype_card&.id == SetID
+
+          [match[:method_name], cardtype_card]
+        end
+
+        def cardtype_card_from_string type
+          Card::Codename[type.to_sym] ? Card[type.to_sym] : Card[type]
+        end
+
+        def ensure_card_simplified name, args
+          ensure_card_update(name, args) || Card.create!(add_name(name, args))
+        end
+
+        def ensure_card_update name, args
+          card = Card[name]
+          return unless card
+
+          ensure_attributes card, args
+          card
+        rescue Card::Error::CodenameNotFound => _e
+          false
+        end
+
+        def validate_setting setting
+          return if Codename.exist?(setting) && Card.fetch_type_id(setting) == SettingID
+
+          raise ArgumentError, "not a valid setting: #{setting}"
+        end
+
+        def normalize_trait_rule_args setting, value
+          return value if value.is_a? Hash
+
+          if Card.fetch_type_id([setting, :right, :default]) == PointerID
+            value = Array(value).to_pointer_content
+          end
+          { content: value }
+        end
+
+        def add_name name, content_or_args
+          if content_or_args.is_a?(Hash)
+            content_or_args.reverse_merge name: name
+          else
+            { content: content_or_args, name: name }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/name/all.rb

@@ -0,0 +1,125 @@
+class Card
+  class Name
+    # methods connecting Card to Card::Name
+    module All
+      include Parts
+      include Descendants
+
+      # TODO: use delegations and include more name functions
+      delegate :simple?, :compound?, :junction?, to: :name
+
+      def name
+        @name ||= left_id ? Lexicon.lex_to_name([left_id, right_id]) : super.to_name
+      end
+
+      def key
+        @key ||= left_id ? name.key : super
+      end
+
+      def name= newname
+        @name = superize_name newname.to_name
+        self.key = @name.key
+        update_subcard_names @name
+        write_attribute :name, (@name.simple? ? @name.s : nil)
+        assign_side_ids
+        @name
+      end
+
+      def [] *args
+        case args[0]
+        when Integer, Range
+          fetch_name = Array.wrap(name.parts[args[0]]).compact.join Name.joint
+          Card.fetch(fetch_name, args[1] || {}) unless simple?
+        else
+          super
+        end
+      end
+
+      def autoname name
+        if Card.exists?(name) || Director.include?(name)
+          autoname name.next
+        else
+          name
+        end
+      end
+
+      def update_superleft cardname
+        @superleft = @supercard if cardname.field_of? @supercard.name
+      end
+
+      def update_subcard_names new_name, name_to_replace=nil
+        return unless @subcards
+        subcards.each do |subcard|
+          update_subcard_name subcard, new_name, name_to_replace if subcard.new?
+        end
+      end
+
+      def key= newkey
+        return if newkey == key
+        update_cache_key key do
+          write_attribute :key, (name.simple? ? newkey : nil)
+          @key = newkey
+        end
+        clean_patterns
+        @key
+      end
+
+      private
+
+      def assign_side_ids
+        if name.simple?
+          self.left_id = self.right_id = nil
+        else
+          assign_side_id :left_id=, :left_name
+          assign_side_id :right_id=, :right_name
+        end
+      end
+
+      # assigns left_id and right_id based on names.
+      # if side card is new, id is temporarily stored as -1
+      def assign_side_id side_id_equals, side_name
+        side_id = Lexicon.id(name.send(side_name)) || -1
+        send side_id_equals, side_id
+      end
+
+      def superize_name cardname
+        return cardname unless @supercard
+
+        @supercard.subcards.rename key, cardname.key
+        update_superleft cardname
+        @supercard.name.relative? ? cardname : cardname.absolute_name(@supercard.name)
+      end
+
+      def clean_patterns
+        return unless patterns?
+        reset_patterns
+        patterns
+      end
+
+      def update_cache_key oldkey
+        yield
+        was_in_cache = Card.cache.soft.delete oldkey
+        Card.write_to_soft_cache self if was_in_cache
+      end
+
+      def update_subcard_name subcard, new_name, name_to_replace
+        name_to_replace ||= name_to_replace_for_subcard subcard, new_name
+        subcard.name = subcard.name.swap name_to_replace, new_name.s
+        # following needed?  shouldn't #name= trigger this?
+        subcard.update_subcard_names new_name, name
+      end
+
+      def name_to_replace_for_subcard subcard, new_name
+        # if subcard has a relative name like +C
+        # and self is a subcard as well that changed from +B to A+B then
+        # +C should change to A+B+C. #replace doesn't work in this case
+        # because the old name +B is not a part of +C
+        if subcard.name.starts_with_joint? && new_name.parts.first.present?
+          "".to_name
+        else
+          name
+        end
+      end
+    end
+  end
+end

data/lib/card/name/all/class_methods.rb

@@ -0,0 +1,28 @@
+class Card
+  class Name
+    module All
+      # Name-related Card class methods
+      module ClassMethods
+        def rename! oldname, newname
+          Card[oldname].update! name: newname, update_referers: true
+        end
+
+        def uniquify_name name, rename=:new
+          return name unless Card.exists? name
+          uniq_name = generate_alternative_name name
+          return uniq_name unless rename == :old
+          rename!(name, uniq_name)
+          name
+        end
+
+        private
+
+        def generate_alternative_name name
+          uniq_name = "#{name} 1"
+          uniq_name.next! while Card.exists?(uniq_name)
+          uniq_name
+        end
+      end
+    end
+  end
+end

data/lib/card/name/all/descendants.rb

@@ -0,0 +1,46 @@
+class Card
+  class Name
+    module All
+      # Card methods for finding name children, eg A+B is a child of A and B
+      module Descendants
+        # NOTE: for all these helpers, method returns *all* fields/children/descendants.
+        # (Not just those current user has permission to read.)
+
+        def fields
+          field_ids.map { |id| Card[id] }
+        end
+
+        def field_names
+          field_ids.map { |id| Card::Name[id] }
+        end
+
+        def field_ids
+          child_ids :left
+        end
+
+        def each_child
+          child_ids.each do |id|
+            (child = Card[id]) && yield(child)
+            # check should not be needed (remove after fixing data problems)
+          end
+        end
+
+        # eg, A+B is a child of A and B
+        def child_ids side=nil
+          return [] unless id
+          side ||= name.simple? ? :part : :left_id
+          Auth.as_bot do
+            Card.search({ side => id, return: :id, limit: 0 }, "children of #{name}")
+          end
+        end
+
+        def each_descendant &block
+          each_child do |child|
+            yield child
+            child.each_descendant(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/name/all/parts.rb

@@ -0,0 +1,67 @@
+class Card
+  class Name
+    module All
+      # Card methods for handling name parts, eg A and B are both parts of A+B
+      module Parts
+        def left *args
+          case
+          when simple?    then nil
+          when superleft then superleft
+          when name_is_changing? && name.to_name.trunk_name == name_before_act.to_name
+            nil # prevent recursion when, eg, renaming A+B to A+B+C
+          else
+            Card.fetch name.left, *args
+          end
+        end
+
+        def left_or_new args={}
+          left(args) || Card.new(args.merge(name: name.left))
+        end
+
+        def right *args
+          Card.fetch(name.right, *args) unless simple?
+        end
+
+        def trunk *args
+          simple? ? self : left(*args)
+        end
+
+        def tag *args
+          simple? ? self : Card.fetch(name.right, *args)
+        end
+
+        def right_id= cardish
+          write_card_or_id :right_id, cardish
+        end
+
+        def left_id= cardish
+          write_card_or_id :left_id, cardish
+        end
+
+        private
+
+        def write_card_or_id attribute, cardish
+          when_id_exists(cardish) { |id| write_attribute attribute, id }
+        end
+
+        def when_id_exists cardish, &block
+          if (card_id = Card.id cardish)
+            yield card_id
+          elsif cardish.is_a? Card
+            with_id_after_store cardish, &block
+          else
+            yield cardish # eg nil
+          end
+        end
+
+        # subcards are usually saved after super cards;
+        # after_store forces it to save the subcard first
+        # and callback afterwards
+        def with_id_after_store subcard
+          add_subcard subcard
+          subcard.director.after_store { |card| yield card.id }
+        end
+      end
+    end
+  end
+end