roda-cj 0.9.6 → 1.0.0

data/lib/roda/plugins/all_verbs.rb

@@ -16,7 +16,7 @@ class Roda
     #   plugin :all_verbs
     #
     #   route do |r|
-    #     r.delete
+    #     r.delete do
     #       # Handle DELETE
     #     end
     #     r.put do

data/lib/roda/plugins/assets.rb

@@ -0,0 +1,277 @@
+require "tilt"
+require 'open-uri'
+
+class Roda
+  module RodaPlugins
+    module Assets
+      def self.load_dependencies(app, opts={})
+        app.plugin :render
+      end
+
+      def self.configure(app, opts={}, &block)
+        if app.opts[:assets]
+          app.opts[:assets].merge!(opts)
+        else
+          app.opts[:assets] = opts.dup
+        end
+
+        opts                   = app.opts[:assets]
+        opts[:css]           ||= []
+        opts[:js]            ||= []
+        opts[:js_folder]     ||= 'js'
+        opts[:css_folder]    ||= 'css'
+        opts[:path]          ||= File.expand_path("assets", Dir.pwd)
+        opts[:compiled_path] ||= opts[:path]
+        opts[:compiled_name] ||= 'compiled.roda.assets'
+        opts[:concat_name]   ||= 'concat.roda.assets'
+        opts[:route]         ||= 'assets'
+        opts[:css_engine]    ||= 'scss'
+        opts[:js_engine]     ||= 'coffee'
+        opts[:concat]        ||= false
+        opts[:compiled]      ||= false
+        opts[:headers]       ||= {}
+
+        if opts.fetch(:cache, true)
+          opts[:cache] = app.thread_safe_cache
+        end
+      end
+
+      module ClassMethods
+        # Copy the assets options into the subclass, duping
+        # them as necessary to prevent changes in the subclass
+        # affecting the parent class.
+        def inherited(subclass)
+          super
+          opts         = subclass.opts[:assets] = assets_opts.dup
+          opts[:cache] = thread_safe_cache if opts[:cache]
+        end
+
+        # Return the assets options for this class.
+        def assets_opts
+          opts[:assets]
+        end
+
+        # Generates a unique id, this is used to keep concat/compiled files
+        # from caching in the browser when they are generated
+        def assets_unique_id type
+          if unique_id = instance_variable_get("@#{type}")
+            unique_id
+          else
+            path    = "#{assets_opts[:compiled_path]}/#{assets_opts[:"#{type}_folder"]}"
+            file    = "#{path}/#{assets_opts[:compiled_name]}.#{type}"
+            content = File.exist?(file) ? File.read(file) : ''
+
+            instance_variable_set("@#{type}", Digest::SHA1.hexdigest(content))
+          end
+        end
+
+        def compile_assets(concat_only = false)
+          assets_opts[:concat_only] = concat_only
+
+          %w(css js).each do |type|
+            files = assets_opts[type.to_sym]
+
+            if files.is_a? Array
+              compile_process_files files, type, type
+            else
+              files.each do |folder, f|
+                compile_process_files f, type, folder
+              end
+            end
+          end
+        end
+
+        private
+
+        def compile_process_files files, type, folder
+          require 'yuicompressor'
+
+          r = new
+
+          content = ''
+
+          files.each do |file|
+            if type != folder
+              file = "#{folder}/#{file}"
+            end
+
+            content += r.read_asset_file file, type
+          end
+
+          path = assets_opts[:compiled_path] \
+                 + "/#{assets_opts[:"#{type}_folder"]}/" \
+                 + assets_opts[:compiled_name] \
+                 + (type != folder ? ".#{folder}" : '') \
+                 + ".#{type}"
+
+          unless assets_opts[:concat_only]
+            content = YUICompressor.send("compress_#{type}", content, munge: true)
+          end
+
+          File.write path, content
+        end
+      end
+
+      module InstanceMethods
+        # This will ouput the files with the appropriate tags
+        def assets folder, options = {}
+          attrs   = options.map{|k,v| "#{k}=\"#{v}\""}
+          tags    = []
+          folder  = [folder] unless folder.is_a? Array
+          type    = folder.first
+          attr    = type.to_s == 'js' ? 'src' : 'href'
+          path    = "#{assets_opts[:route]}/#{assets_opts[:"#{type}_folder"]}"
+          files   = folder.length == 1 \
+                  ? assets_opts[:"#{folder[0]}"] \
+                  : assets_opts[:"#{folder[0]}"][:"#{folder[1]}"]
+
+          # Create a tag for each individual file
+          if !assets_opts[:concat]
+            files.each do |file|
+              # This allows you to do things like:
+              # assets_opts[:css] = ['app', './bower/jquery/jquery-min.js']
+              file.gsub!(/\./, '$2E')
+              # Add tags to the tags array
+              tags << send(
+                "#{type}_assets_tag",
+                attrs.dup.unshift( "#{attr}=\"/#{path}/#{file}.#{type}\"").join(' ')
+              )
+            end
+            # Return tags as string
+            tags.join "\n"
+          else
+            name = assets_opts[:compiled] ? assets_opts[:compiled_name] : assets_opts[:concat_name]
+            name = "#{name}/#{folder.join('-')}"
+            # Generate unique url so middleware knows to check for # compile/concat
+            attrs.unshift("#{attr}=\"/#{path}/#{name}/#{assets_unique_id(type)}.#{type}\"")
+            # Return tag string
+            send("#{type}_assets_tag", attrs.join(' '))
+          end
+        end
+
+        def render_asset(file, type)
+          file.gsub!(/(\$2E|%242E)/, '.')
+
+          if !assets_opts[:compiled] && !assets_opts[:concat]
+            read_asset_file file, type
+          elsif assets_opts[:compiled]
+            folder = file.split('/')[1].split('-', 2)
+            path   = assets_opts[:compiled_path] \
+                   + "/#{assets_opts[:"#{type}_folder"]}/" \
+                   + assets_opts[:compiled_name] \
+                   + (folder.length > 1 ? ".#{folder[1]}" : '') \
+                   + ".#{type}"
+
+            File.read path
+          elsif assets_opts[:concat]
+            # "concat.roda.assets/css/123"
+            content   = ''
+            folder = file.split('/')[1].split('-', 2)
+            files  = folder.length == 1 \
+                    ? assets_opts[:"#{folder[0]}"] \
+                    : assets_opts[:"#{folder[0]}"][:"#{folder[1]}"]
+
+            files.each { |f| content += read_asset_file f, type }
+
+            content
+          end
+        end
+
+        def read_asset_file file, type
+          folder = assets_opts[:"#{type}_folder"]
+
+          # If there is no file it must be a remote file request.
+          # Lets set the file to the url
+          if file == ''
+            route = assets_opts[:route]
+            file  = env['SCRIPT_NAME'].gsub(/^\/#{route}\/#{folder}\//, '')
+          end
+
+          if !file[/^\.\//] && !file[/^http/]
+            path = assets_opts[:path] + '/' + folder + "/#{file}"
+          else
+            path = file
+          end
+
+          engine = assets_opts[:"#{type}_engine"]
+
+          # render via tilt
+          if File.exists? "#{path}.#{engine}"
+            render path: "#{path}.#{engine}"
+          # read file directly
+          elsif File.exists? "#{path}.#{type}"
+            File.read "#{path}.#{type}"
+          # grab remote file content
+          elsif file[/^http/]
+            open(file).read
+          # as a last attempt lets see if the file can be rendered by tilt
+          # otherwise load the file directly
+          elsif File.exists? path
+            begin
+              render path: path
+            rescue
+              File.read path
+            end
+          end
+        end
+
+        # Shortcut for class opts
+        def assets_opts
+          self.class.assets_opts
+        end
+
+        # Shortcut for class assets unique id
+        def assets_unique_id(*args)
+          self.class.assets_unique_id(*args)
+        end
+
+        private
+
+        # CSS tag template
+        # <link rel="stylesheet" href="theme.css">
+        def css_assets_tag attrs
+          "<link rel=\"stylesheet\" #{attrs} />"
+        end
+
+        # JS tag template
+        # <script src="scriptfile.js"></script>
+        def js_assets_tag attrs
+          "<script type=\"text/javascript\" #{attrs}></script>"
+        end
+      end
+
+      module RequestClassMethods
+        # Shortcut for roda class asset opts
+        def assets_opts
+          roda_class.assets_opts
+        end
+
+        # The regex for the assets route
+        def assets_route_regex
+          Regexp.new(
+            assets_opts[:route] + '/' +
+            "(#{assets_opts[:"css_folder"]}|#{assets_opts[:"js_folder"]})" +
+            '/(.*)(?:\.(css|js)|http.*)$'
+          )
+        end
+      end
+
+      module RequestMethods
+        # Handles calls to the assets route
+        def assets
+          on self.class.assets_route_regex do |type, file|
+            content_type = type == 'css' ? 'text/css' : 'application/javascript'
+
+            response.headers.merge!({
+              "Content-Type" => content_type + '; charset=UTF-8',
+            }.merge(scope.assets_opts[:headers]))
+
+            scope.render_asset file, type
+          end
+        end
+      end
+    end
+
+    register_plugin(:assets, Assets)
+  end
+end

data/lib/roda/plugins/backtracking_array.rb

@@ -7,7 +7,7 @@ class Roda
     # block does not match +/a/b+ by default:
     #
     #   r.is ['a', 'a/b'] do |path|
-    #     ...
+    #     # ...
     #   end
     #
     # This is because the <tt>'a'</tt> entry in the array matches, which

data/lib/roda/plugins/error_email.rb

@@ -0,0 +1,110 @@
+require 'net/smtp'
+
+class Roda
+  module RodaPlugins
+    # The error_email plugin adds an +error_email+ instance method that
+    # send an email related to the exception.  This is most useful if you are
+    # also using the error_handler plugin:
+    #
+    #   plugin :error_email, :to=>'to@example.com', :from=>'from@example.com'
+    #   plugin :error_handler do |e|
+    #     error_email(e)
+    #     'Internal Server Error'
+    #   end
+    #
+    # Options:
+    #
+    # :from :: The From address to use in the email (required)
+    # :headers :: A hash of additional headers to use in the email (default: empty hash)
+    # :host :: The SMTP server to use to send the email (default: localhost)
+    # :prefix :: A prefix to use in the email's subject line (default: no prefix)
+    # :to :: The To address to use in the email (required)
+    #
+    # The subject of the error email shows the exception class and message.
+    # The body of the error email shows the backtrace of the error and the
+    # request environment, as well the request params and session variables (if any).
+    #
+    # Note that emailing on every error as shown above is only appropriate
+    # for low traffic web applications.  For high traffic web applications,
+    # use an error reporting service instead of this plugin.
+    module ErrorEmail
+      DEFAULTS = {
+        :headers=>{},
+        :host=>'localhost',
+        :emailer=>lambda{|h| Net::SMTP.start(h[:host]){|s| s.send_message(h[:message], h[:from], h[:to])}},
+        :default_headers=>lambda do |h, e|
+          {'From'=>h[:from], 'To'=>h[:to], 'Subject'=>"#{h[:prefix]}#{e.class}: #{e.message}"}
+        end,
+        :body=>lambda do |s, e|
+          format = lambda{|h| h.map{|k, v| "#{k.inspect} => #{v.inspect}"}.sort.join("\n")}
+
+          message = <<END
+Path: #{s.request.full_path_info}
+
+Backtrace:
+
+#{e.backtrace.join("\n")}
+
+ENV:
+
+#{format[s.env]}
+END
+          unless s.request.params.empty?
+            message << <<END
+
+Params:
+
+#{format[s.request.params]}
+END
+          end
+
+          if s.env['rack.session']
+            message << <<END
+
+Session:
+
+#{format[s.session]}
+END
+          end
+
+          message
+        end
+      }
+
+      # Set default opts for plugin.  See ErrorEmail module RDoc for options.
+      def self.configure(app, opts={})
+        email_opts = app.opts[:error_email] ||= DEFAULTS
+        email_opts = email_opts.merge(opts)
+        unless email_opts[:to] && email_opts[:from]
+          raise RodaError, "must provide :to and :from options to error_email plugin"
+        end
+        app.opts[:error_email] = email_opts
+      end
+
+      module ClassMethods
+        # Dup the error email opts in the subclass so changes to the subclass do not affect
+        # the superclass.
+        def inherited(subclass)
+          super
+          subclass.opts[:error_email] = subclass.opts[:error_email].dup
+          subclass.opts[:error_email][:headers] = subclass.opts[:error_email][:headers].dup
+        end
+      end
+
+      module InstanceMethods
+        # Send an email for the given error.
+        def error_email(e)
+          email_opts = self.class.opts[:error_email].dup
+          headers = email_opts[:default_headers].call(email_opts, e)
+          headers = headers.merge(email_opts[:headers])
+          headers = headers.map{|k,v| "#{k}: #{v}"}.sort.join("\n")
+          body = email_opts[:body].call(self, e)
+          email_opts[:message] = "#{headers}\n\n#{body}"
+          email_opts[:emailer].call(email_opts)
+        end
+      end
+    end
+
+    register_plugin(:error_email, ErrorEmail)
+  end
+end

data/lib/roda/plugins/multi_route.rb

@@ -64,7 +64,7 @@ class Roda
           subclass.instance_variable_set(:@named_routes, @named_routes.dup)
         end
 
-        # An names for the currently stored named routes
+        # The names for the currently stored named routes
         def named_routes
           @named_routes.keys
         end
@@ -74,12 +74,13 @@ class Roda
           @named_routes[name]
         end
 
-        # If the given route has a named, treat it as a named route and
+        # If the given route has a name, treat it as a named route and
         # store the route block.  Otherwise, this is the main route, so
         # call super.
         def route(name=nil, &block)
           if name
             @named_routes[name] = block
+            self::RodaRequest.clear_named_route_regexp!
           else
             super(&block)
           end
@@ -87,9 +88,19 @@ class Roda
       end
 
       module RequestClassMethods
+        # Clear cached regexp for named routes, it will be regenerated
+        # the next time it is needed.
+        #
+        # This shouldn't be an issue in production applications, but
+        # during development it's useful to support new named routes
+        # being added while the application is running.
+        def clear_named_route_regexp!
+          @named_route_regexp = nil
+        end
+
         # A regexp matching any of the current named routes.
         def named_route_regexp
-          @named_route_regexp ||= /(#{Regexp.union(roda_class.named_routes)})/
+          @named_route_regexp ||= /(#{Regexp.union(roda_class.named_routes.select{|s| s.is_a?(String)})})/
         end
       end