middleman 2.0.4 → 2.0.5

data/lib/middleman/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/output_helpers/abstract_handler.rb

@@ -0,0 +1,103 @@
+module Padrino
+  module Helpers
+    module OutputHelpers
+      ##
+      # Returns the list of all available template handlers
+      #
+      # ==== Examples
+      #
+      #   OutputHelpers.handlers => [<OutputHelpers::HamlHandler>, <OutputHelpers::ErbHandler>]
+      #
+      def self.handlers
+        @_template_handlers ||= []
+      end
+
+      ##
+      # Registers a new handler as available to the output helpers
+      #
+      # ==== Examples
+      #
+      #   OutputHelpers.register(OutputHelpers::HamlHandler)
+      #
+      def self.register(handler)
+        handlers << handler
+      end
+
+      class AbstractHandler
+        attr_reader :template
+
+        def initialize(template)
+          @template = template
+        end
+
+        ##
+        # Returns extension of the template
+        #
+        # ==== Examples
+        #
+        #  @handler.template_extension => "erb"
+        #
+        def template_extension
+          caller.find { |c| c =~ /\/views\// }[/\.([\w]*?)\:/, 1] rescue nil
+          # "/some/path/app/views/posts/foo.html.erb:3:in `evaluate_source'"
+          # => "erb"
+        end
+
+        ##
+        # Returns an array of engines used for the template
+        #
+        # ==== Examples
+        #
+        #   @handler.engines => [:erb, :erubis]
+        #
+        def engines
+          # Implemented in subclass
+        end
+
+        ##
+        # Returns true if the current template type is same as this handlers; false otherwise.
+        #
+        # ==== Examples
+        #
+        #  @handler.is_type? => true
+        #
+        def is_type?
+          # Implemented in subclass
+        end
+
+        ##
+        # Returns true if the block given is of the handler's template type; false otherwise.
+        #
+        # ==== Examples
+        #
+        #  @handler.block_is_type?(block) => true
+        #
+        def block_is_type?(block)
+          # Implemented in subclass
+        end
+
+        ##
+        # Captures the html from a block of template code for this handler
+        #
+        # ==== Examples
+        #
+        #  @handler.capture_from_template(&block) => "...html..."
+        #
+        def capture_from_template(*args, &block)
+          # Implemented in subclass
+        end
+
+        ##
+        # Outputs the given text to the templates buffer directly
+        #
+        # ==== Examples
+        #
+        #   @handler.concat_to_template("This will be output to the template buffer")
+        #
+        def concat_to_template(text="")
+          # Implemented in subclass
+        end
+      end # AbstractHandler
+    end # OutputHelpers
+  end # Helpers
+end # Padrino

data/lib/middleman/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/output_helpers/erb_handler.rb

@@ -0,0 +1,79 @@
+module Padrino
+  module Helpers
+    module OutputHelpers
+      class ErbHandler < AbstractHandler
+        attr_reader :output_buffer
+
+        def initialize(template)
+          super
+          @output_buffer = template.instance_variable_get(:@_out_buf)
+        end
+
+        ##
+        # Returns true if the current template type is same as this handlers; false otherwise.
+        #
+        # ==== Examples
+        #
+        #  @handler.is_type? => true
+        #
+        def is_type?
+          !self.output_buffer.nil?
+        end
+
+        # Captures the html from a block of template code for this handler
+        #
+        # ==== Examples
+        #
+        #  @handler.capture_from_template(&block) => "...html..."
+        #
+        def capture_from_template(*args, &block)
+          self.output_buffer, _buf_was = "", self.output_buffer
+          block.call(*args)
+          ret = eval("@_out_buf", block.binding)
+          self.output_buffer = _buf_was
+          ret
+        end
+
+        ##
+        # Outputs the given text to the templates buffer directly
+        #
+        # ==== Examples
+        #
+        #   @handler.concat_to_template("This will be output to the template buffer")
+        #
+        def concat_to_template(text="")
+          self.output_buffer << text if is_type? && text
+          nil
+        end
+
+        ##
+        # Returns true if the block given is of the handler's template type; false otherwise.
+        #
+        # ==== Examples
+        #
+        #  @handler.block_is_type?(block) => true
+        #
+        def block_is_type?(block)
+          is_type? || (block && eval('defined?(__in_erb_template)', block.binding))
+        end
+
+        ##
+        # Returns an array of engines used for the template
+        #
+        # ==== Examples
+        #
+        #   @handler.engines => [:erb, :erubis]
+        #
+        def engines
+          @_engines ||= [:erb, :erubis]
+        end
+
+        protected
+          def output_buffer=(val)
+            template.instance_variable_set(:@_out_buf, val)
+          end
+        end # ErbHandler
+        OutputHelpers.register(ErbHandler)
+    end # OutputHelpers
+  end # Helpers
+end # Padrino

data/lib/middleman/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/output_helpers/haml_handler.rb

@@ -0,0 +1,64 @@
+module Padrino
+  module Helpers
+    module OutputHelpers
+      class HamlHandler < AbstractHandler
+        ##
+        # Returns true if the current template type is same as this handlers; false otherwise.
+        #
+        # ==== Examples
+        #
+        #  @handler.is_type? => true
+        #
+        def is_type?
+          template.respond_to?(:is_haml?) && template.is_haml?
+        end
+
+        ##
+        # Returns true if the block given is of the handler's template type; false otherwise.
+        #
+        # ==== Examples
+        #
+        #  @handler.block_is_type?(block) => true
+        #
+        def block_is_type?(block)
+          template.block_is_haml?(block)
+        end
+
+        # Captures the html from a block of template code for this handler
+        #
+        # ==== Examples
+        #
+        #  @handler.capture_from_template(&block) => "...html..."
+        #
+        def capture_from_template(*args, &block)
+          eval("_hamlout ||= @haml_buffer", block.binding) # this is for rbx
+          template.capture_haml(*args, &block)
+        end
+
+        ##
+        # Outputs the given text to the templates buffer directly
+        #
+        # ==== Examples
+        #
+        #   @handler.concat_to_template("This will be output to the template buffer")
+        #
+        def concat_to_template(text="")
+          template.haml_concat(text)
+          nil
+        end
+
+        ##
+        # Returns an array of engines used for the template
+        #
+        # ==== Examples
+        #
+        #   @handler.engines => [:erb, :erubis]
+        #
+        def engines
+          @_engines ||= [:haml]
+        end
+      end # HamlHandler
+      OutputHelpers.register(HamlHandler)
+    end # OutputHelpers
+  end # Helpers
+end # Padrino

data/lib/middleman/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/output_helpers/slim_handler.rb

@@ -0,0 +1,82 @@
+# Make slim works with sinatra/padrino
+Slim::Engine.set_default_options(:buffer => '@_out_buf', :generator => Temple::Generators::StringBuffer) if defined?(Slim)
+
+module Padrino
+  module Helpers
+    module OutputHelpers
+      class SlimHandler < AbstractHandler
+        attr_reader :output_buffer
+
+        def initialize(template)
+          super
+          @output_buffer = template.instance_variable_get(:@_out_buf)
+        end
+
+        ##
+        # Returns true if the current template type is same as this handlers; false otherwise.
+        #
+        # ==== Examples
+        #
+        #  @handler.is_type? => true
+        #
+        def is_type?
+          !self.output_buffer.nil?
+        end
+
+        # Captures the html from a block of template code for this handler
+        #
+        # ==== Examples
+        #
+        #  @handler.capture_from_template(&block) => "...html..."
+        #
+        def capture_from_template(*args, &block)
+          self.output_buffer, _buf_was = "", self.output_buffer
+          block.call(*args)
+          ret = eval("@_out_buf", block.binding)
+          self.output_buffer = _buf_was
+          ret
+        end
+
+        ##
+        # Outputs the given text to the templates buffer directly
+        #
+        # ==== Examples
+        #
+        #   @handler.concat_to_template("This will be output to the template buffer")
+        #
+        def concat_to_template(text="")
+          self.output_buffer << text if is_type? && text
+          nil
+        end
+
+        ##
+        # Returns true if the block given is of the handler's template type; false otherwise.
+        #
+        # ==== Examples
+        #
+        #  @handler.block_is_type?(block) => true
+        #
+        def block_is_type?(block)
+          is_type? || (block && eval('defined? __in_erb_template', block.binding))
+        end
+
+        ##
+        # Returns an array of engines used for the template
+        #
+        # ==== Examples
+        #
+        #   @handler.engines => [:erb, :erubis]
+        #
+        def engines
+          @_engines ||= [:slim]
+        end
+
+        protected
+          def output_buffer=(val)
+            template.instance_variable_set(:@_out_buf, val)
+          end
+        end # ErbHandler
+        OutputHelpers.register(SlimHandler)
+    end # OutputHelpers
+  end # Helpers
+end # Padrino

data/lib/middleman/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/render_helpers.rb

@@ -0,0 +1,40 @@
+module Padrino
+  module Helpers
+    module RenderHelpers
+      ##
+      # Partials implementation which includes collections support
+      #
+      # ==== Examples
+      #
+      #   partial 'photo/item', :object => @photo
+      #   partial 'photo/item', :collection => @photos
+      #   partial 'photo/item', :locals => { :foo => :bar }
+      #   partial 'photo/item', :engine => :erb
+      #
+      def partial(template, options={})
+        options.reverse_merge!(:locals => {}, :layout => false)
+        path = template.to_s.split(File::SEPARATOR)
+        object_name = path[-1].to_sym
+        path[-1] = "_#{path[-1]}"
+        explicit_engine = options.delete(:engine)
+        template_path = File.join(path).to_sym
+        raise 'Partial collection specified but is nil' if options.has_key?(:collection) && options[:collection].nil?
+        if collection = options.delete(:collection)
+          options.delete(:object)
+          counter = 0
+          collection.map { |member|
+            counter += 1
+            options[:locals].merge!(object_name => member, "#{object_name}_counter".to_sym => counter)
+            render(explicit_engine, template_path, options.dup)
+          }.join("\n")
+        else
+          if member = options.delete(:object)
+            options[:locals].merge!(object_name => member)
+          end
+          render(explicit_engine, template_path, options.dup)
+        end
+      end
+      alias :render_partial :partial
+    end # RenderHelpers
+  end # Helpers
+end # Padrino

data/lib/middleman/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/tag_helpers.rb

@@ -0,0 +1,59 @@
+module Padrino
+  module Helpers
+    module TagHelpers
+      ##
+      # Creates an html input field with given type and options
+      #
+      # ==== Examples
+      #
+      #   input_tag :text, :class => "test"
+      #
+      def input_tag(type, options = {})
+        options.reverse_merge!(:type => type)
+        tag(:input, options)
+      end
+
+      ##
+      # Creates an html tag with given name, content and options
+      #
+      # ==== Examples
+      #
+      #   content_tag(:p, "hello", :class => 'light')
+      #   content_tag(:p, :class => 'dark') do ... end
+      #   content_tag(name, content=nil, options={}, &block)
+      #
+      def content_tag(*args, &block)
+        name = args.first
+        options = args.extract_options!
+        tag_html = block_given? ? capture_html(&block) : args[1]
+        tag_result = tag(name, options.merge(:content => tag_html))
+        block_is_template?(block) ? concat_content(tag_result) : tag_result
+      end
+
+      ##
+      # Creates an html tag with the given name and options
+      #
+      # ==== Examples
+      #
+      #   tag(:br, :style => 'clear:both')
+      #   tag(:p, :content => "hello", :class => 'large')
+      #
+      def tag(name, options={})
+        content, open_tag = options.delete(:content), options.delete(:open)
+        content = content.join("\n") if content.respond_to?(:join)
+        identity_tag_attributes.each { |attr| options[attr] = attr.to_s if options[attr]  }
+        html_attrs = options.map { |a, v| v.nil? || v == false ? nil : "#{a}=\"#{v}\"" }.compact.join(" ")
+        base_tag = (html_attrs.present? ? "<#{name} #{html_attrs}" : "<#{name}")
+        base_tag << (open_tag ? ">" : (content ? ">#{content}</#{name}>" : " />"))
+      end
+
+      private
+        ##
+        # Returns a list of attributes which can only contain an identity value (i.e selected)
+        #
+        def identity_tag_attributes
+          [:checked, :disabled, :selected, :multiple]
+        end
+    end # TagHelpers
+  end # Helpers
+end # Padrino

data/lib/middleman/vendor/padrino-helpers-0.10.0/lib/padrino-helpers/translation_helpers.rb

@@ -0,0 +1,21 @@
+module Padrino
+  module Helpers
+    module TranslationHelpers
+      ##
+      # Delegates to I18n.translate with no additional functionality.
+      #
+      def translate(*args)
+        I18n.translate(*args)
+      end
+      alias :t :translate
+
+      ##
+      # Delegates to I18n.localize with no additional functionality.
+      #
+      def localize(*args)
+        I18n.localize(*args)
+      end
+      alias :l :localize
+    end # TranslationHelpers
+  end # Helpers
+end # Padrino