pakyow-presenter 0.11.3 → 1.0.0.rc1

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

@@ -1,330 +0,0 @@
-module Pakyow
-  module Presenter
-    class ViewCollection
-      include Enumerable
-
-      attr_reader :views, :scoped_as
-
-      def initialize(scope = nil)
-        @views = []
-        @scoped_as = scope
-      end
-
-      def initialize_copy(original_view)
-        super
-
-        @views = Pakyow::Utils::Dup.deep(original_view.views)
-        @scoped_as = original_view.scoped_as
-      end
-
-      def ==(other)
-        @views.each_with_index do |view, i|
-          return false if view != other.views[i]
-        end
-
-        return true
-      end
-
-      def each
-        @views.each { |v| yield(v) }
-      end
-
-      def attrs(attrs = {})
-        inject(AttributesCollection.new) { |coll, view|
-          coll << view.attrs(attrs)
-        }
-      end
-
-      def remove
-        each {|e| e.remove}
-      end
-
-      def clear
-        each {|e| e.clear}
-      end
-
-      def text
-        map { |v| v.text }
-      end
-
-      def text=(text)
-        each {|e| e.text = text}
-      end
-
-      def html
-        map { |v| v.html }
-      end
-
-      def html=(html)
-        each {|e| e.html = html}
-      end
-
-      def to_html
-        map { |v| v.to_html }.join('')
-      end
-
-      alias :to_s :to_html
-
-      def append(content)
-        each do |view|
-          view.append(content)
-        end
-      end
-
-      def prepend(content)
-        each do |view|
-          view.prepend(content)
-        end
-      end
-
-      # TODO: decide if we care to check the type of
-      # objects being added to the collection
-      def <<(val)
-        @views << val
-        self
-      end
-
-      def concat(views)
-        @views.concat(views)
-      end
-
-      def [](i)
-        @views[i]
-      end
-
-      def length
-        @views.length
-      end
-
-      def scope(name)
-        collection = inject(ViewCollection.new(name)) { |coll, view|
-          scopes = view.scope(name)
-          next if scopes.nil?
-
-          scopes.inject(coll) { |coll, scoped_view|
-            coll << scoped_view
-          }
-        }
-
-        if collection.versioned?
-          ViewVersion.new(collection.views)
-        else
-          collection
-        end
-      end
-
-      def prop(name)
-        inject(ViewCollection.new(scoped_as)) { |coll, view|
-          scopes = view.prop(name)
-          next if scopes.nil?
-
-          scopes.inject(coll) { |coll, scoped_view|
-            coll << scoped_view
-          }
-        }
-      end
-
-      def versioned?
-        each do |view|
-          return true if view.versioned?
-        end
-
-        false
-      end
-
-      def exists?
-        each do |view|
-          return true if view.exists?
-        end
-
-        false
-      end
-
-      def component(name)
-        collection = inject(ViewCollection.new(scoped_as)) { |coll, view|
-          scopes = view.component(name)
-          next if scopes.nil?
-
-          scopes.inject(coll) { |coll, scoped_view|
-            coll << scoped_view
-          }
-        }
-
-        if collection.versioned?
-          ViewVersion.new(collection.views)
-        else
-          collection
-        end
-      end
-
-      def component?
-        each do |view|
-          return true if view.component?
-        end
-
-        false
-      end
-
-      def component_name
-        each do |view|
-          return view.component_name if view.component?
-        end
-      end
-
-      # call-seq:
-      #   with {|view| block}
-      #
-      # Creates a context in which view manipulations can be performed.
-      #
-      def with(&block)
-        if block.arity == 0
-          instance_exec(&block)
-        else
-          yield(self)
-        end
-
-        self
-      end
-
-      # call-seq:
-      #   for {|view, datum| block}
-      #
-      # Yields a view and its matching dataum. Datums are yielded until
-      # no more views or data is available. For the ViewCollection case, this
-      # means the block will be yielded self.length times.
-      #
-      # (this is basically Bret's `map` function)
-      #
-      def for(data, &block)
-        data = Array.ensure(data)
-        each_with_index do |view, i|
-          datum = data[i]
-          break if datum.nil?
-
-          if block.arity == 1
-            view.instance_exec(data[i], &block)
-          else
-            block.call(view, data[i])
-          end
-        end
-
-        self
-      end
-
-      # call-seq:
-      #   for_with_index {|view, datum, i| block}
-      #
-      # Yields a view, its matching datum, and index. Datums are yielded until
-      # no more views or data is available. For the ViewCollection case, this
-      # means the block will be yielded self.length times.
-      #
-      def for_with_index(data, &block)
-        i = 0
-        self.for(data) do |ctx, datum|
-          if block.arity == 2
-            ctx.instance_exec(datum, i, &block)
-          else
-            block.call(ctx, datum, i)
-          end
-
-          i += 1
-        end
-      end
-
-      # call-seq:
-      #   match(data) => ViewCollection
-      #
-      # Manipulates the current collection to match the data. The final ViewCollection object
-      # will consist n copies of self[data index] || self[-1], where n = data.length.
-      #
-      def match(data)
-        return self if length == 0
-        data = Array.ensure(data)
-
-        # an empty set always means an empty view
-        if data.empty?
-          remove
-        else
-          if length > data.length
-            self[data.length..-1].each do |view|
-              view.remove
-            end
-          else
-            working = self[-1]
-            data[length..-1].each do
-              duped_view = working.soft_copy
-              working.after(duped_view)
-              working = duped_view
-              self << duped_view
-            end
-          end
-        end
-
-        self
-      end
-
-      # call-seq:
-      #   repeat(data) {|view, datum| block}
-      #
-      # Matches self to data and yields a view/datum pair.
-      #
-      def repeat(data, &block)
-        match(data).for(data, &block)
-      end
-
-      # call-seq:
-      #   repeat_with_index(data) {|view, datum, i| block}
-      #
-      # Matches self with data and yields a view/datum pair with index.
-      #
-      def repeat_with_index(data, &block)
-        match(data).for_with_index(data, &block)
-      end
-
-      # call-seq:
-      #   bind(data)
-      #
-      # Binds data across existing scopes.
-      #
-      def bind(data, bindings: {}, context: nil, &block)
-        self.for(data) do |view, datum|
-          view.bind(datum, bindings: bindings, context: context)
-          next if block.nil?
-
-          if block.arity == 1
-            view.instance_exec(datum, &block)
-          else
-            block.call(view, datum)
-          end
-        end
-      end
-
-      # call-seq:
-      #   bind_with_index(data)
-      #
-      # Binds data across existing scopes, yielding a view/datum pair with index.
-      #
-      def bind_with_index(*a, **k, &block)
-        i = 0
-        bind(*a, **k) do |ctx, datum|
-          if block.arity == 2
-            ctx.instance_exec(datum, i, &block)
-          else
-            block.call(ctx, datum, i)
-          end
-
-          i += 1
-        end
-      end
-
-      # call-seq:
-      #   apply(data)
-      #
-      # Matches self to data then binds data to the view.
-      #
-      def apply(data, bindings: {}, context: nil, &block)
-        match(data).bind(data, bindings: bindings, context: context, &block)
-      end
-    end
-  end
-end

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

@@ -1,237 +0,0 @@
-module Pakyow
-  module Presenter
-    class ViewComposer
-      class << self
-        def from_path(store, path, opts = {}, &block)
-          ViewComposer.new(store, path, opts, &block)
-        end
-      end
-
-      extend Forwardable
-
-      def_delegators :template, :title, :title=
-      def_delegators :parts, :prop, :component
-      def_delegators :view, :to_html
-
-      attr_reader :store, :path, :page, :partials
-
-      def initialize(store, path = nil, opts = {}, &block)
-        @store = store
-        @path = path
-
-        self.page = opts.fetch(:page) {
-          path
-        }
-
-        self.template = opts.fetch(:template) {
-          (@page.is_a?(Page) && @page.info(:template)) || path
-        }
-
-        # Setting up partials is a bit complicated, but here's how it works.
-        #
-        # First we set `@partials` to the ones passed or the partials from the
-        # store for the path that we're composing at. We do this so that
-        # partials are included in `parts` after this (important since we
-        # want partials defined in partials to be found properly).
-        begin
-          @partials = {}
-          @partials = includes(opts.fetch(:includes))
-        rescue
-          @partials = store.partials(path) unless path.nil?
-        end
-
-        # Now we need to build the actual set of partials used by parts of the
-        # view that we're composing. This bit of code counts the number of each
-        # partial present; if it's greater than one we represent them as a view
-        # collection, otherwise it's just a partial.
-        #
-        # FIXME: It's possible there's a more straight-forward way to write this
-        # code; it should be explored at some poitn in the future.
-        partials  = {}
-        @partials.each do |name, view|
-          count = parts.select { |part|
-            part.doc.partials.key?(name)
-          }.map { |part|
-            part.doc.partials[name].count
-          }.inject(&:+) || 0
-
-          partials[name] = view; next if count < 2
-
-          collection = ViewCollection.new
-
-          count.times do
-            collection << view.dup
-          end
-
-          partials[name] = collection
-        end
-
-        @partials = partials
-
-        instance_exec(&block) if block_given?
-      end
-
-      def initialize_copy(original)
-        super
-
-        %w[store path page template partials view].each do |ivar|
-          value = original.instance_variable_get("@#{ivar}")
-          next if value.nil?
-
-          if value.is_a?(Hash)
-            dup_value = {}
-            value.each_pair { |key, value| dup_value[key] = value.dup }
-          else
-            dup_value = value.dup
-          end
-
-          self.instance_variable_set("@#{ivar}", dup_value)
-        end
-      end
-
-      def view
-        build_view
-      end
-      alias_method :composed, :view
-
-      def template(template = nil)
-        if template.nil?
-          return @template
-        end
-
-        self.template = template
-        return self
-      end
-
-      def template=(template)
-        unless template.is_a?(Template)
-          # get template by name
-          template = @store.template(template.to_sym)
-        end
-
-        @template = template
-
-        return self
-      end
-
-      def page=(page)
-        unless page.is_a?(Page)
-          # get page by name
-          page = @store.page(page)
-        end
-
-        @page = page
-
-        return self
-      end
-
-      def includes(partial_map)
-        @partials.merge!(remap_partials(partial_map))
-      end
-
-      def partials=(partial_map)
-        @partials.merge!(remap_partials(partial_map))
-      end
-
-      def partial(name)
-        partial = @partials[name]
-        partial.includes(partials)
-        return partial
-      end
-
-      def container(name)
-        container = @page.container(name)
-        return container
-      end
-
-      def parts
-        # create an array to hold the parts
-        parts = ViewCollection.new
-
-        # add the current template
-        parts << @template
-
-        # add each page container
-        @page.each_container do |_, container|
-          parts << container
-        end
-
-        parts.concat(partials_for_parts(parts))
-
-        return parts
-      end
-
-      def scope(name)
-        collection = parts.scope(name)
-
-        if collection.is_a?(ViewVersion)
-          collection = collection.versions.inject(ViewCollection.new(name)) { |c, v| c << v; c }
-        end
-
-        # include partials so nested scopes/props can be bound to
-        collection.each do |view|
-          view.includes(partials)
-        end
-
-        #TODO make sure anytime we return a collection it tries to version
-        # make this a class level helper method on ViewVersion
-        if !collection.is_a?(ViewVersion) && collection.versioned?
-          ViewVersion.new(collection.views)
-        else
-          collection
-        end
-      end
-
-      private
-
-      def build_view
-        raise MissingTemplate, "No template provided to view composer" if @template.nil?
-        raise MissingPage, "No page provided to view composer" if @page.nil?
-
-        view = @template.dup.build(@page).includes(@partials)
-
-        # set title
-        title = @page.info(:title)
-        view.title = title unless title.nil?
-
-        return view
-      end
-
-      def remap_partials(partials)
-        Hash[partials.map { |name, partial_or_path|
-          if partial_or_path.is_a?(Partial)
-            partial = partial_or_path
-          else
-            partial = Partial.load(@store.expand_partial_path(partial_or_path))
-          end
-
-          [name, partial]
-        }]
-      end
-
-      def partials_for_parts(parts, acc = [])
-        # determine the partials to be included
-        available_partials = parts.inject([]) { |sum, part|
-          if part.is_a?(ViewCollection)
-            part.each do |view|
-              sum.concat(view.doc.partials.keys)
-            end
-          else
-            sum.concat(part.doc.partials.keys)
-          end
-        }
-
-        # add available partials as parts
-        partials.select { |name|
-          available_partials.include?(name)
-        }.each_pair { |_, partial|
-          acc << partial
-          partials_for_parts([partial], acc)
-        }
-
-        return acc
-      end
-
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-module Pakyow
-  module Presenter
-    # This is a wrapper for View / ViewCollection that passes the current
-    # AppContext to all binding methods. This object is expected to only
-    # be used from the app, not internally.
-    #
-    class ViewContext
-      include Helpers
-      VIEW_CLASSES = [View, ViewCollection, Partial, Template, Container, ViewVersion]
-
-      # The arities of misc view methods that switch the behavior from
-      # instance_exec to yield.
-      #
-      EXEC_ARITIES = { with: 0, for: 1, for_with_index: 2, repeat: 1,
-        repeat_with_index: 2, bind: 1, bind_with_index: 2, apply: 1 }
-
-      attr_reader :context
-
-      def initialize(view, context)
-        @view = view
-        @context = context
-      end
-
-      def subject
-        @view
-      end
-
-      # View methods that expect context, so it can be mixed in.
-      #
-      %i[bind bind_with_index apply].each do |method|
-        define_method(method) do |data, **kargs, &block|
-          kargs[:context] ||= @context
-          ret = @view.send(method, data, **kargs, &wrap(method, &block))
-          handle_return_value(ret)
-        end
-      end
-
-      # View methods that return views, but don't expect context.
-      #
-      %i[with for for_with_index repeat repeat_with_index].each do |method|
-        define_method(method) do |*args, &block|
-          ret = @view.send(method, *args, &wrap(method, &block))
-          handle_return_value(ret)
-        end
-      end
-
-      # View methods that support versioning.
-      #
-      %i[scope prop].each do |method|
-        define_method(method) do |*args|
-          collection = @view.send(method, *args)
-
-          if collection.views && collection.versioned?
-            ret = ViewVersion.new(collection.views)
-          else
-            ret = collection
-          end
-
-          handle_return_value(ret)
-        end
-      end
-
-      # Pass these through, handling the return value.
-      #
-      def method_missing(method, *args, &block)
-        ret = @view.send(method, *args, &block)
-        handle_return_value(ret)
-      end
-
-      private
-
-      def view?(obj)
-        VIEW_CLASSES.include?(obj.class)
-      end
-
-      # Returns a new context for returned views, or the return value.
-      #
-      def handle_return_value(value)
-        if view?(value)
-          return ViewContext.new(value, @context)
-        end
-
-        value
-      end
-
-      # Wrap the block, substituting the view with the current view context.
-      #
-      def wrap(method, &block)
-        return if block.nil?
-
-        Proc.new do |*args|
-          ctx = args.map! { |arg|
-            view?(arg) ? ViewContext.new(arg, @context) : arg
-          }.find { |arg| arg.is_a?(ViewContext) }
-
-          case block.arity
-          when EXEC_ARITIES[method]
-            # Rejecting ViewContext handles the edge cases around the order of
-            # arguments from view methods (since view is not present in some
-            # situations and when it is present, is always the first arg).
-            ctx.instance_exec(*args.reject { |arg|
-              arg.is_a?(ViewContext)
-            }, &block)
-          else
-            block.call(*args)
-          end
-        end
-      end
-    end
-  end
-end