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

dryml 1.1.0.pre0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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