wagn 1.14.9 → 1.15.pre

data/lib/wagn/migration.rb

@@ -1,151 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-class Wagn::Migration < ActiveRecord::Migration
-  @type = :deck_cards
-
-  class << self
-    
-    # Rake tasks use class methods, migrations use instance methods.
-    # To avoid repetition a lot of instance methods here just call class methods.
-    # The subclass Wagn::CoreMigration needs a different @type so we can't use a
-    # class variable @@type. It has to be a class instance variable.
-    # Migrations are subclasses of Wagn::Migration or Wagn::CoreMigration but they
-    # don't inherit the @type. The method below solves this problem.
-    def type 
-      @type || (ancestors[1] && ancestors[1].type)
-    end
-    
-    def find_unused_name base_name
-      test_name = base_name
-      add = 1
-      while Card.exists?(test_name) do
-        test_name = "#{base_name}#{add}"
-        add +=1
-      end
-      test_name
-    end
-
-    def paths mig_type=type
-      Wagn.paths["db/migrate#{schema_suffix mig_type}"].to_a
-    end
-  
-    def schema_suffix mig_type=type
-      Wagn::Version.schema_suffix( mig_type )
-    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
-      yield
-      ActiveRecord::Base.table_name_suffix = original_suffix
-    end
-    
-  
-    def data_path filename=nil
-      if filename
-        self.paths.each do |path|
-          path_to_file = File.join path, 'data', filename
-          return path_to_file if File.exists? path_to_file
-        end
-      else
-        File.join self.paths.first, 'data'
-      end
-    end
-  end
-  
-  def contentedly &block
-    Wagn::Cache.reset_global
-    Wagn::Migration.schema_mode '' do
-      Card::Auth.as_bot do
-        ActiveRecord::Base.transaction do
-          begin
-            yield
-          ensure
-            Wagn::Cache.reset_global
-          end
-        end
-      end
-    end
-  end
-  
-  def data_path filename=nil
-    if filename
-      migration_paths.each do |path|
-        path_to_file = File.join path, 'data', filename
-        return path_to_file if File.exists? path_to_file
-      end
-    else
-      File.join migration_paths.first, 'data'
-    end
-  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 }")
-  end
-  
-  def data_path filename=nil
-    self.class.data_path filename
-  end
-    
-  def schema_mode
-    self.class.schema_mode 
-  end
-  
-  def migration_paths
-    self.class.paths
-  end
-  
-  
-  # Execute this migration in the named direction
-  # copied from ActiveRecord to wrap "up" in "contentendly"
-  def migrate(direction)
-    return unless respond_to?(direction)
-
-    case direction
-    when :up   then announce "migrating"
-    when :down then announce "reverting"
-    end
-
-    time   = nil
-    ActiveRecord::Base.connection_pool.with_connection do |conn|
-      @connection = conn
-      if respond_to?(:change)
-        if direction == :down
-          recorder = CommandRecorder.new(@connection)
-          suppress_messages do
-            @connection = recorder
-            change
-          end
-          @connection = conn
-          time = Benchmark.measure {
-            self.revert {
-              recorder.inverse.each do |cmd, args|
-                send(cmd, *args)
-              end
-            }
-          }
-        else
-          time = Benchmark.measure { change }
-        end
-      else
-        time = Benchmark.measure { contentedly { send(direction) } }
-      end
-      @connection = nil
-    end
-
-    case direction
-    when :up   then announce "migrated (%.4fs)" % time.real; write
-    when :down then announce "reverted (%.4fs)" % time.real; write
-    end
-  end
-  
-  def down
-    raise ActiveRecord::IrreversibleMigration
-  end
-end

data/lib/wagn/spec_helper.rb

@@ -1,59 +0,0 @@
-module SpecHelper
-end
-module Wagn::SpecHelper
-
-  include ActionDispatch::Assertions::SelectorAssertions
-  #~~~~~~~~~  HELPER METHODS ~~~~~~~~~~~~~~~#
-  
-  def login_as user
-    Card::Auth.current_id = (uc=Card[user.to_s] and uc.id)
-    if @request
-      @request.session[:user] = Card::Auth.current_id
-    end
-    #warn "(ath)login_as #{user.inspect}, #{Card::Auth.current_id}, #{@request.session[:user]}"
-  end
-  
-  def newcard name, content=""
-    #FIXME - misleading name; sounds like it doesn't save.
-    Card.create! :name=>name, :content=>content
-  end
-
-  def assert_view_select(view_html, *args, &block)
-    node = HTML::Document.new(view_html).root
-    if block_given?
-      assert_select node, *args, &block
-    else
-      assert_select node, *args
-    end
-  end
-
-  def render_editor(type)
-    card = Card.create(:name=>"my favority #{type} + #{rand(4)}", :type=>type)
-    card.format.render(:edit)
-  end
-
-  def render_content content, format_args={}
-    render_content_with_args( content, format_args )
-  end
-  
-  def render_content_with_args content, format_args={}, view_args={}
-    @card ||= Card.new :name=>"Tempo Rary 2"
-    @card.content = content
-    @card.format(format_args)._render :core, view_args
-  end
-
-  def render_card view, card_args={}, format_args={}
-    render_card_with_args view, card_args, format_args
-  end
-  
-  def render_card_with_args view, card_args={}, format_args={}, view_args={}
-    card = begin
-      if card_args[:name]
-        Card.fetch card_args[:name], :new=>card_args
-      else
-        Card.new card_args.merge( :name=> 'Tempo Rary' )
-      end
-    end
-    card.format(format_args)._render(view, view_args)
-  end
-end

data/lib/wagn/version.rb

@@ -1,33 +0,0 @@
-# -*- encoding : utf-8 -*-
-require File.expand_path( '../../wagn', __FILE__ )
-
-module Wagn
-  module Version
-    class << self
-      
-      def release
-        @@version ||= File.read( File.expand_path '../../../VERSION', __FILE__ ).strip
-      end
-    
-      def schema type=nil
-        File.read( schema_stamp_path type ).strip
-      end
-
-      def schema_stamp_path type
-        root_dir = ( type == :deck_cards ? Wagn.root : Wagn.gem_root )
-        stamp_dir = ENV['SCHEMA_STAMP_PATH'] || File.join( root_dir, 'db' )
-        
-        File.join stamp_dir, "version#{ schema_suffix(type) }.txt"  
-      end
-      
-      def schema_suffix type
-        case type
-        when :core_cards then '_core_cards' # was _cards before !!!
-        when :deck_cards then '_deck_cards'
-        else ''
-        end
-      end
-      
-    end
-  end
-end

data/mod/01_core/chunk/include.rb

@@ -1,85 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-require_dependency File.expand_path( '../reference', __FILE__ )
-
-module Card::Chunk
-  class Include < Reference
-    cattr_reader :options
-    @@options = ::Set.new [ :inc_name, :inc_syntax, :view, :items, :type, :size, :title, :hide, :show, :structure ]
-    attr_reader :options
-
-    Card::Chunk.register_class self, {
-      :prefix_re => '\\{\\{',
-      :full_re   =>  /^\{\{([^\}]*)\}\}/,
-      :idx_char  => '{'
-    }
-
-    def interpret match, content
-      in_brackets = strip_tags match[1]
-#      warn "in_brackets = #{in_brackets}"
-      name, @opt_lists = in_brackets.split '|', 2
-      name = name.to_s.strip
-      result = case name
-        when /^\#\#/ ; '' # invisible comment
-        when /^\#/   ; "<!-- #{CGI.escapeHTML in_brackets} -->"
-#        when /^\s*$/ ; '' # no name
-        else
-          @options = @opt_lists.to_s.split('|').reverse.inject(nil) do |prev_level, level_options|
-            process_options level_options, prev_level
-          end || {}
-          @options.merge! :inc_name => name, :inc_syntax => in_brackets
-          @name = name
-        end
-
-      @process_chunk = result if !@name
-    end
-
-    def strip_tags string
-      #note: not using ActionView's strip_tags here because this needs to be super fast.
-      string.gsub /\<[^\>]*\>/, ''
-    end
-
-    def process_options list_string, items
-      hash = {}
-      style_hash = {}
-      hash[:items] = items unless items.nil?
-      Hash.new_from_semicolon_attr_list( list_string ).each do |key, value|
-        key = key.to_sym
-        if key==:item
-          hash[:items] ||= {}
-          hash[:items][:view] = value
-        elsif @@options.include? key
-          hash[key] = value
-        else
-          style_hash[key] = value
-        end
-      end
-
-      if !style_hash.empty?
-        hash[:style] = style_hash.map { |key, value| CGI.escapeHTML "#{key}:#{value};" } * ''
-      end
-      hash
-    end
-
-    def inspect
-      "<##{self.class}:n[#{@name}] p[#{@process_chunk}] txt:#{@text}>"
-    end
-
-    def process_chunk
-      return @process_chunk if @process_chunk
-
-      referee_name
-      if view = @options[:view]
-        view = view.to_sym
-      end
-
-      @processed = yield @options # this is not necessarily text, sometimes objects for json
-    end
-
-    def replace_reference old_name, new_name
-      replace_name_reference old_name, new_name
-      @text = "{{#{ [ @name.to_s, @opt_lists ].compact * '|' }}}"
-    end
-
-  end
-end

data/mod/01_core/chunk/link.rb

@@ -1,87 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-require_dependency File.expand_path( '../reference', __FILE__ )
-
-module Card::Chunk
-  class Link < Reference
-    word = /\s*([^\]\|]+)\s*/
-    # Groups: $1, [$2]: [[$1]] or [[$1|$2]] or $3, $4: [$3][$4]
-    Card::Chunk.register_class self, {
-      :prefix_re => '\\[',
-      :full_re   => /^\[\[([^\]]+)\]\]/,
-      :idx_char  => '['
-    }
-
-    def interpret match, content
-      target, @link_text = if raw_syntax = match[1]
-        if i = divider_index( raw_syntax )  # [[ A | B ]]
-          [ raw_syntax[0..(i-1)], raw_syntax[(i+1)..-1] ]
-        else                                # [[ A ]]
-          [ raw_syntax, nil ]
-        end
-      end
-      
-      @link_text = objectify @link_text
-      if target =~ /\/|mailto:/
-        @explicit_link = objectify target
-      else
-        @name = target
-      end  
-    end
-
-    def divider_index string
-      #there's probably a better way to do the following.  point is to find the first pipe that's not inside an inclusion
-      
-      if string.index '|'
-        string_copy = "#{string}" # had to do this to create new string?!
-        string.scan /\{\{[^\}]*\}\}/ do |incl|
-          string_copy.gsub! incl, ('x'*incl.length)
-        end
-        string_copy.index '|'
-      end
-    end
-
-    def objectify raw
-      if raw
-        raw.strip!
-        if raw =~ /(^|[^\\])\{\{/
-          Card::Content.new raw, format
-        else
-          raw
-        end
-      end
-    end
-
-
-    def render_link
-      @link_text = render_obj @link_text
-      
-      if @explicit_link
-        @explicit_link = render_obj @explicit_link
-        format.web_link @explicit_link, :text=> @link_text
-      elsif @name
-        format.card_link referee_name, :text=>@link_text, :known=>referee_card.send_if(:known?)
-      end
-    end
-
-    def process_chunk
-      @process_chunk ||= render_link
-    end
-
-    def inspect
-      "<##{self.class}:e[#{@explicit_link}]n[#{@name}]l[#{@link_text}] p[#{@process_chunk}] txt:#{@text}>"
-    end
-
-    def replace_reference old_name, new_name
-      replace_name_reference old_name, new_name
-
-      if Card::Content===@link_text
-        @link_text.find_chunks(Card::Chunk::Reference).each { |chunk| chunk.replace_reference old_name, new_name }
-      else
-        @link_text = new_name if old_name.to_name == @link_text
-      end
-      
-      @text = @link_text.nil? ? "[[#{referee_name.to_s}]]" : "[[#{referee_name.to_s}|#{@link_text}]]"
-    end
-  end
-end

data/mod/01_core/chunk/literal.rb

@@ -1,24 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-# These are basic chunks that have a pattern and can be protected.
-# They are used by rendering process to prevent wiki rendering
-# occuring within literal areas such as <code> and <pre> blocks
-# and within HTML tags.
-module Card::Chunk
-  class EscapedLiteral < Abstract
-    FULL_RE = { '[' => /^\\\[\[[^\]]*\]\]/, '{' => /^\\\{\{[^\}]*\}\}/ }
-    Card::Chunk.register_class self, {
-      :prefix_re => '\\\\(?:\\[\\[|\\{\\{)',
-      :idx_char  => '\\'
-    }
-
-    def self.full_re prefix
-      re = FULL_RE[ prefix[1,1] ]
-    end
-
-    def interpret match, content
-      @process_chunk = match[0].sub(/^\\(.)/, "<span>\\1</span>")
-    end
-  end
-
-end

data/mod/01_core/chunk/reference.rb

@@ -1,53 +0,0 @@
-# -*- encoding : utf-8 -*-
-module Card::Chunk
-  class Reference < Abstract
-    attr_accessor :referee_name, :name
-
-    def referee_name
-      return if name.nil?
-      
-      @referee_name ||= begin
-        rendered_name = render_obj( name )
-        ref_card = case rendered_name
-        when /^\~(\d+)$/ # get by id
-          Card.fetch $1.to_i 
-        when /^\:(\w+)$/ # get by codename
-          Card.fetch $1.to_sym
-        end
-        if ref_card
-          ref_card.cardname
-        else
-          rendered_name.to_name
-        end
-      end
-      @referee_name = @referee_name.to_absolute(card.cardname).to_name
-    end
-
-    def referee_card
-      @referee_card ||= referee_name && Card.fetch( referee_name )
-    end
-    def referee_id
-      referee_card and referee_card.id
-    end
-
-    def replace_name_reference old_name, new_name
-      #warn "ref rnr #{inspect}, #{old_name}, #{new_name}"
-      @referee_card = @referee_name = nil
-      if Card::Content===name
-        name.find_chunks(Chunk::Reference).each { |chunk| chunk.replace_reference old_name, new_name }
-      else
-        @name = name.to_name.replace_part( old_name, new_name )
-      end
-    end
-    
-    def render_obj raw
-      if format && Card::Content===raw
-        format.card.references_expired = nil # don't love this; this is to keep from running update_references again
-        format.process_content raw
-      else
-        raw
-      end
-    end
-  end
-end
-