hobo 0.7.5 → 0.8

data/lib/hobo/dryml/dryml_generator.rb

@@ -0,0 +1,210 @@
+require 'set'
+require 'fileutils'
+
+module Hobo
+  
+  module Dryml
+    
+    class DrymlGenerator
+      
+      TEMPLATES = "#{HOBO_ROOT}/dryml_generators"
+      OUTPUT    = "#{RAILS_ROOT}/app/views/taglibs/auto"
+      
+      HEADER = "<!-- AUTOMATICALLY GENERATED FILE - DO NOT EDIT -->\n\n"
+      
+      def self.run
+        @generator ||= DrymlGenerator.new
+        @generator.run
+      end
+      
+      
+      def initialize
+        @templates = {}
+        @digests   = {}
+        load_templates
+      end
+      
+      attr_accessor :subsite
+      
+      
+      def load_templates
+        Dir["#{TEMPLATES}/**/*.dryml.erb"].each do |f|
+          name = f[TEMPLATES.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
+      
+      
+      def run
+        [nil, *Hobo.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 ? "#{OUTPUT}/#{s}" : OUTPUT
+      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::Digest.digest('sha1', 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 = model.name
+        name = name.pluralize                                 if :plural.in?(options)
+        name = name.titleize                                  if :title.in?(options)
+        name = name.titleize.downcase                         if :lowercase.in?(options)
+        name = name.underscore.gsub('_', '-').gsub('/', '--') if :dashed.in?(options)
+        name
+      end
+      
+      
+      def model_class
+        model_name(:dashed)
+      end
+
+      
+      def primary_collection_name(klass=model)
+        dependent_collection_names = klass.reflections.values.select do |refl|
+          refl.macro == :has_many && refl.options[:dependent]
+        end.*.name
+
+        (dependent_collection_names - through_collection_names(klass)).first
+      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
+        end
+
+        fields.reject! { |f| model.never_show? f }
+        fields
+      end
+      
+      
+      def a_or_an(word)
+        (word =~ /^[aeiou]/i ? "an " : "a ") + word
+      end
+            
+    end
+    
+  end
+  
+end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/dryml_support_controller.rb

@@ -1,5 +1,5 @@
 class Hobo::Dryml::DrymlSupportController < ActionController::Base
-  
+
   def edit_source
     dryml_editor = ENV['DRYML_EDITOR']
     if dryml_editor

data/lib/hobo/dryml/parser.rb

@@ -0,0 +1,3 @@
+module Hobo::Dryml::Parser
+
+end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/parser/attribute.rb

@@ -1,14 +1,14 @@
 module Hobo::Dryml::Parser
-  
+
   class Attribute < REXML::Attribute
-    
+
     def initialize(first, second=nil, parent=nil)
       super
       if first.is_a?(String) && second == true
         @value = true
       end
     end
-    
+
     def value
       if has_rhs?
         super
@@ -24,18 +24,18 @@ module Hobo::Dryml::Parser
         @expanded_name
       end
     end
-    
+
     def has_rhs?
       @value != true
     end
 
-    
+
     # Override to supress Text.check call
     def element=( element )
       @element = element
       self
     end
-    
+
   end
 
 end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/parser/base_parser.rb

@@ -1,9 +1,9 @@
 module Hobo::Dryml::Parser
-  
+
   class BaseParser < REXML::Parsers::BaseParser
-    
-    NEW_REX = REXML::VERSION =~ /3\.1\.(\d)(?:\.(\d))?/ && $1.to_i*1000 + $2.to_i >= 7002
-    
+
+    NEW_REX = defined?(REXML::VERSION) && REXML::VERSION =~ /3\.1\.(\d)(?:\.(\d))?/ && $1.to_i*1000 + $2.to_i >= 7002
+
     DRYML_NAME_STR          = "#{NCNAME_STR}(?::(?:#{NCNAME_STR})?)?"
     DRYML_ATTRIBUTE_PATTERN = if NEW_REX
                                 /\s*(#{NAME_STR})(?:\s*=\s*(["'])(.*?)\4)?/um
@@ -16,10 +16,10 @@ module Hobo::Dryml::Parser
                                 /^<((?>#{DRYML_NAME_STR}))\s*((?>\s+#{NAME_STR}(?:\s*=\s*(["']).*?\3)?)*)\s*(\/)?>/um
                               end
     DRYML_CLOSE_MATCH       = /^\s*<\/(#{DRYML_NAME_STR})\s*>/um
-    
+
     # For compatibility with REXML 3.1.7.3
-    IDENTITY = /^([!\*\w\-]+)(\s+#{NCNAME_STR})?(\s+["'](.*?)['"])?(\s+['"](.*?)["'])?/u 
-    
+    IDENTITY = /^([!\*\w\-]+)(\s+#{NCNAME_STR})?(\s+["'](.*?)['"])?(\s+['"](.*?)["'])?/u
+
     def pull
       if @closed
         x, @closed = @closed, nil
@@ -87,7 +87,7 @@ module Hobo::Dryml::Parser
       if @document_status == :in_doctype
         md = @source.match(/\s*(.*?>)/um)
         case md[1]
-        when SYSTEMENTITY 
+        when SYSTEMENTITY
           match = @source.match( SYSTEMENTITY, true )[1]
           return [ :externalentity, match ]
 
@@ -165,10 +165,10 @@ module Hobo::Dryml::Parser
             last_tag, line_no = @tags.pop
             #md = @source.match_to_consume( '>', CLOSE_MATCH)
             md = @source.match(DRYML_CLOSE_MATCH, true)
-            
-            valid_end_tag = last_tag =~ /^#{Regexp.escape(md[1])}(:.*)?/
+
+            valid_end_tag = last_tag =~ /^#{Regexp.escape(md[1])}(:.*)?$/
             raise REXML::ParseException.new( "Missing end tag for "+
-                                             "'#{last_tag}' (line #{line_no}) (got \"#{md[1]}\")", 
+                                             "'#{last_tag}' (line #{line_no}) (got \"#{md[1]}\")",
                                              @source) unless valid_end_tag
             return [ :end_element, last_tag, true ]
           elsif @source.buffer[1] == ?!
@@ -202,15 +202,15 @@ module Hobo::Dryml::Parser
               # Check for missing attribute quotes
               raise REXML::ParseException.new("missing attribute quote", @source) if
                 defined?(MISSING_ATTRIBUTE_QUOTES) && @source.match(MISSING_ATTRIBUTE_QUOTES)
-              raise REXML::ParseException.new("malformed XML: missing tag start", @source) 
-              
+              raise REXML::ParseException.new("malformed XML: missing tag start", @source)
+
             end
             attributes = {}
             #@nsstack.unshift(curr_ns=Set.new)
             if md[2].size > 0
               attrs = md[2].scan(DRYML_ATTRIBUTE_PATTERN)
               raise REXML::ParseException.new( "error parsing attributes: [#{attrs.join ', '}], excess = \"#$'\"", @source) if $' and $'.strip.size > 0
-              attrs.each { |a,b,c,d,e| 
+              attrs.each { |a,b,c,d,e|
                 val = NEW_REX ? e : c
                 if attributes.has_key? a
                   msg = "Duplicate attribute #{a.inspect}"
@@ -219,7 +219,7 @@ module Hobo::Dryml::Parser
                 attributes[a] = val || true
               }
             end
-            
+
             if md[NEW_REX ? 6 : 4]
               @closed = md[1]
               #@nsstack.shift
@@ -250,5 +250,5 @@ module Hobo::Dryml::Parser
       return [ :dummy ]
     end
   end
-  
+
 end

data/lib/hobo/dryml/parser/document.rb

@@ -0,0 +1,57 @@
+module Hobo::Dryml
+
+  module Parser
+
+    class Document < REXML::Document
+
+      def initialize(source, path)
+        super(nil)
+
+        # Replace <%...%> scriptlets with xml-safe references into a hash of scriptlets
+        @scriptlets = {}
+        source = source.gsub(/<%(.*?)%>/m) do
+          _, scriptlet = *Regexp.last_match
+          id = @scriptlets.size + 1
+          @scriptlets[id] = scriptlet
+          newlines = "\n" * scriptlet.count("\n")
+          "[![DRYML-ERB#{id}#{newlines}]!]"
+        end
+
+
+        @reference_src = "<dryml_page>" + source + "</dryml_page>"
+        rex_src = Hobo::Dryml::Parser::Source.new(@reference_src)
+
+        @elements = Hobo::Dryml::Parser::Elements.new(self)
+        build(rex_src)
+
+      rescue REXML::ParseException => e
+        raise Hobo::Dryml::DrymlSyntaxError, "File: #{path}\n#{e}"
+      end
+
+
+      def element_line_num(el)
+        offset = el.source_offset
+        @reference_src[0..offset].count("\n") + 1
+      end
+
+
+      def default_attribute_value
+        "&true"
+      end
+
+
+      def restore_erb_scriptlets(src)
+        src.gsub(/\[!\[DRYML-ERB(\d+)\s*\]!\]/m) {|s| "<%#{@scriptlets[$1.to_i]}%>" }
+      end
+
+
+      private
+      def build( source )
+        Hobo::Dryml::Parser::TreeParser.new( source, self ).parse
+      end
+
+    end
+
+  end
+
+end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/parser/element.rb

@@ -1,27 +1,27 @@
 module Hobo::Dryml::Parser
 
   class Element < REXML::Element
-    
+
     def initialize(*args)
       super
       @elements = Hobo::Dryml::Parser::Elements.new(self)
     end
-    
+
     def dryml_name
       expanded_name.sub(/:.*/, "")
     end
-    
+
     attr_accessor :start_tag_source, :source_offset
-    
+
     attr_writer :has_end_tag
     def has_end_tag?
       @has_end_tag
     end
-    
+
     def parameter_tag?
       expanded_name =~ /:$/
     end
-    
+
   end
-  
+
 end

data/{hobo_files/plugin/lib → lib}/hobo/dryml/parser/elements.rb

@@ -1,31 +1,31 @@
 module Hobo::Dryml::Parser
 
   class Element < REXML::Element
-    
+
     def initialize(*args)
       super
       @elements = Hobo::Dryml::Parser::Elements.new(self)
     end
-    
+
     def dryml_name
       expanded_name.sub(/:.*/, "")
     end
-    
+
     attr_accessor :start_tag_source, :source_offset
-    
+
     attr_writer :has_end_tag
     def has_end_tag?
       @has_end_tag
     end
-    
+
     def parameter_tag?
       expanded_name =~ /:$/
     end
-    
+
   end
-  
+
   class Elements < REXML::Elements
-    
+
     # Override to ensure DRYML elements are created
     def add(element=nil)
       rv = nil
@@ -39,7 +39,7 @@ module Hobo::Dryml::Parser
         element
       end
     end
-    
+
   end
 
 end