mack 0.7.0.1 → 0.7.1

data/lib/mack/tasks/mack_server_tasks.rake

@@ -4,30 +4,17 @@ namespace :mack do
 
     desc "Starts the webserver."
     task :start do |t|
+      puts %{
+This task has been removed. Please use the 'mackery' command to start/stop the server:
 
-      require 'rubygems'
-      require 'optparse'
-      require 'optparse/time'
-      require 'ostruct'
-      require 'fileutils'
+  $ mackery server
 
-      require 'thin'
+The environment can be set like this:
 
-      options = OpenStruct.new
-      options.port = (ENV["PORT"] ||= "3000") # Does NOT work with Thin!! You must edit the thin.yml file!
-      options.handler = (ENV["HANDLER"] ||= "thin")
-
-
-      # require File.join(Mack.root, "config", "boot.rb")
-      require 'mack'
-
-      if options.handler == "thin"
-        # thin_opts = ["start", "-r", "config/thin.ru"]
-        thin_opts = ["start"]
-        Thin::Runner.new(thin_opts.flatten).run!
-      else
-        Mack::SimpleServer.run(options)
-      end
+  $ mackery server -e test
+  
+  $ mackery server -p 8080 -e production # etc...
+      }
     end # start
 
   end # server

data/lib/mack/tasks/mack_tasks.rake

@@ -1,18 +1,45 @@
+require 'fileutils'
 namespace :mack do
   
   desc "Loads the Mack environment. Default is development."
   task :environment do
-    require File.join(File.dirname(__FILE__), '..', "..", 'mack')
+    require File.join(File.dirname(__FILE__), '..', '..', 'mack')
+    Mack::Environment.load
   end # environment
 
-  desc "Loads an irb console allow you full access to the application w/o a browser."
+  # desc "Loads an irb console allow you full access to the application w/o a browser."
   task :console do
-    libs = []
-    libs << "-r irb/completion"
-    libs << "-r #{File.join(File.dirname(__FILE__), '..', 'initialization', 'console')}"
-    system "irb #{libs.join(" ")} --simple-prompt"
+    puts %{
+This task has been removed. Please use the 'mackery' command to access the console:
+
+  $ mackery console
+
+The environment can be set like this:
+
+  $ mackery console -e test
+    }
   end # console
   
+  namespace :freeze do
+    
+    desc "Freezes the Edge Mack code into your vendor/framework folder"
+    task :edge do
+      f_dir = File.join(FileUtils.pwd, 'vendor', 'framework')
+      FileUtils.mkdir_p(f_dir)
+      %w{mack mack-more}.each do |proj|
+        proj_dir = File.join(f_dir, proj)
+        if File.exists?(proj_dir)
+          FileUtils.cd proj_dir
+          system 'git pull'
+        else
+          FileUtils.cd f_dir
+          system "git clone git://github.com/#{ENV["USERNAME"] || 'markbates'}/#{proj}.git"
+        end
+      end
+    end
+    
+  end
+  
 end # mack
 
 alias_task :console, "mack:console"

data/lib/mack/tasks/rake_rules.rake

@@ -17,6 +17,14 @@ rule /^cachetastic:/ do |t|
   Rake::Task["cachetastic:manipulate_caches"].invoke
 end
 
+rule /^generate:.+:desc/ do |t|
+  klass = t.name.gsub("generate:", '')
+  klass.gsub!(":desc", '')
+  Rake::Task["environment"].invoke
+  klass = "#{klass.camelcase}Generator"
+  puts klass.constantize.describe
+end
+
 rule /^generate:/ do |t|
   klass = t.name.gsub("generate:", '')
   Rake::Task["environment"].invoke

data/lib/mack/tasks/test_tasks.rake

@@ -10,24 +10,25 @@ namespace :test do
   
   desc "Run test code."
   Rake::TestTask.new(:test_case) do |t|
+    require File.join(File.dirname(__FILE__), '..', 'initialization', 'configuration')
+    Mack::BootLoader.run(:configuration)
     t.libs << "test"
-    t.pattern = 'test/**/*_test.rb'
+    t.pattern = app_config.mack.send("#{app_config.mack.testing_framework}_file_pattern")
     t.verbose = true
   end
   
   desc 'Run specifications'
   Spec::Rake::SpecTask.new(:rspec) do |t|
+    require File.join(File.dirname(__FILE__), '..', 'initialization', 'configuration')
+    Mack::BootLoader.run(:configuration)
     t.spec_opts << '--options' << 'test/spec.opts' if File.exists?('test/spec.opts')
-    t.spec_files = Dir.glob('test/**/*_spec.rb')
+    t.spec_files = Dir.glob(app_config.mack.send("#{app_config.mack.testing_framework}_file_pattern"))
   end
   
   desc "Report code statistics (KLOCs, etc) from the application. Requires the rcov gem."
   task :stats do |t|
-    ENV["MACK_ENV"] = "test"
-    Rake::Task["mack:environment"].invoke
-    Rake::Task["test:setup"].invoke
-    x = `rcov test/**/*_#{app_config.mack.testing_framework == "rspec" ? "spec" : "test"}.rb -T --no-html -x Rakefile,config\/,tasks\/`
-    x.each do |line|
+    res = common_coverage
+    res.each do |line|
       case line
       when /^\+[\+\-]*\+$/, /^\|.*\|$/, /\d+\sLines\s+\d+\sLOC/
         puts line
@@ -37,11 +38,14 @@ namespace :test do
   
   desc "Generates test coverage from the application. Requires the rcov gem."
   task :coverage do |t|
-    ENV["MACK_ENV"] = "test"
-    Rake::Task["mack:environment"].invoke
-    Rake::Task["test:setup"].invoke
-    `rcov test/**/*_#{app_config.mack.testing_framework == "rspec" ? "spec" : "test"}.rb -x Rakefile,config\/,tasks\/`
-    `open coverage/index.html`
+    common_coverage
+
+    unless PLATFORM['i386-mswin32'] 
+      system("open coverage/index.html") if PLATFORM['darwin'] 
+    else 
+      system("\"C:/Program Files/Mozilla Firefox/firefox.exe\" " + 
+      "coverage/index.html") 
+    end
   end
   
   task :empty do |t|
@@ -52,12 +56,32 @@ namespace :test do
     raise "Oh No!"
   end
   
+  private
+  def common_coverage
+    ENV["MACK_ENV"] = "test"
+    Rake::Task["mack:environment"].invoke
+    Rake::Task["test:setup"].invoke
+    
+    rm_f Mack::Paths.root("coverage")
+    rm_f Mack::Paths.root("coverage.data")
+    unless PLATFORM['i386-mswin32'] 
+      rcov = "rcov --sort coverage --rails --aggregate coverage.data " + 
+      "--text-summary -Ilib -T -x gems/*,rcov*,lib/tasks/*,Rakefile" 
+    else 
+      rcov = "rcov.cmd --sort coverage --rails --aggregate coverage.data " + 
+      "--text-summary -Ilib -T" 
+    end
+    
+    puts "Generating... please wait..."
+    res = `#{rcov} --html #{app_config.mack.send("#{app_config.mack.testing_framework}_file_pattern")}`
+    res
+  end
+  
 end
 
 task :default do
-  require 'application_configuration'
-  app_config.load_file(File.join(FileUtils.pwd, "config", "app_config", "default.yml"))
-  app_config.load_file(File.join(FileUtils.pwd, "config", "app_config", "test.yml"))
+  require File.join(File.dirname(__FILE__), '..', 'initialization', 'configuration')
+  Mack::BootLoader.run(:configuration)
   tf = "rspec"
   begin
     tf = app_config.mack.testing_framework

data/lib/mack/testing/helpers.rb

@@ -19,41 +19,6 @@ module Mack
   module Testing # :nodoc:
     module Helpers
     
-      # Runs the given rake task. Takes an optional hash that mimics command line parameters.
-      def rake_task(name, env = {}, tasks = [])
-        # set up the Rake application
-        rake = Rake::Application.new
-        Rake.application = rake
-      
-        [File.join(File.dirname(__FILE__), "..", "..", "mack_tasks.rb"), tasks].flatten.each do |task|
-          load(task)
-        end
-      
-        # save the old ENV so we can revert it
-        old_env = ENV.to_hash
-        # add in the new ENV stuff
-        env.each_pair {|k,v| ENV[k.to_s] = v}
-      
-        begin
-          # run the rake task
-          rake[name].invoke
-        
-          # yield for the tests
-          yield if block_given?
-        
-        rescue Exception => e
-          raise e
-        ensure
-          # empty out the ENV
-          ENV.clear
-          # revert to the ENV before the test started
-          old_env.to_hash.each_pair {|k,v| ENV[k] = v}
-
-          # get rid of the Rake application
-          Rake.application = nil
-        end
-      end
-    
       # Temporarily changes the application configuration. Changes are reverted after
       # the yield returns.
       def temp_app_config(options = {})
@@ -125,14 +90,16 @@ module Mack
     
       # Returns a Mack::Session from the request.
       def session # :nodoc:
-        Cachetastic::Caches::MackSessionCache.get($current_session_id) do
+        sess = Mack::SessionStore.get($current_session_id, nil, nil, nil)
+        if sess.nil?
           id = String.randomize(40).downcase
           set_cookie(app_config.mack.session_id, id)
           sess = Mack::Session.new(id)
-          Cachetastic::Caches::MackSessionCache.set(id, sess)
+          Mack::SessionStore.store.direct_set(id, sess)
           $current_session_id = id
-          sess
+          sess          
         end
+        sess
       end
     
       # Used to create a 'session' around a block of code. This is great of 'integration' tests.
@@ -148,7 +115,7 @@ module Mack
     
       # Clears all the sessions.
       def clear_session
-        Cachetastic::Caches::MackSessionCache.expire_all
+        Mack::SessionStore.expire_all
       end
     
       # Returns a Hash of cookies from the response.

data/lib/mack/utils/content_length_handler.rb

@@ -0,0 +1,45 @@
+module Mack
+  module Utils
+    #
+    # The whole purpose of this handler is to intercept the rack application process, 
+    # calculate the size of the response body, and set the 'Content-Length' header if necessary.
+    #
+    # From: http://thin.lighthouseapp.com/projects/7212/tickets/74
+    # Content-Length should not be automatically added:
+    # * When the Status code is 1xx, 204 or 304
+    # * When the Transfer-Encoding header is set to chunked
+    # * When the body is neither a String or an Array
+    #
+    class ContentLengthHandler
+      attr_reader :response
+      
+      def initialize(app) # :nodoc:
+        @app = app
+      end
+
+      def call(env) # :nodoc:
+        ret = @app.call(env)
+                
+        status        = ret[0]
+        hdr           = ret[1]
+        @response     = ret[2]
+           
+        unless self.response.is_a?(Rack::File) or 
+               (!self.response.body.kind_of?Array and !self.response.body.kind_of?String) or 
+               hdr["Transfer-Encoding"] == "chunked" or
+               (status == 204 or status == 304 or (status >= 100 and status < 200))
+          size = 0
+          
+          if self.response.body.respond_to?(:to_str)
+            size = self.response.body.to_str.size
+          elsif self.response.body.respond_to?(:each)
+            self.response.body.each { |part| size += part.to_s.size }
+          end
+          
+          hdr["Content-Length"] = size.to_s
+        end
+        return ret
+      end
+    end
+  end
+end

data/lib/mack/utils/forgery_detector.rb

@@ -0,0 +1,152 @@
+module Mack
+  module Utils
+
+    module ForgeryDetector # :nodoc:
+      
+      module ClassMethods
+        
+        #
+        # By default the framework will try to validate incoming
+        # HTTP request (other than GET) by validating a secret token
+        # stored as hidden field in the posted form.
+        #
+        # There are 2 ways of disabling this feature:
+        # 1.  Globally disabling this feature by setting mack::disable_forgery_detector to true in app_config
+        # 2.  In a controller, call this method (disable_forgery_detector) to disable the detection
+        #     for a specified set of methods.
+        #
+        # Supported options:
+        # :only => list_of_methods.
+        #    This directive will tell the framework only disable the detection for the specified list of methods.
+        # :except => list_of_methods
+        #    This directive will tell the framework to disable the detection for all methods except the ones specified.
+        #
+        # Example:
+        # class MyController
+        #   include Mack::Controller
+        #   disable_forgery_detector :only => [:test1, :test2]
+        #
+        #   def test1
+        #   end
+        #
+        #   def test2
+        # end
+        #
+        # Notes:
+        # - This method will not work properly if both :only and :except options are passed in
+        # - In inherited case, the following behavior is to be expected:
+        #   * If the super class declare that it wants to disable detection for all methods, and the
+        #     subclass declare that it wants to disable detection for only a set of methods, then
+        #     when the subclass is run, the "disable all detection" from the parent class will be overwritten
+        #   * On the other hand, if the super class declare that it wants to disable a set of methods,
+        #     and the subclass also declare it wants to disable a set of methods from its own set.  Then
+        #     the "only" list will be the combination of both
+        #   * The first rule apply in inheritance; this method will not work properly if superclass declear
+        #     "except" list, and subclass declare "only" list
+        #
+        def disable_forgery_detector(options = {})
+          hash = self.ignored_actions
+          hash[:all] = true and return if options.empty?
+
+          # TODO: should raise error if type is invalid
+          type = options[:only] ? :only : (options[:except] ? :except : :unknown)
+          list = options[:only] ? [options[:only]].flatten : (options[:except] ? [options[:except]].flatten : [])
+          if !list.empty?
+            hash[type] ||= []
+            hash[type] << list
+            hash[type].flatten!
+            hash[type].uniq!
+            hash[:all] = false
+          end
+        end
+        
+        def ignored_actions # :nodoc:
+          unless @ignored_actions
+            @ignored_actions = {}
+            sc = self.superclass
+            if sc.class_is_a?(Mack::Controller)
+              sc_hash = sc.ignored_actions
+              if sc_hash[:only]
+                @ignored_actions[:only] ||= []
+                @ignored_actions[:only] << sc_hash[:only]
+                @ignored_actions[:only].flatten!
+              elsif sc_hash[:except]
+                @ignored_actions[:except] ||= []
+                @ignored_actions[:except] << sc_hash[:except]
+                @ignored_actions[:except].flatten!
+              elsif sc_hash[:all]
+                @ignored_actions[:all] = sc_hash[:all]
+              end
+            end
+          end
+          return @ignored_actions
+        end
+      end
+      
+      #
+      # This method will be added as "before-filter" for all controllers.
+      # 
+      # This method will filter the incoming request, and raise an exception
+      # if it thinks that the incoming request is a forged request.
+      #
+      # The requirement for a request to be considered a forged:
+      # -  It must not be a GET request
+      # -  The forgery detection is not disabled globally
+      # -  The current action is not part of the "disabled" list
+      # -  The authenticity token in the request param is valid
+      # -  All of the above must be true
+      #
+      def detect_forgery
+        valid_request? || raise(Mack::Errors::InvalidAuthenticityToken.new(request.params[:__authenticity_token] || "unknown token"))
+      end
+
+      protected
+      
+      def symbolize_list_elements(list = []) # :nodoc:
+        list.collect { |x| x.to_sym }
+      end
+          
+      def skip_action? # :nodoc:
+        return true if self.class.ignored_actions[:all] and self.class.ignored_actions.empty?
+        return false if !self.class.ignored_actions[:all] and self.class.ignored_actions.empty? 
+        
+        skip = true
+        action = request.params[:action]        
+        hash   = self.class.ignored_actions
+        if hash[:only]
+          list = [hash[:only]].flatten
+          list = symbolize_list_elements(list)
+          skip = false if !list.include?action.to_sym
+        elsif hash[:except]
+          list = [hash[:except]].flatten
+          list = symbolize_list_elements(list)
+          skip = false if list.include?action.to_sym
+        end
+        return skip
+      end
+      
+      def valid_request? # :nodoc:
+        return true if !self.class.ignored_actions.empty? and self.skip_action?        
+        return app_config.mack.disable_forgery_detector ||
+                self.skip_action? ||
+                request.params[:method] == "get" ||
+                (request.params[:__authenticity_token] == authenticity_token)
+      end
+      
+      def authenticity_token # :nodoc:
+        Mack::Utils::AuthenticityTokenDispenser.instance.dispense_token(request.session.id)
+      end
+    end
+    
+    class AuthenticityTokenDispenser # :nodoc:
+      include Singleton
+
+      def dispense_token(key) # :nodoc:
+        salt = app_config.request_authenticity_token_salt || "shh, it's a secret"
+        salt = "shh, it's a secret" if salt.empty?
+        string_to_hash = key.to_s + salt.to_s
+        Digest::SHA1.hexdigest(string_to_hash)
+      end
+    end
+  end
+end