alfred-workflow 1.11.3 → 2.0.0

data/lib/alfred/feedback/file_item.rb

@@ -8,8 +8,8 @@ module Alfred
       def initialize(path, opts = {})
         if opts[:title]
           @title = opts[:title]
-        elsif ['.ennote', '.webbookmark'].include? File.extname(path)
-          @title = %x{mdls -name kMDItemDisplayName -raw '#{path}'}
+        elsif ['.ennote', '.webbookmark', '.vcf', '.abcdp', '.olk14Contact'].include? File.extname(path)
+          @title = %x{/usr/bin/mdls -name kMDItemDisplayName -raw '#{path}'}
         else
           @title = File.basename(path)
         end
@@ -24,10 +24,6 @@ module Alfred
         super @title, opts
       end
 
-      def match?(query)
-        all_title_match?(query)
-      end
-
     end
   end
 end

data/lib/alfred/feedback/item.rb

@@ -63,6 +63,13 @@ module Alfred
         send(@matcher, query)
       end
 
+      #
+      # Matchers
+      #
+      def always_match?(query)
+        true
+      end
+
       def title_match?(query)
         return true if query.empty?
         if smartcase_query(query).match(@title)
@@ -125,6 +132,9 @@ module Alfred
 
       protected
 
+      #
+      # Regex helpers
+      # 
       def build_regexp(query, option)
         begin
           Regexp.compile(".*#{query.gsub(/\s+/,'.*')}.*", option)

data/lib/alfred/feedback/webloc_item.rb

@@ -8,7 +8,7 @@ module Alfred
       def initialize(title, opts = {})
         unless File.exist? opts[:webloc]
           opts[:webloc] = ::Alfred::Util.make_webloc(
-            opts[:title], opts[:url], File.dirname(opts[:webloc]))
+            opts[:title], opts[:url], opts[:folder])
         end
 
         @subtitle = opts[:url]

data/lib/alfred/handler.rb

@@ -0,0 +1,133 @@
+require 'alfred/util'
+
+require 'set'
+require "rexml/document"
+
+module Alfred
+
+  module Handler
+    class Base
+      Base_Invoke_Order = 100
+
+      attr_reader :status, :order
+
+      def initialize(alfred, opts = {})
+        @core = alfred
+        @order = Base_Invoke_Order
+        @status = :initialize
+      end
+
+
+      def on_parser
+        ;
+      end
+
+      def on_help
+        []
+      end
+
+      def feedback?
+        true
+      end
+      def on_feedback
+        raise NotImplementedError
+      end
+
+      def action?(arg)
+        arg.is_a?(Hash) && arg[:handler].eql?(@settings[:handler])
+      end
+
+      def on_action(arg)
+        ;
+      end
+
+      def on_close
+        ;
+      end
+
+      def register
+        @core.handler_controller.register(self)
+      end
+
+      def <=>(other)
+        order <=> other.order
+      end
+
+
+      def status_message(text, exitstatus)
+        if exitstatus == 0
+          return "⭕ #{text}"
+        else
+          return "❌ #{text}"
+        end
+      end
+
+
+      # from alfred core
+      def xml_builder(arg)
+        @core.xml_builder(arg)
+      end
+
+      def options
+        @core.options
+      end
+
+      def parser
+        @core.query_parser
+      end
+
+      def query
+        @core.query
+      end
+
+      def ui
+        @core.ui
+      end
+
+      def feedback
+        @core.feedback
+      end
+    end
+
+
+    class Controller
+      ## handlers are called based on handler.order
+      # 1-10 : critical handler
+      # 100  : base order
+
+      include Enumerable
+
+      def initialize
+        @handlers = SortedSet.new
+        @status = {:break => [:break, :exclusive]}
+      end
+
+      def register(handler)
+        raise InvalidArgument unless handler.is_a? ::Alfred::Handler::Base
+        @handlers.add(handler)
+      end
+
+      def empty?
+        @handlers.empty?
+      end
+
+      def each
+        return enum_for(__method__) unless block_given?
+
+        @handlers.each do |h|
+          yield(h)
+        end
+      end
+
+      def each_handler
+        return enum_for(__method__) unless block_given?
+
+        @handlers.each do |h|
+          yield(h)
+          break if @status[:break].include?(h.status)
+        end
+      end
+
+    end
+  end
+end

data/lib/alfred/handler/autocomplete.rb

@@ -0,0 +1,86 @@
+require 'alfred/handler'
+require 'fuzzy_match'
+require 'amatch'
+
+module Alfred
+  module Handler
+
+    class Autocomplete < Base
+      def initialize(alfred, opts = {})
+        super
+        @settings = {
+          :handler        => 'Autocomplete' ,
+          :items          => {}             ,
+          :fuzzy_score    => 0.5            ,
+        }.update(opts)
+
+        if @settings[:items].empty?
+          @load_from_workflow_setting = true
+        else
+          @load_from_workflow_setting = false
+        end
+        FuzzyMatch.engine = :amatch
+      end
+
+
+
+      def on_feedback
+        if @load_from_workflow_setting
+          @settings[:items].merge! @core.workflow_setting[:autocomplete]
+        end
+
+        before, option, tail = @core.last_option
+
+        base_item ={
+          :match?   => :always_match?      ,
+          :subtitle => "↩ to autocomplete" ,
+          :valid    => 'no'                ,
+          :icon     => ::Alfred::Feedback.CoreServicesIcon('ForwardArrowIcon') ,
+        }
+
+        if @settings[:items].has_key? tail
+          unify_items(@settings[:items][tail]).each do |item|
+            base_item[:autocomplete] = "#{(before + [tail, item[:complete]]).join(' ')} "
+            feedback.add_item(base_item.update(item))
+          end
+        else
+          add_fuzzy_match_feedback(unify_items(@settings[:items][option]),
+                                   before, tail, base_item, feedback)
+        end
+      end
+
+
+      def add_fuzzy_match_feedback(items, before, query, base_item, to_feedback)
+        matcher = FuzzyMatch.new(items, :read => :complete)
+        matcher.find_all_with_score(query).each do |item, dice_similar, leven_similar|
+          next if item[:complete].size < query.size
+
+          if (item[:complete].start_with?(query) or
+              dice_similar > @settings[:fuzzy_score] or
+              leven_similar > @settings[:fuzzy_score])
+
+            base_item[:autocomplete] = "#{(before + [item[:complete]]).join(' ')} "
+            to_feedback.add_item(base_item.update(item))
+          end
+        end
+      end
+
+      def unify_items(items)
+        return [] unless items
+        items.map do |item|
+          if item.is_a? String
+            {:title => item, :complete => item}
+          elsif item.is_a? Hash
+            unless item.has_key? :complete
+              item[:complete] = item[:title]
+            end
+            item
+          else
+            raise InvalidArgument, "autocomplete handler can only accept string or hash"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/alfred/handler/callback.rb

@@ -0,0 +1,130 @@
+require 'moneta'
+require 'alfred/util'
+
+#
+# = Alfred Callback Hander
+#
+# Each callback is stored using Moneta via YAML backend.!
+#
+# == Example:
+#   Suppose we have a callback with key "demo"
+#
+# - @backend[ENTRIES_KEY] => {
+#   'demo' => {:key => 'demo', :title => 'title', :subtitle => ...}
+# }
+#
+# - @backend['demo'] => the feedback items
+#
+module Alfred::Handler
+
+  class Callback < Base
+    ENTRIES_KEY = 'feedback_entries'
+
+    def initialize(alfred, opts = {})
+      super
+      @settings = {
+        :handler       => 'Callback'                  ,
+        :exclusive?    => true                        ,
+        :backend_dir   => @core.volatile_storage_path ,
+        :backend_file  => 'callback.yaml'             ,
+        :handler_order => ( Base_Invoke_Order / 12 )
+      }.update(opts)
+
+      @order = @settings[:handler_order]
+    end
+
+
+    def on_parser
+      parser.on("--callback [CALLBACK]", "Alfred callback feedback") do |v|
+        options.callback = v || ''
+      end
+    end
+
+    def feedback?
+      options.callback
+    end
+
+    def on_feedback
+      return unless feedback?
+      if entries[options.callback]
+        feedback.merge! backend[options.callback]
+        @status = :exclusive if @settings[:exclusive?]
+
+      elsif entries.empty?
+        # show a warn feedback item
+        feedback.add_item(
+          {
+            :title        => 'No available callback!' ,
+            :valid        => 'no'                     ,
+            :autocomplete => ''                       ,
+            :subtitle     => 'Please check it later. Background task may still be running.',
+            :icon         => ::Alfred::Feedback.CoreServicesIcon('Unsupported') ,
+          }
+        )
+      else
+        # list available callbacks
+        entries.each do |key, entry|
+          feedback.add_item(
+            {
+              :title        => "Feedback Callback: #{key}" ,
+              :subtitle     => "#{entry[:timestamp]}",
+              :valid        => 'no'                        ,
+              :autocomplete => "--callback '#{key}'"       ,
+              :icon         => ::Alfred::Feedback.CoreServicesIcon('AliasBadgeIcon') ,
+            }.merge(entry)
+          )
+        end
+        @status = :exclusive if @settings[:exclusive?]
+      end
+    end
+
+
+    def on_close
+      backend.close
+    end
+
+
+    def on_callback(keyword, entry, feedback_items)
+      add_entry(entry, feedback_items)
+      Alfred::Util.notify("#{keyword} --callback '#{entry[:key]}'",
+                          entry[:title] || entry[:key],
+                          entry)
+    end
+
+
+    def add_entry(entry, feedback_items)
+      entry.merge!(:timestamp => Time.now)
+      key = entry[:key]
+      new_entries = entries.merge(key => entry)
+      backend[ENTRIES_KEY] = new_entries
+      backend[key] = feedback_items
+    end
+
+    def remove_entry(key)
+      new_entries = entries.delete(key)
+      backend[ENTRIES_KEY] = new_entries
+      backend.delete(key)
+    end
+
+
+
+    def entries
+      backend[ENTRIES_KEY]
+    end
+
+
+    def backend
+      @backend ||= Moneta.new(:YAML,
+                              :file => File.join(@settings[:backend_dir],
+                                                 @settings[:backend_file]))
+
+      unless @backend.key?(ENTRIES_KEY)
+        @backend[ENTRIES_KEY] = {}
+      end
+      @backend
+    end
+
+    private
+
+  end
+end

data/lib/alfred/handler/cofig.rb

@@ -0,0 +1,33 @@
+module Alfred::Handler
+
+  class Config < Base
+    def initialize(alfred, opts = {})
+      super
+      @order = 20
+      @settings = {
+        :setting => alfred.workflow_setting ,
+        :break?  => true                    ,
+        :handler => 'Config'
+      }.update(opts)
+
+    end
+
+    def on_parser
+      opts.on("-c", "--config CONFIG", "Config Workflow Settings") do |v|
+        options.config = v
+      end
+    end
+
+    def on_help
+      {
+        :kind     => 'text'                     ,
+        :title    => '-c, --config [query]'     ,
+        :subtitle => 'Config Workflow Settings' ,
+      }
+    end
+
+    def on_feedback
+    end
+
+  end
+end

data/lib/alfred/handler/help.rb

@@ -0,0 +1,162 @@
+require 'alfred/handler'
+
+
+module Alfred
+  module Handler
+
+    class HelpItem < ::Hash
+      Base_Order = 10
+      def initialize(attributes = {}, &block)
+        super(&block)
+        initialize_attributes(attributes)
+      end
+
+      def <=>(other)
+        self[:order] <=> other[:order]
+      end
+
+      private
+
+      def initialize_attributes(attributes)
+        attributes.each_pair do |att, value|
+          self[att] = value
+        end if attributes
+        self[:order] = Base_Order unless self[:order]
+      end
+    end
+
+
+    class Help < Base
+      def initialize(alfred, opts = {})
+        super
+        @settings = {
+          :handler           => 'Help'                     ,
+          :exclusive?        => true                       ,
+          :with_handler_help => true                       ,
+          :items             => []                         ,
+          :handler_order     => ( Base_Invoke_Order / 10 )
+        }.update(opts)
+
+        @order = @settings[:handler_order]
+
+        if @settings[:items].empty?
+          @load_from_workflow_setting = true
+        else
+          @load_from_workflow_setting = false
+        end
+
+      end
+
+      def on_parser
+        parser.on_tail('-?', '-h', '--help', 'Workflow Helper') do
+          options.help = true
+        end
+      end
+
+      def on_help
+        {
+          :kind         => 'text'                      ,
+          :valid        => 'no'                        ,
+          :autocomplete => '-h'                        ,
+          :match?       => :always_match?              ,
+          :order        => (HelpItem::Base_Order * 12) ,
+          :title        => '-?, -h, --help [Show Workflow Usage Help]' ,
+          :subtitle     => 'Other feedbacks are blocked.'              ,
+        }
+      end
+
+      def feedback?
+        options.help
+      end
+
+      def on_feedback
+        return unless feedback?
+
+        if @settings[:with_handler_help]
+          @settings[:items].push @core.on_help
+          @core.handler_controller.each do |h|
+            @settings[:items].push h.on_help
+          end
+        end
+
+        if @load_from_workflow_setting
+          if @core.workflow_setting.has_key?(:help)
+            @settings[:items].push @core.workflow_setting[:help]
+          end
+        end
+
+        @settings[:items].flatten!.compact!
+        @settings[:items].map! { |i| HelpItem.new(i) }.sort!
+
+        @settings[:items].each do |item|
+
+          case item[:kind]
+          when 'file'
+            item[:path] = File.expand_path(item[:path])
+            # action is handled by fallback action in the main loop
+            feedback.add_file_item(item[:path], item)
+          when 'url'
+            item[:arg] = xml_builder(
+              :handler => @settings[:handler] ,
+              :kind    => item[:kind]         ,
+              :url     => item[:url]
+            )
+
+            feedback.add_item(
+              {
+                :icon => ::Alfred::Feedback.CoreServicesIcon('BookmarkIcon')
+              }.merge(item)
+            )
+
+          when 'text', 'message'
+            item[:arg] = xml_builder(
+              {
+                :handler      => @settings[:handler] ,
+                :kind         => item[:kind]         ,
+              }
+            )
+
+            feedback.add_item(
+              {
+                :valid        => 'no' ,
+                :autocomplete => ''   ,
+                :icon         => ::Alfred::Feedback.CoreServicesIcon('ClippingText') ,
+              }.merge(item)
+            )
+
+          else
+            if item.has_key? :title
+              item[:arg] = xml_builder(
+                {
+                  :handler => @settings[:handler] ,
+                  :kind    => item[:kind]         ,
+                }.merge(item)
+              )
+
+              feedback.add_item(
+                {
+                  :icon => ::Alfred::Feedback.CoreServicesIcon('HelpIcon'),
+                }.merge(item)
+              )
+            end
+          end
+        end
+
+        @status = :exclusive if @settings[:exclusive?]
+      end
+
+
+      def on_action(arg)
+        return unless action?(arg)
+
+        case arg[:kind]
+        when 'url'
+          ::Alfred::Util.open_url(arg[:url])
+        when 'file'
+          %x{open "#{arg[:path]}"}
+        end
+      end
+    end
+
+  end
+end