card 1.19.6 → 1.20.0

data/lib/card/migration.rb

@@ -39,15 +39,10 @@ class Card::Migration < ActiveRecord::Migration
     end
 
     def schema_mode mig_type=type
-      new_suffix = schema_suffix mig_type
-      original_suffix = ActiveRecord::Base.table_name_suffix
-
-      ActiveRecord::Base.table_name_suffix = new_suffix
-      ActiveRecord::SchemaMigration.reset_table_name
-      paths = Cardio.migration_paths(type)
-      yield(paths)
-      ActiveRecord::Base.table_name_suffix = original_suffix
-      ActiveRecord::SchemaMigration.reset_table_name
+      Cardio.with_suffix mig_type do
+        paths = Cardio.migration_paths(type)
+        yield(paths)
+      end
     end
 
     def assume_migrated_upto_version
@@ -99,10 +94,19 @@ class Card::Migration < ActiveRecord::Migration
     Card.merge_list full_data, merge_opts
   end
 
+  # uses the data in cards.yml and the card content in db/migrate_cards/data/cards
+  # to update or create the cards given by name or key in names_or_keys
+  def merge_cards names_or_keys
+    names_or_keys = Array(names_or_keys)
+    Card::Mailer.perform_deliveries = false
+
+    Card::Migration::Import.merge only: names_or_keys
+  end
+
   def read_json filename
     raw_json = File.read data_path(filename)
     json = JSON.parse raw_json
-    json["card"]["value"]
+    json.is_a?(Hash) ? json["card"]["value"] : json
   end
 
   def data_path filename=nil

data/lib/card/migration/import.rb

@@ -1,4 +1,5 @@
 require "import_data"
+require "merger"
 
 class Card
   class Migration
@@ -14,25 +15,16 @@ class Card
     # 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
+        # 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(opts).merge
         end
 
         # Get import data from a deck
@@ -91,7 +83,7 @@ class Card
           json_url = "#{url}/#{name}.json"
           json_url += "?view=#{view}" if view
           json = open(json_url).read
-          JSON.parse(json).deep_symbolize_keys
+          parse_and_symbolize json
         end
 
         def fetch_local_data name, view
@@ -99,6 +91,15 @@ class Card
             Card[name].format(format: :json).render(view || :content)
           end
         end
+
+        def parse_and_symbolize json
+          parsed = JSON.parse(json)
+          case parsed
+          when Hash then parsed.deep_symbolize_keys
+          when Array then parsed.map(&:deep_symbolize_keys)
+          else parsed
+          end
+        end
       end
     end
   end

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

@@ -4,13 +4,18 @@ class Card
       # Handles the card attributes and remotes for the import
       class ImportData
         DEFAULT_PATH = Card::Migration.data_path("cards.yml").freeze
-        CARD_CONTENT_DIR = Card::Migration.data_path("cards").freeze
+
+        include CardContent
+        include CardAttributes
 
         class << self
+          # Takes a block to update import data
+          # use #add_card and #add_remote in the block to make
+          # changes
           def update
             data = ImportData.new
             yield(data)
-            data.write
+            data.write_attributes
           end
 
           def all_cards
@@ -20,18 +25,28 @@ class Card
           def changed_cards
             ImportData.new.changed_cards
           end
+
+          def select_cards names_or_keys
+            ImportData.new.select_cards Array(names_or_keys)
+          end
         end
 
         def initialize path=nil
           @path = path || DEFAULT_PATH
-          ensure_path
-          @data = read
+          @data = read_attributes
         end
 
         def all_cards
           cards.map { |data| prepare_for_import data }
         end
 
+        def select_cards names_or_keys
+          cards.map do |attributes|
+            next unless name_or_key_match attributes, names_or_keys
+            prepare_for_import attributes
+          end.compact
+        end
+
         def changed_cards
           cards.map do |data|
             next unless changed?(data)
@@ -44,48 +59,45 @@ class Card
           update_attribute data["name"], :merged, time
         end
 
-        def add_card new_attr
-          card_data = {}
-          [:name, :type, :codename].each do |key|
-            card_data[key] = new_attr[key] if new_attr[key]
-          end
-          card_data[:key] = new_attr[:name].to_name.key
-          card_entry = find_card card_data[:name]
+        # to be used in an update block
+        def add_card card_data
+          card_attr, card_content = split_attributes_and_content card_data
 
-          if card_entry
-            card_entry.replace card_data
-          else
-            cards << card_data
-          end
-          write_card_content card_data, new_attr[: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
-          @data[:remotes][name] = url
+          remotes[name] = url
         end
 
         def url remote_name
-          @data[:remotes][remote_name.to_sym] ||
+          remotes[remote_name.to_sym] ||
             raise("unknown remote: #{remote_name}")
         end
 
-        def read
-          return { cards: [], remotes: {} } unless File.exist? @path
-          YAML.load_file(@path).deep_symbolize_keys
-        end
+        private
 
-        def write
-          File.write @path, @data.to_yaml
+        def split_attributes_and_content data
+          card_data = {}
+          [: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
 
-        private
+        def name_or_key_match attributes, names_or_keys
+          names_or_keys.any? do |nk|
+            nk == attributes[:name] || nk == attributes[:name].to_name.key ||
+              nk == attributes[:key]
+          end
+        end
 
-        def update_attribute name, attr_key, attr_value
-          card = find_card name
-          return unless card
-          card[attr_key] = attr_value
-          card
+        def remotes
+          @data[:remotes]
         end
 
         def cards
@@ -93,41 +105,20 @@ class Card
         end
 
         def prepare_for_import data
-          card_attr = ::Set.new [:name, :type, :codename, :file, :image]
-          hash = data.select { |k, v| v && card_attr.include?(k) }
-          hash[:content] = File.read(content_path(data))
+          hash = card_attributes(data)
+          hash[:content] = card_content(data)
           [:file, :image].each do |attach|
-            hash[attach] &&= Card::Migration.data_path "files/#{hash[attach]}"
+            hash[attach] &&= card_attachment(attach, data)
           end
           hash.with_indifferent_access
         end
 
         def changed? data
-          !data[:merged] ||
-            Time.parse(data[:merged]) < File.mtime(content_path(data))
-        end
-
-        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.key
-          File.join CARD_CONTENT_DIR, filename
-        end
-
-        def find_card name
-          key = name.to_name.key
-          index = cards.find_index { |attr| attr[:key] == key } ||
-                  cards.find_index { |attr| attr[:name] == name }
-          return unless index
-          cards[index]
+          !data[:merged] || content_changed?(data)
         end
 
-        def ensure_path
-          dir = File.dirname(@path)
-          FileUtils.mkpath dir unless Dir.exist? dir
+        def card_attachment attach_type, data
+          Card::Migration.data_path "files/#{data[attach_type]}"
         end
       end
     end

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

@@ -0,0 +1,56 @@
+class Card
+  class Migration
+    class Import
+      class ImportData
+       # handles card attributes for import
+       module CardAttributes
+         def card_attributes data
+           card_attr = ::Set.new [: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]
+           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
+         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
+           index = cards.find_index { |attr| attr[:key] == key } ||
+             cards.find_index { |attr| attr[:name] == name }
+           return unless index
+           cards[index]
+         end
+
+         private
+
+         def ensure_path
+           dir = File.dirname(@path)
+           FileUtils.mkpath dir unless Dir.exist? dir
+         end
+       end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+class Card
+  class Migration
+    class Import
+      class ImportData
+        # handles card content for import
+        module CardContent
+          CARD_CONTENT_DIR = Card::Migration.data_path("cards").freeze
+
+          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.key
+            File.join CARD_CONTENT_DIR, filename
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,47 @@
+class Card
+  class Migration
+    class Import
+      # executes the card import
+      class Merger
+        OUTPUT_FILE = Card::Migration.data_path "unmerged"
+
+        def initialize opts={}
+          load_data opts
+        end
+
+        def merge
+          puts("nothing to merge") && return if @data.empty?
+
+          Card::Mailer.perform_deliveries = false
+          Card::Auth.as_bot do
+            Card.merge_list @data, output_file: OUTPUT_FILE
+          end
+
+          update_import_data
+        end
+
+        private
+
+        def load_data opts
+          @data =
+            if opts[:all]
+              ImportData.all_cards
+            elsif opts[:only]
+              ImportData.select_cards opts[:only]
+            else
+              ImportData.changed_cards
+            end
+        end
+
+        def update_import_data
+          update_time = Time.zone.now.to_s
+          ImportData.update do |import_data|
+            @data.each do |card_data|
+              import_data.merged card_data, update_time
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/mod/loader.rb

@@ -155,11 +155,11 @@ class Card
         end
 
         def rewrite_tmp_files?
-          if defined?(@@rewrite)
-            @@rewrite
+          if defined?(@rewrite)
+            @rewrite
           else
-            @@rewrite = !(Rails.env.production? &&
-                        Card.paths["tmp/set"].existent.first)
+            @rewrite = !(Rails.env.production? &&
+                         Card.paths["tmp/set"].existent.first)
           end
         end
 

data/lib/card/model/save_helper.rb

@@ -16,16 +16,19 @@ class Card
       end
 
       def update_card name, content_or_args
-        args = standardize_update_args content_or_args
+        args = standardize_update_args name, content_or_args
         resolve_name_conflict args
         Card[name].update_attributes! args
       end
 
       def create_or_update_card name_or_args, content_or_args=nil
-        args = standardize_args name_or_args, content_or_args
-        if Card[args[:name]]
-          update_card(args.delete(:name), args)
+        name = name_from_args name_or_args
+
+        if Card[name]
+          args = standardize_update_args name_or_args, content_or_args
+          update_card(name, args)
         else
+          args = standardize_args name_or_args, content_or_args
           create_card(args)
         end
       end
@@ -43,13 +46,16 @@ class Card
       # create if card doesn't exist
       # updates existing card only if given attributes are different except the
       # name
-      # For example if a card with name "under_score" exists
-      # then `ensure_card "Under Score"` doesn't change anything
+      # @example if a card with name "under_score" exists
+      #   ensure_card "Under Score"                 # => no change
+      #   ensure_card "Under Score", type: :pointer # => changes the type to pointer
+      #                                             #    but not the name
       def ensure_card name_or_args, content_or_args=nil
         args = standardize_args name_or_args, content_or_args
         name = args.delete(:name)
         if (card = Card[name])
           ensure_attributes card, args
+          card
         else
           Card.create! args.merge(name: name)
         end
@@ -76,7 +82,7 @@ class Card
       end
 
       def update_card! name, content_or_args
-        args = standardize_update_args content_or_args
+        args = standardize_update_args name, content_or_args
         update_card name, args.reverse_merge(rename_if_conflict: :new)
       end
 
@@ -94,7 +100,8 @@ class Card
         end
       end
 
-      def standardize_update_args content_or_args
+      def standardize_update_args name_or_args, content_or_args
+        return name_or_args if name_or_args.is_a?(Hash)
         if content_or_args.is_a?(String)
           { content: content_or_args }
         else
@@ -102,17 +109,21 @@ class Card
         end
       end
 
+      def name_from_args name_or_args
+        name_or_args.is_a?(Hash) ? name_or_args[:name] : name_or_args
+      end
+
       def add_name name, content_or_args
         if content_or_args.is_a?(String)
           { content: content_or_args, name: name }
         else
-          content_or_args.merge name: name
+          content_or_args.reverse_merge name: name
         end
       end
 
       def resolve_name_conflict args
         rename = args.delete :rename_if_conflict
-        return unless rename
+        return unless args[:name] && rename
         args[:name] = Card.uniquify_name args[:name], rename
       end
 
@@ -122,6 +133,34 @@ class Card
         card.update_attributes! update_args
       end
 
+      def add_style name, opts={}
+        name.sub!(/^style\:?\s?/, '') # in case name is given with prefix
+        # remove it so that we don't double it
+
+        add_coderule_item name, "style",
+                          opts[:type_id] || Card::ScssID,
+                          opts[:to] || "*all+*style"
+      end
+
+      def add_script name, opts={}
+        name.sub!(/^script\:?\s?/, '') # in case name is given with prefix
+        # remove it so that we don't double it
+
+        add_coderule_item name, "script",
+                          opts[:type_id] || Card::CoffeeScriptID,
+                          opts[:to] || "*all+*script"
+      end
+
+
+      def add_coderule_item name, prefix, type_id, to
+        codename = "#{prefix}_#{name.tr(' ', '_').underscore}"
+        name = "#{prefix}: #{name}"
+
+        ensure_card name, type_id: type_id,
+                    codename: codename
+        Card[to].add_item! name
+      end
+
       alias_method :create, :create_card
       alias_method :update, :update_card
       alias_method :create_or_update, :create_or_update_card