qiita_org 0.1.20 → 0.1.25

data/gems/ruby/2.7.0/gems/notiffany-0.1.3/lib/notiffany/notifier/base.rb

@@ -0,0 +1,127 @@
+require "rbconfig"
+
+module Notiffany
+  class Notifier
+    class Base
+      HOSTS = {
+        darwin:  "Mac OS X",
+        linux:   "Linux",
+        'linux-gnu' =>   "Linux",
+        freebsd: "FreeBSD",
+        openbsd: "OpenBSD",
+        sunos:   "SunOS",
+        solaris: "Solaris",
+        mswin:   "Windows",
+        mingw:   "Windows",
+        cygwin:  "Windows"
+      }
+
+      ERROR_ADD_GEM_AND_RUN_BUNDLE = "Please add \"gem '%s'\" to your Gemfile "\
+        "and run your app with \"bundle exec\"."
+
+      class UnavailableError < RuntimeError
+        def initialize(reason)
+          super
+          @reason = reason
+        end
+
+        def message
+          @reason
+        end
+      end
+
+      class RequireFailed < UnavailableError
+        def initialize(gem_name)
+          super ERROR_ADD_GEM_AND_RUN_BUNDLE % gem_name
+        end
+      end
+
+      class UnsupportedPlatform < UnavailableError
+        def initialize
+          super "Unsupported platform #{RbConfig::CONFIG['host_os'].inspect}"
+        end
+      end
+
+      attr_reader :options
+
+      def initialize(opts = {})
+        options = opts.dup
+        options.delete(:silent)
+        @options =
+          { title: "Notiffany" }.
+          merge(self.class.const_get(:DEFAULTS)).
+          merge(options).freeze
+
+        @images_path = Pathname.new(__FILE__).dirname + "../../../images"
+
+        _check_host_supported
+        _require_gem
+        _check_available(@options)
+      end
+
+      def title
+        self.class.to_s[/.+::(\w+)$/, 1]
+      end
+
+      def name
+        title.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      end
+
+      def notify(message, opts = {})
+        new_opts = _notify_options(opts).freeze
+        _perform_notify(message, new_opts)
+      end
+
+      def _image_path(image)
+        images = [:failed, :pending, :success, :guard]
+        images.include?(image) ? @images_path.join("#{image}.png").to_s : image
+      end
+
+      private
+
+      # Override if necessary
+      def _gem_name
+        name
+      end
+
+      # Override if necessary
+      def _supported_hosts
+        :all
+      end
+
+      # Override
+      def _check_available(_options)
+        fail NotImplementedError
+      end
+
+      # Override
+      def _perform_notify(_message, _opts)
+        fail NotImplementedError
+      end
+
+      def _notification_type(image)
+        [:failed, :pending, :success].include?(image) ? image : :notify
+      end
+
+      def _notify_options(overrides = {})
+        opts = @options.merge(overrides)
+        img_type = opts.fetch(:image, :success)
+        opts[:type] ||= _notification_type(img_type)
+        opts[:image] = _image_path(img_type)
+        opts
+      end
+
+      def _check_host_supported
+        return if _supported_hosts == :all
+        expr = /#{_supported_hosts * '|'}/
+        fail UnsupportedPlatform unless expr.match(RbConfig::CONFIG["host_os"])
+      end
+
+      def _require_gem
+        Kernel.require _gem_name unless _gem_name.nil?
+      rescue LoadError, NameError
+        fail RequireFailed, _gem_name
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/notiffany-0.1.3/lib/notiffany/notifier/config.rb

@@ -0,0 +1,34 @@
+require "logger"
+
+module Notiffany
+  class Notifier
+    # Configuration class for Notifier
+    class Config
+      DEFAULTS = { notify: true }.freeze
+
+      attr_reader :env_namespace
+      attr_reader :logger
+      attr_reader :notifiers
+
+      def initialize(opts)
+        options = DEFAULTS.merge(opts)
+        @env_namespace = opts.fetch(:namespace, "notiffany")
+        @logger = _setup_logger(options)
+        @notify = options[:notify]
+        @notifiers = opts.fetch(:notifiers, {})
+      end
+
+      def notify?
+        @notify
+      end
+
+      private
+
+      def _setup_logger(opts)
+        opts.fetch(:logger) do
+          Logger.new($stderr).tap { |l| l.level = Logger::WARN }
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/notiffany-0.1.3/lib/notiffany/notifier/detected.rb

@@ -0,0 +1,122 @@
+require "nenv"
+require "yaml"
+
+require_relative "emacs"
+require_relative "file"
+require_relative "gntp"
+require_relative "growl"
+require_relative "libnotify"
+require_relative "notifysend"
+require_relative "rb_notifu"
+require_relative "terminal_notifier"
+require_relative "terminal_title"
+require_relative "tmux"
+
+module Notiffany
+  class Notifier
+    # @private api
+
+    # TODO: use a socket instead of passing env variables to child processes
+    # (currently probably only used by guard-cucumber anyway)
+    YamlEnvStorage = Nenv::Builder.build do
+      create_method(:notifiers=) { |data| YAML.dump(data || []) }
+      create_method(:notifiers) { |data| data ? YAML.load(data) : [] }
+    end
+
+    # @private api
+    class Detected
+      NO_SUPPORTED_NOTIFIERS = "Notiffany could not detect any of the"\
+        " supported notification libraries."
+
+      class NoneAvailableError < RuntimeError
+      end
+
+      class UnknownNotifier < RuntimeError
+        def initialize(name)
+          super
+          @name = name
+        end
+
+        attr_reader :name
+
+        def message
+          "Unknown notifier: #{@name.inspect}"
+        end
+      end
+
+      def initialize(supported, env_namespace, logger)
+        @supported = supported
+        @environment = YamlEnvStorage.new(env_namespace)
+        @logger = logger
+      end
+
+      def reset
+        @environment.notifiers = []
+      end
+
+      def detect
+        return unless _notifiers.empty?
+        @supported.each do |group|
+          group.detect do |name, _|
+            begin
+              _add(name, {})
+              true
+            rescue Notifier::Base::UnavailableError => e
+              @logger.debug "Notiffany: #{name} not available (#{e.message})."
+              false
+            end
+          end
+        end
+
+        fail NoneAvailableError, NO_SUPPORTED_NOTIFIERS if _notifiers.empty?
+      end
+
+      def available
+        @available ||= _notifiers.map do |entry|
+          _to_module(entry[:name]).new(entry[:options])
+        end
+      end
+
+      # Called when user has notifier-specific config.
+      # Honor the config by warning if something is wrong
+      def add(name, opts)
+        _add(name, opts)
+      rescue Notifier::Base::UnavailableError => e
+        @logger.warning("Notiffany: #{name} not available (#{e.message}).")
+      end
+
+      private
+
+      def _add(name, opts)
+        @available = nil
+        all = _notifiers
+
+        # Silently skip if it's already available, because otherwise
+        # we'd have to do :turn_off, then configure, then :turn_on
+        names = all.map(&:first).map(&:last)
+        unless names.include?(name)
+          fail UnknownNotifier, name unless (klass = _to_module(name))
+
+          klass.new(opts) # raises if unavailable
+          @environment.notifiers = all << { name: name, options: opts }
+        end
+
+        # Just overwrite the options (without turning the notifier off or on),
+        # so those options will be passed in next calls to notify()
+        all.each { |item| item[:options] = opts if item[:name] == name }
+      end
+
+      def _to_module(name)
+        @supported.each do |group|
+          next unless (notifier = group.detect { |n, _| n == name })
+          return notifier.last
+        end
+        nil
+      end
+
+      def _notifiers
+        @environment.notifiers
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/notiffany-0.1.3/lib/notiffany/notifier/emacs.rb

@@ -0,0 +1,97 @@
+require 'notiffany/notifier/base'
+require 'shellany/sheller'
+
+require 'notiffany/notifier/emacs/client'
+
+module Notiffany
+  class Notifier
+    # Send a notification to Emacs with emacsclient
+    # (http://www.emacswiki.org/emacs/EmacsClient).
+    #
+    class Emacs < Base
+      DEFAULTS = {
+        client:    'emacsclient',
+        success:   'ForestGreen',
+        failed:    'Firebrick',
+        default:   'Black',
+        fontcolor: 'White'
+      }.freeze
+
+      DEFAULT_ELISP_ERB = <<EOF.freeze
+(set-face-attribute 'mode-line nil
+  :background "<%= bgcolor %>"
+  :foreground "<%= color %>")
+EOF
+
+      private
+
+      def _gem_name
+        nil
+      end
+
+      def _check_available(options)
+        return if Client.new(options.merge(elisp_erb: "'1'")).available?
+        raise UnavailableError, 'Emacs client failed'
+      end
+
+      # Shows a system notification.
+      #
+      # @param [String] type the notification type. Either 'success',
+      #   'pending', 'failed' or 'notify'
+      # @param [String] title the notification title
+      # @param [String] message the notification message body
+      # @param [String] image the path to the notification image
+      # @param [Hash] opts additional notification library options
+      # @option opts [String] success the color to use for success
+      #   notifications (default is 'ForestGreen')
+      # @option opts [String] failed the color to use for failure
+      #   notifications (default is 'Firebrick')
+      # @option opts [String] pending the color to use for pending
+      #   notifications
+      # @option opts [String] default the default color to use (default is
+      #   'Black')
+      # @option opts [String] client the client to use for notification
+      #   (default is 'emacsclient')
+      # @option opts [String, Integer] priority specify an int or named key
+      #   (default is 0)
+      #
+      def _perform_notify(message, opts = {})
+        color     = _emacs_color(opts[:type], opts)
+        fontcolor = _emacs_color(:fontcolor, opts)
+
+        opts = opts.merge(elisp_erb: _erb_for(opts[:elisp_file]))
+        Client.new(opts).notify(fontcolor, color, message)
+      end
+
+      # Get the Emacs color for the notification type.
+      # You can configure your own color by overwrite the defaults.
+      #
+      # @param [String] type the notification type
+      # @param [Hash] options aditional notification options
+      #
+      # @option options [String] success the color to use for success
+      # notifications (default is 'ForestGreen')
+      #
+      # @option options [String] failed the color to use for failure
+      # notifications (default is 'Firebrick')
+      #
+      # @option options [String] pending the color to use for pending
+      # notifications
+      #
+      # @option options [String] default the default color to use (default is
+      # 'Black')
+      #
+      # @return [String] the name of the emacs color
+      #
+      def _emacs_color(type, options = {})
+        default = options.fetch(:default, DEFAULTS[:default])
+        options.fetch(type.to_sym, default)
+      end
+
+      def _erb_for(filename)
+        return DEFAULT_ELISP_ERB unless filename
+        IO.read(::File.expand_path(filename))
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/notiffany-0.1.3/lib/notiffany/notifier/emacs/client.rb

@@ -0,0 +1,52 @@
+require 'erb'
+module Notiffany
+  class Notifier
+    class Emacs < Base
+      # Handles evaluating ELISP code in Emacs via Erb
+      class Client
+        attr_reader :elisp_erb
+
+        # Creates a safe binding with local variables for ERB
+        class Elisp < ERB
+          attr_reader :color
+          attr_reader :bgcolor
+          attr_reader :message
+
+          def initialize(code, color, bgcolor, message)
+            @color = color
+            @bgcolor = bgcolor
+            @message = message
+            @code = code
+            super(@code)
+          end
+
+          def result
+            super(binding)
+          end
+        end
+
+        def initialize(options)
+          @client = options[:client]
+          @elisp_erb = options[:elisp_erb]
+          raise ArgumentError, 'No :elisp_erb option given!' unless elisp_erb
+        end
+
+        def available?
+          script = Elisp.new(@elisp_erb, nil, nil, nil).result
+          _emacs_eval({ 'ALTERNATE_EDITOR' => 'false' }, script)
+        end
+
+        def notify(color, bgcolor, message = nil)
+          elisp = Elisp.new(elisp_erb, color, bgcolor, message).result
+          _emacs_eval({ 'ALTERNATE_EDITOR' => 'false' }, elisp)
+        end
+
+        private
+
+        def _emacs_eval(env, code)
+          Shellany::Sheller.run(env, @client, '--eval', code)
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/notiffany-0.1.3/lib/notiffany/notifier/file.rb

@@ -0,0 +1,44 @@
+require "notiffany/notifier/base"
+
+module Notiffany
+  class Notifier
+    # Writes notifications to a file.
+    #
+    class File < Base
+      DEFAULTS = { format: "%s\n%s\n%s\n" }
+
+      private
+
+      # @param [Hash] opts some options
+      # @option opts [Boolean] path the path to a file where notification
+      #   message will be written
+      #
+      def _check_available(opts = {})
+        fail UnavailableError, "No :path option given" unless opts[:path]
+      end
+
+      # Writes the notification to a file. By default it writes type, title,
+      # and message separated by newlines.
+      #
+      # @param [String] message the notification message body
+      # @param [Hash] opts additional notification library options
+      # @option opts [String] type the notification type. Either 'success',
+      #   'pending', 'failed' or 'notify'
+      # @option opts [String] title the notification title
+      # @option opts [String] image the path to the notification image
+      # @option opts [String] format printf style format for file contents
+      # @option opts [String] path the path of where to write the file
+      #
+      def _perform_notify(message, opts = {})
+        fail UnavailableError, "No :path option given" unless opts[:path]
+
+        str = format(opts[:format], opts[:type], opts[:title], message)
+        ::File.write(opts[:path], str)
+      end
+
+      def _gem_name
+        nil
+      end
+    end
+  end
+end