pakyow-presenter 0.8rc1 → 0.8.rc4

data/pakyow-presenter/lib/presenter/view.rb

@@ -1,23 +1,10 @@
 module Pakyow
   module Presenter
     class View
-      class << self
-        attr_accessor :binders, :default_view_path, :default_is_root_view
-
-        def view_store
-          Pakyow.app.presenter.current_view_lookup_store
-        end
-
-        def binder_for_scope(scope, bindable)
-          bindings = Pakyow.app.presenter.bindings(scope)
-          bindings.bindable = bindable
-          return bindings
-        end
+      include DocHelpers
 
-        def view_path(dvp, dirv=false)
-          self.default_view_path = dvp
-          self.default_is_root_view = dirv
-        end
+      class << self
+        attr_accessor :binders
 
         def self_closing_tag?(tag)
           %w[area base basefont br hr input img link meta].include? tag
@@ -30,68 +17,42 @@ module Pakyow
         def tag_without_value?(tag)
           %w[select].include? tag
         end
-
-        def at_path(view_path)
-          v = self.new(self.view_store.root_path(view_path), true)
-          v.compile(view_path)
-        end
-
-        def root_at_path(view_path)
-          self.new(self.view_store.root_path(view_path), true)
-        end
-
       end
 
-      attr_accessor :doc, :scoped_as, :scopes
+      attr_accessor :doc, :scoped_as, :scopes, :related_views
       attr_writer   :bindings
 
       def dup
-        v = self.class.new(@doc.dup)
-        v.scoped_as = self.scoped_as
-        v
-      end
-
-      def initialize(arg=nil, is_root_view=false)
-        arg = self.class.default_view_path if arg.nil? && self.class.default_view_path
-        is_root_view = self.class.default_is_root_view if arg.nil? && self.class.default_is_root_view
-
-        if arg.is_a?(Nokogiri::XML::Element) || arg.is_a?(Nokogiri::XML::Document) || arg.is_a?(Nokogiri::HTML::DocumentFragment)
-          @doc = arg
-        elsif arg.is_a?(Pakyow::Presenter::ViewCollection)
-          @doc = arg.first.doc.dup
-        elsif arg.is_a?(Pakyow::Presenter::View)
-          @doc = arg.doc.dup
-        elsif arg.is_a?(String)
-          view_path = self.class.view_store.real_path(arg)
-
-          # run parsers
-          format = StringUtils.split_at_last_dot(view_path)[1].to_sym
-          content = parse_content(File.read(view_path), format)
-          
-          if is_root_view then
-            @doc = Nokogiri::HTML::Document.parse(content)
-          else
-            @doc = Nokogiri::HTML.fragment(content)
-          end
+        view = self.class.from_doc(@doc.dup)
+        view.scoped_as = scoped_as
+        return view
+      end
+
+      def initialize(contents = '', format = :html)
+        @related_views = []
+
+        processed = Presenter.process(contents, format)
+
+        if processed.match(/<html.*>/)
+          @doc = Nokogiri::HTML::Document.parse(processed)
         else
-          raise ArgumentError, "No View for you! Come back, one year."
+          @doc = Nokogiri::HTML.fragment(processed)
         end
       end
 
-      def compile(view_path)
-        return unless view_info = self.class.view_store.view_info(view_path)
-        self.populate_view(self, view_info[:views])
+      def self.from_doc(doc)
+        view = self.new
+        view.doc = doc
+        return view
       end
 
-      def parse_content(content, format)
-        begin
-          Pakyow.app.presenter.parser_store[format].call(content)
-        rescue
-          Log.warn("No parser defined for extension #{format}") unless format.to_sym == :html
-          content
-        end
+      def self.load(path)
+        format    = StringUtils.split_at_last_dot(path)[-1]
+        contents  = File.read(path)
+
+        return self.new(contents, format)
       end
-      
+
       def title=(title)
         if @doc
           if o = @doc.css('title').first
@@ -108,104 +69,113 @@ module Pakyow
         o = @doc.css('title').first
         o.inner_html if o
       end
-      
-      def to_html(container = nil)
-        if container
-          if o = @doc.css("*[#{Configuration::Presenter.container_attribute}='#{container}']").first
-            o.inner_html
-          else
-            ''
-          end
-        else
-          @doc.to_html
-        end
-      end
-
-      alias :to_s :to_html
 
       # Allows multiple attributes to be set at once.
       # root_view.find(selector).attributes(:class => my_class, :style => my_style)
       #
-      def attributes(*args)
-        if args.empty?
-          return Attributes.new(self)
+      def attributes(attrs = {})
+        if attrs.empty?
+          return Attributes.new(self.doc)
         else
-          #TODO mass assign attributes (if we still want to do this)
-          #TODO use this instead of (or combine with) bind_attributes_to_doc?
+          self.bind_attributes_to_doc(attrs, doc)
         end
-
-        # if args.empty?
-        #   @previous_method = :attributes
-        #   return self
-        # else
-        #   args[0].each_pair { |name, value|
-        #     @previous_method = :attributes
-        #     self.send(name.to_sym, value)            
-        #   }
-        # end
       end
 
       alias :attrs :attributes
-      
+
       def remove
         self.doc.remove
+        self.refind_significant_nodes
       end
-      
+
       alias :delete :remove
-      
-      #TODO replace this with a different syntax (?): view.attributes.class.add/remove/has?(:foo)
-      # def add_class(val)
-      #   self.doc['class'] = "#{self.doc['class']} #{val}".strip
-      # end
-      
-      # def remove_class(val)
-      #   self.doc['class'] = self.doc['class'].gsub(val.to_s, '').strip if self.doc['class']
-      # end
-      
-      # def has_class(val)
-      #   self.doc['class'].include? val
-      # end
-      
+
       def clear
         return if self.doc.blank?
         self.doc.inner_html = ''
+        self.refind_significant_nodes
       end
-      
+
       def text
         self.doc.inner_text
       end
-      
-      def content
+
+      def text=(text)
+        text = text.call(self.text) if text.is_a?(Proc)
+        self.doc.content = text.to_s
+        self.refind_significant_nodes
+      end
+
+      def html
         self.doc.inner_html
       end
-      
-      alias :html :content
-      
-      def content=(content)
-        self.doc.inner_html = Nokogiri::HTML.fragment(content.to_s)
+
+      def html=(html)
+        html = html.call(self.html) if html.is_a?(Proc)
+        self.doc.inner_html = Nokogiri::HTML.fragment(html.to_s)
+        self.refind_significant_nodes
       end
-      
-      alias :html= :content=
-      
+
       def append(view)
+        doc  = view.doc
+        num  = doc.children.count
+        path = self.path_to(doc)
+
         self.doc.add_child(view.doc)
+
+        self.update_binding_offset_at_path(num, path)
+        self.refind_significant_nodes
+      end
+
+      def prepend(view)
+        doc  = view.doc
+        num  = doc.children.count
+        path = self.path_to(doc)
+
+        if first_child = self.doc.children.first
+          first_child.add_previous_sibling(doc)
+        else
+          self.doc = doc
+        end
+
+        self.update_binding_offset_at_path(num, path)
+        self.refind_significant_nodes
       end
-      
+
       def after(view)
+        doc  = view.doc
+        num  = doc.children.count
+        path = self.path_to(doc)
+
         self.doc.after(view.doc)
+
+        self.update_binding_offset_at_path(num, path)
+        self.refind_significant_nodes
       end
-      
+
       def before(view)
+        doc  = view.doc
+        num  = doc.children.count
+        path = self.path_to(doc)
+
         self.doc.before(view.doc)
+
+        self.update_binding_offset_at_path(num, path)
+        self.refind_significant_nodes
+      end
+
+      def replace(view)
+        doc.replace(view)
       end
-      
+
       def scope(name)
         name = name.to_sym
 
         views = ViewCollection.new
         self.bindings.select{|b| b[:scope] == name}.each{|s|
           v = self.view_from_path(s[:path])
-          v.bindings = self.bindings_for_child_view(v)
+
+          v.bindings = self.update_binding_paths_from_path([s].concat(s[:nested_bindings]), s[:path])
           v.scoped_as = s[:scope]
 
           views << v
@@ -213,21 +183,22 @@ module Pakyow
 
         views
       end
-      
+
       def prop(name)
         name = name.to_sym
 
         views = ViewCollection.new
-        self.bindings.each {|binding|
+
+        if binding = self.bindings.select{|binding| binding[:scope] == self.scoped_as}[0]
           binding[:props].each {|prop|
             if prop[:prop] == name
               v = self.view_from_path(prop[:path])
-              v.bindings = self.bindings_for_child_view(v)
 
+              v.scoped_as = self.scoped_as
               views << v
             end
           }
-        }
+        end
 
         views
       end
@@ -242,6 +213,7 @@ module Pakyow
       #
       def with
         yield(self)
+        self
       end
 
       # call-seq:
@@ -250,12 +222,13 @@ module Pakyow
       # Yields a view and its matching dataum. This is driven by the view,
       # meaning datums are yielded until no more views are available. For
       # the single View case, only one view/datum pair is yielded.
-      # 
+      #
       # (this is basically Bret's `map` function)
       #
       def for(data, &block)
-        data = [data] unless data.instance_of?(Array)
-        block.call(self, data[0])
+        data = data.to_a if data.is_a?(Enumerator)
+        data = [data] if (!data.is_a?(Enumerable) || data.is_a?(Hash))
+        block.call(self, data[0], 0) if block_given?
       end
 
       # call-seq:
@@ -266,16 +239,17 @@ module Pakyow
       # of self, where n = data.length.
       #
       def match(data)
-        data = [data] unless data.instance_of?(Array)
+        data = data.to_a if data.is_a?(Enumerator)
+        data = [data] if (!data.is_a?(Enumerable) || data.is_a?(Hash))
 
         views = ViewCollection.new
         data.each {|datum|
           d_v = self.doc.dup
           self.doc.before(d_v)
 
-          v = View.new(d_v)
-          v.bindings = self.bindings
-          #TODO set view scope
+          v = View.from_doc(d_v)
+          v.bindings = self.bindings.dup
+          v.scoped_as = self.scoped_as
 
           views << v
         }
@@ -298,14 +272,11 @@ module Pakyow
       #
       # Binds data across existing scopes.
       #
-      def bind(data, bindings = nil, &block)
-        scope = self.bindings.first
+      def bind(data, bindings = {}, &block)
+        scope_info = self.bindings.first
 
-        binder = View.binder_for_scope(scope[:scope], data)
-        binder.merge(bindings)
-        
-        self.bind_data_to_scope(data, scope, binder)
-        yield(self, data) if block_given?
+        self.bind_data_to_scope(data, scope_info, bindings)
+        yield(self, data, 0) if block_given?
       end
 
       # call-seq:
@@ -313,215 +284,191 @@ module Pakyow
       #
       # Matches self to data then binds data to the view.
       #
-      def apply(data, bindings = nil, &block)
+      def apply(data, bindings = {}, &block)
         views = self.match(data).bind(data, bindings, &block)
       end
 
-      def container(name)
-        matches = self.containers.select{|c| c[:name].to_sym == name.to_sym}
-
-        vs = ViewCollection.new
-        matches.each{|m| vs << view_from_path(m[:path])}
-        vs
-      end
-
-      def containers
-        @containers ||= self.find_containers
-      end
-
-      def bindings
-        @bindings ||= self.find_bindings
+      def bindings(refind = false)
+        @bindings = (!@bindings || refind) ? self.find_bindings : @bindings
       end
 
       protected
 
-      def add_content_to_container(content, container)
-        content = content.doc unless content.class == String || content.class == Nokogiri::HTML::DocumentFragment || content.class == Nokogiri::XML::Element
-        container.add_child(content)
-      end
-
-      def reset_container(container)
-        container.inner_html = ''
-      end
-
-
       # populates the root_view using view_store data by recursively building
       # and substituting in child views named in the structure
-      def populate_view(root_view, view_info)
+      def populate_view(root_view, view_store, view_info)
         root_view.containers.each {|e|
           next unless path = view_info[e[:name]]
-          
-          v = self.populate_view(View.new(path), view_info)
+
+          v = self.populate_view(View.new(path, view_store), view_store, view_info)
           self.reset_container(e[:doc])
           self.add_content_to_container(v, e[:doc])
         }
         root_view
       end
 
-      # returns an array of hashes, each with the container name and doc
-      def find_containers
-        elements = []
-        @doc.traverse {|e|
-          if name = e.attr(Configuration::Presenter.container_attribute)
-            elements << { :name => name, :doc => e, :path => path_to(e)}
-          end
-        }
-        elements
-      end
 
       # returns an array of hashes that describe each scope
-      def find_bindings
+      def find_bindings(doc = @doc, ignore_root = false)
         bindings = []
-        breadth_first(@doc) {|o|
-          next unless scope = o[Configuration::Presenter.scope_attribute]
-
-          # find props
-          props = []
-          breadth_first(o) {|so|
-            # don't go into deeper scopes
-            throw :reject if so != o && so[Configuration::Presenter.scope_attribute]
-
-            next unless prop = so[Configuration::Presenter.prop_attribute]
-            props << {:prop => prop.to_sym, :path => path_to(so)}
+        breadth_first(doc) {|o|
+          next if o == doc && ignore_root
+          next if !scope = o[Config::Presenter.scope_attribute]
+
+          bindings << {
+            :scope => scope.to_sym,
+            :path => path_to(o),
+            :props => find_props(o)
           }
 
-          bindings << {:scope => scope.to_sym, :path => path_to(o), :props => props}
+          if o == doc
+            # this is the root node, which we need as the first hash in the
+            # list of bindings, but we don't want to nest other scopes inside
+            # of it in this case
+            bindings.last[:nested_bindings] = {}
+          else
+            bindings.last[:nested_bindings] = find_bindings(o, true)
+            # reject so children aren't traversed
+            throw :reject
+          end
         }
 
-        # determine nestedness (currently unused; leaving in case needed)
-        # bindings.each {|b|
-        #   nested = []
-        #   bindings.each {|b2|
-        #     b_doc = doc_from_path(b[:path])
-        #     b2_doc = doc_from_path(b2[:path])
-        #     nested << b2 if b2_doc.ancestors.include? b_doc
-        #   }
-
-        #   b[:nested_scopes] = nested
-        # }
+        # find unscoped props
+        bindings.unshift({
+          :scope => nil,
+          :path => [],
+          :props => find_props(doc),
+          :nested_bindings => {}
+        })
+
         return bindings
       end
 
-      def bindings_for_child_view(child)
-        child_path = self.path_to(child.doc)
-        child_path_len = child_path.length
-        child_bindings = []
+      def find_props(o)
+        props = []
+        breadth_first(o) {|so|
+          # don't go into deeper scopes
+          throw :reject if so != o && so[Config::Presenter.scope_attribute]
 
-        self.bindings.each {|binding|
-          # we want paths within the child path
-          if (child_path - binding[:path]).empty?
-            # update paths relative to child
-            dup = Marshal.load(Marshal.dump(binding))
-            
-            [dup].concat(dup[:props]).each{|p|
-              p[:path] = p[:path][child_path_len..-1]
-            }
-
-            child_bindings << dup
-          end
+          next unless prop = so[Config::Presenter.prop_attribute]
+          props << {:prop => prop.to_sym, :path => path_to(so)}
         }
 
-        child_bindings
-      end
-
-      def breadth_first(doc)
-        queue = [doc]
-        until queue.empty?
-          node = queue.shift
-          catch(:reject) {
-            yield node
-            queue.concat(node.children)
-          }
-        end
+        return props
       end
 
-      def path_to(child)
-        path = []
+      # returns a new binding set that takes into account the starting point of `path`
+      def update_binding_paths_from_path(bindings, path)
+        return bindings.collect { |binding|
+          dup_binding = binding.dup
+          dup_binding[:path] = dup_binding[:path][path.length..-1] || []
 
-        return path if child == @doc
+          dup_binding[:props] = dup_binding[:props].collect {|prop|
+            dup_prop = prop.dup
+            dup_prop[:path] = dup_prop[:path][path.length..-1]
+            dup_prop
+          }
 
-        child.ancestors.each {|a|
-          # since ancestors goes all the way to doc root, stop when we get to the level of @doc
-          break if a.children.include?(@doc)
+          dup_binding[:nested_bindings] = update_binding_paths_from_path(dup_binding[:nested_bindings], path)
 
-          path.unshift(a.children.index(child))
-          child = a
+          dup_binding
         }
-
-        return path
       end
 
-      def doc_from_path(path)
-        o = @doc
+      def update_binding_offset_at_path(offset, path)
+        # update binding paths for bindings we're iterating on
+        self.bindings.each {|binding|
+          next unless self.path_within_path?(binding[:path], path)
 
-        # if path is empty we're at self
-        return o if path.empty?
+          binding[:path][0] += offset if binding[:path][0]
 
-        path.each {|i|
-          if child = o.children[i]
-            o = child
-          else
-            break
-          end
+          binding[:props].each { |prop|
+            prop[:path][0] += offset if prop[:path][0]
+          }
         }
-
-        return o
       end
 
-      def view_from_path(path)
-        View.new(doc_from_path(path))
+      def refind_significant_nodes
+        self.bindings(true)
+
+        @related_views.each {|v|
+          v.refind_significant_nodes
+        }
       end
 
-      def bind_data_to_scope(data, scope, binder = nil)
+      def bind_data_to_scope(data, scope_info, bindings = {})
         return unless data
 
+        scope = scope_info[:scope]
+
         # handle root binding
-        if binder && v = binder.value_for_prop(:_root)
-          v.is_a?(Hash) ? self.bind_attributes_to_doc(v, self.doc) : self.bind_value_to_doc(v, self.doc)
+        if value = Pakyow.app.presenter.binder.value_for_prop(:_root, scope, data, bindings)
+          value.is_a?(Hash) ? self.bind_attributes_to_doc(value, self.doc) : self.bind_value_to_doc(value, self.doc)
         end
 
-        scope[:props].each {|p|
-          k = p[:prop]
-          v = binder ? binder.value_for_prop(k) : data[k]
+        scope_info[:props].each {|prop_info|
+          catch(:unbound) {
+            prop = prop_info[:prop]
+
+            self.handle_unbound_data(scope, prop) unless data_has_prop?(data, prop) || Pakyow.app.presenter.binder.has_prop?(prop, scope, bindings)
+            value = Pakyow.app.presenter.binder.value_for_prop(prop, scope, data, bindings)
 
-          doc = doc_from_path(p[:path])
+            doc = doc_from_path(prop_info[:path])
 
-          # handle form field
-          self.bind_to_form_field(doc, scope, k, v, binder) if View.form_field?(doc.name)
+            # handle form field
+            self.bind_to_form_field(doc, scope, prop, value, data) if View.form_field?(doc.name)
 
-          # bind attributes or value
-          v.is_a?(Hash) ? self.bind_attributes_to_doc(v, doc) : self.bind_value_to_doc(v, doc)
+            # bind attributes or value
+            value.is_a?(Hash) ? self.bind_attributes_to_doc(value, doc) : self.bind_value_to_doc(value, doc)
+          }
         }
       end
 
+      def data_has_prop?(data, prop)
+        (data.is_a?(Hash) && (data.key?(prop) || data.key?(prop.to_s))) || (!data.is_a?(Hash) && data.class.method_defined?(prop))
+      end
+
       def bind_value_to_doc(value, doc)
-        return unless value
+        value = String(value)
 
         tag = doc.name
         return if View.tag_without_value?(tag)
-        View.self_closing_tag?(tag) ? doc['value'] = value : doc.inner_html = value
+        if View.self_closing_tag?(tag)
+          # don't override value if set
+          if !doc['value'] || doc['value'].empty?
+            doc['value'] = value
+          end
+        else
+          doc.inner_html = value
+        end
       end
 
       def bind_attributes_to_doc(attrs, doc)
         attrs.each do |attr, v|
-          if attr == :content
+          case attr
+          when :content
             v = v.call(doc.inner_html) if v.is_a?(Proc)
             bind_value_to_doc(v, doc)
             next
+          when :view
+            v.call(self)
+            next
           end
 
           attr = attr.to_s
-          v = v.call(doc[attr]) if v.is_a?(Proc)
-          v.nil? ? doc.remove_attribute(attr) : doc[attr] = v.to_s
+          attrs = Attributes.new(doc)
+          v = v.call(attrs.send(attr)) if v.is_a?(Proc)
+          v.nil? ? doc.remove_attribute(attr) : attrs.send(:"#{attr}=", v)
         end
       end
 
-      #TODO refactor to use new options_for
-      def bind_to_form_field(doc, scope, prop, value, binder)
-        return unless !doc['name'] || doc['name'].empty?
-        
-        # set name on form element
-        doc['name'] = "#{scope[:scope]}[#{prop}]"
+      def bind_to_form_field(doc, scope, prop, value, bindable)
+
+        # don't overwrite the name if already defined
+        if !doc['name'] || doc['name'].empty?
+          # set name on form element
+          doc['name'] = "#{scope}[#{prop}]"
+        end
 
         # special binding for checkboxes and radio buttons
         if doc.name == 'input' && (doc[:type] == 'checkbox' || doc[:type] == 'radio')
@@ -531,50 +478,58 @@ module Pakyow
             doc.delete('checked')
           end
 
-          # coerce to string since booleans are often used 
+          # coerce to string since booleans are often used
           # and fail when binding to a view
           value = value.to_s
         # special binding for selects
-        elsif doc.name == 'select' && binder && options = binder.options_for_prop(prop)
-          option_nodes = Nokogiri::HTML::DocumentFragment.parse ""
-          Nokogiri::HTML::Builder.with(option_nodes) do |h|
-            until options.length == 0
-              catch :optgroup do
-                options.each_with_index { |o,i|
+        elsif doc.name == 'select'
+          if options = Pakyow.app.presenter.binder.options_for_prop(prop, scope, bindable)
+            option_nodes = Nokogiri::HTML::DocumentFragment.parse ""
+            Nokogiri::HTML::Builder.with(option_nodes) do |h|
+              until options.length == 0
+                catch :optgroup do
+                  o = options.first
 
                   # an array containing value/content
                   if o.is_a?(Array)
                     h.option o[1], :value => o[0]
-                    options.delete_at(i)
+                    options.shift
                   # likely an object (e.g. string); start a group
                   else
                     h.optgroup(:label => o) {
-                      options.delete_at(i)
+                      options.shift
 
-                      options[i..-1].each_with_index { |o2,i2|
+                      options[0..-1].each_with_index { |o2,i2|
                         # starting a new group
                         throw :optgroup if !o2.is_a?(Array)
 
                         h.option o2[1], :value => o2[0]
-                        options.delete_at(i)
+                        options.shift
                       }
                     }
                   end
-
-                }
+                end
               end
-            end                    
-          end
+            end
 
-          doc.add_child(option_nodes)
-        end
+            # remove existing options
+            doc.children.remove
 
-        # select appropriate option
-        if o = doc.css('option[value="' + value.to_s + '"]').first
-          o[:selected] = 'selected'
+            # add generated options
+            doc.add_child(option_nodes)
+          end
+
+          # select appropriate option
+          if o = doc.css('option[value="' + value.to_s + '"]').first
+            o[:selected] = 'selected'
+          end
         end
       end
 
+      def handle_unbound_data(scope, prop)
+        Pakyow.logger.warn("Unbound data for #{scope}[#{prop}]")
+        throw :unbound
+      end
     end
   end
 end