card 1.19.0 → 1.19.1

data/config/initializers/extensions.rb

@@ -1,3 +0,0 @@
-class Kaminari::Helpers::Tag
-  include Extensions::Kaminari::Helpers::Tag
-end

data/mod/machines/lib/card/machine.rb

@@ -1,261 +0,0 @@
-class Card
-  # ## What are Machines?
-  # {Machine} and {MachineInput} together implement a kind of observer pattern.
-  # {Machine} processes a collection of input cards to generate an output card
-  # (a {Set::Type::File} card by default). If one of the input cards is changed
-  # the output card will be updated.
-  #
-  # The classic example: A style card observes a collection of css and sccs card
-  # to generate a file card with a css file that contains the assembled
-  # compressed  css.
-  #
-  # ## Using Machines
-  # Include the Machine module in the card set that is supposed to produce the
-  # output card. If the output card should be automatically updated when a input
-  # card is changed the input card has to be in a set that includes the
-  # MachineInput module.
-  #
-  # The default machine:
-  #
-  #  -  uses its item cards as input cards or the card itself if there are no
-  # item cards;
-  #  -  can be changed by passing a block to collect_input_cards
-  #  -  takes the raw view of the input cards to generate the output;
-  #  -  can be changed by passing a block to machine_input (in the input card
-  # set)
-  #  -  stores the output as a .txt file in the '+machine output' card;
-  #  -  can be changed by passing a filetype and/or a block to
-  #     store_machine_output
-  #
-  #
-  # ## How does it work?
-  # Machine cards have a '+machine input' and a '+machine output' card. The
-  # '+machine input' card is a pointer to all input cards. Including the
-  # MachineInput module creates an 'on: save' event that runs the machines of
-  # all cards that are linked to that card via the +machine input pointer.
-  module Machine
-    module ClassMethods
-      attr_accessor :output_config
-
-      def collect_input_cards &block
-        define_method :engine_input, &block
-      end
-
-      def prepare_machine_input &block
-        define_method :before_engine, &block
-      end
-
-      def machine_engine &block
-        define_method :engine, &block
-      end
-
-      def store_machine_output args={}, &block
-        output_config.merge!(args)
-        return unless block_given?
-        define_method :after_engine, &block
-      end
-    end
-
-    class << self
-      def included host_class
-        host_class.extend(ClassMethods)
-        host_class.output_config = { filetype: "txt" }
-
-        # for compatibility with old migrations
-        return unless  Codename[:machine_output]
-
-        host_class.card_accessor :machine_output, type: :file
-        host_class.card_accessor :machine_input, type: :pointer
-
-        set_default_machine_behaviour host_class
-        define_machine_views host_class
-        define_machine_events host_class
-      end
-
-      def define_machine_events host_class
-        event_suffix = host_class.name.tr ":", "_"
-        event_name = "reset_machine_output_#{event_suffix}".to_sym
-        host_class.event event_name, after: :expire_related, on: :save do
-          reset_machine_output
-        end
-      end
-
-      def define_machine_views host_class
-        host_class.format do
-          view :machine_output_url do |_args|
-            machine_output_url
-          end
-        end
-      end
-
-      def set_default_machine_behaviour host_class
-        set_default_input_collection_method host_class
-        set_default_input_preparation_method host_class
-        set_default_output_storage_method host_class
-        host_class.machine_engine { |input| input }
-      end
-
-      def set_default_input_preparation_method host_class
-        host_class.prepare_machine_input {}
-      end
-
-      def set_default_output_storage_method host_class
-        host_class.store_machine_output do |output|
-          filetype = host_class.output_config[:filetype]
-          file = Tempfile.new [id.to_s, ".#{filetype}"]
-          file.write output
-          file.rewind
-          Card::Auth.as_bot do
-            p = machine_output_card
-            p.file = file
-            p.save!
-          end
-          file.close
-          file.unlink
-        end
-      end
-
-      def set_default_input_collection_method host_class
-        host_class.collect_input_cards do
-          # traverse through all levels of pointers and
-          # collect all item cards as input
-          items = [self]
-          new_input = []
-          already_extended = {} # avoid loops
-          loop_limit = 5
-          until items.empty?
-            item = items.shift
-            next if item.trash || already_extended[item.id].to_i > loop_limit
-            if item.item_cards == [item] # no pointer card
-              new_input << item
-            else
-              # item_cards instantiates non-existing cards
-              # we don't want those
-              items.insert(0, item.item_cards.reject(&:unknown?))
-              items.flatten!
-
-              new_input << item if item != self && item.known?
-              already_extended[item] = already_extended[item].to_i + 1
-            end
-          end
-          new_input
-        end
-      end
-    end
-
-    def run_machine joint="\n"
-      before_engine
-      output =
-        input_item_cards.map do |input_card|
-          run_engine input_card
-        end.select(&:present?).join(joint)
-      after_engine output
-    end
-
-    def run_engine input_card
-      return if input_card.is_a? Card::Set::Type::Pointer
-      if (cached = fetch_cache_card(input_card))
-        return cached.content
-      end
-
-      input = if input_card.respond_to? :machine_input
-                input_card.machine_input
-              else
-                input_card.format._render_raw
-              end
-      output = engine(input)
-      cache_output_part input_card, output
-      output
-    end
-
-    def fetch_cache_card input_card, new=nil
-      new &&= { type_id: PlainTextID }
-      Card.fetch input_card.name, name, :machine_cache, new: new
-    end
-
-    def cache_output_part input_card, output
-      Auth.as_bot do
-        cache_card = fetch_cache_card(input_card, true)
-        cache_card.update_attributes! content: output
-      end
-    end
-
-    def reset_machine_output
-      Auth.as_bot do
-        (moc = machine_output_card) && moc.real? && moc.delete!
-        update_input_card
-      end
-    end
-
-    def update_machine_output
-      lock do
-        update_input_card
-        run_machine
-      end
-    end
-
-    def regenerate_machine_output
-      lock do
-        run_machine
-      end
-    end
-
-    def lock
-      if ok?(:read) && !(was_already_locked = locked?)
-        Auth.as_bot do
-          lock!
-          yield
-        end
-      end
-    ensure
-      unlock! unless was_already_locked
-    end
-
-    def lock_cache_key
-      "UPDATE-LOCK:#{key}"
-    end
-
-    def locked?
-      Card.cache.read lock_cache_key
-    end
-
-    def lock!
-      Card.cache.write lock_cache_key, true
-    end
-
-    def unlock!
-      Card.cache.write lock_cache_key, false
-    end
-
-    def update_input_card
-      if DirectorRegister.running_act?
-        input_card = attach_subcard! machine_input_card
-        input_card.content = ""
-        engine_input.each { |input| input_card << input }
-      else
-        machine_input_card.items = engine_input
-      end
-    end
-
-    def input_item_cards
-      machine_input_card.item_cards
-    end
-
-    def machine_output_url
-      ensure_machine_output
-      machine_output_card.file.url # (:default, timestamp: false)
-      # to get rid of additional number in url
-    end
-
-    def machine_output_path
-      ensure_machine_output
-      machine_output_card.file.path
-    end
-
-    def ensure_machine_output
-      output = fetch trait: :machine_output
-      return if output && output.selected_content_action_id
-      update_machine_output
-    end
-  end
-end

data/mod/machines/lib/card/machine_input.rb

@@ -1,80 +0,0 @@
-class Card
-  module MachineInput
-    module ClassMethods
-      attr_accessor :machines_wql
-
-      def machine_input_for args
-        @machines_wql = args
-      end
-
-      def machine_input &block
-        define_method :machine_input, block
-      end
-    end
-
-    def self.included host_class
-      host_class.extend(ClassMethods)
-      host_class.machines_wql = {}
-      host_class.machine_input do
-        format._render_raw
-      end
-      event_suffix = host_class.name.tr ":", "_"
-      define_update_event event_suffix, host_class
-      define_delete_events event_suffix, host_class
-    end
-
-    def self.define_delete_events event_suffix, host_class
-      event_name = "before_machine_input_deleted_#{event_suffix}".to_sym
-      host_class.event event_name, :store, on: :delete do
-        # exclude self because it's on the way to the trash
-        # otherwise it will be created again with the reset_machine_output
-        # call in the event below
-        @involved_machines =
-          Card::MachineInput.search_involved_machines(name, host_class)
-                            .reject { |card| card == self }
-      end
-      event_name = "after_machine_input_deleted_#{event_suffix}".to_sym
-      host_class.event event_name, :finalize, on: :delete do
-        expire_machine_cache
-        @involved_machines.each do |item|
-          item.reset_machine_output if item.is_a? Machine
-        end
-      end
-    end
-
-    def self.define_update_event event_suffix, host_class
-      host_class.event(
-        "after_machine_input_updated_#{event_suffix}".to_sym, :integrate,
-        on: :save
-      ) do
-        expire_machine_cache
-        Card::MachineInput.search_involved_machines(name, host_class)
-                          .each do |item|
-          item.reset_machine_output if item.is_a? Machine
-        end
-      end
-    end
-
-    def self.search_involved_machines name, host_class
-      wql_statement =
-        { right_plus: [
-          { codename: "machine_input" },
-          { link_to: name }
-        ] }.merge(host_class.machines_wql)
-      Card.search(wql_statement)
-    end
-
-    def expire_machine_cache
-      Card.search(right_plus: [
-                    { codename: "machine_input" },
-                    { link_to: name }
-                  ],
-                  return: :name).each do |machine_name|
-        next unless (cache = Card.fetch(name, machine_name, :machine_cache))
-        Auth.as_bot do
-          cache.update_attributes! trash: true
-        end
-      end
-    end
-  end
-end

data/mod/standard/spec/set/type/file_spec.rb

@@ -1,99 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Set::Type::File do
-  context "new file card" do
-    before do
-      Card::Auth.as_bot do
-        Card.create name: "file card", type_code: "file",
-                    file: File.new(File.join(FIXTURES_PATH, "file1.txt"))
-      end
-    end
-    subject { Card["file card"] }
-    it "stores correct identifier (<card id>/<action id>.<ext>)" do
-      expect(subject.content)
-        .to eq "~#{subject.id}/#{subject.last_action_id}.txt"
-    end
-
-    it "stores file" do
-      expect(subject.file.read.strip).to eq "file1"
-    end
-
-    it "saves original file name as action comment" do
-      expect(subject.last_action.comment).to eq "file1.txt"
-    end
-
-    it "has correct original filename" do
-      expect(subject.original_filename).to eq "file1.txt"
-    end
-
-    it "has correct url" do
-      expect(subject.file.url).to(
-        eq "/files/~#{subject.id}/#{subject.last_action_id}.txt"
-      )
-    end
-
-    describe "#mod_file?" do
-      it "returns false" do
-        expect(subject.mod_file?).to be_falsey
-      end
-    end
-
-    describe "view: source" do
-      it "renders url" do
-        expect(subject.format.render(:source)).to(
-          eq "/files/~#{subject.id}/#{subject.last_action_id}.txt"
-        )
-      end
-    end
-
-    context "updated file card" do
-      before do
-        file = File.new File.join(FIXTURES_PATH, "file2.txt")
-        subject.update_attributes! file: file
-      end
-      it "updates file" do
-        expect(subject.file.read.strip).to eq "file2"
-      end
-
-      it "updates original file name" do
-        expect(subject.original_filename).to eq "file2.txt"
-      end
-
-      it "updates url" do
-        expect(subject.file.url)
-          .to eq "/files/~#{subject.id}/#{subject.last_action_id}.txt"
-      end
-    end
-
-    context "subcards" do
-      it "handles file subcards" do
-        file = File.open(File.join(FIXTURES_PATH, "file1.txt"))
-        Card.create! name: "new card with file",
-                     subcards: {
-                       "+my file" => {
-                         content: "ignore content",
-                         type_id: Card::FileID,
-                         file: file
-                       }
-                     }
-        expect(Card["new card with file+my file"].file.file.read.strip)
-          .to eq "file1"
-      end
-    end
-  end
-
-  it "creates empty file card without content" do
-    card = Card.create name: "hide and seek", type_id: Card::FileID
-    expect(card.content).to eq("")
-  end
-
-  it "handles urls" do
-    # wagn.org is down so we need another url
-    url = "http://wagn.org/files/bruce_logo-large-122798.png"
-    # url = 'http://www.lcdmedia.de/UserFiles/Image/pages/reparatur/beamer_test.jpg'
-
-    Card.create! name: "url test", type_id: Card::FileID, remote_file_url: url
-    expect(Card["url test"].file.size).to be > 0
-    expect(Card["url test"].file.url).to match(/\.png$/)
-  end
-end