ramaze 0.0.6

data/lib/ramaze/helper/auth.rb

@@ -0,0 +1,120 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'digest/sha1'
+
+module Ramaze
+
+  # A really, really, totally stupid way to do authentication. It has no
+  # roles and only a single password without usernames.
+  #
+  # It is intended to be a simple way to protect various partions of a page
+  # when you start working on it. Also it is a nice way to see how you could
+  # implement your own authentication.
+
+  module AuthHelper
+    def self.included(klass)
+      klass.class_eval do
+        helper :aspect, :stack
+      end
+    end
+
+    # The default Element to use (if any)
+
+    AUTH_ELEMENT = 'Page'
+
+    # action for login, takes a password
+    # ( ?password=passwort or /login/passwort or via a form )
+    # if no password given, shows a simple form to input it.
+
+    def login
+      if check_auth(request['username'], request['password'])
+        session[:logged_in] = true
+        inside_stack? ? answer : redirect( R(self) )
+      else
+        %{
+          <#{AUTH_ELEMENT}>
+            <form method="POST" action="#{R(self, :login)}"
+              <ul style="list-style:none;">
+                <li>Username: <input type="text" name="username" /></li>
+                <li>Password: <input type="password" name="password" /></li>
+                <li><input type="submit" /></li>
+              </ul>
+            </form>
+          </#{AUTH_ELEMENT}>
+        }
+      end
+    end
+
+    # clear the session and redirect to the index action of the mapping of the
+    # current controller.
+
+    def logout
+      session.clear
+      redirect_referer
+    end
+
+    private
+
+    # call( R(self, :login) ) if not logged in
+
+    def login_required
+      call(R(self, :login)) unless logged_in?
+    end
+
+    # checks if the user is already logged in.
+    #   session[:logged_in] is not nil/false
+
+    def logged_in?
+      !!session[:logged_in]
+    end
+
+    # check the authentication (username and password) against the auth_table.
+    #
+    # auth_table is a trait, it may be the name of a method, a Proc or a simple
+    # Hash.
+    # If it is neither of the above it has at least to respond to #[]
+    # which will pass it the username as key and it should answer with the
+    # password as a SHA1.hexdigest.
+    #
+    # The method and Proc are both called on demand.
+    #
+    # If you want to change the way the password is hashed, change
+    #   trait[:auth_hashify]
+    #
+    # The default looks like:
+    #   lambda{ |pass| Digest::SHA1.hexdigest(pass.to_s) }
+    #
+    # As with the auth_table, this has to be an object that responds to #[]
+    #
+    # If you want all your controllers to use the same mechanism set the trait
+    # on one of the ancestors, the traits are looked up by #ancestral_trait
+    #
+    # Examples:
+    #
+    #   # The method to be called.
+    #   trait :auth_table => :auth_table
+    #   trait :auth_tagle => 'auth_table'
+    #
+    #   # Lambda that will be called upon demand
+    #   trait :auth_table => lambda{ {'manveru' => SHA1.hexdigest 'password'} }
+    #
+    #   # Hash holding the data.
+    #   trait :auth_table => {'manveru' => SHA1.hexdigest('password')}
+
+    def check_auth user, pass
+      auth_table = ancestral_trait[:auth_table] ||= {}
+
+      auth_table = method(auth_table) if auth_table.is_a?(Symbol)
+      auth_table = method(auth_table) if auth_table.respond_to?(:to_str)
+      auth_table = auth_table.call    if auth_table.respond_to?(:call)
+
+      default_hashify = lambda{ |pass| Digest::SHA1.hexdigest(pass.to_s) }
+
+      hashify  = (ancestral_trait[:auth_hashify] ||= default_hashify)
+      password = hashify[pass.to_s]
+
+      auth_table[user.to_s] == password
+    end
+  end
+end

data/lib/ramaze/helper/cache.rb

@@ -0,0 +1,52 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+module Ramaze
+  module CacheHelper
+    private
+
+    # a simple cache for values based on Global.cache
+
+    def value_cache
+      @@cache ||= Global.cache.new
+    end
+
+    # forget about one cached action
+
+    def uncache action
+      Global.cached_actions[self.class].each do |e|
+        e.include?(action.to_s)
+      end
+    end
+
+    # uncache all actions
+
+    def uncache_all
+      Global.cached_actions.delete(self.class)
+    end
+    alias uncache_all_actions uncache_all
+
+    # cache all given methods
+
+    def cache(*actions)
+      self.class.cache(*actions)
+    end
+    alias cache_actions cache
+
+    # define the cache class-method on inclusion
+
+    def self.included(klass)
+      klass.class_eval do
+        class << self
+
+          # mark actions for caching
+
+          def cache(*actions)
+            Global.cache_actions[self].merge(*actions.flatten.map{|a| a.to_s })
+          end
+          alias cache_actions cache
+
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/feed.rb

@@ -0,0 +1,135 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module FeedHelper
+
+    # just a stub, for the moment, doing nothing more than calling
+    # #to_xml on the object you pass
+
+    def feed object
+      object.to_xml
+    end
+  end
+end
+
+module ReFeed
+
+  # Does a couple of things on include.
+  #
+  # defines #xml_accessor, which in turn offers a way to define
+  # both an attr_accessor and xml-annotation.
+  #   xml_accessor :name, :age
+  #
+  # defines #xml, a little DSLy way to add an attribute that
+  # is later used to generate/read XML
+  #   xml :name, :age
+  #
+  # defines #from_xml, which takes XML and maps the structure of the
+  # XML to your instances accessors.
+  #   Foo.new.from_xml('<name>manveru</name><age>22</age>')
+  #   # #<Foo @name='manveru', @age=22>
+
+  def self.included(klass)
+    klass.class_eval do
+      const_set('XML_ATTRIBUTES', {})
+
+      class << self
+
+        # Offers a way to define
+        # both an attr_accessor and xml-annotation.
+        #   xml_accessor :name, :age
+
+        def xml_accessor(*args)
+          args = xml(*args)
+          attr_accessor(*args)
+        end
+
+        # A little DSLy way to add an attribute that
+        # is later used to generate/read XML
+        #   xml :name, :age
+
+        def xml(*arguments)
+          args = []
+          hash = nil
+          klass = Object.const_get(self.to_s)
+
+          arguments.each do |arg|
+            if arg.respond_to?(:to_sym)
+              args << arg.to_sym
+            elsif arg.respond_to?(:to_hash)
+              hash = arg
+            end
+          end
+
+          args.each do |arg|
+            klass::XML_ATTRIBUTES[arg] = hash
+          end
+        end
+
+        # Which takes XML and maps the structure of the
+        # XML to your instances accessors.
+        #   Foo.new.from_xml('<name>manveru</name><age>22</age>')
+        #   # #<Foo @name='manveru', @age=22>
+
+        def from_xml(text)
+          instance = self.new
+
+          require 'hpricot'
+
+          xml = Hpricot(text.to_s)
+          attributes = instance.xml_attributes
+
+          attributes.each do |attribute, opts|
+            value = xml.at(attribute)
+            instance.send("#{attribute}=", value.inner_html) if value
+          end
+          instance
+        rescue LoadError => ex
+          error ex
+        ensure
+          instance
+        end
+      end
+    end
+  end
+
+  # return the XML_ATTRIBUTES of self.class
+
+  def xml_attributes
+    self.class::XML_ATTRIBUTES
+  end
+
+  # convert this instance to XML
+
+  def to_xml
+    name = self.class.name
+    xml = xml_attributes.map do |key, opts|
+      value = send(key)
+
+      next unless value
+      next if (opts[:type] == :attribute rescue false)
+
+      if opts and not opts.empty?
+        case opts[:type]
+        when nil, :text : "<#{key}>#{value}</#{key}>"
+        when :cdata : "<#{key}><![CDATA[#{value}]]></#{key}>"
+        when :collection : value.map{|v| v.to_xml }
+        end
+      elsif value.respond_to?(:to_xml)
+        value.to_xml
+      elsif value.respond_to?(:all?) and value.all?{|v| v.respond_to?(:to_xml) }
+        value.map{|v| v.to_xml }
+      end
+    end
+
+    attributes = xml_attributes.select{|k, o| o && o[:type] == :attribute}
+    attributes.map!{|k, o| %{#{k}="#{send(k)}"} }
+
+    unless attributes or attributes.empty?
+      "<#{name}>#{xml}</#{name}>"
+    else
+      "<#{name} #{attributes.join(' ')}><#{xml}></#{name}>"
+    end
+  end
+end

data/lib/ramaze/helper/form.rb

@@ -0,0 +1,204 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module FormHelper
+
+    # Mapping different classes to an specific method on FormHelper::Control.
+
+    ClassMap = {
+      String  => :text,
+      Time    => :time,
+      Date    => :date,
+      Fixnum  => :number,
+    }
+
+    # Create the contents of a <form> for Og-objects.
+    # This can be an instance or the class itself. Depending if you
+    # want to edit an object or create a new one.
+    #
+    # Please note that the enclosing <form> itself is not (yet) generated.
+    #
+    # attributes that have no mapping in ClassMap are silently ignored.
+
+    def form obj, options = {}
+      default = {:deny => /oid/, :submit => true}
+      options = default.merge(options)
+
+      if obj.respond_to? :serializable_attributes
+        instance = obj.new
+      else
+        instance = obj
+        obj = obj.class
+      end
+
+      attributes = obj.serializable_attributes
+      out = []
+
+      chosen_attributes(attributes, options).each do |attribute|
+
+        o = OpenStruct.new :klass => obj.ann[attribute].class,
+                           :value => (instance.send(attribute) rescue nil),
+                           :name  => attribute.to_s,
+                           :title => (options.has_key?(attribute) ? options[attribute] : attribute)
+
+        control = obj.ann[attribute].control
+        control = ClassMap[o.klass] unless control.is_a?(Symbol)
+
+        out << Control.send(control, o) unless control.nil? or control == :none
+      end
+      if options[:submit] == true
+        out << %{<input type="submit" />}
+      elsif options[:submit]
+        out << %{<input type="submit" value="#{options[:submit]}" />}
+      end
+      out.join("<br />\n")
+    end
+
+    # options #=>
+    # { :deny => /oid/ }
+    # { :deny => [/time/, /oid/]}
+
+    def chosen_attributes(attributes, options)
+      attributes.reject do |attribute|
+        attribute = attribute.to_s
+        [options[:deny]].flatten.find do |d|
+          first_comp = attribute =~ d rescue attribute == d
+          first_comp || attribute == d
+        end
+      end
+    end
+
+    # Home of all the methods that output a tag for a specific
+    # attribute.
+    # They take objects that respond to :value and :name, preferably
+    # an modified OpenStruct that responds to :temp to allow for easy
+    # forking. ( lib/ramaze/snippets/openstruct/temp.rb )
+
+    module Control
+      class << self
+
+        # A simple text-control, default to 0
+
+        def number o
+          o.value ||= 0
+          text(o)
+        end
+
+        #   <input type="text" />
+
+        def text o
+          o.value ||= ""
+          tag = ''
+          tag << "#{o.title}: " if o.title
+          tag << %{<input type="text" name="#{o.name}" value="#{o.value}" />}
+        end
+
+        #   <textarea></textarea>
+
+        def textarea o
+          o.value ||= ""
+          %{<textarea name="#{o.name}">#{o.value}</textarea>}
+        end
+
+        # compound of #date_day, #date_month, #date_year, #time_hour,
+        # #time_minute and #time_second
+
+        def time o
+          o.value ||= Time.now
+          [
+            date_day(o.temp(:value => o.value.day)),
+            date_month(o.temp(:value => o.value.month)),
+            date_year(o.temp(:value => o.value.year)),
+            time_hour(o.temp(:value => o.value.hour)),
+            time_minute(o.temp(:value => o.value.min)),
+            time_second(o.temp(:value => o.value.sec)),
+          ].join("\n")
+        end
+
+        #   <select name="xxx[sec]">
+        #     <option value="0">0</option>
+        #     ...
+        #     <option value="60">60</option>
+        #   </select>
+
+        def time_second(o)
+          select(o.name + '[sec]', (0...60), o.value)
+        end
+
+        #   <select name="xxx[min]">
+        #     <option value="0">0</option>
+        #     ...
+        #     <option value="60">60</option>
+        #   </select>
+
+        def time_minute(o)
+          select(o.name + '[min]', (0...60), o.value)
+        end
+
+        #   <select name="xxx[hour]">
+        #     <option value="1">1</option>
+        #     ...
+        #     <option value="23">23</option>
+        #   </select>
+
+        def time_hour(o)
+          select(o.name + '[hour]', (0...23), o.value)
+        end
+
+        # compound of #date_day, #date_month and #date_year
+
+        def date o
+          o.value ||= Date.today
+          [
+            date_day(o.temp(:value => o.value.day)),
+            date_month(o.temp(:value => o.value.month)),
+            date_year(o.temp(:value => o.value.year)),
+          ].join("\n")
+        end
+
+        #   <select name="xxx[day]">
+        #     <option value="1">1</option>
+        #     ...
+        #     <option value="31">31</option>
+        #   </select>
+
+        def date_day(o)
+          select(o.name + '[day]', (1..31), o.value)
+        end
+
+        #   <select name="xxx[month]">
+        #     <option value="1">1950</option>
+        #     ...
+        #     <option value="12">12</option>
+        #   </select>
+
+        def date_month(o)
+          select(o.name + '[month]', (1..12), o.value)
+        end
+
+        #   <select name="xxx[year]">
+        #     <option value="1950">1950</option>
+        #     ...
+        #     <option value="2050">2050</option>
+        #   </select>
+
+        def date_year(o)
+          select(o.name + '[year]', (1950..2050), o.value)
+        end
+
+        #  <select>
+        #    <option></option>
+        #  </select>
+
+        def select name, range, default
+          out = %{<select name="#{name}">\n}
+          range.each do |i|
+            out << %{<option value="#{i}"#{' selected="selected"' if default == i}>#{i}</option>\n}
+          end
+          out << "</select>\n"
+        end
+      end
+    end
+  end
+end