pakyow-presenter 0.9.1 → 0.10.0

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

@@ -1,221 +1,260 @@
 module Pakyow
-  class ViewStore
-    attr_reader :name, :store_path, :templates
+  module Presenter
+    class ViewStore
+      attr_reader :store_name, :store_paths, :templates
 
-    def initialize(store_path, name = :default)
-      @name = name
-      @store_path = store_path
+      def initialize(store_path_or_paths, store_name = :default)
+        @store_name = store_name
+        @store_paths = Array.ensure(store_path_or_paths)
 
-      load_templates
-      load_path_info
-    end
+        load_templates
+        load_path_info
+      end
 
-    def at?(view_path)
-      begin
-        at_path(view_path)
-        return true
-      rescue MissingView
-        return false
+      def at?(view_path)
+        begin
+          at_path(view_path)
+          return true
+        rescue MissingView
+          return false
+        end
       end
-    end
 
-    def template(name_or_path)
-      return name_or_path if name_or_path.is_a?(Template)
+      def template(name_or_path)
+        return name_or_path if name_or_path.is_a?(Template)
 
-      if name_or_path.is_a?(Symbol)
-        return template_with_name(name_or_path)
-      else
-        return at_path(name_or_path, :template)
+        if name_or_path.is_a?(Symbol)
+          return template_with_name(name_or_path)
+        else
+          return at_path(name_or_path, :template)
+        end
       end
-    end
 
-    def page(view_path)
-      return view_path if view_path.is_a?(Page)
+      def page(view_path)
+        return view_path if view_path.is_a?(Page)
 
-      raise ArgumentError, "Cannot build page for nil path" if view_path.nil?
-      return at_path(view_path, :page)
-    end
-
-    def partials(view_path)
-      return at_path(view_path, :partials) || {}
-    end
+        raise ArgumentError, "Cannot build page for nil path" if view_path.nil?
+        return at_path(view_path, :page)
+      end
 
-    def partial(view_path, name)
-      return partials(view_path)[name.to_sym]
-    end
+      def partials(view_path)
+        return at_path(view_path, :partials) || {}
+      end
 
-    def composer(view_path)
-      return at_path(view_path, :composer)
-    end
+      def partial(view_path, name)
+        return partials(view_path)[name.to_sym]
+      end
 
-    def view(view_path)
-      return composer(view_path).view
-    end
+      def composer(view_path)
+        return at_path(view_path, :composer)
+      end
 
-    # iterations through known views, yielding each
-    def views
-      @path_info.each_pair do |path, info|
-        yield(info[:composer].view, path)
+      def view(view_path)
+        return composer(view_path).view
       end
-    end
 
-    def infos
-      @path_info.each_pair do |path, info|
-        yield(info, path)
+      # iterations through known views, yielding each
+      def views
+        @path_info.each_pair do |path, info|
+          yield(info[:composer].view, path)
+        end
       end
-    end
 
-    def expand_path(view_path)
-      File.join(@store_path, view_path)
-    end
+      def infos
+        @path_info.each_pair do |path, info|
+          yield(info, path)
+        end
+      end
 
-    # Builds the full path to a partial.
-    #
-    #   expand_partial_path('path/to/partial')
-    #   # => '{store_path}/path/to/_partial.html'
-    def expand_partial_path(path)
-      parts = path.split('/')
+      def expand_path(view_path)
+        @store_paths.each do |store_path|
+          path = File.join(store_path, view_path)
 
-      # add underscore
-      expanded_path = expand_path((parts[0..-2] << "_#{parts[-1]}").join('/'))
+          if File.extname(path).empty?
+            return path if !Dir.glob(path + '.*').empty?
+          else
+            return path if File.exist?(path)
+          end
+        end
 
-      # attempt to find extension
-      matches = Dir.glob(expanded_path + '.*')
-      raise MissingPartial, "Could not find partial with any extension at #{expanded_path}" if matches.empty?
+        nil
+      end
 
-      return expanded_path + File.extname(matches[0])
-    end
+      # Builds the full path to a partial.
+      #
+      #   expand_partial_path('path/to/partial')
+      #   # => '{store_path}/path/to/_partial.html'
+      def expand_partial_path(path)
+        parts = path.split('/')
 
-    private
+        # add underscore
+        expanded_path = expand_path((parts[0..-2] << "_#{parts[-1]}").join('/'))
 
-    def at_path(view_path, obj = nil)
-      normalized_path = normalize_path(view_path)
-      info = @path_info[normalized_path]
+        # attempt to find extension
+        matches = Dir.glob(expanded_path + '.*')
+        raise MissingPartial, "Could not find partial with any extension at #{expanded_path}" if matches.empty?
 
-      if info.nil?
-        raise MissingView, "No view at path '#{view_path}'"
-      else
-        #TODO need to consider whose responsibility it is to make the dups
-        return (obj ? info[obj.to_sym] : info).dup
+        return expanded_path + File.extname(matches[0])
       end
-    end
 
-    def template_with_name(name)
-      unless template = @templates[name.to_sym]
-        raise MissingTemplate, "No template named '#{name}'"
-      end
+      private
 
-      return template.dup
-    end
+      def at_path(view_path, obj = nil)
+        normalized_path = normalize_path(view_path)
+        info = @path_info[normalized_path]
 
-    def load_templates
-      @templates = {}
+        if info.nil?
+          raise MissingView, "No view at path '#{view_path}'"
+        else
+          #TODO need to consider whose responsibility it is to make the dups
+          view = obj ? info[obj.to_sym] : info
+          raise MissingView, "No #{obj} at path '#{view_path}'" if view.nil?
+          return view.dup
+        end
+      end
 
-      if File.exists?(templates_path)
-        Dir.entries(templates_path).each do |file|
-          next if file =~ /^\./
+      def template_with_name(name)
+        load_templates
 
-          template = Template.load(File.join(templates_path, file))
-          @templates[template.name] = template
+        unless template = @templates[name.to_sym]
+          raise MissingTemplate, "No template named '#{name}'"
         end
-      else
-        raise MissingTemplatesDir, "No templates found at '#{templates_path}'"
-      end
-    end
 
-    def templates_path
-      return File.join(@store_path, Config.presenter.template_dir(@name))
-    end
+        return template.dup
+      end
 
-    def load_path_info
-      @path_info = {}
+      def load_templates
+        return if templates_loaded?
 
-      # for keeping up with pages for previous paths
-      pages = {}
+        @templates = {}
+        @store_paths.each do |store_path|
+          t_path = templates_path(store_path)
+          next unless File.exists?(t_path)
 
-      Dir.walk(@store_path) do |path|
-        # skip root
-        next if path == @store_path
+          Dir.entries(t_path).each do |file|
+            next if file =~ /^\./
 
-        # don't include templates
-        next if path.include?(templates_path)
+            template = Template.load(File.join(t_path, file))
+            @templates[template.name] = template
+          end
+        end
 
-        # skip partial files
-        next if File.basename(path)[0,1] == '_'
+        @templates_loaded = true
+      end
 
-        # skip non-empty folders (these files will be picked up)
-        next if !Dir.glob(File.join(path, 'index.*')).empty?
+      def templates_loaded?
+        @templates_loaded == true
+      end
 
-        normalized_path = normalize_path(path)
+      def templates_path(store_path)
+        return File.join(store_path, Config.presenter.template_dir(@store_name))
+      end
 
-        # if path is a directory we know there's no index page
-        # so use the previous index page instead. this allows
-        # partials to be overridden at a path while the same
-        # page is used
-        if File.directory?(path)
-          # gets the path for the previous page
-          prev_path = normalized_path
-          until page = pages[prev_path]
-            prev_path = prev_path.split('/')[0..-2].join("/")
+      def load_path_info
+        @path_info = {}
+
+        # for keeping up with pages for previous paths
+        pages = {}
+
+        @store_paths.each do |store_path|
+          Dir.walk(store_path) do |path|
+            # don't include templates
+            next if path.include?(templates_path(store_path))
+
+            # skip partial files
+            next if File.basename(path)[0,1] == '_'
+
+            # skip non-empty folders (these files will be picked up)
+            next unless Dir.glob(File.join(path, 'index.*')).empty?
+
+            normalized_path = normalize_path(path, store_path)
+
+            # if path is a directory we know there's no index page
+            # so use the previous index page instead. this allows
+            # partials to be overridden at a path while the same
+            # page is used
+            if File.directory?(path)
+              # gets the path for the previous page
+              prev_path = normalized_path
+              until page = pages[prev_path]
+                break if prev_path.empty?
+                prev_path = prev_path.split('/')[0..-2].join("/")
+              end
+              page = page
+            else
+              page = Page.load(path)
+              pages[normalized_path] = page
+            end
+
+            unless page.nil?
+              template = template_with_name(page.info(:template))
+            end
+
+            #TODO more efficient way of doing this? lot of redundant calls here
+            partials = partials_at_path(path)
+
+            unless page.nil?
+              # compose template/page/partials
+              composer = ViewComposer.from_path(self, normalized_path, template: template, page: page, includes: partials)
+            end
+
+            info = {
+              page: page,
+              template: template,
+              partials: partials,
+              composer: composer,
+            }
+
+            @path_info[normalized_path] = info
           end
-          page = page
-        else
-          page = Page.load(path)
-          pages[normalized_path] = page
         end
+      end
 
-        template = template_with_name(page.info(:template))
-
-        #TODO more efficient way of doing this? lot of redundant calls here
-        partials = partials_at_path(path)
-
-        # compose template/page/partials
-        composer = ViewComposer.from_path(self, normalized_path, template: template, page: page, includes: partials)
+      def normalize_path(path, store_path = nil)
+        if store_path
+          relative_path = path.gsub(store_path, '')
+        else
+          relative_path = path
+          @store_paths.each do |store_path|
+            relative_path = relative_path.gsub(store_path, '')
+          end
+        end
 
-        info = {
-          page: page,
-          template: template,
-          partials: partials,
-          composer: composer,
-        }
+        relative_path = relative_path.gsub(File.extname(relative_path), '')
+        relative_path = relative_path.gsub('index', '')
+        relative_path = String.normalize_path(relative_path)
 
-        @path_info[normalized_path] = info
+        return relative_path
       end
-    end
 
-    def normalize_path(path)
-      relative_path = path.gsub(@store_path, '')
-      relative_path = relative_path.gsub(File.extname(relative_path), '')
-      relative_path = relative_path.gsub('index', '')
-      relative_path = String.normalize_path(relative_path)
+      def partials_at_path(view_path)
+        view_path = File.dirname(view_path) unless File.directory?(view_path)
+        view_path = normalize_path(view_path)
 
-      return relative_path
-    end
-
-    def partials_at_path(view_path)
-      view_path = File.dirname(view_path) unless File.directory?(view_path)
+        partials = {}
+        @store_paths.each do |store_path|
+          Dir.walk(store_path) do |path|
+            # skip non-partials
+            next unless File.basename(path)[0,1] == '_'
 
-      partials = {}
-      Dir.walk(@store_path) do |path|
-        # skip non-partials
-        next unless File.basename(path)[0,1] == '_'
+            # skip directories
+            next if File.directory?(path)
 
-        # skip directories
-        next if File.directory?(path)
+            # skip files not within `view_path`
+            next unless Dir.within_dir?(normalize_path(File.dirname(path), store_path), view_path)
 
-        # skip files not within `view_path`
-        next unless Dir.within_dir?(File.dirname(path), view_path)
+            name = File.basename(path.split('/')[-1], '.*')[1..-1]
+            partials[name.to_sym] = path
+          end
+        end
 
-        name = File.basename(path.split('/')[-1], '.*')[1..-1]
-        partials[name.to_sym] = path
-      end
+        # create instances
+        partials.each do |name, path|
+          partials[name] = Partial.load(path)
+        end
 
-      # create instances
-      partials.each do |name, path|
-        partials[name] = Partial.load(path)
+        return partials
       end
-
-      return partials
     end
   end
 end

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

@@ -0,0 +1,43 @@
+module Pakyow
+  module Presenter
+    class ViewStoreLoader
+      include Singleton
+
+      def initialize
+        @last_mod = {}
+      end
+
+      def modified?(name, paths)
+        paths = Array.ensure(paths)
+
+        if !@last_mod.key?(name)
+          modified(name)
+          return true
+        end
+
+        paths.each do |path|
+          Dir.walk(path) do |p|
+            next if FileTest.directory?(p)
+
+            if File.mtime(p) > @last_mod[name]
+              modified(name)
+              return true
+            end
+          end
+        end
+
+        false
+      end
+
+      def reset
+        @last_mod = {}
+      end
+
+      private
+
+      def modified(name)
+        @last_mod[name] = Time.now
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+class Pakyow::Presenter::ViewVersion
+  attr_reader :default, :empty, :versions
+
+  def initialize(views)
+    @empty    = views.find { |view| view.version == :empty }
+    @default  = views.find { |view| !view.doc.get_attribute(:'data-default').nil? } || views.find { |view| view.version != :empty }
+    @versions = views
+  end
+
+  def initialize_copy(original_view)
+    super
+
+    @empty = original_view.empty.soft_copy if original_view.empty
+    @versions = original_view.versions.map { |view| view.soft_copy }
+    @default = versions.first
+  end
+
+  def apply(data, bindings: {}, context: nil, &block)
+    data = Array.ensure(data)
+
+    if data.empty?
+      @default = @empty
+      cleanup
+      self
+    else
+      cleanup
+
+      match(data).bind(data, bindings: bindings, context: context, &block)
+    end
+  end
+
+  def version(data, &block)
+    data = Array.ensure(data)
+    coll = Pakyow::Presenter::ViewCollection.new
+
+    if data.empty?
+      @versions.each(&:remove)
+    else
+      @empty.remove if @empty
+      self_dup = self.dup
+
+      view = process_version(self, data.first, &block)
+      working = view
+      coll << view
+
+      data[1..-1].inject(coll) { |coll, datum|
+        duped = self_dup.dup
+        view = process_version(duped, datum, &block)
+
+        working.after(view)
+        working = view
+        coll << view
+      }
+
+      coll
+    end
+  end
+
+  def bind(data, bindings: {}, context: nil, &block)
+    @versions.each do |view|
+      view.bind(data, bindings: bindings, context: context, &block)
+    end
+  end
+
+  def use(version)
+    @versions.each do |view|
+      @default = view if view.version == version
+    end
+
+    cleanup
+
+    @default
+  end
+
+  def cleanup
+    @versions.reject { |view| view == @default }.each(&:remove)
+    @versions = [@default]
+  end
+
+  def method_missing(method, *args, &block)
+    if @default.respond_to?(method)
+      @default.send(method, *args, &block)   
+    end
+  end
+
+  private
+
+  def process_version(version, datum, &block)
+    if block.arity == 1
+      version.instance_exec(datum, &block)
+    else
+      block.call(version, datum)
+    end
+
+    version.default
+  end
+end

data/pakyow-presenter/lib/views/errors/404.html

@@ -0,0 +1,5 @@
+<p class="lead">
+  But, we recommend you start by creating a view at <code>app/views/{view_path}</code>.
+  The view will be served up automatically without writing any back-end code! This pattern
+  is called view-first development (you could also call it <em>awesome</em>).
+</p>