wagn 1.12.7

data/lib/wagn/authenticated_system.rb

@@ -0,0 +1,38 @@
+# -*- encoding : utf-8 -*-
+module Wagn::AuthenticatedSystem
+  
+  protected
+  
+  def logged_in?
+    Account.logged_in?
+  end
+
+  # Accesses the current user from the session.
+  def current_account_id
+    @current_account_id ||= begin
+      if card_id = session[:user]
+        if Account[ card_id ]
+          card_id
+        else
+          session[:user] = nil
+        end
+      end
+    end
+  rescue Exception => e
+    session[:user] = nil
+    raise e
+  end
+
+  # Store the given user in the session.
+  def current_account_id= card_id
+    @current_account_id = session[:user] = card_id
+  end
+
+
+  # Inclusion hook to make #current_account_id and #logged_in?
+  # available as ActionView helper methods.
+  def self.included(base)
+    super
+    base.send :helper_method, :current_account_id, :logged_in?
+  end
+end

data/lib/wagn/cache.rb

@@ -0,0 +1,176 @@
+# -*- encoding : utf-8 -*-
+module Wagn
+
+  ActiveSupport::Cache::FileStore.class_eval do
+    # escape special symbols \*"<>| additionaly to :?.
+    # All of them not allowed to use in ms windows file system
+    def real_file_path(name)
+      name = name.gsub('%','%25').gsub('?','%3F').gsub(':','%3A')
+      name = name.gsub('\\','%5C').gsub('*','%2A').gsub('"','%22')
+      name = name.gsub('<','%3C').gsub('>','%3E').gsub('|','%7C')
+      '%s/%s.cache' % [@cache_path, name ]
+    end
+  end
+
+
+  class Cache
+    @@prepopulating     = [ 'test','cucumber' ].include? Rails.env
+    @@using_rails_cache = Rails.env =~ /^cucumber|test$/
+    @@prefix_root       = Wagn.config.database_configuration[Rails.env]['database']
+    @@cache_by_class    = {}
+
+    cattr_reader :cache_by_class, :prefix_root
+
+    class << self
+      def [] klass
+        raise "nil klass" if klass.nil?
+        cache_by_class[klass] ||= new :class=>klass, :store=>(@@using_rails_cache ? nil : Rails.cache)
+      end
+
+      def renew
+        cache_by_class.keys do |klass|
+          if klass.cache
+            cache_by_class[klass].system_prefix = system_prefix(klass)
+          else
+            raise "renewing nil cache: #{klass}"
+          end
+        end
+        reset_local
+      end
+
+      def system_prefix klass
+        "#{ prefix_root }/#{ klass }"
+      end
+
+      def restore klass=nil
+        reset_local
+        prepopulate
+      end
+
+      def generate_cache_id
+        ((Time.now.to_f * 100).to_i).to_s + ('a'..'z').to_a[rand(26)] + ('a'..'z').to_a[rand(26)]
+      end
+
+      def reset_global
+        cache_by_class.keys.each do |klass|
+          next unless cache = klass.cache
+          cache.reset hard=true
+        end
+        Card::Codename.reset_cache
+        Card.delete_tmp_files
+      end
+
+      private
+
+      def prepopulate
+        if @@prepopulating
+          @@rule_cache      ||= Card.rule_cache
+          @@read_rule_cache ||= Card.read_rule_cache
+          Card.cache.write_local 'RULES', @@rule_cache
+          Card.cache.write_local 'READRULES', @@read_rule_cache
+        end
+      end
+
+
+      def reset_local
+        cache_by_class.each do |cc, cache|
+          if Wagn::Cache===cache
+            cache.reset_local
+          else warn "reset class #{cc}, #{cache.class} #{caller[0..8]*"\n"} ???" end
+        end
+      end
+
+    end
+
+    attr_reader :prefix, :store, :klass
+    attr_accessor :local
+
+    def initialize opts={}
+      #warn "new cache #{opts.inspect}"
+      @klass = opts[:class]
+      @store = opts[:store]
+      @local = Hash.new
+      self.system_prefix = opts[:prefix] || self.class.system_prefix(opts[:class])
+      cache_by_class[klass] = self
+    end
+    
+
+    def system_prefix= system_prefix
+      @system_prefix = system_prefix
+      if @store.nil?
+        @prefix = system_prefix + self.class.generate_cache_id + "/"
+      else
+        @system_prefix += '/' unless @system_prefix[-1] == '/'
+        @cache_id = @store.fetch(@system_prefix + "cache_id") do
+          self.class.generate_cache_id
+        end
+        @prefix = @system_prefix + @cache_id + "/"
+      end
+    end
+
+    def read key
+      if @local.has_key? key
+        read_local key
+      elsif @store
+        write_local key, @store.read(@prefix + key)
+      end
+    end
+    
+    def read_local key
+      @local[key]
+    end
+
+    def write key, value
+      @store.write(@prefix + key, value) if @store
+      write_local key, value
+    end
+
+    def write_local key, value
+      @local[key] = value
+    end
+
+    def fetch key, &block
+      fetch_local key do
+        if @store
+          @store.fetch(@prefix + key, &block)
+        else
+          block.call
+        end
+      end
+    end
+    
+    def fetch_local key
+      read_local key or write_local key, yield
+    end
+
+    def delete key
+      @store.delete(@prefix + key) if @store
+      @local.delete key
+    end
+
+    def dump
+      p "dumping local...."
+      @local.each do |k, v|
+        p "#{k} --> #{v.inspect[0..30]}"
+      end
+    end
+
+    def reset hard=false
+      reset_local
+      @cache_id = self.class.generate_cache_id
+      if @store
+        if hard
+          @store.clear
+        else
+          @store.write @system_prefix + "cache_id", @cache_id
+        end
+      end
+      @prefix = @system_prefix + @cache_id + "/"
+    end
+    
+    def reset_local
+      @local = {}
+    end
+  end
+end
+

data/lib/wagn/cli.rb

@@ -0,0 +1,17 @@
+require 'rbconfig'
+require 'wagn/script_wagn_loader'
+
+# If we are inside a Wagn application this method performs an exec and thus
+# the rest of this script is not run.
+Wagn::ScriptWagnLoader.exec_script_wagn!
+
+require 'rails/ruby_version_check'
+Signal.trap("INT") { puts; exit(1) }
+
+#if ARGV.first == 'plugin'
+#  ARGV.shift
+#  require 'wagn/commands/plugin_new'
+#else
+
+require 'wagn/commands/application'
+#end

data/lib/wagn/commands.rb

@@ -0,0 +1,2 @@
+require 'wagn'
+require 'rails/commands'

data/lib/wagn/commands/application.rb

@@ -0,0 +1,10 @@
+require 'rails/generators'
+require File.expand_path( '../../../generators/wagn/wagn_generator', __FILE__ )
+
+if ARGV.first != "new"
+  ARGV[0] = "--help"
+else
+  ARGV.shift
+end
+
+WagnGenerator.start

data/lib/wagn/env.rb

@@ -0,0 +1,42 @@
+# Wagn::Env can differ for each request; Wagn.config should not
+
+module Wagn::Env
+  class << self
+    def reset args={}
+      @@env = { :main_name => nil }
+      
+      if c = args[:controller]
+        self[:controller] = c
+        self[:params] = c.request.params
+        
+        self[:host]       = Wagn.config.override_host     || c.request.env['HTTP_HOST']
+        self[:protocol]   = Wagn.config.override_protocol || c.request.protocol
+        
+        #hacky - should be in module
+        self[:recaptcha_on] = !Account.logged_in? && have_recaptcha_keys?
+        self[:recaptcha_count] = 0
+      end
+    end
+    
+    def [] key
+      @@env[key.to_sym]
+    end
+    
+    def []= key, value
+      @@env[key.to_sym] = value
+    end
+
+    def params
+      self[:params] || {}
+    end
+    
+    private
+    
+    def have_recaptcha_keys?
+      !!( Wagn.config.recaptcha_public_key && Wagn.config.recaptcha_private_key )
+    end    
+  end  
+end
+
+Wagn::Env.reset
+

data/lib/wagn/exceptions.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+module Wagn
+  module Exceptions
+    class Error     < StandardError ; end
+    class NotFound          < Error ; end
+    class BadAddress        < Error ; end
+    class PermissionDenied  < Error ; end
+    class Oops              < Error ; end
+  end
+end

data/lib/wagn/loader.rb

@@ -0,0 +1,135 @@
+# -*- encoding : utf-8 -*-
+
+module Wagn
+
+  include Wagn::Exceptions
+
+  module Loader
+    
+    def self.mod_dirs
+      @@mod_dirs ||= begin
+        (Wagn.paths['gem-mods'].existent + Wagn.paths['local-mods'].existent).map do |dirname|
+          Dir.entries( dirname ).sort.map do |filename|
+            "#{dirname}/#{filename}" if filename !~ /^\./
+          end
+        end.flatten.compact
+      end
+    end
+    
+    def mod_dirs
+      Loader.mod_dirs
+    end
+
+    def load_mods
+      mod_dirs
+      load_set_patterns
+      load_formats
+      load_sets
+    end
+
+    def load_set_patterns
+      mod_dirs.each do |mod|
+        dirname = "#{mod}/set_patterns"
+        if Dir.exists? dirname
+          Dir.entries( dirname ).sort.each do |filename|
+            if m = filename.match( /^(\d+_)?([^\.]*).rb/) and key = m[2]
+              mod = Module.new
+              filename = [ dirname, filename ] * '/'
+              mod.class_eval { mattr_accessor :options }
+              mod.class_eval File.read( filename ), filename, 1
+
+              klass = Card::SetPattern.const_set "#{key.camelize}Pattern", Class.new( Card::SetPattern )
+              klass.extend mod
+              klass.register key, (mod.options || {})
+
+            end
+          end
+        end
+      end
+    end
+
+    def load_formats
+      #cheating on load issues now by putting all inherited-from formats in core mod.
+      mod_dirs.each do |mod|
+        load_dir "#{mod}/formats/*.rb"
+      end
+    end
+
+    def load_chunks
+      mod_dirs.each do |mod|
+        load_dir "#{mod}/chunks/*.rb"
+      end
+    end
+
+    def load_sets
+      mod_dirs.each do |mod|
+        if File.directory? mod
+          load_implicit_sets "#{mod}/sets"
+        else
+          next unless mod =~ /\.rb$/
+          require_dependency mod
+        end
+        Card::Set.process_base_modules #must do this here because core sets must be processed into Card class before loading standard sets
+      end
+      
+      Card::Set.process_base_modules
+      Card::Set.clean_empty_modules
+            
+      Card::Set.register_set Card # reset so events in card.rb will be defined on card itself  (temporary?)
+    end
+
+
+    def load_implicit_sets basedir
+
+      Card.set_patterns.reverse.map(&:key).each do |set_pattern|
+
+        next if set_pattern =~ /^\./
+        dirname = [basedir, set_pattern] * '/'
+        next unless File.exists?( dirname )
+
+        #FIXME support multiple anchors!
+        Dir.entries( dirname ).sort.each do |anchor_filename|
+          next if anchor_filename =~ /^\./
+          anchor = anchor_filename.gsub /\.rb$/, ''
+
+          set_module = Card::Set.set_module_from_name( set_pattern, anchor )
+          filename = [dirname, anchor_filename] * '/'
+          
+          set_module.extend Card::Set
+          set_module.class_eval File.read( filename ), filename, 1
+        end    
+      end
+    end
+
+    def self.load_layouts
+      mod_dirs.inject({}) do |hash, mod|
+        dirname = "#{mod}/layouts"
+        if File.exists? dirname
+          Dir.foreach( dirname ) do |filename|
+            next if filename =~ /^\./
+            hash[ filename.gsub /\.html$/, '' ] = File.read( [dirname, filename] * '/' )
+          end
+        end
+        hash
+      end
+    end
+
+    private
+
+
+
+    def load_dir dir
+      Dir[dir].sort.each do |file|
+        begin
+#          puts Benchmark.measure("from #load_dir: rd: #{file}") {
+          require_dependency file
+#          }.format("%n: %t %r")
+        rescue Exception=>e
+          Rails.logger.info "Error loading file #{file}: #{e.message}\n#{e.backtrace*"\n"}"
+          raise e
+        end
+      end
+    end
+
+  end
+end

data/lib/wagn/location.rb

@@ -0,0 +1,88 @@
+# -*- encoding : utf-8 -*-
+# helper for urls, links, redirects, and other location related things.
+#  note: i'm sure this isn't the optimal name..
+module Wagn::Location
+
+  # we keep a history stack so that in the case of card removal
+  # we can crawl back up to the last un-removed location
+
+  #
+  def location_history
+    #warn "sess #{session.class}, #{session.object_id}"
+    session[:history] ||= [wagn_path('')]
+    if session[:history]
+      session[:history].shift if session[:history].size > 5
+      session[:history]
+    end
+  end
+
+  def save_location
+    return if ajax? || !html? || !@card.known?
+
+    discard_locations_for @card
+    @previous_location = wagn_path @card
+    location_history.push @previous_location
+  end
+
+  def previous_location
+    @previous_location ||= location_history.last if location_history
+  end
+
+  def discard_locations_for(card)
+    # quoting necessary because cards have things like "+*" in the names..
+    session[:history] = location_history.reject do |loc|
+      if url_key = url_key_for_location(loc)
+        url_key.to_name.key == card.key
+      end
+    end.compact
+    @previous_location = nil
+  end
+
+  def url_key_for_location(location)
+    location.match( /\/([^\/]*$)/ ) ? $1 : nil
+  end
+
+   # -----------( urls and redirects from application.rb) ----------------
+
+
+  # FIXME: missing test  shouldn't this have the rootpath?
+  def page_path title, opts={}
+    format = (opts[:format] ? ".#{opts.delete(:format)}"  : "")
+    vars = ''
+    if !opts.empty?
+      pairs = []
+      opts.each_pair{|k,v| pairs<< "#{k}=#{v}"}
+      vars = '?' + pairs.join('&')
+    end
+    wagn_path "#{title.to_name.url_key}#{format}#{vars}"
+  end
+
+  def wagn_path rel #should be in smartname?
+    rel_path = Card===rel ? rel.cardname.url_key : rel.to_s
+    if rel_path =~ /^\//
+      rel_path
+    else
+      "#{ Wagn.config.relative_url_root }/#{ rel_path }"
+    end
+  end
+
+  def wagn_url rel #should be in smartname?
+    if rel =~ /^https?\:/
+      rel
+    else
+      "#{ Wagn::Env[:protocol] }#{ Wagn::Env[:host] }#{ wagn_path rel }"
+    end
+  end
+
+
+  # Links ----------------------------------------------------------------------
+
+  def link_to_page( text, title=nil, options={})
+    title ||= text
+    url_options = {}
+    [:type, :view].each { |k| url_options[k] = options.delete(k) if options[k] }
+    url = wagn_path page_path( title, url_options )
+    link_to text, url, options
+  end
+
+end