pakyow-presenter 0.8rc1 → 0.8.rc4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bf40bbef34bd10129e0986f8009446fe4c9c427a
+  data.tar.gz: afa46cf16a50b2277a1e901d8e021ed8ef7865ce
+SHA512:
+  metadata.gz: 044a33ab081707cd3ac31e43185a7f1f7cfb742f25fd74862fe8b8ce31a4f5fed1749eed120ffac43fd962c0350ff62efe80410e20325c853ec5873a2a5121fb
+  data.tar.gz: 457ca686a0b5ed1cb98aaaf6cd10406143a42eb6fb12996e32d9fe2301297e2817c267bd8de7d9015978880474560dbdcc49c23899a2830be20038fe94a26575

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

@@ -9,5 +9,6 @@ require 'presenter/base'
 include Presenter
 
 require 'presenter/presenter'
-require 'presenter/configuration/base'
+require 'presenter/config/presenter'
 require 'presenter/helpers'
+require 'presenter/ext/app'

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

@@ -1,13 +1,111 @@
 module Pakyow
   module Presenter
-    class Attributes
+    class Attribute
       @@types = {
-        :boolean  => [:selected, :checked, :disabled, :readonly, :multiple],
-        :multiple => [:class]
+        :hash => [:style],
+        :bool => [:selected, :checked, :disabled, :readonly, :multiple],
+        :mult => [:class]
       }
 
-      def initialize(view)
-        @view = view
+      def initialize(name, raw_value, control, doc)
+        @type = type_of_attribute(name)
+        @name = name
+        @value = deconstruct_attribute_value_of_type(raw_value, @type)
+        @control = control
+        @doc = doc
+      end
+
+      def set(value)
+        value = Array(value) if @type == :mult && !value.is_a?(Proc)
+        @value = value
+        update_value
+      end
+
+      # ensures that the value passed is contained in `value`
+      def ensure(value)
+        case @type
+        when :mult
+          @value << value unless @value.include?(value)
+        when :bool
+          @value = value
+        else
+          @value << value if @value.nil? || !@value.match(value)
+        end
+
+        update_value
+      end
+
+      # passes method call to `value`
+      def method_missing(method, *args)
+        ret = @value.send(method, *args)
+        update_value
+
+        return ret
+      end
+
+      # returns the full string value
+      def to_s
+        value = @value
+        value = value.call(deconstruct_attribute_value_of_type(@doc[@name], @type)) if value.is_a? Proc
+        value = construct_attribute_value_of_type(value, @type, @name)
+
+        return value
+      end
+
+      def value
+        @value
+      end
+
+      private
+
+      def update_value
+        updated_value = to_s
+
+        if updated_value.nil?
+          @control.remove_attribute(@name)
+        else
+          @control.update_value_for_attribute(@name, updated_value)
+        end
+      end
+
+      def type_of_attribute(attribute)
+        attribute = attribute.to_sym
+
+        return :bool  if @@types[:bool].include?(attribute)
+        return :mult if @@types[:mult].include?(attribute)
+        return :hash     if @@types[:hash].include?(attribute)
+        return :single
+      end
+
+      def deconstruct_attribute_value_of_type(value, type)
+        return value ? value : ''             if type == :single
+        return value ? value.split(' ') : []  if type == :mult
+        return !value.nil?                    if type == :bool
+        return value_to_hash(value)           if type == :hash
+      end
+
+      def construct_attribute_value_of_type(value, type, attribute)
+        return value if type == :single
+        return value.join(' ') if type == :mult
+        return value ? attribute : nil if type == :bool
+        return value.to_a.map {|a| a.join(':')}.join(';') if type == :hash
+      end
+
+      def value_to_hash(value)
+        return {} if value.nil?
+
+        value.split(';').inject({}) {|h, style|
+          k,v = style.split(':')
+          h[k.to_sym] = v
+          h
+        }
+      end
+    end
+
+    class Attributes
+      def initialize(doc)
+        @doc = doc
+        @attributes = {}
       end
 
       def method_missing(method, *args)
@@ -31,45 +129,30 @@ module Pakyow
         method_missing(:id, *args)
       end
 
-      protected
-
-      def set_attribute(attribute, value)
-        type = self.type_of_attribute(attribute)
-
-        value = value.call(self.deconstruct_attribute_value_of_type(@view.doc[attribute], type)) if value.is_a? Proc
-        value = construct_attribute_value_of_type(value, type, attribute)
-        
-        if value.nil?
-          @view.doc.remove_attribute(attribute)
+      def update_value_for_attribute(attribute, value)
+        if !@doc.is_a?(Nokogiri::XML::Element) && @doc.children.count == 1
+          @doc.children.first[attribute] = value
         else
-          @view.doc[attribute] = value
+          @doc[attribute] = value
         end
       end
 
-      def get_attribute(attribute)
-        self.deconstruct_attribute_value_of_type(@view.doc[attribute], self.type_of_attribute(attribute))
+      def remove_attribute(attribute)
+        @doc.remove_attribute(attribute)
       end
 
-      def type_of_attribute(attribute)
-        attribute = attribute.to_sym
-
-        return :boolean  if @@types[:boolean].include?(attribute)
-        return :multiple if @@types[:multiple].include?(attribute)
-        return :single
-      end
+      protected
 
-      def deconstruct_attribute_value_of_type(value, type)
-        return value                          if type == :single
-        return value ? value.split(' ') : []  if type == :multiple
-        return !value.nil?                    if type == :boolean
+      def set_attribute(attribute, value)
+        get_attribute(attribute).set(value)
       end
 
-      def construct_attribute_value_of_type(value, type, attribute)
-        return value if type == :single
-        return value.join(' ') if type == :multiple
+      def get_attribute(attribute)
+        unless a = @attributes[attribute]
+          a = Attribute.new(attribute, @doc[attribute], self, @doc)
+        end
 
-        # pp value
-        return value ? attribute : nil if type == :boolean
+        return a
       end
     end
 
@@ -85,7 +168,17 @@ module Pakyow
       end
 
       def method_missing(method, *args)
-        @attributes.each{|a| a.send(method, *args)}
+        ret = []
+        @attributes.each{|a| ret << a.send(method, *args)}
+        ret
+      end
+
+      def class(*args)
+        method_missing(:class, *args)
+      end
+      
+      def id(*args)
+        method_missing(:id, *args)
       end
     end
   end

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

@@ -1,11 +1,15 @@
-require 'presenter/view_lookup_store'
+require 'yaml'
+require 'presenter/view_store'
+require 'presenter/doc_helpers'
 require 'presenter/view'
-require 'presenter/lazy_view'
+require 'presenter/template'
+require 'presenter/page'
+require 'presenter/partial'
 require 'presenter/view_collection'
 require 'presenter/binder'
-require 'presenter/view_context'
+require 'presenter/binder_set'
 require 'presenter/attributes'
-require 'presenter/bindings'
+require 'presenter/exceptions'
 
 module Pakyow
   module Presenter

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

@@ -1,43 +1,75 @@
 module Pakyow
   module Presenter
+    # A singleton that manages route sets.
+    #
     class Binder
-      include Pakyow::GeneralHelpers
-
-      class << self
-        attr_accessor :options
-        
-        def binder_for(*args)
-          View.binders ||= {}
-          args.each { |klass| View.binders[klass.to_s.to_sym] = self }
-        end
-        
-        def options_for(*args)
-          self.options = {} unless self.options
-          self.options[args[0]] = args[1]
-        end
+      include Singleton
+      include Helpers
+
+      attr_reader :sets
+
+      def initialize
+        @sets = {}
       end
-      
-      attr_accessor :bindable
-      
-      def initialize(bindable)
-        self.bindable = bindable
+
+      #TODO want to do this for all sets?
+      def reset
+        @sets = {}
+        self
       end
 
-      def value_for_prop(prop)
-        self.class.method_defined?(prop) ? self.send(prop) : bindable[prop]
+      # Creates a new set.
+      #
+      def set(name, &block)
+        @sets[name] = BinderSet.new
+        @sets[name].instance_exec(&block)
       end
-      
-      def fetch_options_for(attribute)
-        if self.class.options
-          if options = self.class.options[attribute]
-            unless options.is_a?(Array) || options.is_a?(Hash)
-              options = self.send(options)
-            end
-          
-            return options
+
+      def value_for_prop(prop, scope, bindable, bindings = {})
+        binding = nil
+        @sets.each {|set|
+          binding = set[1].match_for_prop(prop, scope, bindable, bindings)
+          break if binding
+        }
+
+        if binding
+          case binding.arity
+            when 0
+              binding_eval = BindingEval.new(bindable)
+              binding_eval.instance_exec(&binding)
+            when 1
+              self.instance_exec(bindable, &binding)
           end
+        else
+          # default
+          prop_value_for_bindable(bindable, prop)
         end
       end
+
+      def prop_value_for_bindable(bindable, prop)
+        return bindable[prop] if bindable.is_a?(Hash)
+        return bindable.send(prop) if bindable.class.method_defined?(prop)
+      end
+
+      def options_for_prop(*args)
+        match = nil
+        @sets.each {|set|
+          match = set[1].options_for_prop(*args)
+          break if match
+        }
+
+        return match
+      end
+
+      def has_prop?(*args)
+        has = nil
+        @sets.each {|set|
+          has = set[1].has_prop?(*args)
+          break if has
+        }
+
+        return has
+      end
     end
   end
 end

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

@@ -0,0 +1,95 @@
+module Pakyow
+  module Presenter
+    class BinderSet
+      attr_reader :scopes
+
+      def initialize
+        @scopes = {}
+        @options = {}
+      end
+
+      def scope(name, &block)
+        scope_eval = ScopeEval.new
+        bindings, options = scope_eval.eval(&block)
+
+        @scopes[name.to_sym] = bindings
+        @options[name.to_sym] = options
+      end
+
+      def match_for_prop(prop, scope, bindable, bindings = {})
+        return bindings_for_scope(scope, bindings)[prop]
+      end
+
+      def options_for_prop(prop, scope, bindable)
+        if block = (@options[scope] || {})[prop]
+          binding_eval = BindingEval.new(bindable)
+          binding_eval.instance_exec(&block)
+        end
+      end
+
+      def has_prop?(prop, scope, bindings)
+        bindings_for_scope(scope, bindings).key? prop
+      end
+
+      def bindings_for_scope(scope, bindings)
+        # merge passed bindings with bindings
+        (@scopes[scope] || {}).merge(bindings)
+      end
+    end
+
+    class ScopeEval
+      include Helpers
+
+      def initialize
+        @bindings = {}
+        @options = {}
+      end
+
+      def eval(&block)
+        self.instance_eval(&block)
+        return @bindings, @options
+      end
+
+      def binding(name, &block)
+        @bindings[name.to_sym] = block
+      end
+
+      def options(name, &block)
+        @options[name] = block
+      end
+
+      def restful(route_group)
+        binding(:action) {
+          routes = router.group(route_group)
+          return_data = {}
+
+          if id = bindable[:id]
+            return_data[:view] = lambda { |view|
+              view.prepend(View.from_doc(Nokogiri::HTML.fragment('<input type="hidden" name="_method" value="put">')))
+            }
+
+            action = routes.path(:update, :id => id)
+          else
+            action = routes.path(:create)
+          end
+
+          return_data[:action] = action
+          return_data[:method] = 'post'
+          return_data
+        }
+      end
+
+      #TODO options
+    end
+
+    class BindingEval
+      include Helpers
+
+      attr_reader :bindable
+
+      def initialize(bindable)
+        @bindable = bindable
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Pakyow
+  module Config
+    class Presenter
+      Config::Base.register_config(:presenter, self)
+
+      class << self
+        attr_accessor :javascripts, :stylesheets, :view_stores, :default_views,
+        :scope_attribute, :prop_attribute, :container_attribute, :template_dirs
+
+        # Location of javascripts
+        def javascripts
+          @javascripts || '/javascripts'
+        end
+
+        # Location of stylesheets
+        def stylesheets
+          @stylesheets || '/stylesheets'
+        end
+
+        def view_stores
+          @view_stores ||= {:default => "#{Config::Base.app.root}/app/views"}
+        end
+
+        def default_views(store_name = nil)
+          @default_views ||= {:default => "pakyow.html"}
+        end
+
+        # Returns the default view for store, or default.
+        #
+        def default_view(store_name)
+          views = default_views
+          views.key?(store_name) ? views[store_name] : views[:default]
+        end
+
+        def template_dirs(store_name = nil)
+          @template_dirs ||= {:default => '_templates'}
+        end
+
+        # Returns the default template dir for store, or default.
+        #
+        def template_dir(store_name)
+          dirs = template_dirs
+          dirs.key?(store_name) ? dirs[store_name] : dirs[:default]
+        end
+
+        def scope_attribute
+          @scope_attribute || "data-scope"
+        end
+
+        def prop_attribute
+          @prop_attribute || "data-prop"
+        end
+
+        def container_attribute
+          @container_attribute || "data-container"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Pakyow
+  module Presenter
+    module DocHelpers
+      def breadth_first(doc)
+        queue = [doc]
+        until queue.empty?
+          node = queue.shift
+          catch(:reject) {
+            yield node
+            queue.concat(node.children)
+          }
+        end
+      end
+
+      def path_to(child)
+        path = []
+
+        return path if child == @doc
+
+        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)
+
+          path.unshift(a.children.index(child))
+          child = a
+        }
+
+        return path
+      end
+
+      def path_within_path?(child_path, parent_path)
+        parent_path.each_with_index {|pp_step, i|
+          return false unless pp_step == child_path[i]
+        }
+
+        true
+      end
+
+      def doc_from_path(path)
+        o = @doc
+
+        # if path is empty we're at self
+        return o if path.empty?
+
+        path.each {|i|
+          if child = o.children[i]
+            o = child
+          else
+            break
+          end
+        }
+
+        return o
+      end
+
+      def view_from_path(path)
+        view = View.from_doc(doc_from_path(path))
+        view.related_views << self
+
+        return view
+      end
+
+      def to_html
+        @doc.to_html
+      end
+
+      alias :to_s :to_html
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Pakyow
+  module Presenter
+    class MissingTemplatesDir < Error; end
+    class MissingView < Error; end
+    class MissingTemplate < Error; end
+  end
+end

data/pakyow-presenter/lib/presenter/ext/app.rb

@@ -0,0 +1,32 @@
+module Pakyow
+  class App
+    class << self
+      @@bindings = {}
+      @@processors = {}
+      
+      def bindings(set_name = :main, &block)
+        if set_name && block
+          @@bindings[set_name] = block
+        else
+          @@bindings
+        end
+      end
+
+      def processor(*args, &block)
+        args.each {|format|
+          @@processors[format] = block
+        }
+      end
+
+      def processors
+        @@processors
+      end
+    end
+
+    # Convenience method for defining bindings on an app instance.
+    #
+    def bindings(set_name = :main, &block)
+      self.class.bindings(set_name, &block)
+    end
+  end
+end

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

@@ -1,16 +1,15 @@
 module Pakyow
-  module Helpers
+  module AppHelpers
     def presenter
-      Pakyow.app.presenter.current_context = self
-      Pakyow.app.presenter
+      @presenter
     end
 
     def bindings(name)
       presenter.bindings(name).bindings
     end
-    
+
     def view
-      self.presenter.view
+      presenter.view
     end
   end
 end