pincerna 1.1.3

data/it.cowtech.pincernad.plist

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>it.cowtech.pincernad</string>
+    <key>KeepAlive</key>
+    <true/>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>EnableGlobbing</key>
+    <true/>
+    <key>ProgramArguments</key>
+    <array>
+      <string>~/.rvm/bin/pincernad</string>
+      <string>-e production</string>
+    </array>
+  </dict>
+</plist>

data/lib/pincerna.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+#
+# This file is part of the pincerna gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at https://choosealicense.com/licenses/mit.
+#
+
+require "open-uri"
+require "strscan"
+require "cgi"
+require "fileutils"
+require "nokogiri"
+require "oj"
+require "yahoo_weatherman"
+require "ruby-units"
+require "plist"
+require "daybreak"
+require "em-synchrony"
+require "em-synchrony/em-http"
+
+require "pincerna/version" if !defined?(Pincerna::Version)
+require "pincerna/base"
+require "pincerna/cache"
+require "pincerna/currency_conversion"
+require "pincerna/ip"
+require "pincerna/map"
+require "pincerna/translation"
+require "pincerna/unit_conversion"
+require "pincerna/vpn"
+require "pincerna/weather"
+require "pincerna/bookmark"

data/lib/pincerna/base.rb

@@ -0,0 +1,258 @@
+# encoding: utf-8
+#
+# This file is part of the pincerna gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at https://choosealicense.com/licenses/mit.
+#
+
+# A bunch of useful Alfred 2 workflows.
+module Pincerna
+  # Base class for all filter.
+  #
+  # @attribute [r] output
+  #   @return [String] The output of filtering.
+  # @attribute [r] format
+  #   @return [Symbol] The format of output. Can be `:xml` (default) or `:yml`.
+  # @attribute [r] format_content_type
+  #   @return [String] The content type of the format. Can be `text/xml` (default) or `text/x-yaml`.
+  class Base
+    # The expression to match.
+    MATCHER = /^(?<all>.*)$/i
+
+    # Relevant groups in the match.
+    RELEVANT_MATCHES = {
+      "all" => ->(_, value) { value }
+    }
+
+    # Recognized types of filtering
+    TYPES = {
+      "unit_conversion" => /^(convert|unit|c)$/,
+      "currency_conversion" => /^(currency|cc)$/,
+      "translation" => /^(translate|t)$/,
+      "map" => /^(map|m)$/,
+      "weather" => /^(forecast|weather)$/,
+      "ip" => /^ip$/,
+      "vpn" => /^vpn$/,
+      "chrome_bookmark" => /^(chrome-bookmark|bc)$/,
+      "safari_bookmark" => /^(safari-bookmark|bs)$/,
+      "firefox_bookmark" => /^(firefox-bookmark|bf)$/
+    }
+
+    # The full name of the gem
+    FULL_NAME = "it.cowtech.pincerna"
+
+    # The root of the pincerna gem
+    ROOT = File.expand_path(File.dirname(__FILE__) + "/../../")
+
+    # The root of the cache
+    CACHE_ROOT = File.expand_path("~/Library/Caches/com.runningwithcrayons.Alfred-2/Workflow Data/#{FULL_NAME}")
+
+    # The root of alfred workflows
+    WORKFLOW_ROOT = File.expand_path("~/Library/Application Support/Alfred 2/Alfred.alfredpreferences/workflows/#{FULL_NAME}")
+
+    attr_reader :output, :format, :format_content_type
+
+    # Executes a filtering query.
+    #
+    # @param type [Symbol] The type of the query.
+    # @param query [String] The argument of the query.
+    # @param format [String] The format to use. Valid values are `:xml` (default) and `:yml`.
+    # @param debug [String] The debug mode.
+    # @return [String] The result of the query.
+    def self.execute!(type, query, format = :xml, debug = nil)
+      instance = nil
+
+      type = catch(:type) do
+        TYPES.each do |file, matcher|
+          throw(:type, file) if type =~ matcher
+        end
+
+        nil
+      end
+
+      if type
+        instance = find_class(type).new(query, format, debug)
+        instance.filter
+      end
+
+      instance
+    end
+
+    # Creates a new query.
+    #
+    # @param query [String] The argument of the query.
+    # @param requested_format [String] The format to use. Valid values are `xml` (default), `yaml` or `yml`.
+    # @param debug [String] The debug mode.
+    def initialize(query, requested_format = "xml", debug = nil)
+      @query = query.strip.gsub("\\ ", " ")
+      @cache_dir = CACHE_ROOT
+
+      if requested_format =~ /^y(a?)ml$/i then
+        @format = :yml
+        @format_content_type = "text/x-yaml"
+      else
+        @format = :xml
+        @format_content_type = "text/xml"
+      end
+
+      @debug = debug
+      @feedback_items = []
+    end
+
+    # Filters a query.
+    #
+    # @return [String] The feedback items of the query, formatted as XML.
+    def filter
+      # Match the query
+      matches = self.class::MATCHER.match(@query)
+
+      if matches then
+        # Execute the filtering
+        results = execute_filtering(matches)
+
+        # Show results if appropriate
+        process_results(results).each {|r| add_feedback_item(r) } if !results.empty?
+      end
+
+      output_feedback
+    end
+
+    # Filters a query.
+    #
+    # @param args [Array] The arguments of the query.
+    # @return [Array] A list of items to process.
+    def perform_filtering(*args)
+      raise ArgumentError.new("Must be overriden by subclasses.")
+    end
+
+    # Processes items to obtain feedback items.
+    #
+    # @param results [Array] The items to process.
+    # @return [Array] The feedback items.
+    def process_results(results)
+      raise ArgumentError.new("Must be overriden by subclasses.")
+    end
+
+    # Adds a feedback items.
+    #
+    # @param item [Array] The items to add.
+    def add_feedback_item(item)
+      @feedback_items << item
+    end
+
+    # Prepares the feedback for output.
+    def output_feedback
+      if format == :xml then
+        @output = Nokogiri::XML::Builder.new { |xml|
+          xml.items do
+            @feedback_items.each do |item|
+              childs, attributes = split_output_item(item)
+
+              xml.item(attributes) do
+                childs.each { |name, value| xml.send(name, value) }
+              end
+            end
+          end
+        }.to_xml
+      else
+        @output = @feedback_items.to_yaml
+      end
+    end
+
+    # Rounds a float to a certain precision.
+    #
+    # @param value [Float] The value to convert.
+    # @param precision [Fixnum] The precision to use.
+    # @return [Float] The rounded value.
+    def round_float(value, precision = 3)
+      factor = 10**precision
+      (value * factor).round.to_f / factor
+    end
+
+    # Rounds a float to a certain precision and prints it as a string. Unneeded leading zero are remove.
+    #
+    # @param value [Float] The value to print.
+    # @param precision [Fixnum] The precision to use.
+    # @return [String] The formatted value.
+    def format_float(value, precision = 3)
+      value = round_float(value, precision)
+      value = "%0.#{precision}f" % value
+      value.gsub(/\.?0+$/, "")
+    end
+
+    protected
+      # Instantiates the new class.
+      #
+      # @param file [String] The file name.
+      def self.find_class(file)
+        Pincerna.const_get(file.capitalize.gsub(/_(.)/) { $1.upcase})
+      end
+
+      # Executes filtering on matched data.
+      #
+      # @param matches [MatchData] The matched data.
+      # @return [Array] The results of filtering.
+      def execute_filtering(matches)
+        # Get relevant matches and arguments.
+        relevant = self.class::RELEVANT_MATCHES
+        args = relevant.map {|key, value| value.call(self, matches[key]) }
+
+        # Now perform the operation
+        begin
+          perform_filtering(*args)
+        rescue => e
+          raise e if debug_mode == :error
+          []
+        end
+      end
+
+      # Converts an array of key-value pairs to an hash.
+      #
+      # @param array [Array] The array to convert.
+      # @return [Hash] The converted hash.
+      def array_to_hash(array)
+        array.reduce({}){ |rv, entry|
+          rv[entry[0]] = entry[1]
+          rv
+        }
+      end
+
+      # Gets attributes and children for output.
+      #
+      # @param item [Hash] The output item.
+      # @return [Array] An array with children and attributes.
+      def split_output_item(item)
+        item.partition {|k, _| [:title, :subtitle, :icon].include?(k) }.map {|a| array_to_hash(a) }
+      end
+
+      # Fetches remote JSON resource.
+      #
+      # @param url [String] The URL to get.
+      # @param params [Hash] The parameters to pass to the server.
+      # @param json [Boolean] If the response is a JSON object.
+      # @return [Hash] The server's response.
+      def fetch_remote_resource(url, params, json = true)
+        args = {query: params}
+        args[:head] = {"accept" => "application/json"} if json
+        response = EM::HttpRequest.new(url, {connect_timeout: 5}).get(args).response
+        json ? Oj.load(response) : response
+      end
+
+      # Executes a command and returns its output.
+      #
+      # @param args [Array] The command to execute, with its arguments.
+      # @return [String] The output of the command
+      def execute_command(*args)
+        rv = ""
+        IO.popen(args) {|f| rv = f.read }
+        rv
+      end
+
+      # Returns the current debug mode.
+      #
+      # @return [Boolean|NilClass] The current debug mode.
+      def debug_mode
+        mode = ENV["PINCERNA_DEBUG"] || @debug
+        !mode.nil? ? mode.to_sym : nil
+      end
+  end
+end

data/lib/pincerna/bookmark.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+#
+# This file is part of the pincerna gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at https://choosealicense.com/licenses/mit.
+#
+
+module Pincerna
+  # Show the list of Safari bookmarks.
+  class Bookmark < Base
+    # The expression to match.
+    MATCHER = /^(?<all>.*)$/i
+
+    # The icon to show for each feedback item.
+    ICON = Pincerna::Base::ROOT + "/images/safari.png"
+
+    # The separator for paths.
+    SEPARATOR = "\u2192"
+
+    # Reads the list of Chrome Bookmarks.
+    #
+    # @param query [Array] A query to match against bookmarks names.
+    # @return [Array] A list of boomarks.
+    def perform_filtering(query)
+      Pincerna::Cache.instance.use("bookmarks:#{self.class.to_s}", Pincerna::Cache::EXPIRATIONS[:short]) do
+        # Get bookmarks and then only keep valid ones
+        @bookmarks = []
+        read_bookmarks
+        filter_and_sort(@bookmarks, query)
+      end
+    end
+
+    # Processes items to obtain feedback items.
+    #
+    # @param results [Array] The items to process.
+    # @return [Array] The feedback items.
+    def process_results(results)
+      results.map do |result|
+        subtitle = result[:path] ? result[:path].gsub(/^\s\u2192 /, "") : "Action this item to open the URL in the browser ..."
+        {title: result[:name], arg: result[:url], subtitle: subtitle, icon: ICON}
+      end
+    end
+
+    # Reads the list of bookmarks.
+    def read_bookmarks
+      raise ArgumentError.new("Must be overriden by subclasses.")
+    end
+
+    private
+      # Filters and sorts bookmarks.
+      #
+      # @param bookmarks [Array] The bookmarks list.
+      # @param query [String] The query to filter.
+      def filter_and_sort(bookmarks, query)
+        # Filtering
+        matcher = !query.empty? ? /^#{Regexp.escape(query.downcase)}/i : nil
+        bookmarks = bookmarks.select {|bookmark| bookmark[:name] =~ matcher } if matcher
+
+        # Sorting
+        bookmarks.sort {|first, second|
+          cmp = first[:name] <=> second[:name]
+          cmp = first[:path] <=> second[:path] if cmp == 0
+          cmp
+        }
+      end
+
+    protected
+      # Adds a bookmarks to the list.
+      #
+      # @param title [String] The title of the bookmark.
+      # @param url [String] The URL of the bookmark.
+      # @param path [String] The id of the parent folder.
+      def add_bookmark(title, url, path)
+        @bookmarks << {name: title, url: url, path: path} if title && !title.empty? && url && !url.empty? && url !~ /^javascript:/
+      end
+  end
+end
+
+require "pincerna/safari_bookmark"
+require "pincerna/firefox_bookmark"
+require "pincerna/chrome_bookmark"

data/lib/pincerna/cache.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+#
+# This file is part of the pincerna gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at https://choosealicense.com/licenses/mit.
+#
+
+module Pincerna
+  # A utility class to handle caching.
+  #
+  # @attribute [r] data
+  #   @return [Daybreak::DB] The cache store.
+  class Cache
+    # Expiration of keys.
+    EXPIRATIONS = {short: 1800, long: 2592000} # 30 min, 1 month
+
+    # Location of the cache file
+    FILE = Pincerna::Base::CACHE_ROOT + "/cache.db"
+
+    attr_reader :data
+
+    # Returns the instance of the cache.
+    def self.instance
+      @instance ||= Pincerna::Cache.new
+    end
+
+    # Creates a new cache object.
+    def initialize
+      FileUtils.mkdir_p(File.dirname(FILE))
+      @data = Daybreak::DB.new(FILE)
+      @flusher = EM.add_periodic_timer(5) { Pincerna::Cache.instance.flush }
+    end
+
+    # Closes the cache data.
+    def destroy
+      @flusher.cancel
+      @data.close rescue nil
+    end
+
+    # Flush data into disk.
+    def flush
+      @data.flush
+      @data.compact
+    end
+
+    # Use data from cache or fetches new data.
+    #
+    # @param key [String] The key of the data.
+    # @param expiration [Fixnum] Expiration of new data, in seconds.
+    def use(key, expiration)
+      value = @data[key]
+
+      if !value || Time.now.to_f > value[:expiration] then
+        data = yield
+        @data[key] = {data: data, expiration: Time.now.to_f + expiration}
+        data
+      else
+        value[:data]
+      end
+    end
+  end
+end