card 1.104.2 → 1.105.1

data/lib/card/file_card_creator/script_card.rb

@@ -1,35 +0,0 @@
-require_relative "./abstract_file_card"
-
-class Card
-  class FileCardCreator
-    # Move javascript or coffeescript from the card database to a file.
-    # It generates three files:
-    #  1. a migration file that ensures the card has a codename and adds it to the
-    #     script rule card.
-    #  2. a script file with the source code
-    #  3. a ruby file (=code rule) that ties the script file to the card
-    class ScriptCard < AbstractFileCard
-      @supported_types = %i[js coffee]
-      @category = :script
-      @default_rule_name = "*all+*script"
-
-      private
-
-      def source_file_ext
-        @type == :coffee ? "js.coffee" : @type
-      end
-
-      def type_codename
-        @type_codename ||=
-          case @type
-          when :js then :java_script
-          when :coffee then :coffee_script
-          end
-      end
-
-      def source_file_dir
-        File.join "lib", "javascript"
-      end
-    end
-  end
-end

data/lib/card/file_card_creator/style_card.rb

@@ -1,25 +0,0 @@
-class Card
-  class FileCardCreator
-    # Move css or scss from the card database to a file.
-    # It generates three files:
-    #  1. a migration file that ensures the card has a codename and adds it to the
-    #     style rule card.
-    #  2. a style file with the source code
-    #  3. a ruby file (=code rule) that ties the style file to the card
-    class StyleCard < AbstractFileCard
-      @supported_types = %i[css scss]
-      @category = :style
-      @default_rule_name = "*all+*style"
-
-      private
-
-      def type_codename
-        @type_codename ||= @type.to_sym
-      end
-
-      def source_file_dir
-        File.join "lib", "stylesheets"
-      end
-    end
-  end
-end

data/lib/card/file_card_creator.rb

@@ -1,25 +0,0 @@
-class Card
-  # A Factory class
-  # It chooses the class to create the file card according 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/name/fields_and_traits.rb

@@ -1,42 +0,0 @@
-class Card
-  class Name
-    # Name-based "Fields" are compound names in which the right name is treated
-    # as an attribute of the left.  (Eg MyName+address)
-    #
-    # "Traits" are the subset of fields in which the right name corresponds to a
-    # card with a codename
-    module FieldsAndTraits
-      # @return [String]
-      def field tag_name
-        field_name(tag_name).s
-      end
-
-      # @return [Card::Name]
-      def field_name tag
-        tag = tag.to_s[1..-1] if !tag.is_a?(Symbol) && tag.to_s[0] == "+"
-        [self, tag].to_name
-      end
-
-      # @return [True/False]
-      def field_of? context
-        return false unless compound?
-
-        if context.present?
-          absolute_name(context).left_name.key == context.to_name.key
-        else
-          s.match?(/^\s*\+[^+]+$/)
-        end
-      end
-
-      # name is relative name containing only the rightmost part
-      # @return [True/False]
-      def field_only?
-        relative? && stripped.to_name.parts.reject(&:blank?).first == parts.last
-      end
-
-      def relative_field_name tag_name
-        field_name(tag_name).name_from self
-      end
-    end
-  end
-end

data/lib/cardio/commands/application.rb

@@ -1,10 +0,0 @@
-require "rails/generators"
-require File.expand_path("../../../generators/deck/deck_generator", __FILE__)
-
-if ARGV.first != "new"
-  ARGV[0] = "--help"
-else
-  ARGV.shift
-end
-
-Cardio::Generators::Deck::DeckGenerator.start

data/lib/cardio/migration/import/import_data/card_attributes.rb

@@ -1,64 +0,0 @@
-module Cardio
-  class Migration
-    class Import
-      class ImportData
-        # handles card attributes for import
-        module CardAttributes
-          def card_attributes data
-            card_attr = ::Set.new %i[name type codename file image]
-            data.select { |k, v| v && card_attr.include?(k) }
-          end
-
-          def update_card_attributes card_data
-            card_entry = find_card_attributes card_data[:name]
-            # we only want strings and not the whole name objects
-            # for name and type
-            card_data[:name] = card_data[:name].to_s
-            card_data[:type] = card_data[:type].to_s
-            if card_entry
-              card_entry.replace card_data
-            else
-              cards << card_data
-            end
-          end
-
-          def update_attribute name, attr_key, attr_value
-            card = find_card_attributes name
-            return unless card
-
-            card[attr_key] = attr_value
-            card
-          end
-
-          def write_attributes
-            File.write @path, @data.to_yaml
-          rescue SystemCallError
-            false
-            # card.yml not written
-          end
-
-          def read_attributes
-            ensure_path
-            return { cards: [], remotes: {} } unless File.exist? @path
-
-            YAML.load_file(@path).deep_symbolize_keys
-          end
-
-          def find_card_attributes name
-            key = name.to_name.key
-            cards.find do |attr|
-              key == (attr[:key].present? ? attr[:key] : attr[:name].to_name.key)
-            end
-          end
-
-          private
-
-          def ensure_path
-            dir = File.dirname(@path)
-            FileUtils.mkpath dir unless Dir.exist? dir
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cardio/migration/import/import_data/card_content.rb

@@ -1,30 +0,0 @@
-module Cardio
-  class Migration
-    class Import
-      class ImportData
-        # handles card content for import
-        module CardContent
-          def card_content data
-            File.read content_path(data)
-          end
-
-          def content_changed? data
-            Time.parse(data[:merged]) < File.mtime(content_path(data))
-          end
-
-          private
-
-          def write_card_content data, content
-            FileUtils.mkpath @card_content_dir unless Dir.exist? @card_content_dir
-            File.write content_path(data), content.to_s
-          end
-
-          def content_path data
-            filename = (data[:key] || data[:name]).to_name.safe_key
-            File.join @card_content_dir, filename
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cardio/migration/import/import_data.rb

@@ -1,119 +0,0 @@
-module Cardio
-  class Migration
-    class Import
-      # Handles the card attributes and remotes for the import
-      class ImportData
-        include CardContent
-        include CardAttributes
-
-        # Takes a block to update import data
-        # use #add_card and #add_remote in the block to make
-        # changes
-        def self.update data_path
-          data = ImportData.new(data_path)
-          yield(data)
-          data.write_attributes
-        end
-
-        def self.load data_path, opts={}
-          data = ImportData.new(data_path)
-          if opts[:all]
-            data.all_cards
-          elsif opts[:only]
-            data.select_cards opts[:only]
-          else
-            data.changed_cards
-          end
-        end
-
-        def initialize data_path
-          @path = File.join data_path, "cards.yml"
-          @card_content_dir = File.join data_path, "cards"
-          @data = read_attributes
-        end
-
-        def all_cards
-          cards.map { |data| prepare_for_import data }
-        end
-
-        def select_cards names_or_keys
-          names_or_keys.map do |key|
-            attributes = find_card_attributes(key)
-            unless attributes
-              raise("no entry for #{key} (key: #{key.to_name.key}) in #{@path}")
-            end
-
-            prepare_for_import attributes
-          end
-        end
-
-        def changed_cards
-          cards.map do |data|
-            next unless changed?(data)
-
-            prepare_for_import data
-          end.compact
-        end
-
-        # mark as merged
-        def merged data, time
-          update_attribute data["name"], :merged, time
-        end
-
-        # to be used in an update block
-        def add_card card_data
-          card_attr, card_content = split_attributes_and_content card_data
-
-          update_card_attributes card_attr
-          write_card_content card_attr, card_content
-          card_attr
-        end
-
-        # to be used in an update block
-        def add_remote name, url
-          remotes[name] = url
-        end
-
-        def url remote_name
-          remotes[remote_name.to_sym] || raise("unknown remote: #{remote_name}")
-        end
-
-        private
-
-        def split_attributes_and_content data
-          card_data = {}
-          %i[name type codename].each do |key|
-            card_data[key] = data[key] if data[key]
-          end
-          card_data[:key] = data[:name].to_name.key
-          [card_data, data[:content]]
-        end
-
-        def remotes
-          @data[:remotes]
-        end
-
-        def cards
-          @data[:cards]
-        end
-
-        def prepare_for_import data
-          hash = card_attributes(data)
-          hash[:content] = card_content(data)
-          %i[file image].each do |attach|
-            hash[attach] &&= card_attachment(attach, data)
-          end
-          hash.with_indifferent_access
-        end
-
-        def changed? data
-          !data[:merged] || content_changed?(data)
-        end
-
-        def card_attachment attach_type, data
-          Cardio::Migration.data_path "files/#{data[attach_type]}"
-        end
-      end
-    end
-  end
-end

data/lib/cardio/migration/import/merger.rb

@@ -1,46 +0,0 @@
-module Cardio
-  class Migration
-    class Import
-      # executes the card import
-      class Merger
-        def initialize data_path, opts={}
-          @data_path = data_path
-          @output_path = File.join data_path, "unmerged"
-          @data = ImportData.load @data_path, opts
-        end
-
-        def merge
-          puts("nothing to merge") && return if @data.empty?
-
-          without_mail_deliveries do
-            Card::Auth.as_bot do
-              Card.merge_list @data, output_file: @output_path
-            end
-
-            update_import_data
-          end
-        end
-
-        private
-
-        def without_mail_deliveries
-          m = Card::Mailer
-          prior = m.perform_deliveries
-          m.perform_deliveries = false
-          yield
-        ensure
-          m.perform_deliveries = prior
-        end
-
-        def update_import_data
-          update_time = Time.zone.now.to_s
-          ImportData.update(@data_path) do |import_data|
-            @data.each do |card_data|
-              import_data.merged card_data, update_time
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cardio/migration/import.rb

@@ -1,125 +0,0 @@
-require_relative "import/import_data"
-require_relative "import/merger"
-
-module Cardio
-  class Migration
-    # Imports card data from a local or remote deck
-    #
-    # The cards' content for the import is stored for every card in a separate
-    # file, other attributes like name or type are stored for all cards together
-    # in a yml file.
-    #
-    # To update a card's content you only have to change the card's content
-    # file. The merge method will recognize that the file was changed
-    # since the last merge and merge it into the cards table
-    # To update other attributes change them in the yml file and either remove
-    # the 'merged' value or touch the corresponding content file
-    class Import
-      def initialize data_path
-        @data_path = data_path
-      end
-
-      # Merge the import data into the cards table.
-      # Bu default it merges only the data that was changed or added
-      # since the last merge.
-      # @param [Hash] opts choose which cards to merge
-      # @option opts [Boolean] :all merge all available import data
-      # @option opts [Array] :only a key/name or list of keys/names to
-      #   be merged
-      def merge opts={}
-        Merger.new(@data_path, opts).merge
-      end
-
-      # Get import data from a deck
-      # @param [String] name The name of the card to be imported
-      # @param [Hash] opts pull options
-      # @option opts [String] remote Use a remote url. The remote url must
-      #   have been registered via 'add_remote'
-      # @option opts [Boolean] deep if true fetch all nested cards, too
-      # @option opts [Boolean] items_only if true fetch all nested cards but
-      #   not the card itself
-      def pull name, opts={}
-        update do |import_data|
-          url = opts[:remote] ? import_data.url(opts.delete(:remote)) : nil
-          fetch_card_data(name, url, opts).each do |card_data|
-            import_data.add_card card_data
-          end
-        end
-      end
-
-      # Add a card with the given attributes to the import data
-      def add_card attr
-        update do |data|
-          data.add_card attr
-        end
-      end
-
-      # Save an url as remote deck to make it available for the pull method
-      def add_remote name, url
-        update do |data|
-          data.add_remote name, url
-        end
-      end
-
-      private
-
-      def update &block
-        ImportData.update @data_path, &block
-      end
-
-      def importer
-        @importer ||= ImportData.new @data_path
-      end
-
-      # Returns an array of hashes with card attributes
-      def fetch_card_data name, url, opts
-        view, result_key = fetch_card_data_view_and_key opts
-        card_data = fetch_all_card_data name, view, url
-        result_key ? [card_data[result_key]] : card_data
-      end
-
-      def fetch_all_card_data name, view, url
-        if url
-          fetch_remote_data name, view, url
-        else
-          fetch_local_data name, view
-        end
-      end
-
-      def fetch_card_data_view_and_key opts
-        if opts[:items_only]
-          ["export_items", nil]
-        elsif opts[:deep]
-          ["export", nil]
-        else
-          [nil, :card]
-        end
-      end
-
-      def fetch_remote_data name, view, url
-        json_url = "#{url}/#{name}.json"
-        json_url += "?view=#{view}" if view
-        json = open(json_url).read
-        parse_and_symbolize json
-      end
-
-      def fetch_local_data name, view
-        Card::Auth.as_bot do
-          Card[name].format(format: :json).render!(view || :page)
-        end
-      end
-
-      def parse_and_symbolize json
-        parsed = JSON.parse(json)
-        case parsed
-        when Hash
-          parsed.deep_symbolize_keys
-        when Array
-          parsed.map(&:deep_symbolize_keys)
-        else
-          parsed
-        end
-      end
-    end
-  end
-end

data/lib/tasks/card/create.rake

@@ -1,81 +0,0 @@
-require "colorize"
-
-namespace :card do
-  namespace :create do
-    # 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 source file as content
-    # 3. Creates a card migration that adds the code card to the script/style
-    #    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
-    # @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
-      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
-      ENV["type"] ||= "scss"
-      Rake::Task["card:create:codefile"].invoke
-    end
-
-    # shortcut for create:codefile type=coffee
-    desc "create folders and files for script"
-    task script: :environment do
-      ENV["type"] ||= "coffee"
-      Rake::Task["card:create:codefile"].invoke
-    end
-
-    # 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
-      optional_params = keys.last.is_a?(Hash) ? keys.pop : {}
-      return unless params_present?(*keys)
-
-      values = keys.map { |k| ENV[k.to_s] }
-      optional_params.each_pair do |k, v|
-        values << (ENV[k.to_s] || v)
-      end
-      yield(*values)
-    end
-
-    def params_present? *env_keys
-      missing = env_keys.reject { |k| ENV[k.to_s] }
-      missing.each do |key|
-        color_puts "missing parameter:", :red, key
-      end
-      missing.empty?
-    end
-
-    def color_puts colored_text, color, text=""
-      puts "#{colored_text.send(color.to_s)} #{text}"
-    end
-  end
-end

data/lib/tasks/card.rake

@@ -1,65 +0,0 @@
-require "optparse"
-
-namespace :card do
-  desc "ingest card data from mod yaml"
-  task eat: :environment do
-    parse_options :eat do
-      add_opt :m, :mod, "only merge cards in given mod"
-      add_opt :e, :env, "environment of yaml source (default is current env)"
-      add_opt :u, :user, "user to credit unless specified (otherwise uses Decko Bot)"
-      flag_opt :v, :verbose, "progress info and error backtraces"
-    end
-    Cardio::Mod::Eat.new(**options).up
-    exit 0
-  end
-
-  desc "export card data to mod yaml"
-  task poop: :environment do
-    parse_options :poop do
-      add_opt :n, :name, "export card with name/mark (handles : and ~ prefixes)"
-      flag_opt :i, :items, "also export card items (with -n)"
-      flag_opt :o, :only_items, "also export card items (with -n)", items: :only
-      add_opt :c, :cql, "export cards found by CQL (in JSON format)"
-      add_opt :m, :mod, "output yaml to data/environment.yml file in mod"
-      add_opt :e, :env, "environment to dump to (default is current env)"
-      add_opt :t, :field_tags, "comma-separated list of field tag marks"
-    end
-    result = Cardio::Mod::Poop.new(**options).out
-    exit 0 if result == :success
-
-    puts "ERROR in card:poop\n  #{result}".red
-    exit 1
-  end
-
-  desc "reset cache"
-  task reset_cache: :environment do
-    Card::Cache.reset_all
-  end
-
-  def options
-    @options ||= {}
-  end
-
-  def flag_opt letter, key, desc, hash=nil
-    hash ||= { key => true }
-    op.on("-#{letter}", "--#{key.to_s.tr '_', '-'}", desc) { options.merge! hash }
-  end
-
-  def add_opt letter, key, desc
-    op.on "-#{letter}", "--#{key.to_s.tr '_', '-'} #{key.to_s.upcase}", desc do |val|
-      options[key] = val
-    end
-  end
-
-  def op
-    @op ||= OptionParser.new
-  end
-
-  def parse_options task
-    op.banner = "Usage: rake card:#{task} -- [options]"
-    yield if block_given?
-    args = op.order!(ARGV) {}
-    # args << "-h" if args.empty?
-    op.parse! args
-  end
-end

data/mod/admin/locales/de.yml

@@ -1,4 +0,0 @@
-de:
-  admin_warn: ADMINISTRATOR WARNUNG
-  admin_email_off:
-    E-Mail-Versand ist ausgeschaltet. Ändere die Einstellungen in %{path}, damit Benachrichtigungen verschickt werden, wenn sich neue Nutzer registrieren.

data/mod/admin/locales/en.yml

@@ -1,4 +0,0 @@
-en:
-  admin_warn: ADMINISTRATOR WARNING
-  admin_email_off:
-    Email delivery is turned off. Change settings in %{path} to send sign up notifications.