wagn 1.14.7 → 1.14.8

data/db/migrate/20141121172918_rename_card_migration_table.rb

@@ -1,7 +1,14 @@
 class RenameCardMigrationTable < ActiveRecord::Migration
   def self.up
-    rename_table :schema_migrations_cards, :schema_migrations_core_cards
+    if ActiveRecord::Base.connection.table_exists? :schema_migrations_cards
+      rename_table :schema_migrations_cards, :schema_migrations_core_cards
+    else
+      create_table "schema_migrations_core_cards", :id => false, :force => true do |t|
+        t.string "version", :null => false
+      end
+    end
   end 
+  
   def self.down
     rename_table :schema_migrations_core_cards, :schema_migrations_cards
   end

data/lib/card/chunk.rb

@@ -47,7 +47,6 @@ class Card
     register_list :default, [ :URI, :HostURI, :EmailURI, :EscapedLiteral, :Include, :Link ]
     register_list :references,                         [ :EscapedLiteral, :Include, :Link ]
     register_list :inclusion_only,                     [  :Include ]
-    register_list :inclusion_and_link,                 [  :Include, :Link ]
   
     class Abstract
       class_attribute :config

data/lib/card/content.rb

@@ -26,7 +26,7 @@ class Card
     end
     
     def chunk_list
-      @opts[:chunk_list] || card.chunk_list
+      @opts[:chunk_list] || @format.chunk_list
     end
 
     def to_s

data/lib/card/format.rb

@@ -26,11 +26,13 @@ class Card
       end
     
       def format_class_name format
-        f = format.to_s
-        f = @@aliases[ f ] || f
-        "#{ f.camelize }Format"
+        format = format.to_s
+        format = '' if format == 'base'
+        format = @@aliases[ format ] if @@aliases[ format ]
+        "#{ format.camelize }Format"
       end
 
+      
 
       def extract_class_vars view, opts
         return unless opts.present?
@@ -183,7 +185,7 @@ class Card
         @current_view = view = ok_view canonicalize_view( view ), args       
         args = default_render_args view, args
         with_inclusion_mode view do
-          Wagn.with_logging :view, view, :context=>card.name, :details=>args do
+          Wagn.with_logging :view, :message=>view, :context=>card.name, :details=>args do
             send "_view_#{ view }", args
           end
         end

data/lib/card/generators/card_migration/card_migration_generator.rb

@@ -8,8 +8,7 @@ class CardMigrationGenerator < ActiveRecord::Generators::Base
     desc: "Create card migration for wagn core"
 
   def create_migration_file
-    migration_type = options['core'] ? :core_cards : :deck_cards
-    root = Wagn::Migration.paths(migration_type).first
+    root = options['core'] ? Wagn::CoreMigration.paths.first : Wagn::Migration.paths.first
     set_local_assigns!
     migration_template @migration_template, File.join( root, "#{file_name}.rb")
   end

data/lib/card/loader.rb

@@ -10,6 +10,10 @@ class Card
         load_set_patterns
         load_formats
         load_sets
+        
+        if Wagn.config.performance_logger
+          Wagn::Log::Performance.load_config Wagn.config.performance_logger
+        end
       end
       
       def load_chunks

data/lib/card/set.rb

@@ -107,10 +107,22 @@ class Card
       
     end
 
-    def format format=nil, &block
-      klass = Card::Format.format_class_name format   # format class name, eg. HtmlFormat
-      mod = const_get_or_set klass do                 # called on current set module, eg Card::Set::Type::Pointer
-        m = Module.new                                # yielding set format module, eg Card::Set::Type::Pointer::HtmlFormat
+    
+    def format *format_names, &block
+      if format_names.empty?
+        format_names = [:base]
+      elsif format_names.first == :all
+        format_names = Card::Format.registered.reject {|f| Card::Format.aliases[f]}
+      end
+      format_names.each do |f|
+        define_on_format f, &block
+      end
+    end
+    
+    def define_on_format format_name=:base, &block
+      klass = Card::Format.format_class_name format_name   # format class name, eg. HtmlFormat
+      mod = const_get_or_set klass do                      # called on current set module, eg Card::Set::Type::Pointer
+        m = Module.new                                     # yielding set format module, eg Card::Set::Type::Pointer::HtmlFormat
         register_set_format Card.const_get(klass), m
         m.extend Card::Set::Format
         m
@@ -136,7 +148,7 @@ class Card
 
         define_method event do
           run_callbacks event do
-            Wagn.with_logging :event, event, :context=>self.name, :details=>opts do
+            Wagn.with_logging :event, :message=>event, :context=>self.name, :details=>opts do
               send final_method
             end
           end
@@ -200,9 +212,11 @@ class Card
         # FIXME - this does not properly handle anchorless sets
         # There are special hacks for *all, but others (like *rstar) will not be found by
         # include_set_modules, which will look for Card::Set::Rstar, not Card::Set::Rstar::Blah
-        
+        # This issue appears to be addressed by making the entries, in modules arrays.
+        # If yes remove this comment.
+
         to_file = "#{Wagn.paths['tmp/set'].first}/#{set_pattern}/#{seq}-#{anchors.join '-'}.rb"
-        anchor_modules = anchors.map { |a| "module #{a.camelize};" }.join
+        anchor_modules = anchors.map { |a| "module #{a.camelize};" }.join # use explicit '', not $,
         file_content = <<EOF
 # -*- encoding : utf-8 -*-
 class Card; module Set; module #{set_pattern.camelize}; #{anchor_modules}

data/lib/card/set_pattern.rb

@@ -1,4 +1,5 @@
 class Card
+
   class SetPattern
     
     class << self
@@ -38,11 +39,11 @@ class Card
       def pattern_applies? card
         junction_only? ? card.cardname.junction? : true
       end
-    
+
       def anchor_parts_count 
         @anchor_parts_count ||= ( anchorless? ? 0 : 1 )
       end
-      
+
       def write_tmp_file pattern_code, from_file, seq
         to_file = "#{Wagn.paths['tmp/set_pattern'].first}/#{seq}-#{pattern_code}.rb"
         klass = "Card::#{pattern_code.camelize}Set"
@@ -91,12 +92,16 @@ EOF
       end
     end
 
+    def lookup_module_list modules_hash
+      module_key && modules_hash[ module_key ]
+    end
+
     def module_list
-      module_key and Card::Set.modules[ :nonbase ][ module_key ]
+      lookup_module_list Card::Set.modules[ :nonbase ]
     end
 
     def format_module_list klass
-      module_key and hash = Card::Set.modules[ :nonbase_format ][ klass ] and hash[ module_key ]
+      hash = Card::Set.modules[ :nonbase_format ][ klass ] and lookup_module_list hash
     end
 
     def anchor_codenames
@@ -130,6 +135,34 @@ EOF
         [ @anchor_id, self.class.pattern_code ].map( &:to_s ) * '+'
       end
     end
-  
+  end
+
+  class TypeSet < SetPattern
+    def initialize card
+      super
+      @inherit_card = card unless module_key
+    end
+
+    def lookup_inherited_key
+      return unless @inherit_card
+      card, @inherit_card = @inherit_card, nil
+
+      default_rule = card.rule_card(:default) and
+        type_code = default_rule.type_code and
+        #default_rule.cardname.size > 2 and
+        #default_rule.left.right.codename == self.class.pattern_code
+        mod_key = "Type::#{type_code.to_s.camelize}" and
+        ( Card::Set.modules[:nonbase_format].values +
+          [Card::Set.modules[:nonbase]] ).any?{|hash| hash[mod_key]} and
+        mod_key
+    end
+
+    def inherited_key
+      (defined? @inherited_key) ? @inherited_key : @inherited_key = lookup_inherited_key
+    end
+
+    def lookup_module_list modules_hash
+      module_key ? modules_hash[ module_key ] : inherited_key && modules_hash[ inherited_key ]
+    end
   end
 end

data/lib/wagn.rb

@@ -24,9 +24,9 @@ module Wagn
       WAGN_GEM_ROOT
     end
     
-    def with_logging method, message, opts, &block
-      if (pl_config=Wagn.config.performance_logger) && pl_config[:methods] && pl_config[:methods].include?(method)
-        Wagn::Log::Performance.with_timer(method, message, opts) do
+    def with_logging method, opts, &block
+      if Wagn::Log::Performance.enabled_method? method
+        Wagn::Log::Performance.with_timer(method, opts) do
           block.call
         end
       else

data/lib/wagn/core_migration.rb

@@ -1,19 +1,5 @@
 # -*- encoding : utf-8 -*-
 
 class Wagn::CoreMigration < Wagn::Migration
-  def migration_paths
-    Wagn::Migration.paths :core_cards
-  end
-  
-  def schema_mode
-    Wagn::Migration.schema_mode :core_cards
-  end
-  
-  def import_json filename
-    Wagn.config.action_mailer.perform_deliveries = false
-    raw_json = File.read( data_path filename ) 
-    json = JSON.parse raw_json
-    Card.merge_list json["card"]["value"], :output_file=>File.join(data_path,"unmerged_#{ filename }")
-    #fixme - output file should not be in gem!
-  end
+  @type = :core_cards
 end

data/lib/wagn/generators/wagn/templates/Rakefile

@@ -3,6 +3,5 @@
 # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
 
 require File.expand_path('../config/application', __FILE__)
-require 'jasmine'
 
 <%= app_const %>.load_tasks

data/lib/wagn/log.rb

@@ -1,14 +1,16 @@
 require 'csv'
 
+
 class Wagn::Log
 
   class Request
+
     def self.path
       path = (Wagn.paths['request_log'] && Wagn.paths['request_log'].first) || File.dirname(Wagn.paths['log'].first)
       filename = "#{Date.today}_#{Rails.env}.csv"
       File.join path, filename
     end
-    
+
     def self.write_log_entry controller
       return if controller.env["REQUEST_URI"] =~ %r{^/files?/}
 
@@ -34,24 +36,230 @@ class Wagn::Log
     end
 
   end
-  
+
 
   class Performance
+    # To enable logging add a performance_logger hash to your configuration and change the log_level to :wagn
+    # config options
+    #
+    # Example:
+    # config.performance_logger = {
+    #     :min_time => 100,                              # show only method calls that are slower than 100ms
+    #     :max_depth => 3,                               # show nested method calls only up to depth 3
+    #     :details=> true                                # show method arguments and sql
+    #     :methods => [:event, :search, :fetch, :view],  # choose methods to log
+    # }
+    #
+    # If you give :methods a hash you can log arbitrary methods. The syntax is as follows:
+    #   class =>  method type => method name => log options
+    #
+    # Example:
+    #   Card  => {
+    #              :instance  => [ :fetch, :search ],
+    #              :singleton => { :fetch    => { :title => 'Card.fetch' } },
+    #              :all       => {
+    #                              :fetch    => {
+    #                                             :message => 2                           # use second argument passed to fetch
+    #                                             :details => :to_s                       # use return value of to_s in method context
+    #                                             :title => proc { |method_context| method_context.name }
+    #                                           },
+    #                            },
+    #            },
+    #
+    # class, method type and log options are optional.
+    # Default values are 'Card', ':all'  and { :title => method name, :message => first argument, :details=> remaining arguments }.
+    # For example [:fetch] is equivalent to Card => { :all => { :fetch  => { :message=>1, :details=>1..-1 } }
+
+    DEFAULT_CLASS           = Card
+    DEFAULT_METHOD_TYPE     = :all
+    DEFAULT_METHOD_OPTIONS  = {
+                                :title   => :method_name,
+                                :message => 1,
+                                :details => 1..-1,
+                                :context => nil
+                              }
+
+    SPECIAL_METHODS     = [:search, :view, :event]  # these methods have already a Wagn.with_logging block
+                                                        # we don't have to monkey patch them, only turn the logging on with adding the symbol to the methods hash
+
+
+
     TAB_SIZE = 3
     @@log = []
     @@context_entries = []
     @@active_entries = []
     @@current_level = 0
-   
-    def self.the_log
-     @@the_log  
+
+
+    class << self
+      def load_config args
+        @details   = args[:details]   || false
+        @max_depth = args[:max_depth] || false
+        @min_time  = args[:min_time]  || false
+        @enabled_methods = ::Set.new
+        prepare_methods_for_logging args[:methods] if args[:methods]
+      end
+      
+      def start args={}
+        @@current_level = 0
+        @@log = []
+        @@context_entries = []
+        @@active_entries = []
+        @@first_entry = new_entry(args)
+      end
+
+      def stop
+        while (entry = @@context_entries.pop) do
+          finish_entry entry
+        end
+        if @@first_entry
+          @@first_entry.save_duration
+          finish_entry @@first_entry
+        end
+        print_log
+      end
+
+      
+      def with_timer method, args, &block
+        if args[:context]
+
+          # if the previous context was created by an entry on the same level
+          # then finish the current context if it's a different context
+          if @@context_entries.last && @@current_level == @@context_entries.last.level+1 &&
+                                       args[:context] != @@context_entries.last.context
+            finish_entry @@context_entries.pop
+          end
+
+          # start new context if it's different from the parent context
+          if  @@context_entries.empty? || args[:context] != @@context_entries.last.context
+            @@context_entries << new_entry( :title=>'process', :message=>args[:context], :context=>args[:context] )
+          end
+        end
+
+        timer = new_entry args.merge(:method=>method )
+        begin
+          result = block.call
+        ensure
+          timer.save_duration
+          finish_entry timer
+
+          # finish all deeper nested contexts
+          while @@context_entries.last && @@context_entries.last.level >= @@current_level
+            finish_entry @@context_entries.pop
+          end
+          # we don't know whether the next entry will belong to the same context or will start a new one
+          # so we save the time
+          @@context_entries.last.save_duration if @@context_entries.last
+        end
+        result
+      end
+      
+
+      def enable_method method_name
+        @enabled_methods ||= ::Set.new
+        @enabled_methods << method_name
+      end
+
+      def enabled_method? method_name
+        @enabled_methods && @enabled_methods.include?(method_name)
+      end
+
+      private
+
+      def print_log
+        @@log.each do |entry|
+          Rails.logger.wagn entry.to_s! if entry.valid
+        end
+      end
+
+      def new_entry args
+        args.delete(:details) unless @details
+        level = @@current_level
+
+        last_entry = @@active_entries.last
+        parent = if last_entry
+            last_entry.level == level ? last_entry.parent : last_entry
+          end
+
+        @@log << Wagn::Log::Performance::Entry.new(parent, level, args )
+        @@current_level += 1
+        @@active_entries << @@log.last
+
+        @@log.last
+      end
+
+      def finish_entry entry
+        if (@max_depth && entry.level > @max_depth) || (@min_time && entry.duration < @min_time)
+          entry.delete
+        end
+        @@active_entries.pop
+        @@current_level -= 1
+      end
+      
+      def prepare_methods_for_logging args
+        classes = hashify_and_verify_keys( args, DEFAULT_CLASS ) do |key|
+          key.kind_of?(Class) || key.kind_of?(Module)
+        end
+
+        classes.each do |klass, method_types|
+          klass.extend BigBrother  # add watch methods
+
+          method_types = hashify_and_verify_keys( method_types, DEFAULT_METHOD_TYPE ) do |key|
+            [:all, :instance, :singleton].include? key
+          end
+
+          method_types.each do |method_type, methods|
+            methods = hashify_and_verify_keys methods
+            methods.each do |method_name, options|
+              klass.watch_method  method_name, method_type, DEFAULT_METHOD_OPTIONS.merge(options)
+            end
+          end
+
+        end
+      end
+
+
+      def hashify_and_verify_keys args, default_key=nil
+        if default_key
+          case args
+            when Symbol
+              { default_key => [ args ] }
+            when Array
+              { default_key => args }
+            when Hash
+              if block_given?
+                args.keys.select{ |key| !(yield(key)) }.each do |key|
+                  args[default_key] = { key => args[key] }
+                  args.delete key
+                end
+              end
+              args
+            end
+        else
+          case args
+          when Symbol
+            { args => {} }
+          when Array
+            args.inject({}) do |h, key|
+              h[key] = {}
+              h
+            end
+          else
+            args
+          end
+        end
+      end
+
     end
+    
+    
     class Entry
       attr_accessor :level, :valid, :context, :parent, :children_cnt, :duration
-      
+
       def initialize( parent, level, args )
         @start = Time.new
-        @message = "#{ args[:method] }: #{ args[:message] }"
+        @message = "#{ args[:title] ||  args[:method] || '' }"
+        @message += ": #{ args[:message] }" if args[:message]
         @details = args[:details]
         @context = args[:context]
         @level = level
@@ -59,7 +267,7 @@ class Wagn::Log
         @valid = true
         @parent = parent
         @children_cnt = 0
-        if @parent         
+        if @parent
           @parent.add_children
           #@sibling_nr = @parent.children_cnt
         end
@@ -68,19 +276,19 @@ class Wagn::Log
       def add_children
         @children_cnt += 1
       end
-      
+
       def delete_children
         @children_cnt -= 1
       end
-      
+
       def has_younger_siblings?
         @parent && @parent.children_cnt > 0 #@sibling_nr
       end
-      
+
       def save_duration
         @duration = (Time.now - @start) * 1000
       end
-      
+
       def delete
         @valid = false
         @parent.delete_children if @parent
@@ -90,11 +298,11 @@ class Wagn::Log
       # deletes the children counts in order to print the tree;
       # must be called in the right order
       #
-      # More robuts but more expensive approach: use @sibling_nr instead of counting @children_cnt down, 
-      # but @sibling_nr has to be updated for all siblings of an entry if the entry gets deleted due to 
+      # More robuts but more expensive approach: use @sibling_nr instead of counting @children_cnt down,
+      # but @sibling_nr has to be updated for all siblings of an entry if the entry gets deleted due to
       # min_time or max_depth restrictions in the config, so we have to save all children relations for that
       def to_s!
-        @to_s ||= begin 
+        @to_s ||= begin
           msg = indent
           msg += if @duration
               "(%d.2ms) #{@message}" % @duration
@@ -108,8 +316,8 @@ class Wagn::Log
           msg
         end
       end
-      
-      private 
+
+      private
 
       def indent link=true
         @indent ||= begin
@@ -119,12 +327,12 @@ class Wagn::Log
             res = '  '
             res += (1..level-1).inject('') do |msg, index|
                 if younger_siblings[index]
-                  msg <<  '|' + ' ' * (TAB_SIZE-1) 
+                  msg <<  '|' + ' ' * (TAB_SIZE-1)
                 else
                   msg << ' ' * TAB_SIZE
                 end
               end
-            
+
             res += link ? '|--' : '  '
           end
         end
@@ -139,99 +347,94 @@ class Wagn::Log
         end
         res.reverse
       end
-      
+
     end
+    
+    
+    module BigBrother
 
+      def watch_method method_name, method_type=:all, options={}
+        Wagn::Log::Performance.enable_method method_name
 
-    class << self
-      def start args={}
-        @@current_level = 0
-        @@log = []
-        @@context_entries = []
-        @@active_entries = []
-        @@first_entry = new_entry(args)
-      end
-      
-      def stop
-        while (entry = @@context_entries.pop) do
-          finish_entry entry
+        if !SPECIAL_METHODS.include? method_name
+          if method_type == :all || method_type == :singleton
+            add_singleton_logging method_name, options
+          end
+          if method_type == :all || method_type == :instance
+            add_instance_logging method_name, options
+          end
         end
-        if @@first_entry
-          @@first_entry.save_duration
-          finish_entry @@first_entry
+      end
+
+      def watch_instance_method *names
+        names.each do |name|
+          watch_method name, :instance
         end
-        print_log
       end
-      
-      def with_timer method, message, args, &block
-        if args[:context] 
-          
-          # if the previous context was created by an entry on the same level 
-          # the finish the context if it's a different context
-          if @@context_entries.last && @@current_level == @@context_entries.last.level+1 && 
-                                       args[:context] != @@context_entries.last.context
-            finish_entry @@context_entries.pop
-          end
-          
-          # start new context if it's different from the parent context
-          if  @@context_entries.empty? || args[:context] != @@context_entries.last.context
-            @@context_entries << new_entry( :method=>'process', :message=>args[:context], :context=>args[:context] )
-          end
+
+      def watch_singleton_method *names
+        names.each do |name|
+          watch_method name, :singleton
         end
+      end
 
-        timer = new_entry args.merge(:method=>method, :message=>message)
-        begin
-          result = block.call       
-        ensure
-          timer.save_duration
-          finish_entry timer
+      def watch_all_instance_methods
+        watch_instance_method *instance_methods
+      end
 
-          # finish all deeper nested contexts
-          while @@context_entries.last && @@context_entries.last.level >= @@current_level
-            finish_entry @@context_entries.pop
-          end
-          # we don't know whether the next entry will belong to the same context or will start a new one 
-          # so we save the time    
-          @@context_entries.last.save_duration if @@context_entries.last         
+      def watch_all_singleton_methods
+        fragile_methods = [:default_scope, :default_scopes, :default_scopes=]  # if I touch these methods ActiveRecord breaks
+        watch_singleton_method *(singleton_methods - fragile_methods)
+      end
+
+      def watch_all_methods
+        watch_all_instance_methods
+        watch_all_singleton_methods
+      end
+
+      private
+
+      def add_singleton_logging method_name, options
+        return unless singleton_class.method_defined? method_name
+        m = method(method_name)
+        add_logging method_name, :define_singleton_method, options do |bind_object, args, &block|
+          m.call(*args, &block)
         end
-        result
       end
 
-      private 
-      
-      def print_log
-        @@log.each do |entry|
-          Rails.logger.wagn entry.to_s! if entry.valid
+      def add_instance_logging  method_name, options
+        return unless method_defined? method_name
+        m = instance_method(method_name)
+        add_logging method_name, :define_method, options do  |bind_object, args, &block|
+          m.bind(bind_object).(*args, &block)
         end
       end
-      
-      def new_entry args
-        args.delete(:details) unless Wagn.config.performance_logger[:details]
-        level = @@current_level
-                
-        last_entry = @@active_entries.last
-        parent = if last_entry
-            last_entry.level == level ? last_entry.parent : last_entry
+
+      def add_logging method_name, define_method, options, &bind_block
+        send(define_method, method_name) do |*args, &block|
+          log_args = {}
+          options.each do |key,value|
+            log_args[key] = case value
+              when Integer then args[value-1]
+              when Range   then args[value]
+              when Symbol  then eval(value.to_s)
+              when Proc    then value.call(self)
+              else              value
+              end
+          end
+          Wagn::Log::Performance.with_timer(method_name, log_args) do
+            bind_block.call(self, args, &block)
           end
-        
-        @@log << Wagn::Log::Performance::Entry.new(parent, level, args )
-        @@current_level += 1 
-        @@active_entries << @@log.last
-        
-        @@log.last
-      end
-      
-      def finish_entry entry
-        min_time = Wagn.config.performance_logger[:min_time]
-        max_depth = Wagn.config.performance_logger[:max_depth]
-        if (max_depth && entry.level > max_depth) || (min_time && entry.duration < min_time)
-          entry.delete
         end
-        @@active_entries.pop
-        @@current_level -= 1
       end
-      
+
+      def log_options_variable_name method_name, define_method
+        "@_#{self.class.name}_#{method_name.hash.to_s.sub(/^-/,'_')}_#{define_method}_logging_options".to_sym
+      end
+
     end
+    
+    
   end
 
 end