RubyGems - dryml - Versions diffs - 1.1.0.pre0 - Mend

dryml 1.1.0.pre0

Files changed (31) hide show

data/CHANGES.txt +9 -0
data/LICENSE.txt +22 -0
data/README +36 -0
data/Rakefile +47 -0
data/TODO.txt +6 -0
data/lib/dryml/dryml_builder.rb +140 -0
data/lib/dryml/dryml_doc.rb +155 -0
data/lib/dryml/dryml_generator.rb +271 -0
data/lib/dryml/dryml_support_controller.rb +13 -0
data/lib/dryml/helper.rb +69 -0
data/lib/dryml/parser/attribute.rb +41 -0
data/lib/dryml/parser/base_parser.rb +254 -0
data/lib/dryml/parser/document.rb +57 -0
data/lib/dryml/parser/element.rb +27 -0
data/lib/dryml/parser/elements.rb +21 -0
data/lib/dryml/parser/source.rb +58 -0
data/lib/dryml/parser/text.rb +13 -0
data/lib/dryml/parser/tree_parser.rb +67 -0
data/lib/dryml/parser.rb +3 -0
data/lib/dryml/part_context.rb +133 -0
data/lib/dryml/scoped_variables.rb +42 -0
data/lib/dryml/static_tags +98 -0
data/lib/dryml/tag_parameters.rb +32 -0
data/lib/dryml/taglib.rb +124 -0
data/lib/dryml/template.rb +1021 -0
data/lib/dryml/template_environment.rb +613 -0
data/lib/dryml/template_handler.rb +187 -0
data/lib/dryml.rb +291 -0
data/taglibs/core.dryml +136 -0
data/test/dryml.rdoctest +68 -0
metadata +131 -0

data/CHANGES.txt ADDED Viewed

@@ -0,0 +1,9 @@
+CHANGES:
+ - Hobo::Dryml moved to Dryml
+ - Hobo.static_tags moved to Dryml.static_tags
+ - core.dryml moved to dryml/taglibs
+ - generator_directories moved from constant to parameter to Dryml.enable
+ - APPLICATION_TAGLIB not necessarily loaded automatically
+ - generator input and output directors no longer hardcoded, must be passed to #enable
+ - a bunch of functions in hobo.rb moved to dryml.rb

data/LICENSE.txt ADDED Viewed

@@ -0,0 +1,22 @@
+Copyright (c) 2006 Tom Locke
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README ADDED Viewed

@@ -0,0 +1,36 @@
+# DRYML
+DRYML is the Don't Repeat Yourself Markup Language.  It uses an
+XML-like syntax and is best at creating XHTML documents.  It could be
+used to create other forms of plain-text documents, but the syntax is
+not optimized for that and you may end up with extra carriage returns.
+(Which would be a bug, so please send test cases).
+DRYML was created for the Hobo project, but this is an extraction from
+that project and can be used separately.
+# How to use with Rails but without Hobo
+- install both HoboSupport and Dryml as a plugin or gem
+- create an `application.dryml`
+    $ mkdir app/views/taglibs
+    $ touch app/views/taglibs/application.dryml
+- create `config/initializers/dryml.rb`
+    require 'dryml'
+    require 'dryml/template'
+    require 'dryml/dryml_generator'
+    Dryml.enable
+Now you can use templates that end in ".dryml".  Such templates will
+ignore layouts.
+# How to use outside of Rails
+    Dryml.render("<html><%= this %></html>", {:this => something})
+See the [rdoc](http://fixme/doc/Dryml.html#render-instance_method) for
+more information.

data/Rakefile ADDED Viewed

@@ -0,0 +1,47 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/testtask'
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '/lib')
+$:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '/../hobosupport/lib')
+require 'dryml' # to get VERSION
+RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
+RUBYDOCTEST = ENV['RUBYDOCTEST'] || "#{RUBY} -S rubydoctest"
+desc "Default Task"
+task :default => [ :test ]
+# --- Testing --- #
+desc "Run all tests"
+task :test do |t|
+  files=Dir['test/*.rdoctest'].map {|f| File.expand_path(f)}.join(' ')
+  exit(1) if !system("#{RUBYDOCTEST} #{files}")
+end
+# --- RDOC --- #
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb', 'README', 'LICENSE.txt', 'CHANGES.txt']
+end
+# --- Packaging and Rubyforge & gemcutter & github--- #
+require 'jeweler'
+Jeweler::Tasks.new do |gemspec|
+  gemspec.version      = Dryml::VERSION
+  gemspec.name         = "dryml"
+  gemspec.email        = "tom@tomlocke.com"
+  gemspec.summary      = "The web app builder for Rails"
+  gemspec.homepage     = "http://hobocentral.net/"
+  gemspec.authors      = ["Tom Locke"]
+  gemspec.rubyforge_project = "hobo"
+  gemspec.add_dependency("hobosupport", ["= #{Dryml::VERSION}"])
+  gemspec.add_dependency("actionpack", [">= 2.2.2"])
+end
+Jeweler::GemcutterTasks.new
+Jeweler::RubyforgeTasks.new do |rubyforge|
+  rubyforge.doc_task = false
+end

data/TODO.txt ADDED Viewed

@@ -0,0 +1,6 @@
+- remove actionview requirement
+- get Hobo working
+- standalone generators
+- get it working in Sinatra
+- get it working in rtomayko/tilt
+- get it working in Rails3

data/lib/dryml/dryml_builder.rb ADDED Viewed

@@ -0,0 +1,140 @@
+module Dryml
+  class DRYMLBuilder
+    def initialize(template)
+      @template = template
+      @build_instructions = nil # set to [] on the first add_build_instruction
+      @part_names = []
+    end
+    attr_reader :template, :environment
+    def template_path
+      template.template_path
+    end
+    def set_environment(environment)
+      @environment = environment
+    end
+    def ready?(mtime, d=false)
+      @build_instructions && @last_build_mtime && @last_build_mtime >= mtime
+    end
+    def start
+      @part_names.clear
+      @build_instructions = []
+    end
+    def add_build_instruction(type, params)
+      @build_instructions << params.merge(:type => type)
+    end
+    def add_part(name, src, line_num)
+      raise DrymlException.new("duplicate part: #{name}", template_path, line_num) if name.in?(@part_names)
+      add_build_instruction(:def, :src => src, :line_num => line_num)
+      @part_names << name
+    end
+    def <<(params)
+      @build_instructions << params
+    end
+    def render_page_source(src, local_names)
+      locals = local_names.map{|l| "#{l} = __local_assigns__[:#{l}];"}.join(' ')
+      ("def render_page(__page_this__, __local_assigns__); " +
+            "#{locals} new_object_context(__page_this__) do " +
+            src +
+           "; output_buffer; end; end")
+    end
+    def erb_process(erb_src, method_def=false)
+      trim_mode = ActionView::TemplateHandlers::ERB.erb_trim_mode
+      erb = ERB.new(erb_src, nil, trim_mode, "output_buffer")
+      src = erb.src.split(';')[1..-2].join(';')
+      if method_def
+        src.sub /^\s*def.*?\(.*?\)/, '\0 __in_erb_template=true; '
+      else
+        "__in_erb_template=true; " + src
+      end
+    end
+    def build(local_names, auto_taglibs, src_mtime)
+      auto_taglibs.each { |t| import_taglib(t) }
+      @build_instructions._?.each do |instruction|
+        name = instruction[:name]
+        case instruction[:type]
+        when :eval
+          @environment.class_eval(instruction[:src], template_path, instruction[:line_num])
+        when :def
+          src = erb_process(instruction[:src], true)
+          @environment.class_eval(src, template_path, instruction[:line_num])
+        when :render_page
+          method_src = render_page_source(erb_process(instruction[:src]), local_names)
+          @environment.compiled_local_names = local_names
+          @environment.class_eval(method_src, template_path, instruction[:line_num])
+        when :include
+          import_taglib(instruction)
+        when :module
+          import_module(name.constantize, instruction[:as])
+        when :set_theme
+          set_theme(name)
+        when :alias_method
+          @environment.send(:alias_method, instruction[:new], instruction[:old])
+        else
+          raise RuntimeError.new("DRYML: Unknown build instruction :#{instruction[:type]}, " +
+                                 "building #{template_path}")
+        end
+      end
+      @last_build_mtime = src_mtime
+    end
+    def import_taglib(options)
+      if options[:module]
+        import_module(options[:module].constantize, options[:as])
+      else
+        template_dir = File.dirname(template_path)
+        options = options.merge(:template_dir => template_dir)
+        taglib = Taglib.get(options)
+        taglib.import_into(@environment, options[:as])
+      end
+    end
+    def import_module(mod, as=nil)
+      raise NotImplementedError if as
+      @environment.send(:include, mod)
+    end
+    def set_theme(name)
+      if Hobo.current_theme.nil? or Hobo.current_theme == name
+        Hobo.current_theme = name
+        import_taglib(:src => "taglibs/themes/#{name}/#{name}")
+      end
+    end
+  end
+end

data/lib/dryml/dryml_doc.rb ADDED Viewed

@@ -0,0 +1,155 @@
+require 'rexml/xpath'
+  module Dryml
+    # DrymlDoc provides the facility to parse a directory tree of DRYML taglibs, building a collection of objects that provide metadata
+    module DrymlDoc
+      def self.load_taglibs(directory, taglib_class=DrymlDoc::Taglib)
+        dryml_files = Dir["#{directory}/**/*.dryml"]
+        dryml_files.map { |f| taglib_class.new(directory, f) }
+      end
+      CommentMethods = classy_module do
+        def comment_intro
+          comment && comment =~ /(.*?)^#/m ? $1 : comment
+        end
+        def comment_rest
+          comment && comment[comment_intro.length..-1]
+        end
+        %w(comment comment_intro comment_rest).each do |m|
+          class_eval "def #{m}_html; Maruku.new(#{m}).to_html.gsub(/&amp;/, '&'); end"
+        end
+      end
+      class Taglib
+        def initialize(home, filename, name=nil)
+          @name = name || filename.sub(/.dryml$/, '')[home.length+1..-1]
+          @doc = Dryml::Parser::Document.new(File.read(filename), filename)
+          parse_tag_defs
+        end
+        attr_reader :name, :doc, :tag_defs
+        def comment
+          first_node = doc[0][0]
+          doc.restore_erb_scriptlets(first_node.to_s.strip) if first_node.is_a?(REXML::Comment)
+        end
+        include CommentMethods
+        private
+        def tagdef_class
+          self.class.parent.const_get('TagDef')
+        end
+        def parse_tag_defs
+          @tag_defs = []
+          REXML::XPath.match(doc, '/*/*[@tag]').each { |node| @tag_defs << tagdef_class.new(self, node) }
+        end
+      end
+      class TagDef
+        def initialize(taglib, node)
+          @taglib = taglib
+          @node = node
+        end
+        attr_reader :taglib, :node
+        delegate :doc, :to => :taglib
+        def name
+          node.attributes['tag']
+        end
+        def source
+          doc.restore_erb_scriptlets(node.to_s).strip
+        end
+        # The contents of the XML comment, if any, immediately above the tag definition
+        def comment
+          @comment ||= begin
+            space = node.previous_sibling and
+              space.to_s.blank? && space.to_s.count("\n") == 1 and
+              comment_node = space.previous_sibling
+            if comment_node.is_a?(REXML::Comment)
+              doc.restore_erb_scriptlets(comment_node.to_s.strip)
+            end
+          end
+        end
+        include CommentMethods
+        def no_doc?
+          comment =~ /^nodoc\b/
+        end
+        # An array of the arrtibute names defined by this tag
+        def attributes
+          (node.attributes['attrs'] || "").split(/\s*,\s*/).where_not.blank?
+        end
+        # Returns a recursive array srtucture, where each item in the array is a pair: [parameter_name, sub_parameters]
+        # (sub-parameters is the same kind of structure)
+        def parameters(element=node)
+          result = []
+          element.elements.each do |e|
+            if (p = e.attributes['param'])
+              param_name = p == "&true" ? e.name : p
+              result << [param_name, parameters(e)]
+            else
+              result.concat(parameters(e))
+            end
+          end
+          result
+        end
+        # Is this the base definition of a polymorphic tag
+        def polymorphic?
+          node.attributes['polymorphic'].present?
+        end
+        # Is this an <extend>?
+        def extension?
+          node.name == "extend"
+        end
+        # The definition's 'for' attribute
+        def for_type
+          node.attributes['for']
+        end
+        # The name of the tag, if any, that this definition merges its parameters into
+        # That is, the tag with 'merge' or 'merge-params' declared
+        def merge_params
+          REXML::XPath.first(node, ".//*[@merge|@merge-params]")._?.name
+        end
+        # The name of the tag, if any, that this definition merges its attributes into
+        # That is, the tag with 'merge' or 'merge-attrs' declared
+        def merge_attrs
+          REXML::XPath.first(node, ".//*[@merge|@merge-attrs]")._?.name
+        end
+      end
+    end
+  end

data/lib/dryml/dryml_generator.rb ADDED Viewed

@@ -0,0 +1,271 @@
+# -*- coding: utf-8 -*-
+require 'set'
+require 'fileutils'
+require 'action_controller/dispatcher'
+  module Dryml
+    class DrymlGenerator
+      HEADER = "<!-- AUTOMATICALLY GENERATED FILE - DO NOT EDIT -->\n\n"
+      class << self
+        attr_accessor :run_on_every_request
+        attr_accessor :output_directory
+      end
+      def self.enable(generator_directories = [], output_directory = nil)
+        @output_directory = output_directory
+        @output_directory ||= "#{RAILS_ROOT}/app/views/taglibs/auto" if defined? :RAILS_ROOT
+        @generator_directories = generator_directories
+        # Unfortunately the dispatcher callbacks don't give us the hook we need (after routes are reloaded)
+        # so we have to alias_method_chain
+        ActionController::Dispatcher.class_eval do
+          if respond_to? :reload_application
+            #Rails 2.3
+            class << self
+              def reload_application_with_dryml_generators
+                reload_application_without_dryml_generators
+                DrymlGenerator.run unless Dryml::DrymlGenerator.run_on_every_request == false || Rails.env.production?
+              end
+              alias_method_chain :reload_application, :dryml_generators
+            end
+          else
+            #Rails <= 2.2
+            def reload_application_with_dryml_generators
+              reload_application_without_dryml_generators
+              DrymlGenerator.run unless Dryml::DrymlGenerator.run_on_every_request == false || Rails.env.production?
+            end
+            alias_method_chain :reload_application, :dryml_generators
+          end
+        end
+      end
+      def self.run(generator_directories=nil, output_directory=nil)
+        @generator_directories ||= generator_directories
+        @output_directory ||= output_directory
+        @generator ||= DrymlGenerator.new(generator_directories || @generator_directories)
+        @generator.run
+      end
+      def initialize(generator_directories=nil)
+        @templates = {}
+        @digests   = {}
+        generator_directories ||= Dryml::DrymlGenerator.generator_directories
+        load_templates(generator_directories)
+      end
+      attr_accessor :subsite
+      def load_templates(generator_directories)
+        generator_directories.each do |dir|
+          Dir["#{dir}/**/*.dryml.erb"].each do |f|
+            name = f[dir.length + 1..-11]
+            erb = File.read(f)
+            @templates[name] = ERB.new(erb, nil, '-').src
+            # Create output directories and parents as required
+            [nil, *Hobo.subsites].each do |s|
+              FileUtils.mkdir_p(File.dirname("#{output_dir s}/#{name}"))
+            end
+          end
+        end
+      end
+      def run
+        # FIXME
+        # Ensure all view hints loaded before running
+        subsites = [nil]
+        if defined?(:Hobo)
+          Hobo::Model.all_models.*.view_hints
+          subsites += [*Hobo.subsites]
+        end
+        subsites.each { |s| run_for_subsite(s) }
+      end
+      def run_for_subsite(subsite)
+        self.subsite = subsite
+        @templates.each_pair do |name, src|
+          run_one(name, src)
+        end
+      end
+      def output_dir(s=subsite)
+        s ? "#{Dryml::DrymlGenerator.output_directory}/#{s}" : Dryml::DrymlGenerator.output_directory
+      end
+      def run_one(name, src)
+        dryml = instance_eval(src, name)
+        if dryml_changed?(name, dryml)
+          out = HEADER + dryml
+          File.open("#{output_dir}/#{name}.dryml", 'w') { |f| f.write(out) }
+        end
+      end
+      def dryml_changed?(name, dryml)
+        key = "#{subsite}/#{name}"
+        d = digest dryml
+        if d != @digests[key]
+          @digests[key] = d
+          true
+        else
+          false
+        end
+      end
+      def digest(s)
+        OpenSSL::Digest::SHA1.hexdigest(s)
+      end
+      # --- Helper methods for the templates --- #
+      attr_reader :controller
+      def controllers
+        Hobo::ModelController.all_controllers(subsite).sort_by &:name
+      end
+      def models
+        Hobo::Model.all_models.sort_by &:name
+      end
+      def each_controller
+        controllers.each do |controller|
+          @controller = controller
+          yield
+        end
+        @controller = nil
+      end
+      def each_model
+        models.each do |model|
+          @model = model
+          yield
+        end
+        @model = nil
+      end
+      def model
+        @model || @controller.model
+      end
+      def model_name(*options)
+        name = :plural.in?(options) ? model.view_hints.model_name_plural : model.view_hints.model_name
+        name = name.titleize.downcase                         if :lowercase.in?(options)
+        name = name.camelize                                  if :camel.in?(options)
+        name
+      end
+      # escape single quotes and backslashes for use in a single
+      # quoted string
+      def sq_escape(s)
+        s.gsub(/[\\]/, "\\\\\\\\").gsub(/'/, "\\\\'")
+      end
+      def model_class
+        model.name.underscore.gsub('_', '-').gsub('/', '--')
+      end
+      def view_hints
+        model.view_hints
+      end
+      def through_collection_names(klass=model)
+        klass.reflections.values.select do |refl|
+          refl.macro == :has_many && refl.options[:through]
+        end.map {|x| x.options[:through]}
+      end
+      def linkable?(*args)
+        options = args.extract_options!
+        options[:subsite] = subsite
+        klass, action = if args.length == 1
+                          [model, args.first]
+                        else
+                          args
+                        end
+        Hobo::ModelRouter.linkable?(klass, action, options)
+      end
+      def sortable_collection?(collection, model=self.model)
+        # There's no perfect way to detect for this, given that acts_as_list
+        # does not provide any metadata to reflect on, but if the :order
+        # option is the same as the target classes position_column, that's a
+        # pretty safe bet
+        if defined? ActiveRecord::Acts::List::InstanceMethods
+          refl = model.reflections[collection]
+          klass = refl.klass
+          klass < ActiveRecord::Acts::List::InstanceMethods &&
+            klass.new.position_column == refl.options[:order].to_s
+        end
+      end
+      def standard_fields(*args)
+        klass = args.first.is_a?(Class) ? args.shift : model
+        extras = args
+        fields = klass.attr_order.*.to_s & klass.content_columns.*.name
+        fields -= %w{created_at updated_at created_on updated_on deleted_at} unless extras.include?(:include_timestamps)
+        bt = extras.include?(:belongs_to)
+        hm = extras.include?(:has_many)
+        klass.reflections.values.sort_by { |refl| refl.name.to_s }.map do |refl|
+          fields << refl.name.to_s if bt && refl.macro == :belongs_to
+          fields << refl.name.to_s if hm && refl.macro == :has_many && refl.options[:accessible]
+        end
+        fields.reject! { |f| model.never_show? f }
+        fields
+      end
+      def creators
+        defined?(model::Lifecycle) ? model::Lifecycle.publishable_creators : []
+      end
+      def transitions
+        defined?(model::Lifecycle) ? model::Lifecycle.publishable_transitions : []
+      end
+      def creator_names
+        creators.map { |c| c.name.to_s }
+      end
+      def transition_names
+        transitions.map { |t| t.name.to_s }.uniq
+      end
+      def a_or_an(word)
+        (word =~ /^[aeiou]/i ? "an " : "a ") + word
+      end
+    end
+  end

data/lib/dryml/dryml_support_controller.rb ADDED Viewed

@@ -0,0 +1,13 @@
+class Dryml::DrymlSupportController < ActionController::Base
+  def edit_source
+    dryml_editor = ENV['DRYML_EDITOR']
+    if dryml_editor
+      file = File.join(RAILS_ROOT, params[:file])
+      command = dryml_editor.sub(":file", file).sub(":line", params[:line])
+      system(command)
+    end
+    render :nothing => true
+  end
+end