ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/snippets/object/__dir__.rb

@@ -0,0 +1,25 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+
+module Ramaze
+  module CoreExtensions
+    # Extensions for Object
+    module Object
+      unless defined?(__DIR__)
+
+        # This is similar to +__FILE__+ and +__LINE__+, and returns a String
+        # representing the directory of the current file is.
+        # Unlike +__FILE__+ the path returned is absolute.
+        #
+        # This method is convenience for the
+        #  File.expand_path(File.dirname(__FILE__))
+        # idiom.
+        def __DIR__(*args)
+          filename = caller[0][/^(.*):/, 1]
+          dir = File.expand_path(File.dirname(filename))
+          ::File.expand_path(::File.join(dir, *args.map{|a| a.to_s}))
+        end
+      end
+    end # Object
+  end # CoreExtensions
+end # Ramaze

data/lib/ramaze/snippets/ramaze/deprecated.rb

@@ -0,0 +1,23 @@
+module Ramaze
+  DEPRECATED_CONSTANTS = {
+    :BASEDIR        => :ROOT,
+    :Template       => :View,
+    :Optional       => :Optioned,
+  }
+
+  def self.deprecated(from, to = nil)
+    message = "%s is deprecated"
+    message << ", use %s instead" unless to.nil?
+    message << " - from: %p"
+    Log.warn(message % [from, to, caller[1]])
+  end
+
+  def self.const_missing(name)
+    if to = DEPRECATED_CONSTANTS[name]
+      Log.warn "Ramaze::#{name} is deprecated, use #{to} instead"
+      constant(to)
+    else
+      super
+    end
+  end
+end # Ramaze

data/lib/ramaze/snippets/string/camel_case.rb

@@ -1,16 +1,19 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-# Extensions for String
-
-class String
-
-  # simple transformation to CamelCase from snake_case
-  #
-  #   'foo_bar'.camel_case # => 'FooBar'
-
-  def camel_case
-    split('_').map{|e| e.capitalize}.join
-  end
-end
+# All files in this distribution are subject to the terms of the MIT license.
 
+module Ramaze
+  module CoreExtensions
+    # Extensions for String
+    module String
+      ##
+      # Simple transformation to CamelCase from snake_case
+      #
+      # @example
+      #  'foo_bar'.camel_case # => 'FooBar'
+      #
+      def camel_case
+        split('_').map{|e| e.capitalize}.join
+      end
+    end # String
+  end # CoreExtensions
+end # Ramaze

data/lib/ramaze/snippets/string/color.rb

@@ -1,27 +1,30 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+# All files in this distribution are subject to the terms of the MIT license.
 
-# Extensions for String
-
-class String
-  { :reset          =>  0,
-    :bold           =>  1,
-    :dark           =>  2,
-    :underline      =>  4,
-    :blink          =>  5,
-    :negative       =>  7,
-    :black          => 30,
-    :red            => 31,
-    :green          => 32,
-    :yellow         => 33,
-    :blue           => 34,
-    :magenta        => 35,
-    :cyan           => 36,
-    :white          => 37,
-  }.each do |key, value|
-    define_method key do
-      "\e[#{value}m" + self + "\e[0m"
-    end
-  end
-end
+module Ramaze
+  module CoreExtensions
+    # Extensions for String
 
+    module String
+      { :reset          =>  0,
+        :bold           =>  1,
+        :dark           =>  2,
+        :underline      =>  4,
+        :blink          =>  5,
+        :negative       =>  7,
+        :black          => 30,
+        :red            => 31,
+        :green          => 32,
+        :yellow         => 33,
+        :blue           => 34,
+        :magenta        => 35,
+        :cyan           => 36,
+        :white          => 37,
+      }.each do |key, value|
+        define_method key do
+          "\e[#{value}m" + self + "\e[0m"
+        end
+      end
+    end # String
+  end # CoreExtensions
+end # Ramaze

data/lib/ramaze/snippets/string/esc.rb

@@ -1,29 +1,29 @@
 require 'cgi'
 require 'uri'
 
-class String
+module Ramaze
+  module CoreExtensions
+    # Extensions for String
+    module String
+      # String#escape is an extensible escaping mechanism for string.  currently
+      # it suports
+      #   '<div>foo bar</div>'.esc(:html)
+      #   'foo bar'.esc(:uri)
+      #   'foo bar'.esc(:cgi)
+      def escape which = :html
+        case which
+        when :html
+          Rack::Utils.escape_html(self)
+        when :cgi
+          Rack::Utils.escape(self)
+        when :uri
+          ::URI.escape(self)
+        else
+          raise ArgumentError, "do not know how to escape '#{ which }'"
+        end
+      end
 
-  # String#escape is an extensible escaping mechanism for string.  currently
-  # it suports
-  #   '<div>foo bar</div>'.esc(:html)
-  #   'foo bar'.esc(:uri)
-  #   'foo bar'.esc(:cgi)
-  #   "foo 'bar'".esc(:sql)
-
-  def escape which = :html
-    case which
-    when :html
-      ::CGI.escapeHTML(self)
-    when :cgi
-      ::CGI.escape(self)
-    when :uri
-      ::URI.escape(self)
-    when :sql  # TODO - leverage DBI or something
-      gsub(%r/'/, "''")
-    else
-      raise ArgumentError, "do not know how to escape '#{ which }'"
-    end
-  end
-
-  alias_method 'esc', 'escape'
-end
+      alias_method 'esc', 'escape'
+    end # String
+  end # CoreExtensions
+end # Ramaze

data/lib/ramaze/snippets/string/snake_case.rb

@@ -1,15 +1,18 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+# All files in this distribution are subject to the terms of the MIT license.
 
-# Extensions for String
-
-class String
-
-  # convert to snake_case from CamelCase
-  #
-  #   'FooBar'.snake_case # => 'foo_bar'
-
-  def snake_case
-    gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
-  end
-end
+module Ramaze
+  module CoreExtensions
+    # Extensions for String
+    module String
+      # convert to snake_case from CamelCase
+      #
+      # @example
+      #  'FooBar'.snake_case # => 'foo_bar'
+      #
+      def snake_case
+        gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
+      end
+    end # String
+  end # CoreExtensions
+end # Ramaze

data/lib/ramaze/snippets/string/unindent.rb

@@ -1,12 +1,25 @@
-class String
-  def unindent
-    space = self.split("\n").find{|l| !l.strip.empty?}.to_s[/^(\s+)/, 1]
-    strip.gsub(/^#{space}/, '')
-  end
-  alias ui unindent
+module Ramaze
+  module CoreExtensions
+    # Extensions for String
+    module String
+      # Useful for writing indented String and unindent on demand, based on the
+      # first line with indentation.
+      def unindent
+        find_indent = proc{ |l| l.find{|l| !l.strip.empty?}.to_s[/^(\s+)/, 1] }
 
-  def unindent!
-    self.replace unindent
-  end
-  alias ui! unindent!
-end
+        lines = self.split("\n")
+        space = find_indent[lines]
+        space = find_indent[lines.reverse] unless space
+
+        strip.gsub(/^#{space}/, '')
+      end
+      alias ui unindent
+
+      # Destructive variant of undindent, replacing the String
+      def unindent!
+        self.replace unindent
+      end
+      alias ui! unindent!
+    end # String
+  end # CoreExtensions
+end # Ramaze

data/lib/ramaze/snippets.rb

@@ -1,9 +1,24 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
 
-dir  = File.join(File.expand_path(File.dirname(__FILE__)), 'snippets')
-glob = File.join(dir, '**', '*.rb')
+require 'ramaze/snippets/blankslate'
+require 'ramaze/snippets/object/__dir__'
+require 'ramaze/snippets/ramaze/deprecated'
+require 'ramaze/snippets/string/camel_case'
+require 'ramaze/snippets/string/color'
+require 'ramaze/snippets/string/esc'
+require 'ramaze/snippets/string/snake_case'
+require 'ramaze/snippets/string/unindent'
 
-Dir[glob].each do |snippet|
-  require(snippet)
+Ramaze::CoreExtensions.constants.each do |const|
+  ext = Ramaze::CoreExtensions.const_get(const)
+  into = Module.const_get(const)
+
+  collisions = ext.instance_methods & into.instance_methods
+
+  if collisions.empty?
+    into.__send__(:include, ext)
+  else
+    warn "Won't include %p with %p, %p exists" % [into, ext, collisions]
+  end
 end

data/lib/ramaze/spec/bacon.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../../../ramaze', __FILE__)
+require 'bacon'
+require 'innate/spec/bacon'
+
+Ramaze.middleware(:spec) { run Ramaze.core }
+
+def spec_requires(*libs)
+  spec_precondition 'require' do
+    libs.each { |lib| require(lib) }
+  end
+end
+alias spec_require spec_requires
+
+def spec_precondition(name)
+  yield
+rescue LoadError => ex
+  puts "Spec require: %p failed: %p" % [name, ex.message]
+  exit 0
+rescue Exception => ex
+  puts "Spec precondition: %p failed: %p" % [name, ex.message]
+  exit 0
+end
+
+shared :rack_test do
+  Ramaze.setup_dependencies
+
+  extend Rack::Test::Methods
+
+  def app; Ramaze; end
+end
+
+shared :webrat do
+  behaves_like :rack_test
+
+  require 'webrat'
+
+  Webrat.configure { |config| config.mode = :rack }
+
+  extend Webrat::Methods
+  extend Webrat::Matchers
+end
+
+# Ignore log messages
+Ramaze::Log.level = Logger::ERROR

data/lib/ramaze/spec/helper/bacon.rb

@@ -1,7 +1,7 @@
-libdir = File.expand_path(File.join(File.dirname(__FILE__), '../../../'))
-$LOAD_PATH.unshift libdir
-require 'vendor/bacon'
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../ramaze'))
+
+require 'bacon'
 require 'ramaze/spec/helper/pretty_output'
+
 Bacon.extend Bacon::PrettyOutput
-# Bacon.extend Bacon::TestUnitOutput
 Bacon.summary_on_exit

data/lib/ramaze/spec/helper/pretty_output.rb

@@ -2,6 +2,7 @@ module Bacon
   module PrettyOutput
     NAME = ''
 
+    # store name and run
     def handle_specification(name)
       NAME.replace name
 			puts NAME
@@ -9,6 +10,7 @@ module Bacon
 			puts
     end
 
+    # Core, yields the requirement and outputs problems
     def handle_requirement(description)
 	    print "- #{description}\n"
       error = yield
@@ -16,7 +18,7 @@ module Bacon
       unless error.empty?
         if defined?(Ramaze::Logging)
           puts '', " #{NAME} -- #{description} [FAILED]".center(70, '-'), ''
-          colors = Ramaze::Informer::COLORS
+          colors = Ramaze::Logger::Informer::COLORS
 
           until RamazeLogger.history.empty?
             tag, line = RamazeLogger.history.shift
@@ -29,6 +31,7 @@ module Bacon
       end
     end
 
+    # Show nicer output on error
     def general_error
       puts "", ErrorLog
       ErrorLog.scan(/^\s*(.*?):(\d+): #{NAME} - (.*?)$/) do
@@ -37,6 +40,7 @@ module Bacon
       ErrorLog.replace ''
     end
 
+    # output summary
     def handle_summary
 	    puts
       puts "%d tests, %d assertions, %d failures, %d errors" %
@@ -47,20 +51,24 @@ end
 
 if defined?(Ramaze::Logging)
   module Ramaze
+    # Special Logger, stores everything in its history
     class SpecLogger
       include Ramaze::Logging
       include Enumerable
 
       attr_accessor :history
 
+      # Create new history
       def initialize
         @history = []
       end
 
+      # Yield the history
       def each
         @history.each{|e| yield(e) }
       end
 
+      # general log
       def log(tag, str)
         @history << [tag, str]
       end

data/lib/ramaze/spec/helper/snippets.rb

@@ -1,6 +1,16 @@
 if caller
   snippet = caller.grep(%r!spec/snippets/!).first.split(':').first
   require File.expand_path(snippet).gsub('/spec/', '/lib/ramaze/')
+
+  if defined?(Ramaze::CoreExtensions)
+    Ramaze::CoreExtensions.constants.each do |const|
+      ext = Ramaze::CoreExtensions.const_get(const)
+      into = Module.const_get(const)
+      into.__send__(:include, ext)
+    end
+  end
 end
 
-require 'lib/ramaze/spec/helper/bacon'
+require 'bacon'
+
+Bacon.summary_on_exit

data/lib/ramaze/spec/helper/template_examples.rb

@@ -0,0 +1,22 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+
+shared :template_spec do
+  behaves_like :rack_test
+
+  def spec_template(spec_engine)
+    it 'works on /' do
+      get('/').body.strip.
+        should =~ %r{<a href\s*=\s*"/">Home</a>\s+\|\s+<a href\s*=\s*"/internal">internal</a>\s+\|\s+<a href\s*=\s*"/external">external</a>}
+    end
+
+    %w[/internal /external].each do |url|
+      it "works on #{url}" do
+        html = get(url).body
+        html.should.not == nil
+        html.should =~ %r{<title>Template::#{spec_engine} (internal|external)</title>}
+        html.should =~ %r{<h1>The (internal|external) Template for #{spec_engine}</h1>}
+      end
+    end
+  end
+end

data/lib/ramaze/version.rb

@@ -1,14 +1,5 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-module Ramaze #:nodoc:
-  module Version #:nodoc:
-    MAJOR = 0
-    MINOR = 3
-    TINY  = 9.1
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-
-  VERSION = Version::STRING
+module Ramaze
+  VERSION = Gem::Specification.load(
+    File.expand_path('../../../ramaze.gemspec', __FILE__)
+  ).version.to_s
 end

data/lib/ramaze/view/erector.rb

@@ -0,0 +1,116 @@
+require 'erector'
+
+module Ramaze
+  module View
+    ##
+    # Adapter for Erector. Erector is a view engine that works a bit like
+    # Markably but offers a much more pleasant way of building your views. By
+    # creating classes in plain ruby you can generate layouts and views without
+    # having to write a single line of HTML.
+    #
+    # Each layout or view is a simple class that matches the filename. A layout
+    # named "default.erector" would result in a class with the name "Default".
+    # It's *very* important to know that you should ALWAYS extend
+    # Ramaze::View::Erector.  Without extending this class you won't be able to
+    # use Erector at all.
+    #
+    # When working with the Erector adapter there are a few things you'll need
+    # to know. First all your views and layouts should be classes as explained
+    # earlier on. Each class should have at least a single method named
+    # "content". This method is executed by Erector and the HTML it produces
+    # will either be stored in the @content instance variable (if it's a view)
+    # or sent to the browser if it's a layout.  The @content variable can be
+    # displayed by calling the rawtext() method and passing the variable as it's
+    # parameter.
+    #
+    # Using helper methods, such as the render_* methods is also possible
+    # although slightly different than you're used to. Due to the way the
+    # Erector adapter works it isn't possible to directly call a helper method.
+    # As a workaround you can access these methods from the "@controller"
+    # instance variable. Don't forget to render the output of these helpers
+    # using rawtext(). Feel free to submit any patches if you think you have a
+    # better solution so that developers don't have to use the @controller
+    # instance variable.
+    #
+    # @example
+    #   # This is the code for the layout
+    #   class Default < Erector::Widget
+    #     html do
+    #       head do
+    #         title 'Erector Layout'
+    #       end
+    #
+    #       body do
+    #         rawtext @content
+    #       end
+    #
+    #     end
+    #   end
+    #
+    #   # And here's the view
+    #   class Index < Erector::Widget
+    #     def content
+    #       h2 'This is the view'
+    #     end
+    #   end
+    #
+    #   # Render an extra view
+    #   class ExtraView < Erector::Widget
+    #     def content
+    #       rawtext @controller.render_view :some_extra_view
+    #     end
+    #   end
+    #
+    # @author  Yorick Peterse
+    #
+    module Erector
+      # Include the Erector gem. By doing this Erector views can extend the
+      # Erector gem without causing any namespace errors.
+      include ::Erector
+
+      ##
+      # The call method is called whenever a view is loaded. A view can either
+      # be a layout or an actual view since they're treated the same way. First
+      # the view is loaded, followed by the layout.
+      #
+      # @author Yorick Peterse
+      # @param [Object] action Object containing a copy of the current Action
+      #  class data.
+      # @param [String] string The content of the currently loaded layout. This
+      #  variable isn't used by the Erector adapter but is required since Ramaze
+      #  expects 2 parameters. Usually this string is used to inline load (or
+      #  evaluate) the content of a view.
+      # @return [String] The generated HTML.
+      #
+      def self.call action, string
+        # Return the contents unless a view has been defined
+        return string, 'text/html' unless action.view
+
+        # Evaluate the class so we can use it. The content of "string"
+        # is a full blown class that should always have a "content" method.
+        #eval string, action.binding
+        eval string
+
+        # Generate the class name based on the filename.
+        # Class names are a CamelCased version of the filename (without the
+        # extension).
+        klass    = File.basename action.view, '.erector'
+        klass    = klass.camel_case
+        view_obj = self.const_get(klass)
+
+        # Synchronize the methods of action.instance with the view. These
+        # methods can be accessed by calling @controller.METHOD
+        action.variables[:controller] = action.instance
+
+        # Now that we have all the data we can start rendering the HTML.
+        # Note that we pass the action.variables hash to the new() method. This
+        # is done to give the view access to all existing (instance) variables.
+        # Syncing them using action.copy_variables didn't seem to do the trick.
+        html = view_obj.new(action.variables).to_html
+
+        # All done
+        return html, 'text/html'
+      end
+    end # Erector
+  end # View
+end # Ramaze

data/lib/ramaze/view/erubis.rb

@@ -0,0 +1,26 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+require 'erubis'
+
+module Ramaze
+  module View
+    ##
+    # View adapter for the Erubis template engine. More information about Erubis
+    # can be found here: http://www.kuwata-lab.com/erubis/
+    #
+    module Erubis
+      OPTIONS = { :engine => ::Erubis::Eruby }
+
+      def self.call(action, string)
+        options = OPTIONS.dup
+        engine = options.delete(:engine)
+
+        eruby = View.compile(string){|s| engine.new(s, options) }
+        eruby.init_evaluator(:filename => (action.view || __FILE__))
+        html = eruby.evaluate(action.instance)
+
+        return html, 'text/html'
+      end
+    end # Erubis
+  end # View
+end # Ramaze

data/lib/ramaze/view/ezamar.rb

@@ -0,0 +1,27 @@
+require 'ezamar'
+
+module Ramaze
+  module View
+    ##
+    # View adapter for the Ezamar template engine. More information about this
+    # engine can be found here: https://github.com/manveru/ezamar
+    #
+    module Ezamar
+      TRANSFORM_PIPELINE = [ ::Ezamar::Element ]
+
+      def self.call(action, string)
+        ezamar = View.compile(string){|s| compile(action, s) }
+        html = ezamar.result(action.binding)
+        return html, 'text/html'
+      end
+
+      def self.compile(action, template)
+        file = action.view || __FILE__
+
+        TRANSFORM_PIPELINE.each{|tp| template = tp.transform(template) }
+
+        ::Ezamar::Template.new(template, :file => file)
+      end
+    end # Ezamar
+  end # View
+end # Ramaze

data/lib/ramaze/view/gestalt.rb

@@ -0,0 +1,20 @@
+require 'ramaze/gestalt'
+
+module Ramaze
+  module View
+    ##
+    # View adapter that allows you to use Ramaze::Gestalt in your views. See the
+    # documentation of Ramaze::Gestalt for more information.
+    #
+    # @see Ramaze::Gestalt
+    #
+    module Gestalt
+      def self.call(action, string)
+        string = action.instance.instance_eval(string) if action.view
+        html = [string].join
+
+        return html, 'text/html'
+      end
+    end # Gestalt
+  end # View
+end # Ramaze