hobo 1.0.3 → 1.1.0.pre0

data/lib/hobo/dryml/dryml_generator.rb

@@ -1,263 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'set'
-require 'fileutils'
-
-require 'action_controller/dispatcher'
-
-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"
-      
-      class << self
-        attr_accessor :run_on_every_request
-      end
-      
-      def self.enable
-        
-        # 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 Hobo::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 Hobo::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 ||= 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
-        # Ensure all view hints loaded before running
-        Hobo::Model.all_models.*.view_hints
-        
-        [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::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
-  
-end

data/lib/hobo/dryml/dryml_support_controller.rb

@@ -1,13 +0,0 @@
-class Hobo::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

data/lib/hobo/dryml/parser.rb

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

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

@@ -1,41 +0,0 @@
-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
-      else
-        element.document.default_attribute_value
-      end
-    end
-
-    def to_string
-      if has_rhs?
-        super
-      else
-        @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/lib/hobo/dryml/parser/base_parser.rb

@@ -1,254 +0,0 @@
-module Hobo::Dryml::Parser
-
-  class BaseParser < REXML::Parsers::BaseParser
-
-    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
-                              else
-                                /\s*(#{NAME_STR})(?:\s*=\s*(["'])(.*?)\2)?/um
-                              end
-    DRYML_TAG_MATCH         = if NEW_REX
-                                /^<((?>#{DRYML_NAME_STR}))\s*((?>\s+#{NAME_STR}(?:\s*=\s*(["']).*?\5)?)*)\s*(\/)?>/um
-                              else
-                                /^<((?>#{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
-
-    def pull
-      if @closed
-        x, @closed = @closed, nil
-        return [ :end_element, x, false ]
-      end
-      return [ :end_document ] if empty?
-      return @stack.shift if @stack.size > 0
-      #STDERR.puts @source.encoding
-      @source.read if @source.buffer.size<2
-      #STDERR.puts "BUFFER = #{@source.buffer.inspect}"
-      if @document_status == nil
-        #@source.consume( /^\s*/um )
-        word = @source.match( /^((?:\s+)|(?:<[^>]*>))/um ) #word = @source.match(/(<[^>]*)>/um)
-        word = word[1] unless word.nil?
-        #STDERR.puts "WORD = #{word.inspect}"
-        case word
-        when COMMENT_START
-          return [ :comment, @source.match( COMMENT_PATTERN, true )[1] ]
-        when XMLDECL_START
-          #STDERR.puts "XMLDECL"
-          results = @source.match( XMLDECL_PATTERN, true )[1]
-          version = VERSION.match( results )
-          version = version[1] unless version.nil?
-          encoding = ENCODING.match(results)
-          encoding = encoding[1] unless encoding.nil?
-          @source.encoding = encoding
-          standalone = STANDALONE.match(results)
-          standalone = standalone[1] unless standalone.nil?
-          return [ :xmldecl, version, encoding, standalone ]
-        when INSTRUCTION_START
-          return [ :processing_instruction, *@source.match(INSTRUCTION_PATTERN, true)[1,2] ]
-        when DOCTYPE_START
-          md = @source.match( DOCTYPE_PATTERN, true )
-          #@nsstack.unshift(curr_ns=Set.new)
-          identity = md[1]
-          close = md[2]
-          identity =~ IDENTITY
-          name = $1
-          raise REXML::ParseException.new("DOCTYPE is missing a name") if name.nil?
-          pub_sys = $2.nil? ? nil : $2.strip
-          long_name = $4.nil? ? nil : $4.strip
-          uri = $6.nil? ? nil : $6.strip
-          args = [ :start_doctype, name, pub_sys, long_name, uri ]
-          if close == ">"
-            @document_status = :after_doctype
-            @source.read if @source.buffer.size<2
-            md = @source.match(/^\s*/um, true)
-            @stack << [ :end_doctype ]
-          else
-            @document_status = :in_doctype
-          end
-          return args
-        when /^\s+/
-        else
-          @document_status = :after_doctype
-          @source.read if @source.buffer.size<2
-          md = @source.match(/\s*/um, true)
-          if @source.encoding == "UTF-8"
-            if @source.buffer.respond_to? :force_encoding
-              @source.buffer.force_encoding(Encoding::UTF_8)
-            end
-          end
-        end
-      end
-      if @document_status == :in_doctype
-        md = @source.match(/\s*(.*?>)/um)
-        case md[1]
-        when SYSTEMENTITY
-          match = @source.match( SYSTEMENTITY, true )[1]
-          return [ :externalentity, match ]
-
-        when ELEMENTDECL_START
-          return [ :elementdecl, @source.match( ELEMENTDECL_PATTERN, true )[1] ]
-
-        when ENTITY_START
-          match = @source.match( ENTITYDECL, true ).to_a.compact
-          match[0] = :entitydecl
-          ref = false
-          if match[1] == '%'
-            ref = true
-            match.delete_at 1
-          end
-          # Now we have to sort out what kind of entity reference this is
-          if match[2] == 'SYSTEM'
-            # External reference
-            match[3] = match[3][1..-2] # PUBID
-            match.delete_at(4) if match.size > 4 # Chop out NDATA decl
-            # match is [ :entity, name, SYSTEM, pubid(, ndata)? ]
-          elsif match[2] == 'PUBLIC'
-            # External reference
-            match[3] = match[3][1..-2] # PUBID
-            match[4] = match[4][1..-2] # HREF
-            # match is [ :entity, name, PUBLIC, pubid, href ]
-          else
-            match[2] = match[2][1..-2]
-            match.pop if match.size == 4
-            # match is [ :entity, name, value ]
-          end
-          match << '%' if ref
-          return match
-        when ATTLISTDECL_START
-          md = @source.match( ATTLISTDECL_PATTERN, true )
-          raise REXML::ParseException.new( "Bad ATTLIST declaration!", @source ) if md.nil?
-          element = md[1]
-          contents = md[0]
-
-          pairs = {}
-          values = md[0].scan( ATTDEF_RE )
-          values.each do |attdef|
-            unless attdef[3] == "#IMPLIED"
-              attdef.compact!
-              val = attdef[3]
-              val = attdef[4] if val == "#FIXED "
-              pairs[attdef[0]] = val
-              if attdef[0] =~ /^xmlns:(.*)/
-                #@nsstack[0] << $1
-              end
-            end
-          end
-          return [ :attlistdecl, element, pairs, contents ]
-        when NOTATIONDECL_START
-          md = nil
-          if @source.match( PUBLIC )
-            md = @source.match( PUBLIC, true )
-            vals = [md[1],md[2],md[4],md[6]]
-          elsif @source.match( SYSTEM )
-            md = @source.match( SYSTEM, true )
-            vals = [md[1],md[2],nil,md[4]]
-          else
-            raise REXML::ParseException.new( "error parsing notation: no matching pattern", @source )
-          end
-          return [ :notationdecl, *vals ]
-        when CDATA_END
-          @document_status = :after_doctype
-          @source.match( CDATA_END, true )
-          return [ :end_doctype ]
-        end
-      end
-      begin
-        if @source.buffer[0] == ?<
-          if @source.buffer[1] == ?/
-            #@nsstack.shift
-            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])}(:.*)?$/
-            raise REXML::ParseException.new( "Missing end tag for "+
-                                             "'#{last_tag}' (line #{line_no}) (got \"#{md[1]}\")",
-                                             @source) unless valid_end_tag
-            return [ :end_element, last_tag, true ]
-          elsif @source.buffer[1] == ?!
-            md = @source.match(/\A(\s*[^>]*>)/um)
-            #STDERR.puts "SOURCE BUFFER = #{source.buffer}, #{source.buffer.size}"
-            raise REXML::ParseException.new("Malformed node", @source) unless md
-            if md[0][2] == ?-
-              md = @source.match( COMMENT_PATTERN, true )
-
-              case md[1]
-              when /--/, /-$/
-                raise REXML::ParseException.new("Malformed comment", @source)
-              end
-
-              return [ :comment, md[1] ] if md
-            else
-              md = @source.match( CDATA_PATTERN, true )
-              return [ :cdata, md[1] ] if md
-            end
-            raise REXML::ParseException.new( "Declarations can only occur "+
-                                             "in the doctype declaration.", @source)
-          elsif @source.buffer[1] == ??
-            md = @source.match( INSTRUCTION_PATTERN, true )
-            return [ :processing_instruction, md[1], md[2] ] if md
-            raise REXML::ParseException.new( "Bad instruction declaration",
-                                             @source)
-          else
-            # Get the next tag
-            md = @source.match(DRYML_TAG_MATCH, true)
-            unless md
-              # 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)
-
-            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|
-                val = NEW_REX ? e : c
-                if attributes.has_key? a
-                  msg = "Duplicate attribute #{a.inspect}"
-                  raise REXML::ParseException.new( msg, @source, self)
-                end
-                attributes[a] = val || true
-              }
-            end
-
-            if md[NEW_REX ? 6 : 4]
-              @closed = md[1]
-              #@nsstack.shift
-            else
-              cl = @source.current_line
-              @tags.push( [md[1], cl && cl[2]] )
-            end
-            return [ :start_element, md[1], attributes, md[0],
-                     @source.respond_to?(:last_match_offset) && @source.last_match_offset ]
-          end
-        else
-          md = @source.match( TEXT_PATTERN, true )
-          if md[0].length == 0
-            @source.match( /(\s+)/, true )
-          end
-          #STDERR.puts "GOT #{md[1].inspect}" unless md[0].length == 0
-          #return [ :text, "" ] if md[0].length == 0
-          # unnormalized = Text::unnormalize( md[1], self )
-          # return PullEvent.new( :text, md[1], unnormalized )
-          return [ :text, md[1] ]
-        end
-      rescue REXML::ParseException
-        raise
-      rescue Exception, NameError => error
-        raise REXML::ParseException.new( "Exception parsing",
-                                         @source, self, (error ? error : $!) )
-      end
-      return [ :dummy ]
-    end
-  end
-
-end