dryml 1.1.0.pre0

data/lib/dryml/part_context.rb

@@ -0,0 +1,133 @@
+  module Dryml
+
+    # Raised when the part context fails its integrity check.
+    class PartContext
+
+      class TamperedWithPartContext < StandardError; end
+
+      class TypedId < String; end
+
+      class << self
+        attr_accessor :secret, :digest
+      end
+      self.digest = 'SHA1'
+
+
+      def self.client_side_storage(contexts, session)
+        return "" if contexts.empty?
+
+        contexts.map do |dom_id, context|
+          code = context.marshal(session).split("\n").map{|line| "'#{line}\\n'"}.join(" +\n    ")
+          "hoboParts['#{dom_id}'] = (#{code});\n"
+        end.join
+      end
+      
+      
+      def self.pre_marshal(x)
+        if x.is_a?(ActiveRecord::Base) && x.respond_to?(:typed_id)
+          TypedId.new(x.typed_id)
+        else
+          x
+        end
+      end
+
+
+      def self.for_call(part_name, environment, locals)
+        new do |c|
+          c.part_name       = part_name
+          c.locals          = locals.map { |l| pre_marshal(l) }
+          c.this_id         = environment.typed_id
+          c.form_field_path = environment.form_field_path
+        end
+      end
+      
+      
+      def self.for_refresh(encoded_context, page_this, session)
+        new do |c|
+          c.unmarshal(encoded_context, page_this, session)
+        end
+      end
+      
+      
+      def initialize
+        yield self
+      end
+      
+      attr_accessor :part_name, :locals, :this, :this_field, :this_id, :form_field_path
+
+
+      def marshal(session)
+        context = [@part_name, @this_id, @locals]
+        context << form_field_path if form_field_path
+        data = Base64.encode64(Marshal.dump(context)).strip
+        digest = generate_digest(data, session)
+        "#{data}--#{digest}"
+      end
+
+
+      # Unmarshal part context to a hash and verify its integrity.
+      def unmarshal(client_store, page_this, session)
+        data, digest = CGI.unescape(client_store).strip.split('--')
+
+        raise TamperedWithPartContext unless digest == generate_digest(data, session)
+
+        context = Marshal.load(Base64.decode64(data))
+        
+        part_name, this_id, locals, form_field_path = context
+
+        if RAILS_DEFAULT_LOGGER
+          RAILS_DEFAULT_LOGGER.info "Call part: #{part_name}. this-id = #{this_id}, locals = #{locals.inspect}"
+          RAILS_DEFAULT_LOGGER.info "         : form_field_path = #{form_field_path.inspect}" if form_field_path
+        end
+        
+        self.part_name             = part_name
+        self.this_id               = this_id
+        self.locals                = restore_locals(locals)
+        self.form_field_path       = form_field_path
+        
+        parse_this_id(page_this)        
+      end
+
+
+      # Generate the HMAC keyed message digest. Uses SHA1 by default.
+      def generate_digest(data, session)
+        secret = self.class.secret || ActionController::Base.session_options[:secret] || ActionController::Base.cached_session_options.first[:secret]
+        key = secret.respond_to?(:call) ? secret.call(session) : secret
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new(self.class.digest), key, data)
+      end
+
+
+
+      def parse_this_id(page_this)
+        if this_id == "this"
+          self.this = page_this
+        elsif this_id =~ /^this:(.*)/
+          self.this = page_this
+          self.this_field = $1
+        elsif this_id == "nil"
+          nil
+        else
+          parts = this_id.split(':')
+          if parts.length == 3
+            self.this       = Hobo::Model.find_by_typed_id("#{parts[0]}:#{parts[1]}")
+            self.this_field = parts[2]
+          else
+            self.this = Hobo::Model.find_by_typed_id(this_id)
+          end
+        end
+      end
+
+
+      def restore_locals(locals)
+        locals.map do |l|
+          if l.is_a?(TypedId)
+            Hobo::Model.find_by_typed_id(this_id)
+          else
+            l
+          end
+        end
+      end
+
+    end
+
+  end

data/lib/dryml/scoped_variables.rb

@@ -0,0 +1,42 @@
+module Dryml
+
+  class ScopedVariables
+
+    def initialize(variables=nil)
+      @scopes = variables ? [variables] : []
+    end
+
+    def [](key)
+     s = scope_with_key(key) and s[key]
+    end
+
+    def []=(key, val)
+      s = scope_with_key(key) or raise ArgumentError, "no such scoped variable: #{key}"
+      s[key] = val
+    end
+
+    def new_scope(variables)
+      @scopes << variables.dup
+      res = yield
+      @scopes.pop
+      res
+    end
+
+    def scope_with_key(key)
+      @scopes.reverse_each do |s|
+        return s if s.has_key?(key)
+      end
+      nil
+    end
+
+    def method_missing(name, *args)
+      if name.to_s =~ /=$/
+        self[name.to_s[0..-2].to_sym] = args.first
+      else
+        self[name]
+      end
+    end
+
+  end
+
+end

data/lib/dryml/static_tags

@@ -0,0 +1,98 @@
+abbr
+acronym
+address
+applet
+article
+audio
+b
+basefont
+bdo
+big
+blockquote
+body
+button
+canvas
+caption
+center
+cite
+code
+colgroup
+command
+datagrid
+datalist
+dd
+del
+details
+dfn
+dialog
+dir
+div
+dl
+dt
+em
+embed
+fieldset
+figure
+font
+frameset
+h1
+h2
+h3
+h4
+h5
+h6
+head
+hgroup
+i
+iframe
+ins
+isindex
+kbd
+label
+legend
+li
+map
+mark
+menu
+meter
+nav
+noframes
+noscript
+object
+ol
+optgroup
+option
+output
+p
+pre
+progress
+q
+rp
+rt
+ruby
+s
+samp
+script
+select
+small
+source
+span
+strike
+strong
+style
+sub
+sup
+tbody
+td
+textarea
+tfoot
+th
+thead
+time
+title
+tr
+tt
+u
+ul
+var
+video

data/lib/dryml/tag_parameters.rb

@@ -0,0 +1,32 @@
+  module Dryml
+
+    class NoParameterError < RuntimeError; end
+
+    class TagParameters < Hash
+
+      def initialize(parameters, exclude_names=nil)
+        if exclude_names.blank?
+          update(parameters)
+        else
+          parameters.each_pair { |k, v| self[k] = v unless k.in?(exclude_names) }
+        end
+      end
+
+      def method_missing(name, default_content="")
+        if name.to_s =~ /\?$/
+          has_key?(name.to_s[0..-2].to_sym)
+        else
+          self[name]._?.call(default_content) || ""
+        end
+      end
+
+      undef_method :default
+
+      # Question: does this do anything? -Tom 
+      def [](param_name)
+        fetch(param_name, nil)
+      end
+
+    end
+
+  end

data/lib/dryml/taglib.rb

@@ -0,0 +1,124 @@
+  module Dryml
+
+    class Taglib
+
+      @cache = {}
+
+      class << self
+
+        def get(options)
+          src_file = taglib_filename(options)
+          taglib = @cache[src_file]
+          if taglib
+            taglib.reload
+          else
+            taglib = Taglib.new(src_file)
+            @cache[src_file] = taglib
+          end
+          taglib
+        end
+
+        def clear_cache
+          @cache = {}
+        end
+
+        private
+
+        def taglib_filename(options)
+          plugin = options[:plugin]
+          rails_root = Object.const_defined?(:RAILS_ROOT) ? RAILS_ROOT : "."
+          base = if plugin == "dryml"
+                   "#{DRYML_ROOT}/taglibs"
+                 elsif plugin == "hobo"
+                   "#{HOBO_ROOT}/taglibs"
+                 elsif plugin
+                   "#{rails_root}/vendor/plugins/#{plugin}/taglibs"
+                 elsif options[:src] =~ /\//
+                   "#{rails_root}/app/views"
+                 elsif options[:template_dir] =~ /^#{HOBO_ROOT}/
+                   options[:template_dir]
+                 elsif options[:absolute_template_path]
+                    options[:absolute_template_path]
+                 else
+                   "#{rails_root}/#{options[:template_dir].gsub(/^\//, '')}" # remove leading / if there is one
+                 end
+
+          src = options[:src] || plugin
+          filename = "#{base}/#{src}.dryml"
+          raise DrymlException, "No such taglib: #{base} #{options.inspect} #{filename}" unless File.exists?(filename)
+          filename
+        end
+
+      end
+
+      def initialize(src_file)
+        @src_file = src_file
+        load
+      end
+
+      def reload
+        load if File.mtime(@src_file) > @last_load_time
+      end
+
+      def load
+        @module = Module.new do
+
+          @tag_attrs = {}
+          @tag_aliases = []
+
+          class << self
+
+            def included(base)
+              @tag_aliases.each do |tag, feature|
+                if base.respond_to? :alias_method_chain_on_include
+                  base.alias_method_chain_on_include tag, feature
+                else
+                  base.send(:alias_method_chain, tag, feature)
+                end
+              end
+            end
+
+            def _register_tag_attrs(tag, attrs)
+              @tag_attrs[tag] = attrs
+            end
+            attr_reader :tag_attrs
+
+            def alias_method_chain_on_include(tag, feature)
+              @tag_aliases << [tag, feature]
+            end
+
+          end
+
+        end
+        template = Template.new(File.read(@src_file), @module, @src_file)
+        template.compile([], [])
+        @last_load_time = File.mtime(@src_file)
+      end
+
+      def import_into(class_or_module, as)
+        if as
+          # Define a method on class_or_module named whatever 'as'
+          # is. The first time the method is called it creates and
+          # returns an object that provides the taglib's tags as
+          # methods. On subsequent calls the object is cached in an
+          # instance variable "@_#{as}_taglib"
+
+          taglib_module = @module
+          ivar = "@_#{as}_taglib"
+          class_or_module.send(:define_method, as) do
+            instance_variable_get(ivar) or begin
+                                             as_class = Class.new(TemplateEnvironment) { include taglib_module }
+                                             as_object = as_class.new
+                                             as_object.copy_instance_variables_from(self)
+                                             instance_variable_set(ivar, as_object)
+                                           end
+          end
+        else
+          class_or_module.send(:include, @module)
+          class_or_module.tag_attrs.update(@module.tag_attrs) if @module.respond_to?(:tag_attrs)
+        end
+      end
+
+    end
+
+  end