card 1.93.3 → 1.93.4

data/lib/card/subcards/add.rb

@@ -0,0 +1,121 @@
+class Card
+  class Subcards
+    # Methods for adding subcards
+    module Add
+      # @example Add a subcard with name 'spoiler'
+      #   add 'spoiler', type: 'Phrase', content: 'John Snow is a Targaryen'
+      #   card_obj = Card.new name: 'spoiler', type: 'Phrase',
+      #                       content: 'John Snow is a Targaryen'
+      #   add card_obj
+      #   add name: 'spoiler', type: 'Phrase', content: 'John Snow is a Targaryen'
+      #
+      # @example Add a subcard that is added in the integration phase
+      #     (and hence doesn't hold up the transaction for the main card)
+      #   add 'spoiler', content: 'John Snow is a Targaryen',
+      #                  transact_in_stage: :integrate
+      #   add card_obj, delayed: true
+
+      def << value
+        add value
+      end
+
+      def []= name, card_or_attr
+        case card_or_attr
+        when Hash
+          new_by_attributes name, card_or_attr
+        when Card
+          new_by_card card_or_attr
+        end
+      end
+
+      def add *args
+        case args.first
+        when Card then new_by_card(*args)
+        when Hash then add_hash args.first
+        else new_by_attributes(*args)
+        end
+      end
+
+      def add_hash hash
+        if (name = hash.delete :name)
+          new_by_attributes name, hash
+        else
+          multi_add hash
+        end
+      end
+
+      def add_child name, args
+        name = name.is_a?(Symbol) ? name.cardname : name.to_name
+        add name.prepend_joint, args
+      end
+      alias_method :add_field, :add_child
+
+      def new_by_card card, opts={}
+        card.supercard = @context_card
+        if !card.name.simple? && card.name.field_of?(@context_card.name)
+          card.superleft = @context_card
+        end
+        @keys << card.key
+        Card.write_to_soft_cache card
+        card.director = @context_card.director.subdirectors.add(card, opts)
+        card
+      end
+
+      def new_by_attributes name, attributes={}
+        attributes ||= {}
+        absolute_name = absolutize_subcard_name name
+        subcard_args = extract_subcard_args! attributes
+        t_i_s = attributes.delete(:transact_in_stage)
+        card = initialize_by_attributes absolute_name, attributes
+        subcard = new_by_card card, transact_in_stage: t_i_s
+        card.subcards.add subcard_args
+        subcard
+      end
+
+      def initialize_by_attributes name, attributes
+        Card.assign_or_initialize_by name, attributes, local_only: true
+      end
+
+      # TODO: this method already exists as card instance method in
+      #   tracked_attributes.rb. Find a place for it where its accessible
+      #   for both. There is one important difference. The keys are symbols
+      # here instead of strings
+      def extract_subcard_args! args
+        subcards = args.delete(:subcards) || {}
+        if (subfields = args.delete(:subfields))
+          subfields.each_pair do |key, value|
+            subcards[normalize_subfield_key(key)] = value
+          end
+        end
+        args.keys.each do |key|
+          subcards[key] = args.delete(key) if key =~ /^\+/
+        end
+        subcards
+      end
+
+      private
+
+      # ensure a leading '+'
+      def normalize_subfield_key key
+        if key.is_a?(Symbol) && Card::Codename.exist?(key)
+          key = Card::Codename.name(key)
+        end
+        key.to_name.prepend_joint
+      end
+
+      # Handles hash with several subcards
+      def multi_add args
+        args.each_pair do |key, val|
+          case val
+          when String then new_by_attributes key, content: val
+          when Card
+            val.name = absolutize_subcard_name key
+            new_by_card val
+          when nil then next
+          else new_by_attributes key, val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/subcards/relate.rb

@@ -0,0 +1,27 @@
+class Card
+  class Subcards
+    # Methods for handling related subcards
+    module Relate
+      def field_name_to_key name
+        if @context_card.name.starts_with_joint?
+          relative_child(name).key
+        else
+          child(name).key
+        end
+      end
+
+      def child name
+        absolute_name = @context_card.name.field_name name
+        if @keys.include? absolute_name.key
+          absolute_name
+        else
+          relative_child name
+        end
+      end
+
+      def relative_child name
+        @context_card.name.relative_field_name name
+      end
+    end
+  end
+end

data/lib/card/subcards/remove.rb

@@ -0,0 +1,42 @@
+class Card
+  class Subcards
+    # Methods for removing/clearing subcards
+    module Remove
+      def remove_child cardish
+        child = cardish.is_a?(Card) ? cardish : child(cardish)
+        remove child
+      end
+      alias_method :remove_field, :remove_child
+
+      def remove name_or_card
+        key = subcard_key name_or_card
+        return unless @keys.include? key
+        @keys.delete key
+        clear_key key
+      end
+
+      def clear
+        @keys.each { |key| clear_key key }
+        @keys = ::Set.new
+      end
+
+      def clear_key key
+        if (subcard = fetch_subcard key)
+          ActManager.deep_delete subcard.director
+          subcard.current_action&.delete
+        end
+        Card.cache.soft.delete key
+        subcard
+      end
+
+      def deep_clear cleared=::Set.new
+        each_card do |card|
+          next if cleared.include? card.id
+          cleared << card.id
+          card.subcards.deep_clear cleared
+        end
+        clear
+      end
+    end
+  end
+end

data/lib/card/tasks/card/create.rake

@@ -2,31 +2,38 @@ require "colorize"
 
 namespace :card do
   namespace :create do
-    DEFAULT_RULE = { style: "*all+*style",
-                     script: "*all+*script" }.freeze
-
-    # 1. Creates a js/coffee/css/scss file with the appropriate path in
+    # 1. Creates a js/coffee/css/scss/haml source file with the appropriate path in
     #    the given mod.
     #    If a card with the given name exists it copies the content to that
     #    file.
-    # 2. Creates a self set file that loads the code file as content
+    # 2. Creates a self set file that loads the source file as content
     # 3. Creates a card migration that adds the code card to the script/style
-    #    rule defined by DEFAULT_RULE. Override the rule_card_name
-    #    method to change it.
-    # @parem mod [String] the name of the mod where the files are created
+    #    rule defined by ScriptCard/StyleCard.default_rule_name.
+    #    Override the set_default_rule_names method to change it.
+    #    In the haml case it creates a html card with codename.
+    # @param mod [String] the name of the mod where the files are created
     # @param name [String] the card name
-    #   A "script: " or "style: " prefix is added if missing.
-    #   Whitespaces are translated to underscores for the codename.
-    # @param type supported options are js, coffee, css, scss
-    desc "create folders and files for scripts or styles"
+    # @param type [String] supported options are js, coffee, css, scss, haml
+    # @param codename [String] optional defaults to key of the name
+    # @param force ["true", "false"] if true override existing files
+    # @example
+    #   rake card:create:codefile type=scss mod=standard name="script card"
+    #                             codename=not_the_key force=true
+    desc "create folders and files for scripts, styles or haml"
     task codefile: :environment do
-      with_params(:mod, :name, :type) do |mod, name, category, type, type_codename|
-        create_content_file mod, name, type
-        create_rb_file mod, name
-        create_migration_file name, category, type_codename
+      set_default_rule_names
+      with_params :mod, :name, :type,
+                  codename: nil, force: false do |mod, name, type, codename, force|
+        Card::FileCardCreator.new(mod, name, type, codename, force == "true").create
       end
     end
 
+    # override to which rule cards script and styles cards are added
+    def set_default_rule_names
+      # Card::FileCardCreator::ScriptCard.default_rule_name =
+      # Card::FileCardCreator::StyleCard.default_rule_name =
+    end
+
     # shortcut for create:codefile type=scss
     desc "create folders and files for stylesheet"
     task style: :environment do
@@ -41,137 +48,33 @@ namespace :card do
       Rake::Task["card:create:codefile"].invoke
     end
 
-    def create_content_file mod, name, type
-      write_to_mod(mod, content_dir(type), content_filename(name, type)) do |f|
-        content = (card = Card.fetch(name)) ? card.content : ""
-        f.puts content
-      end
-    end
-
-    def create_rb_file mod, name
-      self_dir = File.join "set", "self"
-      self_file = name + ".rb"
-      write_to_mod(mod, self_dir, self_file) do |f|
-        f.puts("include_set Abstract::CodeFile")
-      end
-    end
-
-    def create_migration_file name, category, type_codename
-      puts "creating migration file...".yellow
-      migration_out = `bundle exec decko generate card:migration #{name}`
-      migration_file = migration_out[/db.*/]
-      content = migration_content name, category, type_codename
-      write_at migration_file, 5, content # 5 is line no.
+    # shortcut for create:codefile type=haml
+    desc "create folders and files for haml"
+    task haml: :environment do
+      ENV["type"] ||= "haml"
+      Rake::Task["card:create:codefile"].invoke
     end
 
     def with_params *keys
-      return unless parameters_present?(*keys)
+      optional_params = keys.last.is_a?(Hash) ? keys.pop : {}
+      return unless params_present?(*keys)
       values = keys.map { |k| ENV[k.to_s] }
-      mod, name, type = values
-      name = remove_prefix name
-      typecode = type_codename(type)
-      yield mod, name, category(typecode), type, typecode
-    end
-
-    def remove_prefix name
-      name.sub(/^(?:script|style):?_?\s*/, "")
-    end
-
-    def category typecode
-      case typecode
-      when :java_script, :coffee_script then
-        :script
-      when :css, :scss then
-        :style
+      optional_params.each_pair do |k, v|
+        values << (ENV[k.to_s] || v)
       end
+      yield(*values)
     end
 
-    def parameters_present? *env_keys
+    def params_present? *env_keys
       missing = env_keys.select { |k| !ENV[k.to_s] }
-      return true if missing.empty?
       missing.each do |key|
         color_puts "missing parameter:", :red, key
       end
-      false
+      missing.empty?
     end
 
     def color_puts colored_text, color, text=""
       puts "#{colored_text.send(color.to_s)} #{text}"
     end
-
-    def write_at fname, at_line, sdat
-      open(fname, "r+") do |f|
-        (at_line - 1).times do # read up to the line you want to write after
-          f.readline
-        end
-        pos = f.pos # save your position in the file
-        rest = f.read # save the rest of the file
-        f.seek pos # go back to the old position
-        f.puts sdat # write new data & rest of file
-        f.puts rest
-        color_puts "created", :green, fname
-      end
-    end
-
-    def write_to_mod mod, relative_dir, filename
-      mod_dir = File.join "mod", mod
-      dir = File.join mod_dir, relative_dir
-      path = File.join dir, filename
-      Dir.mkdir(dir) unless Dir.exist?(dir)
-      if File.exist?(path)
-        color_puts "file exists", :yellow, path
-      else
-        File.open(path, "w") do |opened_file|
-          yield(opened_file)
-          color_puts "created", :green, path
-        end
-      end
-    end
-
-    def type_codename type
-      case type
-      when "js" then
-        :java_script
-      when "coffee" then
-        :coffee_script
-      when "css", "scss" then
-        type.to_sym
-      else
-        color_puts "'#{type}' is not a valid type. "\
-                 "Please choose between js, coffee, css and scss.", :red
-        exit
-      end
-    end
-
-    def migration_content name, category, type_codename
-      <<-RUBY
-    add_#{category} "#{name}",
-                type_id: #{type_id type_codename},
-                to: "#{rule_card_name category}"
-      RUBY
-    end
-
-    def content_dir type
-      dir = case type
-      when "js", "coffee" then
-        "javascript"
-      when "css", "scss" then
-        "stylesheets"
-      end
-      File.join "lib", dir
-    end
-
-    def content_filename name, type
-      file_ext = type == "coffee" ? ".js.coffee" : "." + type
-      name + file_ext
-    end
-
-    def type_id type_codename
-      "Card::#{type_codename.to_s.camelcase}ID"
-    end
-
-    def rule_card_name category
-      DEFAULT_RULE[category]
-    end
   end
 end

data/lib/card/tasks/card/file_card_creator.rb

@@ -0,0 +1,25 @@
+class Card
+  # A Factory class
+  # It choses the class to create the file card accoring to the given type.
+  class FileCardCreator
+    CARD_CLASSES = [StyleCard, ScriptCard, HamlCard].freeze
+
+    attr_reader :creator
+
+    def initialize mod, name, type, codename, force
+      card_class = FileCardCreator.card_class type
+      unless card_class
+        raise "'#{type}' is not a valid type. "\
+              "Please choose between js, coffee, css, scss and haml", :red
+      end
+
+      @creator = card_class.new mod, name, type, codename: codename, force: force
+    end
+    def self.card_class type
+
+      CARD_CLASSES.find { |cc| cc.valid_type? type }
+    end
+
+    delegate :create, to: :creator
+  end
+end

data/lib/card/tasks/card/file_card_creator/abstract_file_card.rb

@@ -0,0 +1,44 @@
+class Card
+  class FileCardCreator
+    # A template class for generating cards that are linked to source files.
+    class AbstractFileCard
+      include OutputHelper
+      include SourceFile
+      include MigrationFile
+      include RubyFile
+
+      class << self
+        attr_reader :supported_types, :category
+        attr_accessor :default_rule_name
+
+        def valid_type? type
+          supported_types.include? type.to_sym
+        end
+      end
+
+      def initialize mod, name, type, codename: nil, force: false
+        @mod = mod
+        @type = type.to_sym
+        @name = name
+        @force = force
+        @codename = codename || name.to_name.key
+      end
+
+      def create
+        create_source_file
+        create_ruby_file
+        create_migration_file
+      end
+
+      def category
+        self.class.category
+      end
+
+      private
+
+      def rule_card_name
+        self.class.default_rule_name
+      end
+    end
+  end
+end