card 1.19.0 → 1.19.1

data/tmpsets/set/mod002-core/all/utils.rb

@@ -0,0 +1,62 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class All; module Utils; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/utils.rb ~~
+module ClassMethods
+  def delete_tmp_files id=nil
+    dir = Cardio.paths["files"].existent.first + "/tmp"
+    dir += "/#{id}" if id
+    FileUtils.rm_rf dir, secure: true
+  rescue
+    Rails.logger.info "failed to remove tmp files"
+  end
+
+  def merge_list attribs, opts={}
+    unmerged = []
+    attribs.each do |row|
+      result = begin
+        merge row["name"], row, opts
+      end
+      unmerged.push row unless result == true
+    end
+
+    if unmerged.empty?
+      Rails.logger.info "successfully merged all!"
+    else
+      unmerged_json = JSON.pretty_generate unmerged
+      report_unmerged_json unmerged_json, opts[:output_file]
+    end
+    unmerged
+  end
+
+  def report_unmerged_json unmerged_json, output_file
+    if output_file
+      ::File.open output_file, "w" do |f|
+        f.write unmerged_json
+      end
+    else
+      Rails.logger.info "failed to merge:\n\n#{unmerged_json}"
+    end
+  end
+
+  def merge name, attribs={}, opts={}
+    puts "merging #{name}"
+    card = fetch name, new: {}
+    [:image, :file].each do |attach|
+      next unless attribs[attach] && attribs[attach].is_a?(String)
+      attribs[attach] = ::File.open(attribs[attach])
+    end
+    if opts[:pristine] && !card.pristine?
+      false
+    else
+      card.update_attributes! attribs
+    end
+  end
+
+  def seed_test_db
+    system "env RAILS_ENV=test bundle exec rake db:fixtures:load"
+  end
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/utils.rb ~~
+end;end;end;end;

data/tmpsets/set/{mod002-history → mod003-history}/all/history.rb

@@ -85,7 +85,8 @@ event :rollback_actions, :prepare_to_validate,
   Env.params["action_ids"] = nil
   update_attributes! revision
   rollback_actions.each do |action|
-    action.card.try :symlink_to, action.id
+    # rollback file and image cards
+    action.card.try :rollback_to, action
   end
   clear_drafts
   abort :success

data/tmpsets/set/{mod003-basic_formats → mod004-basic_formats}/self/head.rb

@@ -54,7 +54,7 @@ format :html do
       if params[:debug] == "style"
         page_path(style_card.cardname, item: :import, format: :css)
       elsif style_card
-        card_path style_card.machine_output_url
+        style_card.machine_output_url
       end
     return unless @css_path
     %(<link href="#{@css_path}" media="all" rel="stylesheet" type="text/css" />)

data/tmpsets/set/mod011-machines/abstract/machine.rb

@@ -0,0 +1,277 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Machine; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/machines/set/abstract/machine.rb ~~
+# ## 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 MachineClassMethods
+  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(MachineClassMethods)
+    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 make_machine_output_coded mod=:machines
+  update_machine_output
+  Auth.as_bot do
+    output_codename =
+      machine_output_card.cardname.parts.map do |part|
+        Card[part].codename || Card[part].cardname.safe_key
+      end.join '_'
+    machine_output_card.update_attributes! codename: output_codename,
+                                           storage_type: :coded,
+                                           mod: mod
+  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
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/machines/set/abstract/machine.rb ~~
+end;end;end;end;

data/tmpsets/set/mod011-machines/abstract/machine_input.rb

@@ -0,0 +1,83 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module MachineInput; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/machines/set/abstract/machine_input.rb ~~
+module MachineInputClassMethods
+  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(MachineInputClassMethods)
+  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 =
+      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
+    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
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/machines/set/abstract/machine_input.rb ~~
+end;end;end;end;