hypertemplate 1.2.0

data/lib/hypertemplate/builder/values.rb

@@ -0,0 +1,33 @@
+module Hypertemplate
+  module Builder
+  
+    # This is a Blank Slate class to support the renderization of the values block of Builder DSLs
+    # Every Media type should implement a Builder with a insert_value method that renders the values block to a specific format
+    class Values
+      attr_accessor :builder
+
+      # BlankSlate
+      instance_methods.each do |m|
+        undef_method m unless m.to_s =~ /\[\]|method_missing|object_id|send|respond_to\?|^__/
+      end
+
+      def initialize(builder)
+        @builder = builder
+        @current_prefix = nil
+      end
+
+      def [](prefix)
+        @current_prefix = prefix
+        self
+      end
+
+      def method_missing(symbol, *args, &block)
+        name = symbol.to_s
+        prefix = @current_prefix
+        @current_prefix = nil
+        @builder.insert_value(name, prefix, *args, &block)
+      end
+    end
+    
+  end
+end

data/lib/hypertemplate/builder/xml.rb

@@ -0,0 +1,119 @@
+module Hypertemplate
+  module Builder
+    class Xml < Hypertemplate::Builder::Base
+
+      def self.media_types
+        ["application/xml", "text/xml"]
+      end
+
+      attr_reader :raw
+
+      def initialize(obj, options = {})
+        initialize_library
+        @raw = Nokogiri::XML::Document.new
+        @obj = obj
+        @parent = @raw.create_element(options[:root] || "root")
+        @parent.parent = @raw
+      end
+
+      def initialize_library
+        return if defined?(::Nokogiri)
+        require "nokogiri"
+      end
+
+      def members(options = {}, &block)
+        collection = options[:collection] || @obj
+        raise Hypertemplate::BuilderError.new("Members method require a collection to execute") unless collection.respond_to?(:each)
+        name = options[:root] || "member"
+        collection.each do |element|
+          member_root = @raw.create_element(name)
+          member_root.parent = @parent
+          @parent = member_root
+          if block.arity==1
+            # new dsl
+            block.call(element)
+          else
+            # old dsl (deprecate at 1.3?)
+            block.call(self, element)
+          end
+          @parent = member_root.parent
+        end
+      end
+
+      def values(options = {}, &block)
+        options.each do |key,value|
+          apply_namespace(@parent, key.to_s, value)
+        end
+        yield Values.new(self)
+      end
+
+      def link(relationship, uri, options = {})
+        options["rel"] = relationship.to_s
+        options["href"] = uri
+        options["type"] ||= options[:type] || "application/xml"
+        insert_value("link", nil, options)
+      end
+
+      def insert_value(name, prefix, *args, &block)
+        # Protected if empty array
+        unless args.size == 1 and args.first == []
+          node = create_element(name.to_s, prefix, *args)
+          node.parent = @parent
+          if block_given?
+            @parent = node
+            block.call
+            @parent = node.parent
+          end
+        end
+      end
+
+      def representation
+        @raw.to_xml
+      end
+
+    private
+
+      def apply_namespace(node, key, value)
+        if key =~ /^xmlns(:\w+)?$/
+          ns_name = key.split(":", 2)[1]
+          node.add_namespace_definition(ns_name, value)
+          return true
+        end
+        false
+      end
+
+      def create_element(node, prefix, *args)
+        n = @raw.create_element(node)
+        if prefix
+          if namespace = find_prefix(prefix)
+            n.namespace = namespace
+          end
+        end
+
+        args.each do |arg|
+          if arg.kind_of? Hash
+            # Adding XML attributes
+            arg.each { |k,v|
+              key = k.to_s
+              n[key] = v.to_s unless apply_namespace(n, key, v)
+            }
+          elsif arg.kind_of?(Time) || arg.kind_of?(DateTime)
+            # Adding XML node content
+            n.content = arg.xmlschema
+          else
+            n.content = arg
+          end
+        end
+        n
+      end
+
+      def find_prefix(prefix)
+        all = [@parent] + @parent.ancestors
+        all.each do |a|
+          return a.namespace_definitions.find { |x| x.prefix == prefix.to_s } if a != @raw
+        end
+      end
+
+    end
+  end
+end

data/lib/hypertemplate/errors.rb

@@ -0,0 +1,3 @@
+module Hypertemplate
+  class BuilderError < StandardError; end
+end

data/lib/hypertemplate/hook.rb

@@ -0,0 +1,6 @@
+module Hypertemplate
+  module Hook
+    autoload :Rails , "hypertemplate/hook/rails"
+    autoload :Tilt  , "hypertemplate/hook/tilt"
+  end
+end

data/lib/hypertemplate/hook/rails.rb

@@ -0,0 +1,112 @@
+require 'hypertemplate' unless defined? ::Hypertemplate
+
+module Hypertemplate
+  module RegistryContainer
+    
+    def hypertemplate_registry
+      @hypertemplate || use_hypertemplate
+    end
+    
+    def use_hypertemplate(&block)
+      @hypertemplate = ::Hypertemplate::Registry.new
+      if block_given?
+        yield @hypertemplate
+      else
+        @hypertemplate << ::Hypertemplate::Builder::Json
+        @hypertemplate << ::Hypertemplate::Builder::Xml
+      end
+      @hypertemplate
+    end
+    
+  end
+end
+
+module ActionController
+  class Base
+    include Hypertemplate::RegistryContainer
+  end
+end
+
+module Hypertemplate
+  module Hook
+    module Rails
+
+      class Hypertemplate < ::ActionView::TemplateHandler
+        include ::ActionView::TemplateHandlers::Compilable
+
+        def compile(template)
+          "@content_type_helpers = @controller.hypertemplate_registry[self.response.content_type].helper; " +
+          "extend @content_type_helpers; " +
+          "extend Hypertemplate::Hook::Rails::Helpers; " +
+          "code_block = lambda { #{template.source} };" +
+          "builder = code_block.call; " +
+          "builder"
+        end
+      end
+
+      module Helpers
+        # Load a partial template to execute in describe
+        #
+        # For example:
+        #
+        # Passing the current context to partial in template:
+        #
+        #  member(@album) do |member, album|
+        #    partial('member', binding)
+        #  end
+        #
+        # in partial:
+        #
+        #  member.links << link(:rel => :artists, :href => album_artists_url(album))
+        #
+        # Or passing local variables assing
+        #
+        # collection(@albums) do |collection|
+        #   collection.members do |member, album|
+        #     partial("member", :locals => {:member => member, :album => album})
+        #   end
+        # end
+        #
+        def partial(partial_path, caller_binding = nil)
+          template = _pick_partial_template(partial_path)
+
+          # Create a context to assing variables
+          if caller_binding.kind_of?(Hash)
+            Proc.new do
+              extend @content_type_helpers
+              context = eval("(class << self; self; end)", binding)
+
+              caller_binding.fetch(:locals, {}).each do |k, v|
+                context.send(:define_method, k.to_sym) { v }
+              end
+
+              partial(partial_path, binding)
+            end.call
+          else
+            eval(template.source, caller_binding, template.path)
+          end
+        end
+      end
+
+    private
+      
+      def self.registry
+        if defined? ::ActionView::Template and ::ActionView::Template.respond_to?(:register_template_handler)
+          ::ActionView::Template
+        else
+          if defined? ::ActionController::Base
+            ::ActionController::Base.exempt_from_layout :hyper
+            ::ActionController::Base.exempt_from_layout :hypertemplate
+            ::ActionController::Base.exempt_from_layout :tokamak
+          end
+          ::ActionView::Base
+        end
+      end
+
+      registry.register_template_handler(:hyper, Hypertemplate)
+      registry.register_template_handler(:hypertemplate, Hypertemplate)
+      registry.register_template_handler(:tokamak, Hypertemplate)
+
+    end
+  end
+end

data/lib/hypertemplate/hook/sinatra.rb

@@ -0,0 +1,44 @@
+require 'hypertemplate' unless defined? ::Hypertemplate
+require "hypertemplate/hook/tilt"
+
+module Rack
+  class Hypertemplate
+    
+    def initialize(app)
+      @app = app
+      @registry = ::Hypertemplate::Registry.new
+      if block_given?
+        yield @registry
+      else
+        @registry << ::Hypertemplate::Builder::Json
+        @registry << ::Hypertemplate::Builder::Xml
+      end
+    end
+    
+    def call(env)
+      env["hypertemplate"] = @registry
+      @app.call(env)
+    end
+    
+  end
+end
+
+module Hypertemplate
+  module Hook
+    module Sinatra
+
+      module ::Sinatra::Templates
+
+        def tokamak(template, options={}, locals={})
+          hyler(template, options, locals)
+        end
+        
+        def hyper(template, options={}, locals={})
+          options.merge! :layout => false, :media_type => response["Content-Type"]
+          render :hyper, template, options, locals
+        end
+
+      end
+    end
+  end
+end

data/lib/hypertemplate/hook/tilt.rb

@@ -0,0 +1,68 @@
+require 'hypertemplate' unless defined? ::Hypertemplate
+
+module Hypertemplate
+  module Hook
+    module Tilt
+      
+      class HypertemplateTilt
+        
+        def initialize
+          @registry = Hypertemplate::Registry.new
+        end
+        
+        # unfortunately Tilt uses a global registry
+        def new(view = nil, line = 1, options = {}, &block)
+          HypertemplateTemplate.new(@registry, view, line,options, &block)
+        end
+        
+      end
+
+      class HypertemplateTemplate < ::Tilt::Template
+        
+        def initialize(registry, view = nil, line = 1,options = {}, &block)
+          super(view, line, options, &block)
+          @registry = registry
+        end
+        
+        def initialize_engine
+          return if defined?(::Hypertemplate)
+          require_template_library 'hypertemplate'
+        end
+
+        def prepare
+          @media_type = options[:media_type]
+          raise Hypertemplate::BuilderError.new("Content type required to build representation.") unless @media_type
+        end
+
+        def precompiled_preamble(locals)
+          local_assigns = super
+          <<-RUBY
+            begin
+              unless self.class.method_defined?(:hypertemplate_registry)
+                def hypertemplate_registry
+                  env['hypertemplate']
+                end
+              end
+              extend hypertemplate_registry[#{@media_type.inspect}].helper
+              #{local_assigns}
+          RUBY
+        end
+
+        def precompiled_postamble(locals)
+          <<-RUBY
+            end
+          RUBY
+        end
+
+        def precompiled_template(locals)
+          data.to_str
+        end
+      end
+
+      ::Tilt.register 'hypertemplate', HypertemplateTilt.new
+      ::Tilt.register 'tokamak', HypertemplateTilt.new
+      ::Tilt.register 'hyper', HypertemplateTilt.new
+
+    end
+  end
+end

data/lib/hypertemplate/recipes.rb

@@ -0,0 +1,25 @@
+module Hypertemplate
+  class Recipes
+
+    def initialize
+      @recipes = {}
+    end
+
+    def add(recipe_name, &block)
+      @recipes[recipe_name] = block
+    end
+
+    def remove(recipe_name)
+      @recipes.delete(recipe_name)
+    end
+
+    def [](recipe_name)
+      @recipes[recipe_name]
+    end
+
+    def list
+      @recipes.keys
+    end
+
+  end
+end

data/lib/hypertemplate/registry.rb

@@ -0,0 +1,24 @@
+module Hypertemplate
+  class Registry
+
+    def initialize
+      @media_types = {}
+    end
+
+    def <<(handler)
+      handler.media_types.each do |type|
+        @media_types[type] = handler
+      end
+    end
+
+    def [](media_type)
+      @media_types[media_type[/^([^\s\;]+)/, 1]]
+    end
+    
+    def []=(media_type, handler)
+      @media_types[media_type] = handler
+    end
+
+  end
+end
+

data/lib/hypertemplate/version.rb

@@ -0,0 +1,13 @@
+module Hypertemplate
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 2
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+
+    def self.to_s
+      STRING
+    end
+  end
+end