card 1.18.6 → 1.19.0

data/lib/card/format/nest/subformat.rb

@@ -0,0 +1,32 @@
+class Card
+  class Format
+    module Nest
+      module Subformat
+        def subformat subcard
+          subcard = Card.fetch(subcard, new: {}) if subcard.is_a?(String)
+          self.class.new subcard,
+                         parent: self, depth: @depth + 1, root: @root,
+                         # FIXME: - the following four should not be hard-coded
+                         # here.  need a generalized mechanism
+                         # for attribute inheritance
+                         context_names: @context_names, mode: @mode,
+                         mainline: @mainline, form: @form
+        end
+
+        def field_subformat field
+          field = card.cardname.field(field) unless field.is_a?(Card)
+          subformat field
+        end
+
+        private
+
+        def nest_subformat nested_card, opts
+          return self if opts[:inc_name] =~ /^_(self)?$/
+          sub = subformat nested_card
+          sub.nest_opts = opts[:items] ? opts[:items].clone : {}
+          sub
+        end
+      end
+    end
+  end
+end

data/lib/card/format/nest/view.rb

@@ -0,0 +1,74 @@
+class Card
+  class Format
+    module Nest
+      # Renders views for a nests
+      module View
+        NEST_MODES = { new: :edit,
+                       closed_content: :closed,
+                       setup: :edit,
+                       edit: :edit, closed: :closed, layout: :layout,
+                       normal: :normal, template: :template }.freeze
+
+        def nest_render view, opts
+          optional_render nest_view(view), opts
+        end
+
+        def with_nest_mode mode
+          if (switch_mode = NEST_MODES[mode]) && @mode != switch_mode
+            old_mode = @mode
+            @mode = switch_mode
+            @nest_defaults = nil
+          end
+          result = yield
+          if old_mode
+            @nest_defaults = nil
+            @mode = old_mode
+          end
+          result
+        end
+
+        private
+
+        def nest_view view
+          # This was refactored based on the assumption that the subformat
+          # has always the same @mode as its parent format
+          # The nest view used to be based on the mode of the parent format
+          case @mode
+          when :edit then view_in_edit_mode(view)
+          when :template then :template_rule
+          when :closed then view_in_closed_mode(view)
+          else view
+          end
+        end
+
+        # Returns the view that the card should use
+        # if nested in edit mode
+        def view_in_edit_mode homeview
+          not_in_form =
+            Card::Format.perms[homeview] == :none || # view configured not to keep in form
+            card.structure || # not yet nesting structures
+            card.key.blank? # eg {{_self|type}} on new cards
+
+          not_in_form ? :blank : :edit_in_form
+        end
+
+        # Return the view that the card should use
+        # if nested in closed mode
+        def view_in_closed_mode homeview
+          approved_view = Card::Format.closed[homeview]
+          if approved_view == true
+            homeview
+          elsif Card::Format.error_code[homeview]
+            homeview
+          elsif approved_view
+            approved_view
+          elsif !card.known?
+            :closed_missing
+          else
+            :closed_content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/format/registration.rb

@@ -0,0 +1,69 @@
+class Card
+  class Format
+    module Registration
+      def register format
+        registered << format.to_s
+      end
+
+      def format_class_name format
+        format = format.to_s
+        format = "" if format == "base"
+        format = aliases[format] if aliases[format]
+        "#{format.camelize}Format"
+      end
+
+      def format_sym format
+        return format if format.is_a? Symbol
+        match = format.to_s.match(/::(?<format>[^:]+)Format/)
+        match ? match[:format] : :base
+      end
+
+      def extract_class_vars view, opts
+        return unless opts.present?
+        [:perms, :error_code, :denial, :closed].each do |varname|
+          class_var = send varname
+          class_var[view] = opts.delete(varname) if opts[varname]
+        end
+        extract_view_tags view, opts
+      end
+
+      def extract_view_tags view, opts
+        tags = opts.delete :tags
+        return unless tags
+        Array.wrap(tags).each do |tag|
+          view_tags[view] ||= {}
+          view_tags[view][tag] = true
+        end
+      end
+
+      def new card, opts={}
+        if self != Format
+          super
+        else
+          format = opts[:format] || :html
+          klass = class_from_name format_class_name(format)
+          self == klass ? super : klass.new(card, opts)
+        end
+      end
+
+      def class_from_name formatname
+        if formatname == "Format"
+          Card::Format
+        else
+          Card::Format.const_get formatname
+        end
+      end
+
+      def tagged view, tag
+        return unless view && tag && (viewhash = view_tags[view.to_sym])
+        viewhash[tag.to_sym]
+      end
+
+      def format_ancestry
+        ancestry = [self]
+        ancestry += superclass.format_ancestry unless self == Card::Format
+        ancestry
+      end
+    end
+  end
+end

data/lib/card/format/render.rb

@@ -1,11 +1,11 @@
 class Card
   class Format
+    # View rendering methods.
+    #
     module Render
-      def page view, slot_opts
-        @card.run_callbacks :show_page do
-          show view, slot_opts
-        end
-      end
+      DEPRECATED_VIEWS = {
+        view: :open, card: :open, line: :closed, bare: :core, naked: :core
+      }.freeze
 
       def render view, args={}
         view = canonicalize_view view
@@ -14,9 +14,9 @@ class Card
         current_view(view) do
           args = default_render_args view, args
           with_nest_mode view do
-            Card::ViewCache.fetch(self, view, args) do
+            Card::Cache::ViewCache.fetch(self, view, args) do
               method = view_method view, args
-              method.arity == 0 ? method.call : method.call(args)
+              method.arity.zero? ? method.call : method.call(args)
             end
           end
         end
@@ -24,11 +24,24 @@ class Card
         rescue_view e, view
       end
 
+      def render_api match, opts
+        view = match[3] ? match[4] : opts.shift
+        args = opts[0] ? opts.shift.clone : {}
+        optional_render_args(args, opts) if match[2]
+        args[:skip_permissions] = true if match[1]
+        render view, args
+      end
+
+      def optional_render_args args, opts
+        args[:optional] = true
+        args[:default_visibility] = opts.shift
+      end
+
       def view_method view, args
         method "_view_#{view}"
       rescue
         args[:unsupported_view] = view
-        method '_view_unsupported_view'
+        method "_view_unsupported_view"
       end
 
       def canonicalize_view view
@@ -46,21 +59,23 @@ class Card
       end
 
       def show_view? view, args
-        default = args.delete(:default_visibility) || :show # FIXME: - ugly
-        api_option = args["optional_#{view}".to_sym]
-        case api_option
+        code_config = args["optional_#{view}".to_sym]
+        case code_config
           # permanent visibility specified in code
         when :always then true
-        when  :never then false
+        when :never  then false
+        else configured_visibility view, args, code_config
+        end
+      end
+
+      def configured_visibility view, args, code_config
+        card_config = nest_arg_visibility view, args
+        case (card_config || code_config)
+        when :show then true
+        when :hide then false
         else
-          # wagneer can override code settings
-          contextual_setting = nest_arg_visibility(view, args) || api_option
-          case contextual_setting
-          when :show then true
-          when :hide then false
-          else
-            default == :show
-          end
+          default_viz = args.delete :default_visibility
+          default_viz ? default_viz == :show : true
         end
       end
 
@@ -73,28 +88,20 @@ class Card
 
       def parse_view_visibility val
         case val
-        when NilClass then
-          []
-        when Array then
-          val
-        when String then
-          val.split(/[\s,]+/)
-        else
-          raise Card::Error, "bad show/hide argument: #{val}"
+        when NilClass then []
+        when Array    then val
+        when String   then val.split(/[\s,]+/)
+        else raise Card::Error, "bad show/hide argument: #{val}"
         end.map { |view| canonicalize_view view }
       end
 
       def default_render_args view, a=nil
         args =
           case a
-          when nil then
-            {}
-          when Hash then
-            a.clone
-          when Array then
-            a[0].merge a[1]
-          else
-            raise Card::Error, "bad render args: #{a}"
+          when nil   then {}
+          when Hash  then a.clone
+          when Array then a[0].merge a[1]
+          else raise Card::Error, "bad render args: #{a}"
           end
 
         default_method = "default_#{view}_args"
@@ -102,16 +109,6 @@ class Card
         args
       end
 
-      def rescue_view e, view
-        raise e if Rails.env =~ /^cucumber|test$/
-        Rails.logger.info "\nError rendering #{error_cardname} / #{view}: "\
-                        "#{e.class} : #{e.message}"
-        Card::Error.current = e
-        card.notable_exception_raised
-        raise e if (debug = Card[:debugger]) && debug.content == 'on'
-        rendering_error e, view
-      end
-
       def current_view view
         old_view = @current_view
         @current_view = view
@@ -119,28 +116,6 @@ class Card
       ensure
         @current_view = old_view
       end
-
-      def error_cardname
-        card && card.name.present? ? card.name : 'unknown card'
-      end
-
-      def rendering_error _exception, view
-        "Error rendering: #{error_cardname} (#{view} view)"
-      end
-
-      def add_class options, klass
-        options[:class] = [options[:class], klass].flatten.compact * ' '
-      end
-
-      def id_counter
-        return @parent.id_counter if @parent
-        @id_counter ||= 0
-        @id_counter += 1
-      end
-
-      def unique_id
-        "#{card.key}-#{id_counter}"
-      end
     end
   end
 end

data/lib/card/mailer.rb

@@ -1,12 +1,12 @@
 # -*- encoding : utf-8 -*-
-require 'open-uri'
+require "open-uri"
 
 class Card
   class Mailer < ActionMailer::Base
     @@defaults = Card.config.email_defaults || {}
     @@defaults.symbolize_keys!
     @@defaults[:return_path] ||= @@defaults[:from] if @@defaults[:from]
-    @@defaults[:charset] ||= 'utf-8'
+    @@defaults[:charset] ||= "utf-8"
     default @@defaults
 
     class << self

data/lib/card/migration.rb

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 
 class Card::Migration < ActiveRecord::Migration
-  include Card::ActiveRecordHelper
+  include Card::Model::SaveHelper
   @type = :deck_cards
 
   class << self
@@ -59,13 +59,13 @@ class Card::Migration < ActiveRecord::Migration
 
     def data_path filename=nil
       path = migration_paths.first
-      File.join([path, 'data', filename].compact)
+      File.join([path, "data", filename].compact)
     end
   end
 
   def contentedly
     Card::Cache.reset_all
-    Cardio.schema_mode '' do
+    Cardio.schema_mode "" do
       Card::Auth.as_bot do
         ActiveRecord::Base.transaction do
           begin
@@ -92,8 +92,8 @@ class Card::Migration < ActiveRecord::Migration
     meta_data = JSON.parse(File.read(data_path(filename)))
     full_data =
       meta_data.map do |hash|
-        hash['content'] =
-          File.read data_path(File.join('cards', hash['name'].to_name.key))
+        hash["content"] =
+          File.read data_path(File.join("cards", hash["name"].to_name.key))
         hash
       end
     Card.merge_list full_data, merge_opts
@@ -102,7 +102,7 @@ class Card::Migration < ActiveRecord::Migration
   def read_json filename
     raw_json = File.read data_path(filename)
     json = JSON.parse raw_json
-    json['card']['value']
+    json["card"]["value"]
   end
 
   def data_path filename=nil
@@ -139,8 +139,8 @@ class Card::Migration < ActiveRecord::Migration
   end
 
   def update_machine_output
-    Card.search(right: { codename: 'machine_output' }).each(&:delete)
+    Card.search(right: { codename: "machine_output" }).each(&:delete)
   end
 end
 
-require 'card/core_migration'
+require "card/migration/core"

data/lib/card/migration/core.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+require "card/migration"
+
+class Card
+  class Migration
+    class Core < Migration
+      @type = :core_cards
+    end
+  end
+end

data/lib/card/migration/import.rb

@@ -0,0 +1,105 @@
+require "import_data"
+
+class Card
+  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
+      OUTPUT_FILE = Card::Migration.data_path "unmerged"
+      class << self
+        # Merge the import data into the cards table
+        # If 'all' is true all import data is merged.
+        # Otherwise only the data that was changed or added since the last merge
+        def merge all=false
+          merge_data = all ? ImportData.all_cards : ImportData.changed_cards
+          puts("nothing to merge") && return if merge_data.empty?
+
+          Card::Mailer.perform_deliveries = false
+          Card::Auth.as_bot do
+            Card.merge_list merge_data, output_file: OUTPUT_FILE
+          end
+          update_time = Time.zone.now.to_s
+          ImportData.update do |import_data|
+            merge_data.each do |card_data|
+              import_data.merged card_data, update_time
+            end
+          end
+        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={}
+          ImportData.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
+          ImportData.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
+          ImportData.update do |data|
+            data.add_remote name, url
+          end
+        end
+
+        private
+
+        # Returns an array of hashes with card attributes
+        def fetch_card_data name, url, opts
+          view, result_key =
+            if opts[:items_only]
+              ["export_items", nil]
+            elsif opts[:deep]
+              ["export", nil]
+            else
+              [nil, :card]
+            end
+          card_data =
+            if url
+              fetch_remote_data name, view, url
+            else
+              fetch_local_data name, view
+            end
+          result_key ? [card_data[result_key]] : card_data
+        end
+
+        def fetch_remote_data name, view, url
+          json_url = "#{url}/#{name}.json"
+          json_url += "?view=#{view}" if view
+          json = open(json_url).read
+          JSON.parse(json).deep_symbolize_keys
+        end
+
+        def fetch_local_data name, view
+          Card::Auth.as_bot do
+            Card[name].format(format: :json).render(view || :content)
+          end
+        end
+      end
+    end
+  end
+end