card 1.18.4 → 1.18.5

data/VERSION

@@ -1 +1 @@
-1.18.4
+1.18.5

data/card.gemspec

@@ -38,7 +38,9 @@ Gem::Specification.new do |s|
   [
     ['smartname',                  '0.2.3'],
     ['uuid',                       '~> 2.3'],
-    ['carrierwave',                '~> 0.10'],
+    # with carrierwave 0.11.1 and 0.11.2 wagn hangs in a loop on creating
+    # style and script machine output
+    ['carrierwave',                '<= 0.11.0'],
     ['htmlentities',               '~> 4.3'],
     ['mini_magick',                '~> 4.2'],
     ['recaptcha',                  '~> 0.4.0'],
@@ -55,7 +57,8 @@ Gem::Specification.new do |s|
     ['diff-lcs',                   '~> 1.2'],
     # mime-types can be removed if we drop support for ruby 1.9.3
     # mime-types 3.0 uses mime-types-data which isn't compatible with 1.9.3
-    ['mime-types',                  '2.99.1']
+    ['mime-types',                  '2.99.1'],
+
   ].each do |dep|
     s.add_runtime_dependency(*dep)
   end

data/config/initializers/01_core_extensions/array.rb

@@ -0,0 +1,9 @@
+module CoreExtensions
+  module Array
+    def to_pointer_content
+      map do |item|
+        "[[#{item}]]"
+      end.join "\n"
+    end
+  end
+end

data/config/initializers/01_core_extensions/hash.rb

@@ -0,0 +1,57 @@
+module CoreExtensions
+  module Hash
+    module ClassMethods
+      module Nesting
+        # create hash with default nested structures
+        # @example
+        #   h = Hash.new_nested Hash, Array
+        #   h[:a] # => {}
+        #   h[:b][:c] # => []
+        def new_nested *classes
+          initialize_nested classes.unshift ::Hash
+        end
+
+        def initialize_nested classes, level=0
+          return classes[level].new if level == classes.size - 1
+          classes[level].new do |h, k|
+            h[k] = initialize_nested classes, level + 1
+          end
+        end
+      end
+    end
+
+    module Merging
+      # attach CSS classes
+      # @example
+      #  {}.css_merge({:class => "btn"}) # => {:class=>"btn"}
+      #
+      #  h = {:class => "btn"} # => {:class=>"btn"}
+      #  h.css_merge({:class => "btn-primary"}) # => {:class=>"btn
+      # btn-primary"}
+      def css_merge other_hash, separator=' '
+        merge(other_hash) do |key, old, new|
+          key == :class ? old.to_s + separator + new.to_s : new
+        end
+      end
+
+      def css_merge! other_hash, separator=' '
+        merge!(other_hash) do |key, old, new|
+          key == :class ? old.to_s + separator + new.to_s : new
+        end
+      end
+
+      # merge string values with `separator`
+      def string_merge other_hash, separator=' '
+        merge(other_hash) do |_key, old, new|
+          old.is_a?(String) ? old + separator + new.to_s : new
+        end
+      end
+
+      def string_merge! other_hash, separator=' '
+        merge!(other_hash) do |_key, old, new|
+          old.is_a?(String) ? old + separator + new.to_s : new
+        end
+      end
+    end
+  end
+end

data/config/initializers/01_core_extensions/module.rb

@@ -0,0 +1,14 @@
+module CoreExtensions
+  module Module
+    RUBY_VERSION_18 = !!(RUBY_VERSION =~ /^1\.8/)
+
+    def const_get_if_defined const
+      args = RUBY_VERSION_18 ? [const] : [const, false]
+      const_get(*args) if const_defined?(*args)
+    end
+
+    def const_get_or_set const
+      const_get_if_defined(const) || const_set(const, yield)
+    end
+  end
+end

data/config/initializers/01_core_extensions/object.rb

@@ -0,0 +1,43 @@
+module CoreExtensions
+  module Object
+    def deep_clone
+      case self
+      when Fixnum, Bignum, Float, NilClass, FalseClass, TrueClass, Symbol
+        klone = self
+      when Hash
+        klone = clone
+        each { |k, v| klone[k] = v.deep_clone }
+      when Array
+        klone = clone
+        klone.clear
+        each { |v| klone << v.deep_clone }
+      else
+        klone = clone
+      end
+      klone.deep_clone_instance_variables
+      klone
+    end
+
+    def send_unless method, *args, &_block
+      (block_given? ? yield : self) || send(method, *args)
+    end
+
+    def send_if     method, *args, &_block
+      (block_given? ? yield : self) && send(method, *args)
+    end
+
+    def to_name
+      Card::Name.new self
+    end
+
+    def to_viewname
+      Card::ViewName.new self
+    end
+
+    def deep_clone_instance_variables
+      instance_variables.each do |v|
+        instance_variable_set v, instance_variable_get(v).deep_clone
+      end
+    end
+  end
+end

data/config/initializers/02_extensions/kaminari.rb

@@ -0,0 +1,38 @@
+module Extensions
+  module Kaminari
+    module Helpers
+      module Tag
+        def page_url_for page
+          p = params_for(page)
+          p.delete :controller
+          p.delete :action
+          card = Card[p.delete('id')]
+          card.format.path p
+        end
+
+        private
+
+        def params_for page
+          page_params = Rack::Utils.parse_nested_query "#{@param_name}=#{page}"
+          page_params = @params.with_indifferent_access.deep_merge(page_params)
+
+          if Kaminari.config.respond_to?(:params_on_first_page) &&
+             !Kaminari.config.params_on_first_page && page <= 1
+            # This converts a hash:
+            #   from: {other: "params", page: 1}
+            #     to: {other: "params", page: nil}
+            #   (when @param_name == "page")
+            #
+            #   from: {other: "params", user: {name: "yuki", page: 1}}
+            #     to: {other: "params", user: {name: "yuki", page: nil}}
+            #   (when @param_name == "user[page]")
+            @param_name.to_s.scan(/\w+/)[0..-2]
+              .inject(page_params) { |h, k| h[k] }[$&] = nil
+          end
+
+          page_params
+        end
+      end
+    end
+  end
+end

data/config/initializers/core_extensions.rb

@@ -0,0 +1,24 @@
+# -*- encoding : utf-8 -*-
+
+# include is private in ruby 1.9.3
+# Object.include CoreExtensions::Object
+# Module.include CoreExtensions::Module
+# Hash.include CoreExtensions::Hash::Merging
+# Array.include CoreExtensions::Array
+class Object
+  include CoreExtensions::Object
+end
+
+class Module
+  include CoreExtensions::Module
+end
+
+class Hash
+  include CoreExtensions::Hash::Merging
+end
+
+class Array
+  include CoreExtensions::Array
+end
+
+Hash.extend CoreExtensions::Hash::ClassMethods::Nesting

data/config/initializers/extensions.rb

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

data/lib/card.rb

@@ -15,7 +15,7 @@ class Card < ActiveRecord::Base
   # attributes that ActiveJob can handle
   def self.serializable_attr_accessor *args
     self.serializable_attributes = args
-    attr_accessor *args
+    attr_accessor(*args)
   end
 
   require_dependency 'card/active_record_ext'
@@ -35,7 +35,6 @@ class Card < ActiveRecord::Base
   require_dependency 'card/stage_director'
   require_dependency 'card/director_register'
 
-
   has_many :references_in,  class_name: :Reference, foreign_key: :referee_id
   has_many :references_out, class_name: :Reference, foreign_key: :referer_id
   has_many :acts, -> { order :id }
@@ -44,8 +43,8 @@ class Card < ActiveRecord::Base
 
   cattr_accessor :set_patterns, :serializable_attributes, :error_codes,
                  :set_specific_attributes, :current_act
-  @@set_patterns = []
-  @@error_codes = {}
+  self.set_patterns = []
+  self.error_codes = {}
 
   serializable_attr_accessor(
     :action, :supercard, :superleft,
@@ -61,12 +60,18 @@ class Card < ActiveRecord::Base
 
   attr_accessor :follower_stash
 
-  define_callbacks :select_action, :show_page, :handle, :act,
-                   :initialize_stage,
-                   :prepare_to_validate_stage, :validate_stage,
-                   :prepare_to_store_stage, :store_stage,
-                   :finalize_stage,
-                   :integrate_stage, :integrate_with_delay_stage
+  define_callbacks(
+    :select_action, :show_page, :handle, :act,
+
+    # VALIDATION PHASE
+    :initialize_stage, :prepare_to_validate_stage, :validate_stage,
+
+    # STORAGE PHASE
+    :prepare_to_store_stage, :store_stage, :finalize_stage,
+
+    # INTEGRATION PHASE
+    :integrate_stage, :integrate_with_delay_stage
+  )
 
   before_validation :validation_phase, if: -> { run_phases? }
   around_save :storage_phase

data/lib/card/director_register.rb

@@ -63,6 +63,13 @@ class Card
         director.delete
       end
 
+      def deep_delete director
+        director.subdirectors.each do |subdir|
+          deep_delete subdir
+        end
+        delete director
+      end
+
       def to_s
         directors.values.map(&:to_s).join "\n"
       end

data/lib/card/loader.rb

@@ -21,45 +21,7 @@ class Card
         load_formats
         load_sets
 
-        update_machine_output_hack if ENV['RAILS_ENV'] == 'development'
-      end
-
-      def update_machine_output_hack
-        update_script_output
-        update_style_output
-      end
-
-      def update_script_output
-        script = Card['*all+*script']
-        return unless (mtime_output = script.machine_output_card.updated_at)
-        ['wagn_mod.js.coffee', 'wagn.js.coffee',
-         'script_card_menu.js.coffee'].each do |name|
-          mtime_file = File.mtime(
-            "#{Cardio.gem_root}/mod/03_machines/lib/javascript/#{name}"
-          )
-          if mtime_file > mtime_output
-            script.update_machine_output
-            break
-          end
-        end
-      end
-
-      def update_style_output
-        style = Card['*all+*style']
-        return unless (mtime_output = style.machine_output_card.updated_at)
-        style.machine_input_card.item_cards.each do |i_card|
-          next unless i_card.codename
-          %w(03_machines 06_bootstrap).each do |mod|
-            style_dir = "#{Cardio.gem_root}/mod/#{mod}/lib/stylesheets"
-            file_path = "#{style_dir}/#{i_card.codename}.scss"
-            next unless File.exist? file_path
-            mtime_file = File.mtime file_path
-            if mtime_file > mtime_output
-              style.update_machine_output
-              break
-            end
-          end
-        end
+        refresh_script_and_style if ENV['RAILS_ENV'] == 'development'
       end
 
       def load_chunks
@@ -94,6 +56,34 @@ class Card
 
       private
 
+      def refresh_script_and_style
+        update_if_source_file_changed Card[:all, :script]
+        update_if_source_file_changed Card[:all, :style]
+      end
+
+      # regenerates the machine output if a source file of a input card
+      # has been changed
+      def update_if_source_file_changed machine_card
+        mtime_output = machine_card.machine_output_card.updated_at
+        return unless mtime_output
+        source_files(machine_card).each do |path|
+          if File.mtime(path) > mtime_output
+            machine_card.update_machine_output
+            break
+          end
+        end
+      end
+
+      def source_files card
+        files = []
+        card.machine_input_card.extended_item_cards.each do |i_card|
+          next unless i_card.codename
+          next unless i_card.respond_to?(:existing_source_paths)
+          files << i_card.existing_source_paths
+        end
+        files.flatten
+      end
+
       def load_set_patterns
         generate_set_pattern_tmp_files if rewrite_tmp_files?
         load_dir "#{Card.paths['tmp/set_pattern'].first}/*.rb"

data/lib/card/migration.rb

@@ -85,6 +85,20 @@ class Card::Migration < ActiveRecord::Migration
     Card.merge_list read_json(filename), merge_opts
   end
 
+  def import_cards filename, merge_opts={}
+    Card::Mailer.perform_deliveries = false
+    output_file = File.join data_path, "unmerged_#{filename}"
+    merge_opts[:output_file] ||= output_file
+    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
+      end
+    Card.merge_list full_data, merge_opts
+  end
+
   def read_json filename
     raw_json = File.read data_path(filename)
     json = JSON.parse raw_json

data/lib/card/query.rb

@@ -43,10 +43,15 @@ class Card
 
     include Clause
     include Attributes
+    include RelationalAttributes
+    include Interpretation
+    include Sorting
+    include Conjunctions
+    include Helpers
 
     ATTRIBUTES = {
       basic:           %w( id name key type_id content left_id right_id
-                           creator_id updater_id codename read_rule_id ),
+                           creator_id updater_id codename read_rule_id        ),
       relational:      %w( type part left right
                            editor_of edited_by last_editor_of last_edited_by
                            creator_of created_by member_of member             ),
@@ -74,6 +79,17 @@ class Card
                 :subqueries, :superquery
     attr_accessor :joins, :table_seq, :unjoined, :conditions_on_join
 
+
+    # Query Execution
+
+    # By default a query returns card objects. This is accomplished by returning
+    # a card identifier from SQL and then hooking into our caching system (see
+    # Card::Fetch)
+
+    def self.run statement, comment=nil
+      new(statement, comment).run
+    end
+
     def initialize statement, comment=nil
       @subqueries = []
       @conditions = []
@@ -98,15 +114,6 @@ class Card
       statement.to_s
     end
 
-    # Query Execution
-    # By default a query returns card objects. This is accomplished by returning
-    # a card identifier from SQL and then hooking into our caching system (see
-    # Card::Fetch)
-
-    def self.run statement, comment=nil
-      new(statement, comment).run
-    end
-
     # run the current query
     # @return array of card objects by default
     def run
@@ -162,52 +169,6 @@ class Card
       subquery
     end
 
-    # Query Interpretation
-
-    # normalize and extract meaning from a clause
-    # @param clause [Hash, String, Integer] statement or chunk thereof
-    def interpret clause
-      interpret_by_key normalize_clause(clause)
-    end
-
-    def normalize_clause clause
-      clause = clause_to_hash clause
-      clause.symbolize_keys!
-      clause.each do |key, val|
-        clause[key] = normalize_value val
-      end
-      clause
-    end
-
-    def clause_to_hash clause
-      case clause
-      when Hash    then clause
-      when String  then { key: clause.to_name.key }
-      when Integer then { id: clause }
-      else raise BadQuery, "Invalid query args #{clause.inspect}"
-      end
-    end
-
-    def normalize_value val
-      case val
-      when Integer, Float, Symbol, Hash then val
-      when String, SmartName            then normalize_string_value val
-      when Array                        then val.map { |v| normalize_value v }
-      else raise BadQuery, "unknown WQL value type: #{val.class}"
-      end
-    end
-
-    def normalize_string_value val
-      case val.to_s
-      when /^\$(\w+)$/                       # replace from @vars
-        @vars[Regexp.last_match[1].to_sym].to_s.strip
-      when /\b_/                             # absolutize based on @context
-        val.to_name.to_absolute(context)
-      else
-        val
-      end
-    end
-
     def context
       if !@context.nil?
         @context
@@ -215,77 +176,5 @@ class Card
         @context = @superquery ? @superquery.context : ''
       end
     end
-
-    def interpret_by_key clause
-      clause.each do |key, val|
-        case
-        when OPERATORS.key?(key.to_s) && !ATTRIBUTES[key]
-          # eg "match" is both operator and attribute;
-          # interpret as attribute when "match" is key
-          interpret content: [key, val]
-        when MODIFIERS.key?(key) && !clause[key].is_a?(Hash)
-          # eg when "sort" is hash, it can have subqueries
-          # and must be interpreted like an attribute
-          @mods[key] = val.is_a?(Array) ? val : val.to_s
-        else
-          interpret_attributes key, val
-        end
-      end
-    end
-
-    def add_condition *args
-      @conditions <<
-        if args.size > 1
-          [args.shift, Value.new(args.shift, self)]
-        else
-          args[0]
-        end
-    end
-
-    def interpret_attributes key, val
-      case ATTRIBUTES[key]
-      when :basic            then add_condition key, val
-      when :conjunction      then send key, val
-      when :relational       then relate key, val
-      when :special          then relate key, val
-      when :ref_relational   then relate key, val, method: :join_references
-      when :plus_relational  then relate_compound key, val
-      when :ignore           then # noop
-      else                   raise BadQuery, "Invalid attribute #{key}"
-      end
-    end
-
-    def relate_compound key, val
-      has_multiple_values =
-        val.is_a?(Array) &&
-        (val.first.is_a?(Array) || conjunction(val.first).present?)
-      relate key, val, multiple: has_multiple_values
-    end
-
-    def relate key, val, opts={}
-      multiple = opts[:multiple].nil? ? val.is_a?(Array) : opts[:multiple]
-      method = opts[:method] || :send
-
-      if multiple
-        conj = conjunction(val.first) ? conjunction(val.shift) : :and
-        if conj == current_conjunction
-          # same conjunction as container, no need for subcondition
-          val.each { |v| send method, key, v }
-        else
-          send conj, val.map { |v| { key => v } }
-        end
-      else
-        send method, key, val
-      end
-    end
-
-    def current_conjunction
-      @mods[:conj].blank? ? :and : @mods[:conj]
-    end
-
-    def all_joins
-      @all_joins ||=
-        (joins + subqueries.select(&:unjoined).map(&:all_joins)).flatten
-    end
   end
 end