pakyow-presenter 0.11.3 → 1.0.0.rc1

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

@@ -1,94 +0,0 @@
-module Pakyow
-  module Presenter
-    class BinderSet
-      attr_reader :scopes
-
-      def initialize(&block)
-        @scopes = {}
-        @options = {}
-        @config = {}
-
-        instance_exec(&block)
-      end
-
-      def scope(name, &block)
-        scope_eval = ScopeEval.new
-        bindings, options, config = scope_eval.eval(&block)
-
-        @scopes[name.to_sym] = bindings
-        @options[name.to_sym] = options
-        @config[name.to_sym] = config
-      end
-
-      def match_for_prop(prop, scope, bindable, bindings = {})
-        return bindings_for_scope(scope, bindings)[prop]
-      end
-
-      def options_for_prop(scope, prop, bindable, context)
-        if block = (@options[scope] || {})[prop]
-          binding_eval = BindingEval.new(prop, bindable, context)
-          values = binding_eval.instance_exec(binding_eval.value, bindable, context, &block)
-          values.unshift(['', '']) if @config[scope][prop][:empty]
-          values
-        end
-      end
-
-      def has_prop?(scope, prop, 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 = {}
-        @config = {}
-      end
-
-      def eval(&block)
-        self.instance_eval(&block)
-        return @bindings, @options, @config
-      end
-
-      def binding(name, &block)
-        @bindings[name.to_sym] = block
-      end
-
-      def options(name, empty: false, &block)
-        @options[name] = block
-        @config[name] = { empty: empty }
-      end
-
-      def restful(route_group)
-        binding :_root do
-          part :view do |view|
-            routes = Router.instance.group(route_group)
-            action = view.attrs.action.value
-            next if (action && !action.empty?)
-
-            route_params = params.dup
-            if view.doc.tagname == 'form'
-              if id = bindable[:id]
-                view.prepend(View.new('<input type="hidden" name="_method" value="patch">'))
-                route_params[:"#{route_group}_id"] = id
-                action = :update
-              else
-                action = :create
-              end
-
-              view.attrs.action = routes.path(action, route_params)
-              view.attrs.method = 'post'
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-module Pakyow
-  module Presenter
-    class BindingEval
-      include Pakyow::Helpers
-
-      attr_reader :context, :bindable
-
-      def initialize(prop, bindable, context)
-        @parts = {}
-        @prop = prop
-        @bindable = bindable
-        @context = context
-      end
-
-      def value
-        if bindable.is_a?(Hash)
-          bindable[@prop]
-        elsif bindable.respond_to?(@prop)
-          bindable.send(@prop)
-        end
-      end
-
-      def eval(&block)
-        ret = instance_exec(value, bindable, context, &block)
-        if ret.respond_to?(:to_hash)
-          @parts.merge!(ret.to_hash)
-        end
-        @parts.empty? ? ret : @parts
-      end
-
-      def part(name, &block)
-        @parts[name.to_sym] = block
-        nil # Return nil so #part return value is ignored
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-Pakyow::Config.register :presenter do |config|
-  # registered view stores
-  config.opt :view_stores, -> {
-    @stores ||= {
-      default: File.join(Pakyow::Config.app.root, 'app', 'views')
-    }
-  }
-
-  # the default view for each view store
-  config.opt :default_views, { default: :default }
-
-  # a convenience option to lookup the default_view for a view store by name
-  config.opt :default_view, -> (store_name) {
-    views = Pakyow::Config.presenter.default_views
-    views.fetch(store_name) { views[:default] }
-  }
-
-  # the default template dir for each view store
-  config.opt :template_dirs, { default: '_templates' }
-
-  # a convenience option to lookup the template_dir for a view store by name
-  config.opt :template_dir, -> (store_name) {
-    dirs = Pakyow::Config.presenter.template_dirs
-    dirs.fetch(store_name) { dirs[:default] }
-  }
-
-  # the attribute expected for scope definitions
-  config.opt :scope_attribute, 'data-scope'
-
-  # the attribute expected for prop definitions
-  config.opt :prop_attribute, 'data-prop'
-
-  # if true, views are visible without a route defined
-  config.opt :require_route, true
-
-  # the document class used to parse and render views
-  config.opt :view_doc_class, Pakyow::Presenter::StringDoc
-end.env :development do |opts|
-  opts.require_route = false
-end.env :production do |opts|
-  opts.require_route = true
-end

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

@@ -1,6 +0,0 @@
-module Pakyow
-  module Presenter
-    class Container < View
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Pakyow
-  module Presenter
-    module DocHelpers
-      def self.self_closing_tag?(tag)
-        %w[area base basefont br hr input img link meta].include? tag
-      end
-
-      def self.form_field?(tag)
-        %w[input select textarea button].include? tag
-      end
-
-      def self.tag_without_value?(tag)
-        %w[select].include? tag
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-module Pakyow
-  module Presenter
-    class MissingTemplatesDir < Error; end
-    class MissingView < Error; end
-    class MissingTemplate < Error; end
-    class MissingPage < Error; end
-    class MissingPartial < Error; end
-    class MissingComposer < Error; end
-    class MissingContainer < Error; end
-  end
-end

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

@@ -1,33 +0,0 @@
-module Pakyow
-  class App
-    class << self
-      RESOURCE_ACTIONS[:presenter] = Proc.new { |app, set_name, _, _|
-        app.bindings(set_name) { scope(set_name) { restful(set_name) } }
-      }
-
-      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/pakyow/presenter/ext/call_context.rb

@@ -1,28 +0,0 @@
-require 'erb'
-
-module Pakyow
-  class CallContext
-    protected
-
-    def presenter_handle_error(code)
-      return if !config.app.errors_in_browser || req.format != :html
-      response.body = [content_for_code(code)]
-    end
-
-    def content_for_code(code)
-      content = ERB.new(File.read(path_for_code(code))).result(binding)
-      page = Presenter::Page.new(:presenter, content, '/')
-      composer = presenter.compose_at('/', page: page)
-      composer.to_html
-    end
-
-    def path_for_code(code)
-      File.join(
-        File.expand_path('../../../', __FILE__),
-        'views',
-        'errors',
-        code.to_s + '.erb'
-      )
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-require 'forwardable'
-
-module Pakyow
-  module Helpers
-    module Context
-      extend Forwardable
-
-      def_delegators :@presenter, :store, :store=, :content, :view=,
-      :template=, :page=, :path, :path=, :compose, :composer, :precompose!
-
-      def view
-        Presenter::ViewContext.new(presenter.view, self)
-      end
-
-      def partial(*args)
-        Presenter::ViewContext.new(presenter.partial(*args), self)
-      end
-
-      def template
-        Presenter::ViewContext.new(presenter.template, self)
-      end
-
-      def page
-        Presenter::ViewContext.new(presenter.page, self)
-      end
-
-      def container(*args)
-        Presenter::ViewContext.new(presenter.container(*args), self)
-      end
-
-      def bindings(name)
-        presenter.bindings(name).bindings
-      end
-
-      def presenter
-        @presenter
-      end
-    end
-
-    module App
-      def presenter
-        @presenter
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-module Pakyow
-  module Presenter
-    class Page
-      MATTER_MATCHER = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
-
-      class << self
-        def load(path, view_store_name = :default)
-          format   = String.split_at_last_dot(path)[-1]
-          name     = File.basename(path, '.*').to_sym
-          contents = FileTest.file?(path) ? File.read(path) : nil
-
-          return Page.new(name, contents, path, format, view_store_name)
-        end
-      end
-
-      attr_reader :path, :contents
-
-      def initialize(name, contents, path, format = :html, view_store_name = :default)
-        @name, @contents, @path, @format = name, contents, path, format
-
-        @info    = { template: Pakyow::App.config.presenter.default_view(view_store_name) }
-        @containers = {}
-
-        unless @contents.nil?
-          parse_info
-          parse_content
-        end
-      end
-
-      def initialize_copy(original_page)
-        super
-
-        # copy content
-        @containers = {}
-        original_page.instance_variable_get(:'@containers').each_pair do |k, v|
-          @containers[k] = v.dup
-        end
-      end
-
-      def content(container = nil)
-        return @contents if container.nil?
-
-        container = @containers.fetch(container.to_sym) {
-          raise MissingContainer, "No container named #{container} in #{@path}"
-        }
-
-        return container.doc
-      end
-
-      def info(key = nil)
-        return @info if key.nil?
-        return @info[key]
-      end
-
-      def ==(page)
-        @contents == page.contents
-      end
-
-      def container(name)
-        @containers.fetch(name.to_sym) {
-          raise MissingContainer, "No container named #{name} in #{@path}"
-        }
-      end
-
-      def each_container
-        @containers.each_pair { |name, container| yield(name, container) }
-      end
-
-      private
-
-      def parse_info
-        info = parse_front_matter(@contents)
-        info = {} if !info || !info.is_a?(Hash)
-
-        @info.merge!(Hash.symbolize(info))
-      end
-
-      def parse_content
-        # remove yaml front matter
-        @contents.gsub!(/---(.|\n)*---/, '')
-
-        # process contents
-        @contents = Presenter.process(@contents, @format)
-
-        # find content in named containers
-        within_regex = /<!--\s*@within\s*([a-zA-Z0-9\-_]*)\s*-->(.*?)<!--\s*\/within\s*-->/m
-
-        @contents.scan(within_regex) do |m|
-          container_name = m[0].to_sym
-          @containers[container_name] = Container.new(m[1])
-        end
-
-        # find default content
-        @containers[:default] = Container.new(@contents.gsub(within_regex, ''))
-      end
-
-      def parse_front_matter(contents)
-        # match the matter
-        matter = contents.match(MATTER_MATCHER).to_s
-
-        # remove the opening/closing '---'
-        matter = matter.split("\n")[1..-2]
-        # return if no matter
-        return {} if matter.nil?
-
-        YAML.load(matter.join("\n"))
-      end
-    end
-  end
-end

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

@@ -1,6 +0,0 @@
-module Pakyow
-  module Presenter
-    class Partial < View
-    end
-  end
-end

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

@@ -1,232 +0,0 @@
-module Pakyow
-  module Presenter
-    class Presenter
-      class << self
-        def process(contents, format)
-          format = format.to_sym
-
-          unless app = Pakyow.app
-            return contents
-          end
-
-          unless presenter = app.presenter
-            return contents
-          end
-
-          unless processor = presenter.processor_store[format]
-            Pakyow.logger.warn("No processor defined for extension #{format}") unless format == :html
-            return contents
-          end
-
-          processed = processor.call(contents)
-
-          # reprocess html content unless we just did that
-          return processed if format == :html
-          process(processed, :html)
-        end
-      end
-
-      Pakyow::App.before(:init) {
-        @presenter = Presenter.new
-        ViewStoreLoader.instance.reset
-      }
-
-      Pakyow::App.after(:match) {
-        @presenter = Pakyow.app.presenter.dup
-        @presenter.prepare_with_context(context)
-      }
-
-      Pakyow::App.after(:route) {
-        if Config.presenter.require_route && !found?
-          @found 
-        else
-          if @presenter.presented?
-            @found = true
-            @context.response.body = [@presenter.content]
-          else
-            @found = false unless found?
-          end
-        end
-      }
-
-      Pakyow::App.after(:load) {
-        @presenter.load
-      }
-
-      Pakyow::App.after(:error) {
-        unless config.app.errors_in_browser
-          @context.response.body = [@presenter.content] if @presenter.presented?
-        end
-      }
-
-      attr_accessor :processor_store, :binder, :path, :context, :composer
-
-      def initialize
-        setup
-      end
-
-      def store(name = nil)
-        if name
-          @view_stores[name]
-        else
-          @view_stores[@store]
-        end
-      end
-
-      def store=(name)
-        @store = name
-
-        return unless has_path?
-        setup_for_path(@path)
-      end
-
-      def load
-        load_processors
-        load_views
-        load_bindings
-      end
-
-      def prepare_with_context(context)
-        @context = context
-
-        if @context.request.has_route_vars?
-          @path = String.remove_route_vars(@context.request.route_path)
-        else
-          @path = @context.request.path
-        end
-
-        setup
-      end
-
-      def presented?
-        !view.nil?
-      rescue MissingView
-        false
-      end
-
-      def content
-        to_present = view
-        to_present.is_a?(ViewComposer) ? to_present.composed.to_html : to_present.to_html
-      end
-
-      def view
-        @composer || @view || raise(MissingView)
-      end
-
-      def view?(path)
-        if composer_for_path(path)
-          true
-        else
-          false
-        end
-      end
-
-      def precompose!
-        self.view = @composer.view
-      end
-
-      def view=(view)
-        @view = view
-
-        # setting a view means we no longer use/need the composer
-        @composer = nil
-      end
-
-      def template=(template)
-        raise MissingComposer 'Cannot set template without a composer' if @composer.nil?
-        @composer.template = template
-      end
-
-      def template
-        raise MissingComposer 'Cannot get template without a composer' if @composer.nil?
-        @composer.template
-      end
-
-      def page=(page)
-        raise MissingComposer, 'Cannot set page without a composer' if @composer.nil?
-        @composer.page = page
-      end
-
-      def page
-        raise MissingComposer 'Cannot get page without a composer' if @composer.nil?
-        @composer.page
-      end
-
-      def container(name)
-        raise MissingComposer 'Cannot get container without a composer' if @composer.nil?
-        @composer.container(name)
-      end
-
-      def partial(name)
-        raise MissingComposer 'Cannot get partial without a composer' if @composer.nil?
-        @composer.partial(name)
-      end
-
-      def path=(path)
-        setup_for_path(path, true)
-      end
-
-      def compose(opts = {}, &block)
-        compose_at(@path, opts, &block)
-      end
-
-      def compose_at(path, opts = {}, &block)
-        @composer = ViewComposer.from_path(store, path, opts, &block)
-      end
-
-      def has_path?
-        !@path.nil?
-      end
-
-      protected
-
-      def setup
-        @view, @composer = nil
-        self.store = :default
-      end
-
-      def setup_for_path(path, explicit = false)
-        if composer = composer_for_path(path)
-          @composer = composer
-          @path = path
-          return
-        end
-
-        e = MissingView.new("No view at path '#{path}'")
-        explicit ? raise(e) : Pakyow.logger.info(e.message)
-      end
-
-      def load_views
-        @view_stores ||= {}
-
-        Pakyow::Config.presenter.view_stores.each_pair { |name, path|
-          next unless ViewStoreLoader.instance.modified?(name, path)
-          @view_stores[name] = ViewStore.new(path, name)
-        }
-      end
-
-      def load_bindings
-        @binder = Binder.instance.reset
-
-        Pakyow::App.bindings.each_pair {|set_name, block|
-          @binder.set(set_name, &block)
-        }
-      end
-
-      def load_processors
-        @processor_store = Pakyow::App.processors
-      end
-
-      def composer_for_path(path)
-        @view_stores.each do |name, store|
-          begin
-            return store.composer(path)
-          rescue MissingView
-          end
-        end
-
-        return nil
-      end
-    end
-  end
-end