alfred-workflow 1.11.3 → 2.0.0

data/lib/alfred.rb

@@ -3,10 +3,15 @@ require 'rubygems' unless defined? Gem # rubygems is only needed in 1.8
 require 'plist'
 require 'fileutils'
 require 'yaml'
+require 'optparse'
+require 'ostruct'
+require 'gyoku'
+require 'nori'
 
 require 'alfred/ui'
 require 'alfred/feedback'
 require 'alfred/setting'
+require 'alfred/handler/help'
 
 module Alfred
 
@@ -18,15 +23,33 @@ module Alfred
 
   class ObjCError           < AlfredError; status_code(1) ; end
   class NoBundleIDError     < AlfredError; status_code(2) ; end
+  class InvalidArgument     < AlfredError; status_code(10) ; end
   class InvalidFormat       < AlfredError; status_code(11) ; end
   class NoMethodError       < AlfredError; status_code(13) ; end
   class PathError           < AlfredError; status_code(14) ; end
 
   class << self
 
+    #
+    # Default entry point to build alfred workflow with this gem
+    #
+    # Example:
+    #
+    #    class MyHandler < ::Alfred::Handler::Base
+    #      # ......
+    #    end
+    #    Alfred.with_friendly_error do |alfred|
+    #      alfred.with_rescue_feedback = true
+    #      alfred.with_help_feedback = true
+    #      MyHandler.new(alfred).register
+    #    end
+    #
     def with_friendly_error(alfred = Alfred::Core.new, &blk)
       begin
+
         yield alfred
+        alfred.start_handler
+
       rescue AlfredError => e
         alfred.ui.error e.message
         alfred.ui.debug e.backtrace.join("\n")
@@ -42,6 +65,8 @@ module Alfred
       rescue SystemExit => e
         puts alfred.rescue_feedback(
           :title => "SystemExit: #{e.status}") if alfred.with_rescue_feedback
+        alfred.ui.error e.message
+        alfred.ui.debug e.backtrace.join("\n")
         exit e.status
       rescue Exception => e
         alfred.ui.error(
@@ -83,41 +108,190 @@ __APPLESCRIPT__}.chop
   end
 
   class Core
-    attr_accessor :with_rescue_feedback
-    attr_accessor :with_help_feedback
+    attr_accessor :with_rescue_feedback, :with_help_feedback
+    attr_accessor :cached_feedback_reload_option
 
-    def initialize(with_help_feedback = false,
-                   with_rescue_feedback = false,
-                   &blk)
-      @workflow_dir = Dir.pwd
-      @with_rescue_feedback = with_rescue_feedback
-      @with_help_feedback = with_rescue_feedback
+    attr_reader :handler_controller
+    attr_reader :query, :raw_query
+
+
+    def initialize(&blk)
+      @with_rescue_feedback = true
+      @with_help_feedback = false
+      @cached_feedback_reload_option = {
+        :use_reload_option => false,
+        :use_exclamation_mark => false
+      }
+
+      @query = ARGV
+      @raw_query = ARGV.dup
+
+      @handler_controller = ::Alfred::Handler::Controller.new
 
       instance_eval(&blk) if block_given?
+
+      raise NoBundleIDError unless bundle_id
+    end
+
+
+    def debug?
+      ui.level >= LogUI::WARN
+    end
+
+    #
+    # Main loop to work with handlers
+    #
+    def start_handler
+
+      if @with_help_feedback
+        ::Alfred::Handler::Help.new(self, :with_handler_help => true).register
+      end
+
+      return if @handler_controller.empty?
+
+      # step 1: register option parser for handlers
+      @handler_controller.each do |handler|
+        handler.on_parser
+      end
+
+      begin
+        query_parser.parse!
+      rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+        ui.warn(
+          "Fail to parse user query.\n" \
+          "  #{e.inspect}\n  #{e.backtrace.join("  \n")}\n") if debug?
+      end
+
+      if @cached_feedback_reload_option[:use_exclamation_mark] && !options.should_reload_cached_feedback
+        if ARGV[0].eql?('!')
+          ARGV.shift
+          options.should_reload_cached_feedback = true
+        elsif ARGV[-1].eql?('!')
+          ARGV.delete_at(-1)
+          options.should_reload_cached_feedback = true
+        end
+      end
+
+      @query = ARGV
+
+      # step 2: dispatch options to handler for FEEDBACK or ACTION
+      case options.workflow_mode
+      when :feedback
+        @handler_controller.each_handler do |handler|
+          handler.on_feedback
+        end
+
+        puts feedback.to_alfred(@query)
+      when :action
+        arg = @query
+        if @query.length == 1
+          if hsh = xml_parser(@query[0])
+            arg = hsh
+          end
+        end
+
+        if arg.is_a?(Hash)
+          @handler_controller.each_handler do |handler|
+            handler.on_action(arg)
+          end
+        else
+          #fallback default action
+          arg.each do |a|
+            if File.exist? a
+              %x{open "#{a}"}
+            end
+          end
+        end
+      else
+        raise InvalidArgument, "#{options.workflow_mode} mode is not supported."
+      end
+
+      # step 3: close
+      close
+      @handler_controller.each_handler do |handler|
+        handler.on_close
+      end
+
+    end
+
+    def close
+      @feedback.close if @feedback
+      @setting.close if @setting
+      # @workflow_setting.close if @workflow_setting
+    end
+
+
+    #
+    # Parse and return user query to three parts
+    #
+    #   [ [before], last option, tail ]
+    #
+    def last_option
+      (@raw_query.size - 1).downto(0) do |i|
+        if @raw_query[i].start_with? '-'
+          if @raw_query[i] == @raw_query[-1]
+            return @raw_query[0...i], '', @raw_query[i]
+          else
+            return @raw_query[0..i], @raw_query[i], @raw_query[(i + 1)..-1].join(' ')
+          end
+        end
+      end
+
+      return [], '', @raw_query.join(' ')
+    end
+
+    def options(opts = {})
+      @options ||= OpenStruct.new(opts)
+    end
+
+    def query_parser
+      @query_parser ||= init_query_parser
+    end
+
+    def xml_parser(xml)
+      @xml_parser ||= Nori.new(:parser => :rexml,
+                               :convert_tags_to => lambda { |tag| tag.to_sym })
+      begin
+        hsh = @xml_parser.parse(xml)
+        return hsh[:root]
+      rescue REXML::ParseException, Nokogiri::XML::SyntaxError
+        return nil
+      end
+    end
+
+    def xml_builder(arg)
+      Gyoku.xml(:root => arg)
     end
 
     def ui
-      raise NoBundleIDError unless bundle_id
       @ui ||= LogUI.new(bundle_id)
     end
 
-    def setting(&blk)
-      @setting ||= Setting.new(self, &blk)
-    end
 
+    #
+    # workflow setting is stored in the workflow_folder
+    #
     def workflow_setting(opts = {})
-      @workflow_setting ||= init_workflow_setting(opts)
+      @workflow_setting ||= new_setting(opts)
     end
 
-    def with_cached_feedback(&blk)
-      @feedback = CachedFeedback.new(self, &blk)
+    #
+    # user setting is stored in the storage_path by default
+    #
+    def user_setting(&blk)
+      @setting ||= new_setting(
+        :file => File.join(storage_path, "setting.yaml")
+      )
     end
+    alias_method :setting, :user_setting
 
-    def feedback
-      raise NoBundleIDError unless bundle_id
-      @feedback ||= Feedback.new
+
+    def feedback(opts = {}, &blk)
+      @feedback ||= new_feedback(opts, &blk)
     end
 
+    alias_method :with_cached_feedback, :feedback
+
     def info_plist
       @info_plist ||= Plist::parse_xml('info.plist')
     end
@@ -128,9 +302,8 @@ __APPLESCRIPT__}.chop
     end
 
     def volatile_storage_path
-      raise NoBundleIDError unless bundle_id
       path = "#{ENV['HOME']}/Library/Caches/com.runningwithcrayons.Alfred-2/Workflow Data/#{bundle_id}"
-      unless File.exist?(path)
+      unless File.directory?(path)
         FileUtils.mkdir_p(path)
       end
       path
@@ -138,7 +311,6 @@ __APPLESCRIPT__}.chop
 
     # Non-volatile storage directory for this bundle
     def storage_path
-      raise NoBundleIDError unless bundle_id
       path = "#{ENV['HOME']}/Library/Application Support/Alfred 2/Workflow Data/#{bundle_id}"
       unless File.exist?(path)
         FileUtils.mkdir_p(path)
@@ -147,55 +319,111 @@ __APPLESCRIPT__}.chop
     end
 
 
-    def help_feedback(opts = {})
-      ws = workflow_setting.load
-      if ws.has_key? :help
-        ws[:help].map do |item|
-          case item[:kind]
-          when 'url'
-            item[:folder] = storage_path
-            Feedback::UrlItem.new(item)
-          end
-        end
-      end
+    def cached_feedback?
+      @cached_feedback_reload_option.values.any?
     end
 
 
     def rescue_feedback(opts = {})
       default_opts = {
-        :title    => "Failed Query!",
-        :subtitle => "Check the log file below for extra debug info.",
-        :uid      => 'Rescue Feedback',
-        :icon     => {
-          :type => "default" ,
-          :name => "/System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/AlertStopIcon.icns"
-        }
+        :title        => "Failed Query!"                                  ,
+        :subtitle     => "Check log #{ui.log_file} for extra debug info." ,
+        :uid          => 'Rescue Feedback'                                ,
+        :valid        => 'no'                                             ,
+        :autocomplete => ''                                               ,
+        :icon         => Feedback.CoreServicesIcon('AlertStopIcon')
       }
+      if @with_help_feedback
+       default_opts[:autocomplete] = '-h'
+      end
       opts = default_opts.update(opts)
 
       items = []
       items << Feedback::Item.new(opts[:title], opts)
-      items << Feedback::FileItem.new(ui.log_file)
+      log_item = Feedback::FileItem.new(ui.log_file)
+      log_item.uid = nil
+      items << log_item
 
       feedback.to_alfred('', items)
     end
 
-    private
+    def on_help
+      reload_help_item
+    end
+
 
-    def init_workflow_setting(opts)
+    def new_feedback(opts, &blk)
+      ::Alfred::Feedback.new(self, opts, &blk)
+    end
+
+
+    def new_setting(opts)
       default_opts = {
-        :file    => "setting.yaml",
+        :file    => File.join(Alfred.workflow_folder, "setting.yaml"),
         :format  => 'yaml',
       }
       opts = default_opts.update(opts)
 
-      @workflow_setting = Setting.new(self) do
-        use_setting_file opts
+      ::Alfred::Setting.new(self) do
+        @backend_file = opts[:file]
+        @formt = opts[:format]
       end
-      @workflow_setting
     end
 
-  end
+    private
+
+    def reload_help_item
+      title = []
+      if  @cached_feedback_reload_option[:use_exclamation_mark]
+        title.push "!"
+      end
+
+      if @cached_feedback_reload_option[:use_reload_option]
+        title.push "-r, --reload"
+      end
+
+      unless title.empty?
+        return {
+          :kind  => 'text',
+          :order => (Handler::HelpItem::Base_Order * 10),
+          :title => "#{title.join(', ')} [Reload cached feedback unconditionally]" ,
+          :subtitle => %q{The '!' mark must be at the beginning or end of the query.} ,
+        }
+      else
+        return nil
+      end
+    end
 
+    def init_query_parser
+      options.workflow_mode = :feedback
+      options.modifier = :none
+      options.should_reload_cached_feedback = false
+
+      modifiers = [:command, :alt, :control, :shift, :fn, :none]
+      OptionParser.new do |opts|
+        opts.separator ""
+        opts.separator "Built-in Options:"
+
+        opts.on("--workflow-mode [TYPE]", [:feedback, :action],
+                "Alfred handler working mode (feedback, action)") do |t|
+          options.workflow_mode = t
+        end
+
+        opts.on("--modifier [MODIFIER]", modifiers,
+                "Alfred action modifier (#{modifiers})") do |t|
+          options.modifier = t
+        end
+
+        if @cached_feedback_reload_option[:use_reload_option]
+          opts.on("-r", "--reload", "Reload cached feedback") do
+            options.should_reload_cached_feedback = true
+          end
+        end
+        opts.separator ""
+        opts.separator "Handler Options:"
+      end
+
+    end
+  end
 end
 

data/lib/alfred/feedback.rb

@@ -1,14 +1,20 @@
 require "rexml/document"
 require 'alfred/feedback/item'
 require 'alfred/feedback/file_item'
+require 'alfred/feedback/webloc_item'
 
 module Alfred
 
   class Feedback
     attr_accessor :items
+    attr_reader :backend_file
 
-    def initialize
+    def initialize(alfred, opts = {}, &blk)
       @items = []
+      @core = alfred
+      use_backend(opts)
+      instance_eval(&blk) if block_given?
+
     end
 
     def add_item(opts = {})
@@ -20,6 +26,13 @@ module Alfred
       @items << FileItem.new(path, opts)
     end
 
+    def add_webloc_item(path, opts = {})
+      unless opts[:folder]
+        opts[:folder] = @core.storage_path
+      end
+      @items << WeblocItem.new(path, opts)
+    end
+
     def to_xml(with_query = '', items = @items)
       document = REXML::Element.new("items")
       if with_query.empty?
@@ -36,47 +49,122 @@ module Alfred
 
     alias_method :to_alfred, :to_xml
 
+    #
+    # Merge with other feedback
+    #
+    def merge!(other)
+      if other.is_a? Array
+        @items |= other
+      elsif other.is_a? Alfred::Feedback
+        @items |= other.items
+      else
+        raise ArgumentError, "Feedback can not merge with #{other.class}"
+      end
+    end
 
+    #
+    # The workflow is about to complete
+    #
+    # - save cached feedback if necessary
+    #
+    def close
+      put_cached_feedback if @backend_file
+    end
 
-    # serialize
-    def dump(to_file)
-      File.open(to_file, "wb") { |f| Marshal.dump(@items, f) }
+    #
+    # ## helper class method for icon
+    #
+    def self.CoreServicesIcon(name)
+      {
+        :type => "default" ,
+        :name => "/System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/#{name}.icns"
+      }
     end
 
-    def load(from_file)
-      @items = File.open(from_file, "rb") { |f| Marshal.load(f) }
+    def self.Icon(name)
+      {
+        :type => "default" ,
+        :name => name       ,
+      }
+    end
+    def self.FileIcon(path)
+      {
+        :type => "fileicon" ,
+        :name => path       ,
+      }
     end
-  end
 
 
-  class CachedFeedback < Feedback
-    def initialize(alfred, &blk)
-      super()
-      @core = alfred
+    #
+    # ## serialization
+    #
 
-      instance_eval(&blk) if block_given?
+    def use_backend(opts = {})
+      @backend_file = opts[:file] if opts[:file]
+      @should_expire_after_second = opts[:expire].to_i if opts[:expire]
     end
+    alias_method :use_cache_file, :use_backend
 
-    def use_cache_file(opts = {})
-      @cf_file = opts[:file] if opts[:file]
-      @cf_file_valid_time = opts[:expire] if opts[:expire]
+    def backend_file
+      @backend_file ||= File.join(@core.volatile_storage_path, "cached_feedback")
     end
 
-    def cache_file
-      @cf_file ||= File.join(@core.volatile_storage_path, "cached_feedback")
+    def expired?
+      return false unless @should_expire_after_second
+      Time.now - File.ctime(backend_file) > @should_expire_after_second
     end
+
     def get_cached_feedback
-      return nil unless File.exist?(cache_file)
-      if @cf_file_valid_time
-        return nil if Time.now - File.ctime(cache_file) > @cf_file_valid_time
-      end
-      load(@cf_file)
-      return self
+      return nil unless File.exist?(backend_file)
+      return nil if expired?
+
+      load(@backend_file)
+      self
     end
 
     def put_cached_feedback
-      dump(cache_file)
+      dump(backend_file)
+    end
+
+    def dump(to_file)
+      File.open(to_file, "wb") { |f| Marshal.dump(@items, f) }
+    end
+
+    def load(from_file)
+      @items = File.open(from_file, "rb") { |f| Marshal.load(f) }
+    end
+
+    def append(from_file)
+      @items << File.open(from_file, "rb") { |f| Marshal.load(f) }
+    end
+
+    #
+    # Provides yaml serialization support
+    #
+    if RUBY_VERSION < "1.9"
+      def to_yaml_properties
+        [ '@items' ]
+      end
+    else
+      def encode_with(coder)
+        coder['items'] = @items
+      end
     end
+
+    #
+    # Provides marshalling support for use by the Marshal library.
+    #
+    def marshal_dump
+      @items
+    end
+
+    #
+    # Provides marshalling support for use by the Marshal library.
+    #
+    def marshal_load(x)
+      @items = x
+    end
+
   end
 
 end