ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/helper/layout.rb

@@ -0,0 +1,128 @@
+module Ramaze
+  module Helper
+    ##
+    # Provides wrapper methods for a higher-level approach than the core layout
+    # method. The layout() method that comes with Innate/Ramaze is fairly basic
+    # as it only allows you to specify a single layout to always use or a block
+    # giving you some extra flexibility. The latter however is still a bit of a
+    # pain when dealing with many custom layouts in a single controller. Meet
+    # the Layout helper. This helper provides a single method (since April 2011,
+    # it used to provide more) called "set_layout".  This method allows you to
+    # specify a number of layouts and the methods for which these layouts should
+    # be used.
+    #
+    # ## Examples
+    #
+    # The most basic example is simply setting a layout as you would do with the
+    # layout() method:
+    #
+    #     set_layout 'default'
+    #
+    # This of course is very boring, time to add some more spices to our code:
+    #
+    #     set_layout 'default' => [:index]
+    #
+    # Woah! What just happened? It's quite easy actually, we merely defined that
+    # the layout called "default" should be used for the index method *only*.
+    # Pretty sweet huh? It gets even better:
+    #
+    #     set_layout 'default' => [:index, :edit], 'alternative' => [:add, :process]
+    #
+    # A few things changed. First of all there are now two key/value groups.
+    # Each group defines a layout (the key) and a set of methods (the value) for
+    # which each layout should be used. In this case the layout "default" will
+    # be used for index() and edit() but the layout "alternative" will be used
+    # for add() and process().
+    #
+    # Last but not least, multiple calls to set_layout will no longer override
+    # any existing settings *unless* you actually specify the same method with a
+    # different layout. This is possible because the set_layout method stores
+    # all these details in an instance variable called "_ramaze_layouts".
+    #
+    # @author Yorick Peterse
+    # @author Michael Fellinger
+    # @author Pistos
+    #
+    module Layout
+
+      ##
+      # Extends the class that included this module so that the methods that
+      # this helper provides can be called outside of instance of class methods.
+      #
+      # @param  [Object] into The class that included this module.
+      # @author Michael Fellinger
+      # @author Pistos
+      #
+      def self.included(into)
+        into.extend SingletonMethods
+      end
+
+      module SingletonMethods
+        ##
+        # The set_layout method allows you to specify a number of methods and
+        # their layout. This allows you to use layout A for methods 1, 2 and 3
+        # but layout B for method 4.
+        #
+        # @example
+        #  # The key is the layout, the value an array of methods
+        #  set_layout 'default' => [:method_1], 'alternative' => [:method_2]
+        #
+        #  # We can combine this method with layout()
+        #  layout 'default'
+        #  set_layout 'alternative' => [:method_1]
+        #
+        #  # This is also perfectly fine
+        #  set_layout 'default'
+        #
+        # @param  [String, Symbol, #to_hash] hash_or_layout
+        #   In case it's a String or Symbol it will directly be used as the
+        #   layout.
+        #   When setting a Hash this hash should have it's keys set to the
+        #   layouts and it's values to an array of methods that use the
+        #   specific layout. For more information see the examples.
+        #
+        # @author Yorick Peterse
+        # @author Michael Fellinger
+        # @author Pistos
+        # @since 2011-04-07
+        #
+        def set_layout(hash_or_layout)
+          @_ramaze_layouts    ||= {}
+          @_ramaze_old_layout ||= trait[:layout]
+
+          # Extract the layout to use
+          if hash_or_layout.respond_to?(:to_hash)
+            # Invert the method/layout hash and save them so they don't get lost
+            hash_or_layout.to_hash.each do |layout, layout_methods|
+              layout_methods.each do |layout_method|
+                @_ramaze_layouts[layout_method.to_s] = layout.to_s
+              end
+            end
+
+            layout do |path, wish|
+              path = path.to_s
+
+              if @_ramaze_layouts.key?(path)
+                use_layout = @_ramaze_layouts[path.to_s]
+              # Use the old layout
+              elsif @_ramaze_old_layout.respond_to?(:call)
+                use_layout = @_ramaze_old_layout.call(path, wish)
+              else
+                use_layout = @_ramaze_old_layout
+              end
+
+              use_layout
+            end
+          else
+            layout { |path| hash_or_layout }
+          end
+        end
+
+        # @deprecated because it's not longer useful
+        def set_layout_except(hash_or_layout)
+          Ramaze.deprecated('set_layout_except', 'set_layout')
+        end
+      end # SingletonMethods
+    end # Layout
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/link.rb

@@ -1,124 +1,57 @@
-#          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.
 
-module Ramaze
-  # Helper::Link is included into the Controller by default
-  #
-  # Usage is shown in spec/ramaze/helper/link.rb and the rdocs below.
-
-  module Helper::Link
-  private
-
-    # Builds a basic <a> tag.
-    #
-    # `text` is mandatory, the second hash of options will be transformed into
-    # arguments of the tag, :href is a special case and its segments will be
-    # CGI.escaped.
-    #
-    # If you pass no :href, the text will be run through Rs and its result is
-    # used instead. If you really want an empty href, use :href => ''
-    #
-    # Usage:
-    #   A('text')                       #> <a href="/text">text</a>
-    #   A('foo/bar')                    #> <a href="/foo/bar">foo/bar</a>
-    #   A('/foo?x=y')                   #> <a href="/foo?x=y">/foo?x=y</a>
-    #   A('text', :href => '/foo?x=y')  #> <a href="/foo?x=y">text</a>
-    #   A('Home', :href => Rs(:/))      #> <a href="/foo/bar">Home</a>
-
-    def A(*args)
-      hash = args.last.respond_to?(:to_hash) ? args.pop : {}
-
-      hash[:href] ||= Rs(*args)
-      text = hash.delete(:text) || args.last || hash[:title] || hash[:href]
-      hash[:href] = hash[:href].to_s.gsub(/[^\/?;=]+/) {|m| CGI.escape(m) }
-
-      args = ['']
-      hash.each {|k,v| args << %(#{k}="#{v}") if k and v }
-
-      %(<a#{args.join(' ')}>#{text}</a>)
-    end
-
-    # Builds links out of segments.
-    #
-    # Pass it strings, symbols, controllers and it will produce a link out of
-    # it. Paths to Controllers are obtained from Global.mapping.
-    #
-    # For brevity, the mapping for the example below is following:
-    #   { MC => '/', OC => '/o', ODC => '/od' }
-    #
-    # Usage:
-    #   R(MC) #=> '/'
-    #   R(OC) #=> '/o'
-    #   R(ODC) #=> '/od'
-    #   R(MC, :foo) #=> '/foo'
-    #   R(OC, :foo) #=> '/o/foo'
-    #   R(ODC, :foo) #=> '/od/foo'
-    #   R(MC, :foo, :bar => :x) #=> '/foo?bar=x'
-
-    def R(*atoms)
-      args, atoms = atoms.flatten.partition{|a| a.is_a?(Hash) }
-      args = args.flatten.inject{|s,v| s.merge!(v) }
+require 'innate/helper/link'
 
-      map = Global.mapping.invert
-
-      atoms.map! do |atom|
-        if atom.is_a?(Ramaze::Controller)
-          map[atom.class]
-        else
-          map[atom]
-        end or atom.to_s
-      end
-
-      front = atoms.join('/').squeeze('/')
-
-      if args
-        rear = args.inject('?'){|s,(k,v)| s << "#{CGI.escape k.to_s}=#{CGI.escape v.to_s};"}[0..-2]
-        front + rear
-      else
-        front
+module Ramaze
+  module Helper
+    # This is a modification of Innate::Helper::Link to respect the routing of
+    # Ramaze
+    #
+    # NOTE: The A/R/Rs methods have been deprecated.
+    module Link
+      def route_location(klass)
+        prefix = Ramaze.options.prefix
+        location = Ramaze.to(klass) || Ramaze.to(klass.class)
+        [prefix, location].join('/')
       end
-    end
-
-    # Uses R with Controller.current as first element.
-
-    def Rs(*atoms)
-      atoms.unshift Controller.current unless atoms.first.is_a?(Controller)
-      R(*atoms)
-    end
-
-    # Give it a path with character to split at and one to join the crumbs with.
-    # It will generate a list of links that act as pointers to previous pages on
-    # this path.
-    #
-    # Example:
-    #   breadcrumbs('/path/to/somewhere')
-    #
-    #   # results in this, newlines added for readability:
-    #
-    #   <a href="/path">path</a>/
-    #   <a href="/path/to">to</a>/
-    #   <a href="/path/to/somewhere">somewhere</a>
-    #
-    # Optionally a href prefix can be specified which generate link
-    # names a above, but with the prefix prepended to the href path.
-    #
-    # Example:
-    #   breadcrumbs('/path/to/somewhere', '/', '/', '/mycontroller/action')
-    #
-    #   # results in this, newlines added for readability:
-    #
-    #   <a href="/mycontroller/action/path">path</a>/
-    #   <a href="/mycontroller/action/path/to">to</a>/
-    #   <a href="/mycontroller/action/path/to/somewhere">somewhere</a>
 
-    def breadcrumbs(path, split = '/', join = '/', href_prefix = '')
-      atoms = path.split(split).reject{|a| a.empty?}
-      crumbs = atoms.inject([]){|s,v| s << [s.last,v]}
-      bread = crumbs.map do |a|
-        href_path = href_prefix + a*'/'
-        A(a[-1], :href=>(href_path))
+      ##
+      # Give it a path with character to split at and one to join the crumbs
+      # with.  It will generate a list of links that act as pointers to previous
+      # pages on this path.
+      #
+      # @example usage
+      #   breadcrumbs('/path/to/somewhere')
+      #
+      #   # results in this, newlines added for readability:
+      #
+      #   <a href="/path">path</a>/
+      #   <a href="/path/to">to</a>/
+      #   <a href="/path/to/somewhere">somewhere</a>
+      #
+      # Optionally a href prefix can be specified which generate link
+      # names a above, but with the prefix prepended to the href path.
+      #
+      # @example usage
+      #   breadcrumbs('/path/to/somewhere', '/', '/', '/mycontroller/action')
+      #
+      #   # results in this, newlines added for readability:
+      #
+      #   <a href="/mycontroller/action/path">path</a>/
+      #   <a href="/mycontroller/action/path/to">to</a>/
+      #   <a href="/mycontroller/action/path/to/somewhere">somewhere</a>
+      #
+      # @return [String]
+      def breadcrumbs(path, split = '/', join = '/', href_prefix = '')
+        atoms = path.split(split).reject{|a| a.empty?}
+        crumbs = atoms.inject([]){|s,v| s << [s.last,v]}
+        bread = crumbs.map do |a|
+          href_path = href_prefix + a*'/'
+          a(a[-1], href_path)
+        end
+        bread.join(join)
       end
-      bread.join(join)
-    end
-  end
-end
+    end # Link
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/localize.rb

@@ -0,0 +1,143 @@
+require 'locale/tag'
+require 'locale'
+
+module Ramaze
+  module Helper
+    ##
+    # The localization helper can be used to output translated strings.  This
+    # enables your application to use multiple language files for English, Dutch
+    # and so on.
+    #
+    module Localize
+      include Traited
+
+      trait :localize_locale => ::Locale::Tag::Simple.new('en')
+      trait :localize_charset => 'UTF-8'
+
+      def localize(string, substitute = nil)
+        localize_dictionary.translate(string, locales, substitute)
+      end
+      alias l localize
+
+      def locale
+        locales.first
+      end
+
+      def locales
+        locales = request.env['localize.locales']
+        return locales if locales
+
+        fallback = ancestral_trait[:localize_locale]
+        locales = Parser.new(request).locales(fallback)
+        request.env['localize.locales'] = locales
+      end
+
+      class Dictionary
+        attr_reader :dict
+
+        def initialize
+          @dict = {}
+        end
+
+        def translate(string, locales, substitute)
+          target = string.to_s.dup
+          locales = locales.flatten.uniq
+
+          if substitute
+            substitute.each do |key, value|
+              target.gsub!(/\{#{Regexp.escape(key)}\}/, lookup(value, locales))
+            end
+            return target
+          elsif target =~ /\{/
+            target.gsub!(/\{([^\}]+)\}/){ lookup($1, locales) }
+            return target
+          else
+            lookup(target, locales)
+          end
+        end
+
+        def lookup(string, locales)
+          locales.each do |locale|
+            next unless dict = self[locale]
+            next unless translated = dict[string]
+            return translated
+          end
+
+          string
+        end
+
+        def locales
+          @dict.keys
+        end
+
+        def [](locale)
+          @dict[arg_to_locale(locale)]
+        end
+
+        def []=(locale, dict)
+          @dict[arg_to_locale(locale)] = dict
+        end
+
+        def load(locale, options = {})
+          if file = options.delete(:yaml)
+            dict = ::YAML.load_file(file)
+          elsif hash = options.delete(:hash)
+            dict = hash
+          elsif marshal = options.delete(:marshal)
+            dict = Marshal.load(File.read(marshal))
+          else
+            raise ArgumentError, "either :yaml, :marshal, or :hash"
+          end
+
+          @dict[arg_to_locale(locale)] = dict
+        end
+
+        private
+
+        def arg_to_locale(arg, raises = true)
+          if raises and not arg
+            raise(ArgumentError, "%p cannot be converted to a Locale" % arg)
+          end
+          arg.respond_to?(:language) ? arg : ::Locale::Tag.parse(arg.to_s)
+        end
+      end
+
+      class Parser
+        attr_accessor :request
+
+        def initialize(request)
+          @request = request
+        end
+
+        def locales(fallback = nil)
+          locales = [parse, fallback].flatten.uniq
+          ::Locale::TagList.new(locales)
+        end
+
+        def parse
+          parse_params || parse_session || parse_cookie || parse_header
+        end
+
+        def parse_params(key = 'lang')
+          return unless lang = request.params[key]
+          ::Locale::Tag.parse(lang)
+        end
+
+        def parse_session(key = :lang)
+          return unless lang = Current.session[key]
+          ::Locale::Tag.parse(lang)
+        end
+
+        def parse_cookie(key = 'lang')
+          return unless lang = request.cookies[key]
+          ::Locale::Tag.parse(lang)
+        end
+
+        def parse_header
+          request.accept_language.map{|lang|
+            ::Locale::Tag.parse(lang) }
+        end
+      end
+    end # Localize
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/markaby.rb

@@ -1,31 +1,33 @@
 #          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.
 
 module Ramaze
+  module Helper
+    # Allows you to use some shortcuts for markaby in your Controller.
+    module Markaby
+      ##
+      # Use this inside your controller to directly build Markaby
+      # Refer to the Markaby-documentation and testsuite for more examples.
+      #
+      # @example
+      #  mab { h1 "Apples & Oranges"}  #=> "<h1>Apples &amp; Oranges</h1>"
+      #  mab { h1 'Apples', :class => 'fruits&floots' }
+      #
+      def markaby(ivs = {}, helpers = nil, &block)
+        builder = ::Markaby::Builder
+        builder.extend(Ramaze::Helper::Methods)
+        builder.send(:helper, :link)
 
-  # Allows you to use some shortcuts for markaby in your Controller.
+        iv_hash = {}
+        instance_variables.each do |iv|
+          key, value = iv.gsub('@', '').to_sym, instance_variable_get(iv)
+          iv_hash[key] = value
+        end
 
-  module Helper::Markaby
-    # use this inside your controller to directly build Markaby
-    # Refer to the Markaby-documentation and testsuite for more examples.
-    # Usage:
-    #   mab { h1 "Apples & Oranges"}                    #=> "<h1>Apples &amp; Oranges</h1>"
-    #   mab { h1 'Apples', :class => 'fruits&floots' }  #=> "<h1 class=\"fruits&amp;floots\">Apples</h1>"
-
-    def markaby(ivs = {}, helpers = nil, &block)
-      builder = ::Markaby::Builder
-      builder.extend(Ramaze::Helper::Methods)
-      builder.send(:helper, :link)
-
-      iv_hash = {}
-      instance_variables.each do |iv|
-        key, value = iv.gsub('@', '').to_sym, instance_variable_get(iv)
-        iv_hash[key] = value
+        builder.new(iv_hash.merge(ivs), helpers, &block).to_s
       end
 
-      builder.new(iv_hash.merge(ivs), helpers, &block).to_s
-    end
-
-    alias mab markaby
-  end
-end
+      alias mab markaby
+    end # Markaby
+  end # Helper
+end # Ramaze

data/lib/ramaze/helper/maruku.rb

@@ -1,7 +1,16 @@
+require 'maruku'
+
 module Ramaze
-  module Helper::Maruku
-    def maruku(text)
-      Maruku.new(text).to_html
-    end
-  end
-end
+  module Helper
+    module Maruku
+      # Shortcut to generate HTML from Markdown code using Maruku
+      #
+      # @param [#to_str] text the markdown to be converted
+      # @return [String] html generated from +text+
+      # @author manveru
+      def maruku(text)
+        ::Maruku.new(text.to_str).to_html
+      end
+    end # Maruku
+  end # Helper
+end # Ramaze