bijou 0.1.0

data/lib/bijou/console/handler.rb

@@ -0,0 +1,4 @@
+
+require 'bijou/console/adapter'
+
+Bijou::Console::Adapter.handle

data/lib/bijou/console/request.rb

@@ -0,0 +1,26 @@
+
+require 'bijou/minicgi'
+require 'bijou/httprequest'
+
+module Bijou
+  module Console
+    #
+    # A very simple request object that takes a query string from the command
+    # line and feeds it to the component.
+    #
+    class Request < Bijou::HttpRequest
+      def initialize(qs)
+        super()
+
+        query_string = ::CGI::parse(qs) || {}
+
+        @query_string = Bijou::MiniCGI.singularize(query_string)
+
+        @form = @query_string.clone
+        @params = @query_string.clone
+
+        @http_method = 'GET'
+      end
+    end
+  end
+end

data/lib/bijou/context.rb

@@ -0,0 +1,431 @@
+#
+# Copyright (c) 2007-2008 Todd Lucas. All rights reserved.
+#
+# context.rb - Contains Context and related classes.
+#
+require 'bijou/common'
+require 'bijou/config'
+
+module Bijou
+  # Represents a single component in a component/container chain.
+  class Frame
+    attr_reader :output
+    attr_reader :args
+    attr_reader :component
+
+    def initialize(component)
+      @component = component
+      @output = ''
+      @args = {}
+    end
+
+    def flush
+      s = @output
+      @output = ''
+      s
+    end
+  end
+
+  # Each comonent/container chain is represented by a Stack object. The stack
+  # class contains a list of Frame objects and an output buffer.
+  class Stack
+    def initialize()
+      @frame_index = 0
+      @frames = []
+      @buffer = ''
+    end
+
+    attr_reader :buffer
+    attr_reader :frames
+
+    def index
+      @frame_index
+    end
+
+    def to_s
+      s = ''
+      @frames.each {|f|
+        s << "'#{f.component}': "
+        s << "'#{f.output}' "
+      }
+      s << " -> '#{@buffer}'"
+      s
+    end
+
+    def push_frame(component)
+      if @frames.length > 0
+        @buffer << @frames[-1].flush
+      end
+
+      @frames.push(Frame.new(component))
+    end
+
+    def start
+      @frame_index = @frames.length - 1
+    end
+
+    def top_frame
+      @frames[@frame_index]
+    end
+
+    def next_frame
+      @frame_index -= 1
+      top_frame
+    end
+
+    def peek_frame(offset = 1)
+      @frames[@frame_index - offset]
+    end
+
+    def flush_frame()
+      @buffer << top_frame.flush
+    end
+
+    def pop_frame()
+      flush_frame()
+#      @buffer << self.output
+      @frames.pop()
+    end
+
+    def output
+      @frames[@frame_index].output
+    end
+
+    def flush
+      s = @buffer
+      @buffer = ''
+      s
+    end
+  end
+
+  # Represents execution state shared by the execution contexts.
+  class Environment
+    def initialize()
+      @component = nil
+      @trace_level = Log::None
+      @trace_buffer = true
+      @log = ''
+      @trace = ''
+    end
+
+    attr_accessor :component, :trace_level, :trace_buffer
+
+    # Logs with carriage return.
+    def log(level, str)
+      @log << str + "\n"
+    end
+
+    # Logs without carriage return.
+    def log_(level, str)
+      @log << str
+    end
+
+    def get_log
+      @log
+    end
+
+    # Trace with carriage return.
+    def trace(level, str)
+      if level <= @trace_level
+        if @trace_buffer
+          @trace << str + "\n"
+        else
+          puts str
+        end
+      end
+    end
+
+    # Trace without carriage return.
+    def trace_(level, str)
+      if level <= @trace_level
+        if @trace_buffer
+          @trace << str
+        else
+          print str
+        end
+      end
+    end
+
+    def get_trace
+      @trace
+    end
+  end
+
+  #
+  # When a Bijou file is loaded by the processor, each component that is 
+  # encountered causes a Bijou::Component class to be instantiated in
+  # the context. This context can then be executed with a set of input
+  # arguments, causing each component to be evaluated and the output to be
+  # rendered. A context may be used to invoke the same arrangement of 
+  # components any number of times with different arguments.
+  #
+  class Context
+    attr_accessor :component_callback
+    attr_accessor :container_callback
+    attr_reader :stack
+    attr_reader :config
+    attr_reader :environment
+
+    attr_accessor :cgi
+    attr_accessor :request
+    attr_accessor :response
+
+    def initialize(config, environment=nil)
+      if !environment 
+        environment = Environment.new
+        environment.trace_level = config.trace_level
+        environment.trace_buffer = config.trace_buffer
+      end
+      
+      @args = {}
+      @stack = Stack.new
+      @config = config
+      @environment = environment
+      @container_callback = nil
+      @component_callback = nil
+
+      @request = nil
+      @response = nil
+
+      @cgi = nil
+    end
+    
+    # Called after clone
+    def reset()
+      @args = {}
+      @stack = Stack.new
+    end
+
+    def write(str)
+      @stack.output << str
+    end
+
+    def writeline(str)
+      @stack.output << str + "\n"
+    end
+
+    def output
+      @stack.buffer
+    end
+
+    def clear
+      @stack.flush
+    end
+
+    # Used to retrieve the last active frame in the event of an exception.
+    def source_filename
+      if @environment.component
+        @environment.component.class.source_filename
+      else
+        nil
+      end
+    end
+
+    # Used to retrieve the last active frame in the event of an exception.
+    def cache_filename
+      if @environment.component
+        @environment.component.class.cache_filename
+      else
+        nil
+      end
+    end
+
+    def add_component(component)
+      @stack.push_frame(component)
+
+      # If the owner registered a container load handler, invoke after the
+      # component has been added.
+      if component.class.container && @container_callback
+        @container_callback.call(self, component.class.container)
+      end
+    end
+
+    def render(args)
+      trace Bijou::Log::Info, "render init"
+
+      prev_component = @environment.component
+
+      # Init may render, after the headers but before the page text.
+      @stack.frames.each { |frame|
+        @environment.component = frame.component
+        frame.component.init(args)
+      }
+
+      @environment.component = prev_component
+
+      # Render the component chain to the response target.
+      render_component(args)
+
+      trace Bijou::Log::Info, "render fini"
+
+      # Fini may still render to the stream, at the end after the page text.
+      @stack.frames.each { |frame|
+        @environment.component = frame.component
+        frame.component.fini()
+      }
+
+      @environment.component = prev_component
+
+      return @output
+    end
+
+    # The render method renders the component chain.
+    def render_component(args)
+      if @stack.frames.length == 0
+        return
+      end
+
+      # Set top-level args so they are available to all components.
+      @args = args
+
+      # Start with the outer-most container at the end of the list.
+      @stack.start
+
+      prev_component = @environment.component
+
+      component = @stack.top_frame.component
+      @environment.component = component
+      component.render(@args)
+      @environment.component = prev_component
+
+      # This flushes the component's output to the stack's buffer.
+      @stack.flush_frame
+    end
+
+    # Container modules render their callers by calling the content method
+    # once at the location where the caller's output should be rendered.
+    def call_next(extra={})
+      if @stack.index == 0
+        raise 'next called too many times'
+      end
+
+      # Flush the first part of the component's output to the stack's buffer.
+      @stack.flush_frame
+
+      prev_component = @environment.component
+
+      # REVIEW: Argument merge and override is experimental.
+      # Render the child content.
+      component = @stack.next_frame.component
+      @environment.component = component
+      component.render(@args.merge(extra))
+      @environment.component = prev_component
+
+      # The remainder of the content will be flushed at the end of render.
+      # @stack.flush_frame
+    end
+
+    def try_fetch_next
+      if @stack.index == 0
+        nil
+      else
+        @stack.peek_frame
+      end
+    end
+
+    def fetch_next
+      try_fetch_next || raise('fetch_next cannot find next component')
+    end
+
+    def try_fetch_remainder
+      if @stack.index == 0
+        nil
+      else
+        @stack.frames[0, @stack.index].reverse
+      end
+    end
+
+    def fetch_remainder
+      try_fetch_remainder || raise('fetch_remainder cannot find next component')
+    end
+
+    # Used to invoke a method or a component. The output is rendered to a
+    # string, which is returned as the result. If no match is found returns nil.
+    def sinvoke(name, args)
+      # Does this look like a method? We don't include setters, etc. (?!=).
+      if name =~ /[_a-z][_a-z0-9]*/
+        prev_component = @environment.component
+
+        # Do any of the components support this method?
+        @stack.frames.each { |f|
+          if f.component.respond_to?(name)
+            @stack.flush_frame
+            @environment.component = f.component
+            m = f.component.method(name)
+            m.call(args)
+            @environment.component = prev_component
+            return @stack.top_frame.flush
+          end
+        }
+
+        @environment.component = prev_component
+      end
+      
+      # Delegate to context owner
+      if @component_callback
+        # The subcontext wraps a new stack for the component, but shares 
+        # common data. This allows us to encapsulate the rendered output
+        # into a separate buffer chain.
+        subcontext = self.clone
+        subcontext.reset
+
+        # TODO: Handle new context and buffer merging.
+        @component_callback.call(subcontext, name, args)
+
+        return subcontext.stack.flush
+      end
+
+      nil
+    end
+
+    # Used to invoke a method or a component. The output is rendered to the
+    # buffer. Returns true if a match was found.
+    def invoke(name, args)
+      if name == 'content'
+        # REVIEW: This is an experimental feature. An alternative (without 
+        # argument support) is <%content>, but it is an unclosed tag.
+        return call_next(args)
+      end
+
+      if text = sinvoke(name, args)
+        write text
+        return true
+      end
+
+      false
+    end
+
+    def argument_exception(method, name)
+      # BUGBUG: We need to print the page (component) name.
+      raise "Expected argument '#{name}' to method '#{method}'"
+    end
+
+    # Logs with carriage return.
+    def log(level, str)
+      @environment.log(level, str)
+    end
+
+    # Logs without carriage return.
+    def log_(level, str)
+      @environment.log_(level, str)
+    end
+
+    def get_log()
+      @environment.get_log()
+    end
+
+    # Trace with carriage return.
+    def trace(level, str)
+      @environment.trace(level, str)
+    end
+
+    # Trace without carriage return.
+    def trace_(level, str)
+      @environment.trace_(level, str)
+    end
+
+    def get_trace()
+      @environment.get_trace()
+    end
+  end
+end