olelo 0.9.0

data/lib/olelo/patch.rb

@@ -0,0 +1,311 @@
+module Olelo
+  class PatchParser
+    include Util
+
+    class Handler
+      include Util
+
+      def initialize!
+      end
+
+      def finalize!
+      end
+
+      def begin!(src, dst)
+      end
+
+      def end!
+      end
+
+      def binary!
+      end
+
+      def deleted!
+      end
+
+      def no_changes!
+      end
+
+      def separator!
+      end
+
+      def insertion!(line)
+      end
+
+      def deletion!(line)
+      end
+
+      def context!(line)
+      end
+
+      def line!(line)
+        case line[0..0]
+        when '@'
+          separator!
+        when '+'
+          insertion!(line[1..-1])
+        when '-'
+          deletion!(line[1..-1])
+        else
+          context!(line[1..-1])
+        end
+      end
+    end
+
+    class Debugger
+      def method_missing(name, *args)
+        puts "#{name}: #{args.inspect}"
+      end
+    end
+
+    class Adapter
+      def initialize(adapter)
+        @adapter = adapter
+      end
+
+      def method_missing(name, *args)
+        @adapter.each {|a| a.send(name, *args) }
+      end
+    end
+
+    class ChangeHandler < Handler
+      def end!
+        handle_change
+      end
+
+      def change!(deletion, insertion)
+        deletion!(deletion)
+        insertion!(insertion)
+      end
+
+      def line!(line)
+        ch = line[0..0]
+        case ch
+        when '@'
+          handle_change
+          separator!
+        when '+'
+          handle_change if @deletion && @first == '+'
+          @first ||= '+'
+          (@insertion ||= '') << line[1..-1] << "\n"
+        when '-'
+          handle_change if @insertion && @first == '-'
+          @first ||= '-'
+          (@deletion ||= '') << line[1..-1] << "\n"
+        when ' '
+          handle_change
+          context!(line[1..-1] + "\n")
+        end
+      end
+
+      private
+
+      def handle_change
+        if @insertion && @deletion
+          change!(@deletion, @insertion)
+        elsif @insertion
+          insertion!(@insertion)
+        elsif @deletion
+          deletion!(@deletion)
+        end
+        @insertion = @deletion = @first = nil
+      end
+    end
+
+    def self.parse(patch, *h)
+      h = h.size == 1 ? h[0] : Adapter.new(h)
+      src = dst = nil
+      state = :start
+      h.initialize!
+      patch.split("\n").each do |line|
+        case state
+        when :start
+          case line
+          when %r{^diff.* ("?a/.*"?) ("?b/.*"?)$}
+            src, dst = unescape_path($1), unescape_path($2)
+            state = :header
+          when /^\+\+\+ (.*)/
+            dst = unescape_path($1)
+            state = :header
+          when /^\-\-\- (.*)/
+            src = unescape_path($1)
+            state = :header
+          end
+        when :header
+          case line
+          when %r{^diff.* ("?a/.*"?) ("?b/.*"?)$}
+            a, b = $1, $2
+            h.begin!(src, dst)
+            dst ? h.no_changes! : h.deleted!
+            h.end!
+            src, dst = unescape_path(a), unescape_path(b)
+          when /^\+\+\+ (.*)/
+            dst = unescape_path($1)
+          when /^\-\-\- (.*)/
+            src = unescape_path($1)
+          when /^deleted file/
+            dst = nil
+          when /^Binary files (.*) and (.*) differ/
+            src, dst = unescape_path($1), unescape_path($2)
+            h.begin!(src, dst)
+            h.binary!
+            h.end!
+            state = :start
+          when /^@/
+            state = :body
+            h.begin!(src, dst)
+          end
+        when :body
+          case line
+          when %r{^diff.* ("?a/.*"?) ("?b/.*"?)$}
+            src, dst = unescape_path($1), unescape_path($2)
+            h.end!
+            state = :header
+          else
+            h.line!(line)
+          end
+        end
+      end
+      case state
+      when :header
+        h.begin!(src, dst)
+        dst ? h.no_changes! : h.deleted!
+        h.end!
+      when :body
+        h.end!
+      end
+      h.finalize!
+      h
+    end
+
+    def self.unescape_path(path)
+      path = unescape_backslash(path[1..-2]) if path.starts_with? '"'
+      path == '/dev/null' ? nil : path[2..-1]
+    end
+  end
+
+  class PatchSummary < PatchParser::Handler
+    attr_reader :html
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def initialize!
+      @html = %{<table class="patch-summary"><thead><tr><th>#{escape_html :summary.t}</th><th class="ins">+</th><th class="del">-</th></tr></thead><tbody>}
+      @file = 0
+    end
+
+    def finalize!
+      @html << %{<tr><td colspan="3">#{escape_html :no_changes.t}</td></tr>} if @file == 0
+      @html << "</tbody></table>"
+    end
+
+    def begin!(src, dst)
+      @src, @dst = src, dst
+      @ins = @del = 0
+    end
+
+    def end!
+      if @src && @dst
+        if @src == @dst
+          @html << %{<tr class="edit"><td class="name">#{link(escape_html @src)}</td><td class="ins">#{@ins}</td><td class="del">#{@del}</td></tr>}
+        else
+          text = "#{escape_html @src} &#8594; #{escape_html @dst}"
+          @html << %{<tr class="move"><td class="name">#{link text}</td><td class="ins">#{@ins}</td><td class="del">#{@del}</td></tr>}
+        end
+      elsif @src
+        @html << %{<tr class="delete"><td class="name">#{link(escape_html @src)}</td><td class="ins">#{@ins}</td><td class="del">#{@del}</td></tr>}
+      else
+        @html << %{<tr class="new"><td class="name">#{link(escape_html @dst)}</td><td class="ins">#{@ins}</td><td class="del">#{@del}</td></tr>}
+      end
+      @file += 1
+    end
+
+    def binary!
+      @ins = @del = '-'
+    end
+
+    def insertion!(line)
+      @ins += 1
+    end
+
+    def deletion!(line)
+      @del += 1
+    end
+
+    def link(text)
+      @options[:links] ? %{<a href="#patch-#{@file}">#{text}</a>} : text
+    end
+  end
+
+  class PatchFormatter < PatchParser::ChangeHandler
+    attr_reader :html
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def initialize!
+      @html = ''
+      @file = 0
+    end
+
+    def begin!(src, dst)
+      super
+      @html << '<table class="patch"'
+      @html << %{ id="patch-#{@file}"} if @options[:links]
+      if @options[:header]
+        @html << '><thead><tr class="'
+        if src && dst
+          if src == dst
+            @html << 'edit"><th>' << escape_html(src)
+          else
+            @html << 'move"><th>' << escape_html(src) << ' &#8594; ' << escape_html(dst)
+          end
+        elsif src
+          @html << 'delete"><th>' << escape_html(src)
+        else
+          @html << 'new"><th>' << escape_html(dst)
+        end
+        @html << '</th></tr></thead><tbody><tr><td><pre>'
+      else
+        @html << '><tbody><tr><td><pre>'
+      end
+    end
+
+    def end!
+      super
+      @html << '</pre></td></tr></tbody></table>'
+      @file += 1
+    end
+
+    def binary!
+      @html << escape_html(:binary_file.t)
+    end
+
+    def deleted!
+      @html << escape_html(:deleted.t)
+    end
+
+    def no_changes!
+      @html << escape_html(:no_changes.t)
+    end
+
+    def separator!
+      @html << '</pre></td></tr><tr><td><pre>'
+    end
+
+    def insertion!(text)
+      @html << '<ins>' << escape_html(text) << '</ins>'
+    end
+
+    def deletion!(text)
+      @html << '<del>' << escape_html(text) << '</del>'
+    end
+
+    def context!(text)
+      @html << escape_html(text)
+    end
+  end
+end

data/lib/olelo/plugin.rb

@@ -0,0 +1,188 @@
+module Olelo
+  # Olelo plugin system
+  class Plugin < Module
+    include Util
+    include Hooks
+
+    has_around_hooks :load
+
+    @loaded = {}
+    @failed = []
+    @disabled = []
+    @dir = ''
+
+    class<< self
+      attr_accessor :dir, :disabled
+
+      # Get failed plugins
+      attr_reader :failed
+
+      # Current plugin
+      def caller
+        last, stack = nil, []
+        Kernel.caller(1).each do |line|
+          if line =~ %r{^#{@dir}/(.+?)(?:\/main)?\.rb} && $1 != last
+            stack << @loaded[$1]
+            last = $1
+          end
+        end
+        stack
+      end
+
+      # Get loaded plugins
+      def loaded
+        @loaded.values
+      end
+
+      # Start plugins
+      # @return [void]
+      def start
+        @loaded.each_value {|plugin| plugin.start }
+      end
+
+      def register(path, plugin)
+        @loaded[path] = plugin
+      end
+
+      # Load plugins by path
+      #
+      # @param list List of plugin paths to load
+      # @return [Boolean] true if every plugin was loaded
+      def load(*list)
+        files = list.map {|path| [File.join(@dir, path, 'main.rb'), File.join(@dir, "#{path}.rb")] }.flatten.select {|file| File.file?(file) }
+        return false if files.empty?
+        files.inject(true) do |result,file|
+          path = File.basename(file) == 'main.rb' ? file[(@dir.size+1)..-9] : file[(@dir.size+1)..-4]
+          if @loaded.include?(path)
+	    result
+	  elsif @failed.include?(path) || !enabled?(path)
+	    false
+	  else
+            begin
+	      new(path, file)
+            rescue Exception => ex
+              @failed << path
+              if LoadError === ex
+                Olelo.logger.warn "Plugin #{path} could not be loaded due to: #{ex.message} (Missing gem?)"
+              else
+                Olelo.logger.error "Plugin #{path} could not be loaded due to: #{ex.message}"
+                Olelo.logger.error ex
+              end
+              @loaded.delete(path)
+              false
+            end
+	  end
+        end
+      end
+
+      # Load all plugins
+      def load_all
+        load(*Dir[File.join(@dir, '**', '*.rb')].map {|file| file[(@dir.size+1)..-4] })
+      end
+
+      # Check if plugin is enabled
+      #
+      # @param [String] plugin path
+      # @return [Boolean] true if enabled
+      #
+      def enabled?(path)
+        path.split('/').inject('') do |parent, x|
+          parent /= x
+          return false if disabled.include?(parent)
+          parent
+        end
+        true
+      end
+
+      def for(obj)
+        if Module === obj
+          names = obj.name.split('::')
+          mod = Object
+          names.map {|name| mod = mod.const_get(name) }.reverse.each do |mod|
+            return mod if Plugin === mod
+          end
+        elsif Proc === obj
+          return obj.binding.eval('PLUGIN')
+        else
+          raise 'Plugin cannot be found for #{obj}'
+        end
+      end
+    end
+
+    attr_reader :path, :file
+    attr_setter :description
+    attr_reader? :started
+
+    def initialize(path, file)
+      @path, @file = path, file
+      @started = false
+      @dependencies = Set.new
+      const_set(:PLUGIN, self)
+
+      with_hooks :load do
+        names = path.split('/')
+        names[0..-2].inject('') do |parent, x|
+          parent /= x
+          Plugin.load(parent)
+          parent
+        end
+
+        (0...names.length).inject(Plugin) do |mod, i|
+          elem = names[i].split('_').map(&:capitalize).join
+          if mod.local_const_defined?(elem)
+            mod.const_get(elem)
+          else
+            child = i == names.length - 1 ? self : Module.new
+            child.module_eval { include mod } if mod != Plugin
+            mod.const_set(elem, child)
+          end
+        end
+
+        Plugin.register(path, self)
+        module_eval(File.read(file), file)
+        Olelo.logger.debug("Plugin #{path} successfully loaded")
+      end
+    end
+
+    # Virtual filesystem used to load plugin assets
+    def virtual_fs
+      VirtualFS::Union.new(VirtualFS::Embedded.new(file),
+                           VirtualFS::Native.new(File.dirname(file)))
+    end
+
+    # Start the plugin by calling the {#setup} method
+    #
+    # @return [Boolean] true for success
+    def start
+      return true if @started
+      module_eval(&@setup) if @setup
+      Olelo.logger.debug "Plugin #{path} successfully started"
+      @started = true
+    rescue Exception => ex
+      Olelo.logger.error "Plugin #{path} failed to start due to: #{ex.message}"
+      Olelo.logger.error ex
+      false
+    end
+
+    # Load specified plugins and fail with LoadError if dependencies are missing
+    #
+    # @param list List of plugin paths to load
+    # @return List of dependencies (plugin paths)
+    def dependencies(*list)
+      if !list.empty?
+        raise 'Plugin is already started' if started?
+        @dependencies.merge(list)
+        list.each do |dep|
+          raise(LoadError, "Could not load dependency #{dep} for #{path}") if !Plugin.load(dep)
+        end
+      end
+      @dependencies
+    end
+
+    def setup(&block)
+      @setup = block
+    end
+
+    private_class_method :new
+  end
+end