mixins.rb

module Temple
  module Mixins
    module EngineDSL
      def append(*args, &block)
        chain << element(args, block)
      end

      def prepend(*args, &block)
        chain.unshift(element(args, block))
      end

      alias use append

      def before(name, *args, &block)
        name = Class === name ? name.name.to_sym : name
        raise(ArgumentError, 'First argument must be Class or Symbol') unless Symbol === name
        e = element(args, block)
        found, i = false, 0
        while i < chain.size
          if chain[i].first == name
            found = true
            chain.insert(i, e)
            i += 2
          else
            i += 1
          end
        end
        raise "#{name} not found" unless found
      end

      def after(name, *args, &block)
        name = Class === name ? name.name.to_sym : name
        raise(ArgumentError, 'First argument must be Class or Symbol') unless Symbol === name
        e = element(args, block)
        found, i = false, 0
        while i < chain.size
          if chain[i].first == name
            found = true
            i += 1
            chain.insert(i, e)
          end
          i += 1
        end
        raise "#{name} not found" unless found
      end

      def replace(name, *args, &block)
        name = Class === name ? name.name.to_sym : name
        raise(ArgumentError, 'First argument must be Class or Symbol') unless Symbol === name
        e = element(args, block)
        found = false
        chain.each_with_index do |c, i|
          if c.first == name
            found = true
            chain[i] = e
          end
        end
        raise "#{name} not found" unless found
      end

      def filter(name, *options, &block)
        use(name, Temple::Filters.const_get(name), *options, &block)
      end

      def generator(name, *options, &block)
        use(name, Temple::Generators.const_get(name), *options, &block)
      end

      private

      def element(args, block)
        name = args.shift
        if Class === name
          filter = name
          name = filter.name.to_sym
        end
        raise(ArgumentError, 'First argument must be Class or Symbol') unless Symbol === name

        if block
          raise(ArgumentError, 'Class and block argument are not allowed at the same time') if filter
          raise(ArgumentError, 'Block must have arity 1') unless block.arity == 1
          filter = block
        end

        filter ||= args.shift
        raise(ArgumentError, 'Class or callable argument is required') unless Class === filter || filter.respond_to?(:call)

        if Proc === filter
          raise(ArgumentError, 'No option filter allowed') unless args.empty?
          method_name = "FILTER #{name}"
          if Class === self
            define_method(method_name, &filter)
            [name, instance_method(method_name)]
          else
            (class << self; self; end).class_eval { define_method(method_name, &filter) }
            [name, method(method_name)]
          end
        else
          local_options = Hash === args.last ? args.pop : nil
          raise(ArgumentError, 'Only symbols allowed in option filter') unless args.all? {|o| Symbol === o }
          [name, filter, args, local_options]
        end
      end
    end

    module CoreDispatcher
      def on_multi(*exps)
        [:multi, *exps.map {|exp| compile(exp) }]
      end

      def on_capture(name, exp)
        [:capture, name, compile(exp)]
      end

      def on_escape(flag, exp)
        [:escape, flag, compile(exp)]
      end
    end

    module Dispatcher
      include CoreDispatcher

      def self.included(base)
        base.class_eval { extend ClassMethods }
      end

      def call(exp)
        compile(exp)
      end

      def compile(exp)
        type, *args = exp
        if respond_to?("on_#{type}")
          send("on_#{type}", *args)
        else
          exp
        end
      end

      module ClassMethods
        def temple_dispatch(*bases)
          bases.each do |base|
            class_eval %{def on_#{base}(type, *args)
              if respond_to?("on_" #{base.to_s.inspect} "_\#{type}")
                send("on_" #{base.to_s.inspect} "_\#{type}", *args)
              else
                [:#{base}, type, *args]
              end
            end}
          end
        end
      end
    end

    module DefaultOptions
      def set_default_options(options)
        default_options.update(options)
      end

      def default_options
        @default_options ||= Utils::MutableHash.new(superclass.respond_to?(:default_options) ?
                                                    superclass.default_options : nil)
      end
    end

    module Options
      def self.included(base)
        base.class_eval { extend DefaultOptions }
      end

      attr_reader :options

      def initialize(options = {})
        @options = Utils::ImmutableHash.new(options, self.class.default_options)
      end
    end
  end
end