card 1.18.6 → 1.19.0

data/mod/machines/set/abstract/script.rb

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+require "uglifier"
+
+include_set Abstract::AceEditor
+
+def comment_with_source js
+  "//#{name}\n#{js}"
+end
+
+def clean_html?
+  false
+end
+
+format do
+  def chunk_list  # turn off autodetection of uri's
+    :nest_only
+  end
+end
+
+format :html do
+  def default_editor_args args
+    args[:ace_mode] ||= "javascript"
+  end
+
+  view :content_changes do |args|
+    %(
+      <pre>#{super(args)}</pre>
+    )
+  end
+
+  view :core do |_args|
+    process_content highlighted_js
+  end
+
+  def highlighted_js
+    ::CodeRay.scan(_render_raw, :js).div
+  end
+end
+
+def diff_args
+  { format: :text }
+end

data/mod/machines/set/all/reset_machines.rb

@@ -0,0 +1,12 @@
+module ClassMethods
+  def reset_all_machines
+    Auth.as_bot do
+      Card.search(
+        right: { codename: %w(in machine_cache machine_output) }
+      ).each do |card|
+        card.update_columns trash: true
+        card.expire
+      end
+    end
+  end
+end

data/mod/machines/set/right/machine_cache.rb

@@ -0,0 +1,11 @@
+def history?
+  false
+end
+
+def followable?
+  false
+end
+
+def clean_html?
+  false
+end

data/mod/machines/set/self/script_slot.rb

@@ -0,0 +1,7 @@
+include_set Abstract::CodeFile
+
+def source_files
+  %w(wagn_mod wagn_editor wagn_layout wagn_navbox wagn_upload wagn).map do |n|
+    "#{n}.js.coffee"
+  end
+end

data/mod/machines/set/type/coffee_script.rb

@@ -0,0 +1,40 @@
+# -*- encoding : utf-8 -*-
+require "coffee-script"
+
+include_set Abstract::Script
+
+require_dependency "card/machine"
+require_dependency "card/machine_input"
+
+include Machine
+include MachineInput
+
+store_machine_output filetype: "js"
+
+machine_input do
+  js = Uglifier.compile compile_coffee(format(:js)._render_raw)
+  comment_with_source js
+end
+
+def compile_coffee script
+  ::CoffeeScript.compile script
+rescue => e
+  raise Card::Error, "CoffeeScript::Error (#{name}): #{e.message}"
+end
+
+format :html do
+  def default_editor_args args
+    args[:ace_mode] ||= "coffee"
+  end
+
+  def highlighted_js
+    js = card.compile_coffee _render_raw
+    ::CodeRay.scan(js, :js).div
+  end
+end
+
+format do
+  view :core do |_args|
+    process_content card.compile_coffee(_render_raw)
+  end
+end

data/mod/machines/set/type/css.rb

@@ -0,0 +1,60 @@
+# -*- encoding : utf-8 -*-
+require "sass"
+include Machine
+include MachineInput
+include_set Abstract::AceEditor
+
+store_machine_output filetype: "css"
+
+machine_input do
+  compress_css format(format: :css)._render_core
+end
+
+def compress_css input
+  Sass.compile input, style: :compressed
+rescue => e
+  # scss is compiled in a view
+  # If there is a scss syntax error we get the rescued view here
+  # and the error that the rescued view is no valid css
+  # To get the original error we have to refer to Card::Error.current
+  msg = if Card::Error.current
+          Card::Error.current.message
+        else
+          "Sass::SyntaxError (#{name}): #{e.message}"
+        end
+  raise Card::Error, msg
+end
+
+def clean_html?
+  false
+end
+
+format do
+  def chunk_list # turn off autodetection of uri's
+    :references
+  end
+end
+
+format :html do
+  def default_editor_args args
+    args[:ace_mode] = "css"
+  end
+
+  def get_nest_defaults _nested_card
+    { view: :closed }
+  end
+
+  view :core do |_args|
+    # FIXME: scan must happen before process for inclusion interactions to
+    # work, but this will likely cause
+    # problems with including other css?
+    process_content ::CodeRay.scan(_render_raw, :css).div,
+                    content_opts: { size: :icon }
+  end
+
+  view :content_changes, mod: Abstract::Script::HtmlFormat
+end
+
+def diff_args
+  { format: :text }
+end

data/mod/machines/set/type/java_script.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+
+include_set Abstract::Script
+
+include Machine
+include MachineInput
+
+store_machine_output filetype: "js"
+
+machine_input do
+  js = compress_js format(:js)._render_core
+  comment_with_source js
+end
+
+def compress_js input
+  Uglifier.compile(input)
+rescue => e
+  # CoffeeScript is compiled in a view
+  # If there is a CoffeeScript syntax error we get the rescued view here
+  # and the error that the rescued view is no valid Javascript
+  # To get the original error we have to refer to Card::Error.current
+  msg = if Card::Error.current
+          Card::Error.current.message
+        else
+          "CoffeeScript::SyntaxError (#{name}): #{e.message}"
+        end
+  raise Card::Error, msg
+end
+

data/mod/machines/set/type/scss.rb

@@ -0,0 +1,14 @@
+include_set Type::Css
+
+format do
+  view :core do |_args|
+    compile_scss(process_content _render_raw)
+  end
+
+  def compile_scss scss, style=:expanded
+    Sass.compile scss, style: style
+  rescue Sass::SyntaxError => e
+    raise Card::Error, "Sass::SyntaxError (#{card.name}:#{e.sass_line}): " \
+                       "#{e.message}"
+  end
+end

data/mod/machines/set/type/skin.rb

@@ -0,0 +1,6 @@
+include Machine
+include MachineInput
+
+store_machine_output filetype: "css"
+
+include_set Pointer

data/mod/machines/spec/lib/shared_machine_examples.rb

@@ -0,0 +1,181 @@
+# -*- encoding : utf-8 -*-
+
+def that_produces type
+  type
+end
+
+def method_missing m, *args, &block
+  case m
+  when /that_produces_(.+)/
+    return Regexp.last_match(1)
+  else
+    super
+  end
+end
+
+shared_examples_for "machine" do |filetype|
+  context "machine is run" do
+    before do
+      machine.update_machine_output
+    end
+
+    it "has +machine_input card" do
+      expect(machine.machine_input_card.real?).to be_truthy
+    end
+    it "has +machine_output card" do
+      expect(machine.machine_output_card.real?).to be_truthy
+    end
+    it "generates #{filetype} file" do
+      expect(machine.machine_output_path).to match(/\.#{filetype}$/)
+    end
+  end
+end
+
+shared_examples_for "content machine" do |filetype|
+  it_should_behave_like "machine", that_produces(filetype) do
+    let(:machine) { machine_card }
+  end
+
+  context "+machine_input card" do
+    it "points to self" do
+      Card::Auth.as_bot do
+        machine_card.update_input_card
+      end
+      expect(machine_card.input_item_cards).to eq([machine_card])
+    end
+  end
+
+  context "+machine_output card" do
+    it "creates file with supplied content" do
+      path = machine_card.machine_output_path
+      expect(File.read(path)).to eq(card_content[:out])
+    end
+    it "updates #{filetype} file when content is changed" do
+      changed_factory = machine_card
+      changed_factory.putty content: card_content[:changed_in]
+      changed_path = changed_factory.machine_output_path
+      expect(File.read(changed_path)).to eq(card_content[:changed_out])
+    end
+  end
+end
+
+shared_examples_for "pointer machine" do |filetype|
+  subject do
+    # We build the following structure:
+    #
+    #  #{machine_card}
+    #    |- expected_input_items (passed by the calling test if it prepopulates
+    #                             the machine_card with some additional items)
+    #    |_ level 0 #{filetype}
+    #         |- level 1 basic 1
+    #         |- level 1 #{filetype}
+    #         |    |- level 2 basic 1
+    #         |    |- level 2 #{filetype}
+    #         |    |    |_ ....
+    #         |    |_ level 2 basic 2
+    #         |_ level 1 basic 2
+    #
+
+    change_machine = machine_card
+    @depth = 2
+    @leaf_items = []
+    @expected_items = expected_input_items || []
+    start = @expected_items.size
+    Card::Auth.as_bot do
+      @depth.times do |i|
+        @leaf_items << Card.fetch("level #{i} basic 1",
+                                  new: { type: Card::BasicID })
+        @leaf_items.last.save
+        @leaf_items << Card.fetch("level #{i} basic 2",
+                                  new: { type: Card::BasicID })
+        @leaf_items.last.save
+      end
+
+      # we build the tree from bottom up
+      last_level = false
+      (@depth - 1).downto(0) do |i|
+        next_level = Card.fetch("level #{i} #{filetype} ",
+                                new: { type: :pointer })
+        next_level.content = ""
+        next_level << @leaf_items[i * 2]
+        next_level << last_level if last_level
+        next_level << @leaf_items[i * 2 + 1]
+        next_level.save!
+        @expected_items.insert(start, @leaf_items[i * 2])
+        @expected_items.insert(start + 1, last_level) if last_level
+        @expected_items << @leaf_items[i * 2 + 1]
+        last_level = next_level
+      end
+      change_machine << last_level
+      @expected_items.insert(start, last_level)
+      change_machine << machine_input_card
+      @expected_items << machine_input_card
+      change_machine.save!
+    end
+    change_machine
+  end
+
+  it_should_behave_like "machine", that_produces(filetype) do
+    let(:machine) { machine_card }
+  end
+
+  describe "+machine_input card" do
+    before do
+      Card::Auth.as_bot do
+        subject.update_input_card
+      end
+    end
+
+    it "contains items of all levels" do
+      expect(subject.machine_input_card.item_cards.map(&:id).sort)
+        .to eq(@expected_items.map(&:id).sort)
+    end
+
+    it "preserves order of items" do
+      expect(subject.machine_input_card.item_cards.map(&:id))
+        .to eq(@expected_items.map(&:id))
+    end
+  end
+
+  describe "+machine_output card" do
+    it 'creates #{filetype} file with supplied content' do
+      path = subject.machine_output_path
+      expect(File.read(path)).to eq(card_content[:out])
+    end
+
+    it 'updates #{filetype} file if item is changed' do
+      machine_input_card.putty content: card_content[:changed_in]
+      changed_path = subject.machine_output_path
+      expect(File.read(changed_path)).to eq(card_content[:changed_out])
+    end
+
+    it 'updates #{filetype} file if item is added' do
+      Card::Auth.as_bot do
+        ca = Card.gimme! "pointer item", type: Card::SkinID, content: ""
+        subject.items = [ca]
+        ca << another_machine_input_card
+        ca.save!
+        changed_path = subject.machine_output_path
+        expect(File.read(changed_path)).to eq(card_content[:new_out])
+      end
+    end
+
+    context "a non-existent card was added as item and now created" do
+      it 'updates #{filetype} file' do
+        Card::Auth.as_bot do
+          subject.content = "[[non-existent input]]"
+          subject.save!
+          ca = Card.gimme! "non-existent input",
+                           type: input_type,
+                           content: card_content[:changed_in]
+          ca.save!
+          changed_path = subject.machine_output_path
+          input_name = machine_input_card.name
+          out =
+            card_content[:changed_out].gsub(input_name, "non-existent input")
+          expect(File.read(changed_path)).to eq(out)
+        end
+      end
+    end
+  end
+end

data/mod/machines/spec/lib/shared_machine_input_examples.rb

@@ -0,0 +1,69 @@
+# -*- encoding : utf-8 -*-
+
+shared_examples_for "machine input" do
+  subject(:input) do
+    myinput = create_machine_input_card
+    myinput
+  end
+  let!(:machine) do
+    f = create_machine_card
+    f << create_machine_input_card
+    f.putty
+    f
+  end
+  let(:more_input) do
+    moreinput = create_another_machine_input_card
+    moreinput
+  end
+
+  context "when removed" do
+    it "updates machine_input card of machine card" do
+      machine
+      Card::Auth.as_bot do
+        input.delete!
+      end
+      ca = Card.gimme machine.name
+      expect(ca.machine_input_card.item_cards).to eq([])
+    end
+
+    it "updates output of machine card" do
+      machine
+      Card::Auth.as_bot do
+        input.delete!
+      end
+      f = Card.gimme machine.cardname
+      path = f.machine_output_path
+      expect(File.read(path)).to eq("")
+    end
+  end
+
+  it "delivers machine input" do
+    expect(input.machine_input).to eq(card_content[:out])
+  end
+
+  context "when updated" do
+    it "updates output of related machine card" do
+      input.putty content: card_content[:changed_in]
+      updated_machine = Card.gimme machine.cardname
+      path = updated_machine.machine_output_path
+      expect(File.read(path)).to eq(card_content[:changed_out])
+    end
+  end
+
+  context "when added" do
+    it "updates output of related machine card" do
+      if machine.is_a? Card::Set::Type::Pointer
+        machine << more_input
+        machine.putty
+        updated_machine = Card.gimme machine.cardname
+        path = updated_machine.machine_output_path
+        out = if card_content[:added_out]
+                card_content[:added_out]
+              else
+                ([card_content[:out]] * 2).join("\n")
+              end
+        expect(File.read(path)).to eq(out)
+      end
+    end
+  end
+end