pincerna 1.1.3

data/lib/pincerna/server.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+# 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
+  # Main HTTP server to handle requests.
+  class Server < Goliath::API
+    use Goliath::Rack::Params
+    use Goliath::Rack::Heartbeat
+    use Goliath::Rack::Validation::RequestMethod, %w(GET)
+
+    # Delay before responding to a request.
+    DELAY=0.05
+
+    # Enqueues a request.
+    def self.enqueue_request
+      @requests ||= Queue.new
+      @requests << Time.now.to_f
+      EM::Synchrony.sleep(DELAY)
+    end
+
+    # Enqueues a request.
+    #
+    # @return [Boolean] `true` if the request was the last arrived and therefore must be performed, `false` otherwise.
+    def self.perform_request?
+      @requests.pop
+      @requests.empty?
+    end
+
+    # Handles a valid request.
+    #
+    # @param type [String] The type of request.
+    # @param args [Hash] The parameters of the request.
+    # @return [Array] A response complaint to Rack interface.
+    def handle_request(type, args)
+      # Enqueue the request. This will wait to avoid too many requests.
+      Server.enqueue_request
+
+      # Execute the request, if none were added.
+      response = Server.perform_request? ? Pincerna::Base.execute!(type, (args["q"] || "").strip, args["format"], args["debug"]) : false
+
+      if response then
+        [200, {"Content-Type" => response.format_content_type}, response.output]
+      else
+        [response.nil? ? 404 : 429, {"Content-Type" => "text/plain"}, ""]
+      end
+    end
+
+    # Schedule the server's stop.
+    # @return [Array] A response complaint to Rack interface.
+    def handle_stop
+      EM.add_timer(0.1) { stop_server }
+      [200, {}, ""]
+    end
+
+    # Send a response to a request.
+    #
+    # @param env [Goliath::Env] The environment of the request.
+    # @return [Array] A response complaint to Rack interface.
+    def response(env)
+      begin
+        type = env["REQUEST_PATH"].gsub(/\//, "")
+
+        case type
+          when "quit" then handle_stop
+          when "install" then handle_install
+          when "uninstall" then handle_uninstall
+          else handle_request(type, params)
+        end
+      rescue => e
+        [500, {"X-Error" => e.class.to_s, "X-Error-Message" => e.message, "Content-Type" => "text/plain"}, e.backtrace.join("\n")]
+      end
+    end
+
+    private
+      # Stops the server.
+      def stop_server
+        Pincerna::Cache.instance.destroy
+        EM.stop
+      end
+  end
+end

data/lib/pincerna/translation.rb

@@ -0,0 +1,67 @@
+# 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
+  # Translates text using Google Translate.
+  class Translation < Base
+    # The expression to match.
+    MATCHER = /^
+        (from\s+)?(?<from>[a-z_-]{2,5})
+        \s+
+        (to\s+)?((?<to>[a-z_-]{2,5})\s+)?
+        (?<text>.+)
+      $/mix
+
+    # Relevant groups in the match.
+    RELEVANT_MATCHES = {
+      "from" => ->(_, value) { value.downcase },
+      "to" => ->(_, value) { value && value.downcase },
+      "text" => ->(_, value) { value.strip },
+    }
+
+    # The icon to show for each feedback item.
+    ICON = Pincerna::Base::ROOT + "/images/translate.png"
+
+    # The URL of the webservice.
+    URL = "http://translate.google.com.br/translate_a/t"
+
+    # Translates text using Google Translate.
+    #
+    # @param from [String] The code of the source language.
+    # @param to [String] The code of the target language.
+    # @param value [String] The text to translate.
+    # @return [Hash|NilClass] The translation data or `nil` if the translation failed.
+    def perform_filtering(from, to, value)
+      # By default we translate from English
+      if !to then
+        to = from
+        from = "en"
+      end
+
+      response = Pincerna::Cache.instance.use("translation:#{from}:#{to}:#{value}", Pincerna::Cache::EXPIRATIONS[:short]) {
+        fetch_remote_resource(URL, {client: "p", text: value, sl: from, tl: to, multires: 1, ssel: 0, tsel: 0, sc: 1, ie: "UTF-8", oe: "UTF-8"})
+      }
+
+      # Parse results
+      if response["dict"] then
+        translations = response["dict"][0]["entry"].map {|t| t["word"] }
+        {main: translations.shift, alternatives: translations}
+      else
+        translation = response["sentences"][0]["trans"]
+        {main: translation} if translation != value
+      end
+    end
+
+    # Processes items to obtain feedback items.
+    #
+    # @param results [Array] The items to process.
+    # @return [Array] The feedback items.
+    def process_results(results)
+      alternatives = results[:alternatives] ? "Alternatives: #{results[:alternatives].join(", ")}" : "Action this item to copy the translation on the clipboard."
+      [{title: results[:main], arg: results[:main], subtitle: alternatives, icon: ICON}]
+    end
+  end
+end

data/lib/pincerna/unit_conversion.rb

@@ -0,0 +1,120 @@
+# 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
+  # Converts a value from a unit to another.
+  class UnitConversion < Base
+    # The expression to match.
+    MATCHER = /^
+      (?<value>([+-]?)(\d+)([.,]\d+)?)
+      \s+
+      (?<from>\S+?)
+      \s+
+      (to\s+)?
+      (?<to>\S+)
+      (?<rate>\s+with\s+rate)?
+      (?<split>\s+split\s+units)?
+    $/mix
+
+    # Relevant groups in the match.
+    RELEVANT_MATCHES = {
+      "value" => ->(context, value) { context.round_float(value.gsub(",", ".").to_f) },
+      "from" => ->(_, value) { value },
+      "to" => ->(_, value) { value },
+      "rate" => ->(_, value) { !value.nil? }, # If show conversion rate
+      "split" => ->(_, value) { !value.nil? } # If group unit for ft+in and lb+oz
+    }
+
+    # The icon to show for each feedback item.
+    ICON = Pincerna::Base::ROOT + "/images/unit.png"
+
+    # Defines a new unit.
+    #
+    # @param name [String] The name of the unit.
+    # @param definition [String] The definition of the unit.
+    # @param aliases [Array] The aliases of this unit.
+    def self.define_unit(name, definition, aliases)
+      RubyUnits::Unit.define(name) do |unit|
+        unit.definition = RubyUnits::Unit.new(definition)
+        unit.aliases = aliases
+      end
+    end
+
+    # Converts a value from a unit to another.
+    #
+    # @param value [Float] The value to convert.
+    # @param from [String] The origin unit.
+    # @param to [String] The target unit.
+    # @param with_rate [Boolean] If to return the conversion rate in the results.
+    # @param multiple [Boolean] If to use multiple units for ft (ft+in) and lb/oz (lb+oz).
+    # @return [Hash|NilClass] The converted data or `nil` if the conversion failed.
+    def perform_filtering(value, from, to, with_rate, multiple)
+      from = check_temperature(from)
+      to = check_temperature(to)
+      converted = convert_value(value, from, to)
+      converted ? {from: from, to: to, value: convert_value(value, from, from), unit: convert_value(1, from, from), result: converted, rate: convert_value(1, from, to), with_rate: with_rate, multiple: multiple} : nil
+    end
+
+    # Processes items to obtain feedback items.
+    #
+    # @param results [Hash] The items to process.
+    # @return [Array] The feedback items.
+    def process_results(results)
+      multiple = results[:multiple]
+      title = "#{format_value(results[:value], multiple)} = #{format_value(results[:result], multiple)}"
+      title << " (#{format_value(results[:unit], multiple)} = #{format_value(results[:rate], multiple)})" if results[:with_rate]
+
+      [{title: title, arg: format_value(results[:result], :raw), subtitle: "Action this item to copy the converted amount on the clipboard.", icon: ICON}]
+    end
+
+    # Checks if a unit is a temperature and prepend "temp" if needed.
+    #
+    # @param unit [String] The unit to check.
+    # @return [String] The adjusted unit.
+    def check_temperature(unit)
+      unit = unit.gsub("°", "")
+      /^[CFKR]$/.match(unit.upcase) ? "temp#{unit.upcase}" : unit
+    end
+
+    # Converts a value from a unit to another.
+    #
+    # @param value [Float] The value to convert.
+    # @param from [String] The origin unit.
+    # @param to [String] The target unit.
+    # @return [String|NilClass] The converted unit or `nil` if the conversion failed.
+    def convert_value(value, from, to)
+      Unit.new("#{value} #{from}").convert_to(to)
+    end
+
+    # Formats a value.
+    #
+    # @param value [String] The value to format.
+    # @param modifier [Boolean|Symbol] If to use multiple units for ft (ft+in) and lb/oz (lb+oz). If `:raw`, only the unitless (float) value is returned.
+    # @param precision [Fixnum] The precision to use for rounding.
+    # @return [String|Float] The formatted value or the unitless value.
+    def format_value(value, modifier = nil, precision = 3)
+      rounded = round_float(value.scalar.to_f, precision)
+
+      if modifier != :raw then
+        format = "%0.#{precision}f"
+        units = value.units
+
+        if modifier && units =~ /ft|oz|lb/ then
+          format = units == "ft" ? :ft : :lbs
+        elsif rounded.to_i == rounded then
+          format = "%0.0f"
+        end
+
+        value.to_s(format).gsub(", ", " ").gsub(/ temp([CFKR])/, "°\\1")
+      else
+        rounded
+      end
+    end
+  end
+end
+
+Pincerna::UnitConversion.define_unit("miles per gallon", "1 mi/gal", ["mpg" "miles-per-gallon"])
+Pincerna::UnitConversion.define_unit("kilometers per liter", "1 km/L", ["kpl" "kilometers-per-liter"])

data/lib/pincerna/version.rb

@@ -0,0 +1,24 @@
+# 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
+  # The current version of pincerna, according to semantic versioning.
+  #
+  # @see http://semver.org
+  module Version
+    # The major version.
+    MAJOR = 1
+
+    # The minor version.
+    MINOR = 1
+
+    # The patch version.
+    PATCH = 3
+
+    # The current version of pincerna.
+    STRING = [MAJOR, MINOR, PATCH].compact.join(".")
+  end
+end

data/lib/pincerna/vpn.rb

@@ -0,0 +1,74 @@
+# 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
+  # Connects or disconnects from system's VPNs.
+  class Vpn < Base
+    # The expression to match.
+    MATCHER = /^(?<all>.*)$/i
+
+    # The icon to show for each feedback item.
+    ICON = Pincerna::Base::ROOT + "/images/vpn.png"
+
+    # Connects to or disconnects from system VPN.
+    #
+    # @param query [Array] A query to match against VPNs names.
+    # @return [Array] A list of items to process.
+    def perform_filtering(query)
+      rv = []
+      interface_filter ||= query.empty? ? /.+/ : /#{query}/i
+
+      execute_command("/usr/sbin/networksetup", "-listnetworkserviceorder").split(/\n\n/).each do |i|
+        # Scan every interface
+        token = StringScanner.new(i)
+
+        if token.scan_until(/^\(\d+\)/) then
+          name = token.scan_until(/\n/).strip # Get VPN name
+          next if !interface_filter.match(name)
+
+          # Get the type
+          token.scan_until(/Hardware Port:\s/)
+
+          # If type matches
+          rv << {name: name, connected: vpn_connected?(name)} if is_vpn_service?(token.scan_until(/,/))
+        end
+      end
+
+      rv
+    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|
+        title = "#{result[:connected] ? "Disconnect from" : "Connect to"} #{result[:name]}"
+        subtitle = "Action this item to #{result[:connected] ? "disconnect from" : "connect to"} the VPN service."
+        arg = "#{result[:connected] ? "disconnect" : "connect"} service \"#{result[:name]}\""
+
+        {title: title, arg: arg, subtitle: subtitle, icon: ICON}
+      end
+    end
+
+    # Checks if a VPN is connected.
+    #
+    # @param name [String] The VPN's name.
+    # @return [Boolean] `true` if the VPN is connected, `false` otherwise.
+    def vpn_connected?(name)
+      execute_command("/usr/sbin/networksetup", "-showpppoestatus", "\"#{name}\"").strip == "connected"
+    end
+
+    private
+      # Check if a service is a VPN.
+      #
+      # @param service [String] The service name.
+      # @return `true` if the service is a VPN service, `false` otherwise.
+      def is_vpn_service?(service)
+        ["L2TP", "IPSec"].include?(service.gsub(/,$/, ""))
+      end
+  end
+end

data/lib/pincerna/weather.rb

@@ -0,0 +1,188 @@
+# 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
+  # Gets weather forecast from Yahoo! Weather.
+  class Weather < Base
+    # The expression to match.
+    MATCHER = /^
+      (?<place>.+?)
+      (\s+in\s+(?<scale>[cf]))?
+    $/mix
+
+    # Relevant groups in the match.
+    RELEVANT_MATCHES = {
+      "place" => ->(_, value) { value }, # Place or WOEID
+      "scale" => ->(_, value) { value.nil? ? "c" : value.downcase } # Temperature scale
+    }
+
+    # The icon to show for each feedback item.
+    ICON = Pincerna::Base::ROOT + "/images/weather.png"
+
+    # The URL of the webservice.
+    URL = "http://where.yahooapis.com/v1/places.q(%s);count=5"
+
+    # Yahoo! API key.
+    API_KEY = "dj0yJmk9ZUpBZk1hQTJGRHM5JmQ9WVdrOVlUSnBjMGhUTjJVbWNHbzlOemsyTURNeU5EWXkmcz1jb25zdW1lcnNlY3JldCZ4PWRi"
+
+    # Gets forecast for a place.
+    #
+    # @param query [String] A place to search.
+    # @return [Array] A list of items to process.
+    def perform_filtering(query, scale)
+      places = lookup_places(query)
+      places.empty? ? nil : get_forecast(places, scale) if !places.empty?
+    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|
+        # Format results
+        current = result[:current]
+        forecast = result[:forecast]
+        combined = "#{current[:temperature]}, #{current[:description].downcase.capitalize}, wind #{current[:wind][:speed]} #{current[:wind][:direction]} - Next: #{forecast[:high]} / #{forecast[:low]}, #{forecast[:description]}"
+
+        {title: result[:name], arg: result[:link], subtitle: combined, icon: result[:image]}
+      end
+    end
+
+    # Lookups a place on Yahoo! to obtain WOEID(s).
+    #
+    # @param query [String] The place to search.
+    # @return [Array] A list of matching places data.
+    def lookup_places(query)
+      if query !~ /^(\d+)$/ then
+        Pincerna::Cache.instance.use("woeid:#{query}", Pincerna::Cache::EXPIRATIONS[:long]) do
+          response = fetch_remote_resource(URL % CGI.escape(query), {appid: API_KEY, format: :json})
+          response["places"].fetch("place", []).map { |place| parse_place(place) }
+        end
+      else
+        # We already have the woeid. The name will be given by Yahoo!
+        [{woeid: query}]
+      end
+    end
+
+    # Gets weather forecast for one or more places.
+    #
+    # @param places [Array] The places to query.
+    # @param scale [String] The unit system to use: `f` for the US system (Farenheit) and `c` for the International System one (Celsius).
+    # @return [Array|NilClass] An array with forecasts data or `nil` if the query failed.
+    def get_forecast(places, scale = "c")
+      client = Weatherman::Client.new(unit: scale)
+      temperature_unit = "°#{scale.upcase}"
+
+      places.map do |place|
+        Pincerna::Cache.instance.use("forecast:#{place[:woeid]}", Pincerna::Cache::EXPIRATIONS[:short]) {
+          parse_forecast_response(place, client.lookup_by_woeid(place[:woeid]), temperature_unit)
+        }
+      end
+    end
+
+    # Converts the degrees direction of the wind to the cardinal points notation (like NE or SW).
+    #
+    # @param degrees [Fixnum] The direction in degrees.
+    # @return [String] The direction in cardinal points notation.
+    def get_wind_direction(degrees)
+      # Normalize value
+      degrees += 360 if degrees < 0
+      degrees = degrees % 360
+
+      # Get the position
+      directions = ["N", "NE", "NE", "E", "E", "SE", "SE", "S", "S", "SW", "SW", "W", "W", "NW", "NW", "N"]
+      position = ((degrees.to_f / 22.5) - 0.5).ceil.to_i % directions.count # The mod operation is needed for values close to 360 who, after ceiling, would otherwise overflow.
+      directions[position]
+    end
+
+    private
+      # Gets and downloads an image for a forecast.
+      #
+      # @param url [String] The image URL.
+      # @return [String] The path of the downloaded image.
+      def download_image(url)
+        # Extract the URL and use it to build the path
+        rv = (@cache_dir + "/weather/#{File.basename(URI.parse(url).path)}")
+
+        if !File.exists?(rv) then
+          # Create the directory and download the file
+          FileUtils.mkdir_p(@cache_dir + "/weather/")
+          open(rv, 'wb') {|f| f.write(open(url).read) }
+        end
+
+        rv
+      end
+
+      # Gets a location name.
+      #
+      # @param location [Hash] The location data.
+      # @return [String] The location name.
+      def get_name(location)
+        ["city", "region", "country"].map { |field| location[field].strip }.reject(&:empty?).join(", ")
+      end
+
+      # Parses a WOEID lookup.
+      #
+      # @param place [Hash] The place to parse.
+      # @return [Hash] The parsed place.
+      def parse_place(place)
+        {
+          woeid: place["woeid"],
+          name: ["locality1", "admin3", "admin2", "admin1", "country"].map { |field| place[field] }.reject(&:empty?).uniq.join(", ")
+        }
+      end
+
+      # Formats a weather forecast.
+      #
+      # @param place [Hash] The basic place information.
+      # @param response [Weatherman::Response] The forecast response.
+      # @param temperature_unit [String] The temperature unit.
+      # @return [Hash] A formatted forecast.
+      def parse_forecast_response(place, response, temperature_unit)
+        image, link = extract_forecast_media(response)
+        place[:name] ||= get_name(response.location)
+
+        format_forecast(place, download_image(image), link, response.condition, response.forecasts.first, response.wind, temperature_unit, response.units["speed"])
+      end
+
+      # Formats a weather forecast.
+      #
+      # @param place [Hash] The basic place information.
+      # @param image [String] The icon for the current weather conditions.
+      # @param link [String] The link to view weather conditions on Yahoo!.
+      # @param current [Hash] The current weather conditions.
+      # @param forecast [Hash] The weather forecast for tomorrow.
+      # @param wind [Hash] The current wind conditions.
+      # @param temperature_unit [String] The temperature unit.
+      # @param speed_unit [String] The speed unit.
+      # @return [Hash] The parsed forecast.
+      def format_forecast(place, image, link, current, forecast, wind, temperature_unit, speed_unit)
+        place.merge({
+          image: image,
+          link: link,
+          current: {
+            description: current["text"],
+            temperature: "#{current["temp"]} #{temperature_unit}",
+            wind: {speed: "#{wind["speed"]} #{speed_unit}", direction: get_wind_direction(wind["direction"])}
+          },
+          forecast: {
+            description: forecast["text"],
+            high: "#{forecast["high"]} #{temperature_unit}",
+            low: "#{forecast["low"]} #{temperature_unit}"
+          },
+        })
+      end
+
+      # Extracts forecast media from a response.
+      #
+      # @param response The response to analyze.
+      # @return [Array] An array of media.
+      def extract_forecast_media(response)
+        [response.description_image.attr("src"), response.document_root.at_xpath("link").content.to_s]
+      end
+  end
+end