cline 0.3.2 → 1.0.0

data/lib/cline/collectors.rb

@@ -4,6 +4,8 @@ module Cline::Collectors
   class Base
     class << self
       def create_or_pass(message, notified_at)
+        return unless notified_at
+
         message     = message.encode(Encoding::UTF_8)
         notified_at = parse_time_string_if_needed(notified_at)
 
@@ -13,7 +15,10 @@ module Cline::Collectors
           create!(message: message, notified_at: notified_at) unless find_by_message_and_notified_at(message, notified_at)
         end
       rescue ActiveRecord::StatementInvalid, ActiveRecord::RecordInvalid => e
-        puts e.class, e.message
+        error = [e.class, e.message].join(' ')
+
+        puts error
+        Cline.logger.error error
       end
 
       private
@@ -27,8 +32,7 @@ module Cline::Collectors
       end
 
       def oldest_notification
-        @oldest_notification ||=
-          Cline::Notification.order(:notified_at).limit(1).first
+        @oldest_notification ||= Cline::Notification.order(:notified_at).limit(1).first
       end
 
       def reset_oldest_notification

data/lib/cline/collectors/feed.rb

@@ -1,11 +1,14 @@
 # coding: utf-8
 
+require 'pathname'
+
 module Cline::Collectors
   class Feed < Base
     class << self
       def collect
         new(opml_path.read).entries.each do |entry|
           message = Cline::Notification.normalize_message("#{entry.title} #{entry.url}")
+
           create_or_pass message, entry.published
         end
       end
@@ -17,47 +20,50 @@ module Cline::Collectors
 
     def initialize(opml_str)
       require 'rexml/document'
+      require 'active_support/deprecation'
       require 'feedzirra'
 
       @opml = REXML::Document.new(opml_str)
-      @feeds = parse_opml(@opml.elements['opml/body'])
     end
 
     def entries
-      entries = []
-
-      @feeds.map { |feed_url|
-        Thread.fork {
-          begin
-            feed = Feedzirra::Feed.fetch_and_parse(feed_url)
-
-            if feed.is_a?(Feedzirra::FeedUtilities)
-              feed.entries.each { |entry| entries << entry }
-            end
-          rescue
-            puts $!.class, $!.message
-          ensure
-            Thread.pass
-          end
-        }
-      }.map(&:join)
+      feed_urls = parse_opml(@opml.elements['opml/body'])
+      entries   = []
+
+      3.times.map { Thread.fork {
+        while url = feed_urls.pop
+          entries += fetch_entries(url)
+        end
+
+        Thread.pass
+      } }.map(&:join)
 
       entries
     end
 
+    private
+
     def parse_opml(opml_node)
-      feeds = []
+      urls = []
 
       opml_node.elements.each('outline') do |el|
         unless el.elements.size.zero?
-          feeds += parse_opml(el) 
+          urls += parse_opml(el)
         else
           url = el.attributes['xmlUrl']
-          feeds << url if url
+          urls << url if url
         end
       end
 
-      feeds
+      urls
+    end
+
+    def fetch_entries(feed_url)
+      feed = Feedzirra::Feed.fetch_and_parse(feed_url)
+
+      feed.is_a?(Feedzirra::FeedUtilities) ? feed.entries : []
+    rescue => e
+      Cline.logger.error [e.class, e.message].join(' ')
     end
   end
 end

data/lib/cline/command.rb

@@ -1,12 +1,35 @@
 # coding: utf-8
 
-require 'launchy'
+require 'thor'
 
 module Cline
   class Command < Thor
-    def self.start(*)
-      Cline.boot
-      super
+    class << self
+      def start(args = ARGV, *)
+        return super unless server_available?(args)
+
+        Cline::Client.start args
+      rescue => e
+        Cline.logger.fatal :cline do
+          %(#{e.class} #{e.message}\n#{e.backtrace.join($/)})
+        end
+
+        raise
+      end
+
+      private
+
+      def server_available?(args)
+        return false if client_command?(args)
+        return false unless Cline::Server.running?
+        return false unless Cline::Server.client_process?
+
+        true
+      end
+
+      def client_command?(args)
+        %w(collect open).include? args.first
+      end
     end
 
     map '-s'  => :show,
@@ -15,20 +38,22 @@ module Cline
         '-st' => :status,
         '-c'  => :collect,
         '-i'  => :init,
+        '-d'  => :server,
         '-v'  => :version
 
     desc :show, 'Show a latest message'
     method_options offset: :integer
     def show(offset = options[:offset] || 0)
-      Notification.display offset
+      notify Notification.display!(offset)
     end
 
     desc :tick, 'Rotate message'
     method_options offset: :integer, interval: :integer
-    def tick(offset = options[:offset] || 0, interval = options[:interval] || 60)
+    def tick(interval = options[:interval] || 5, offset = options[:offset] || 0)
       loop do
         show offset
-        sleep interval.to_i
+
+        sleep Integer(interval)
       end
     end
 
@@ -36,13 +61,15 @@ module Cline
     method_options query: :string
     def search(keyword = optoins[:query])
       Notification.by_keyword(keyword).each do |notification|
-        say notification.display_message
+        puts notification.display_message
       end
     end
 
     desc :open, 'Open the URL in the message if exists'
     method_options hint: :string
     def open(alias_string = options[:hint])
+      require 'launchy'
+
       notification = Notification.by_alias_string(alias_string).last
 
       if notification && url = notification.detect_url
@@ -54,19 +81,27 @@ module Cline
 
     desc :status, 'Show status'
     def status
-      say "displayed : #{Notification.displayed.count}", :green
-      say "total     : #{Notification.count}", :cyan
+      puts "displayed : #{Notification.displayed.count}"
+      puts "total     : #{Notification.count}"
+
+      server :status
     end
 
     desc :collect, 'Collect sources'
     def collect
-      Cline.collectors.each &:collect
+      pid = Process.fork {
+        Cline.collectors.each &:collect
 
-      clean_obsoletes
+        Notification.clean(Cline.notifications_limit) if Cline.notifications_limit
+      }
+
+      Process.waitpid pid
     end
 
     desc :init, 'Init database'
     def init
+      Cline.establish_database_connection
+
       ActiveRecord::Base.connection.create_table(:notifications) do |t|
         t.text     :message, null: false, default: ''
         t.integer  :display_count, null: false, default: 0
@@ -78,19 +113,60 @@ module Cline
     method_options limit: :integer
     def recent(limit = options[:limit] || 1)
       Notification.recent_notified.limit(limit).each do |notification|
-        say notification.display_message
+        puts notification.display_message
       end
     end
 
-    desc :version, 'Show version.'
+    desc :version, 'Show version'
     def version
-      say "cline version #{Cline::VERSION}"
+      puts "cline version #{Cline::VERSION}"
+    end
+
+    desc :server, 'start or stop server'
+    def server(command = :start)
+      case command.intern
+      when :start
+        puts 'starting cline server'
+
+        Server.start
+      when :stop
+        puts 'stopping cline server'
+
+        Server.stop
+      when :reload
+        puts 'reloading configuration'
+
+        Cline.tap do |c|
+          c.load_config_if_exists
+          c.load_default_config
+        end
+      when :status
+        if Server.running?
+          puts "Socket file exists"
+          puts "But server isn't responding" if Server.client_process?
+        else
+          puts "Server isn't running"
+        end
+      else
+        puts 'Usage: cline server (start|stop)'
+      end
     end
 
     private
 
-    def clean_obsoletes
-      Notification.clean(Cline.pool_size) if Cline.pool_size
+    def notify(str)
+      Cline.notify_io.tap do |io|
+        io.puts str
+        io.flush if io.respond_to?(:flush)
+      end
+
+      Thread.current[:stdout].tap do |stdout|
+        stdout.puts str if stdout
+      end
+    end
+
+    def puts(str)
+      Cline.stdout.puts str
     end
   end
 end

data/lib/cline/configure.rb

@@ -5,13 +5,15 @@ require 'forwardable'
 module Cline
   def self.configure(&block)
     configure = Configure.new
-    block ? block.(configure) : configure
+    block ? block[configure] : configure
   end
 
   class Configure
     extend Forwardable
 
-    def_delegators Cline, :pool_size=, :out_stream=
+    def_delegators Cline,
+      :logger, :logger=, :notify_io, :notify_io=, :notifications_limit, :notifications_limit=, :collectors, :collectors=, :jobs, :jobs=,
+      :pool_size=, :out_stream= # obsoletes
 
     def notification
       Cline::Notification

data/lib/cline/monkey.rb

@@ -0,0 +1,7 @@
+require 'thor'
+
+class Thor::Shell::Basic
+  extend Forwardable
+
+  def_delegators Cline, :stdout, :stderr
+end

data/lib/cline/notification.rb

@@ -1,8 +1,12 @@
 # coding: utf-8
 
 require 'uri'
+require 'sqlite3'
+require 'active_record'
 
 module Cline
+  establish_database_connection
+
   class Notification < ActiveRecord::Base
     validate :notified_at, presence: true
     validate :message, presence: true, uniqueness: true
@@ -37,30 +41,26 @@ module Cline
     end
 
     class << self
-      def display(offset = 0)
-        earliest(1, offset).first.display
+      def display!(offset = 0)
+        earliest(1, offset).first.display!
       end
 
       def normalize_message(m)
         m.gsub(/[\r\n]/, '')
       end
 
-      def clean(pool_size)
+      def clean(limit)
         order('notified_at DESC').
           order(:display_count).
-          offset(pool_size).
+          offset(limit).
           destroy_all
       end
     end
 
-    def display
-      Cline.out_stream.tap do |out|
-        out.puts display_message
-
-        out.flush if out.respond_to?(:flush)
-      end
-
-      increment! :display_count
+    def display!
+      display_message.tap {
+        increment! :display_count
+      }
     end
 
     def display_message

data/lib/cline/notify_io.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+autoload :Notify, 'notify'
+
+module Cline
+  module NotifyIO
+    class WithNotify
+      def initialize(io = $stdout)
+        @io = io
+      end
+
+      def puts(str)
+        @io.puts str
+
+        Notify.notify 'cline', str
+      end
+    end
+
+    WithGrowl = WithNotify
+  end
+
+  OutStreams = NotifyIO
+end
+

data/lib/cline/scheduled_job.rb

@@ -0,0 +1,26 @@
+module Cline
+  class ScheduledJob
+    INTERVAL = 60
+
+    def initialize(trigger, &block)
+      @trigger = trigger
+      @job     = block
+    end
+
+    def run
+      loop do
+        invoke_if_needed
+
+        sleep INTERVAL
+      end
+    end
+
+    private
+
+    def invoke_if_needed
+      Thread.fork { Command.new.instance_eval(&@job) } if @trigger.()
+    rescue Exception => e
+      Cline.logger.error [e.class, e.message].join(' ')
+    end
+  end
+end

data/lib/cline/server.rb

@@ -0,0 +1,102 @@
+# coding: utf-8
+
+require 'pathname'
+require 'socket'
+require 'json'
+require 'cline/monkey'
+
+module Cline
+  class Server
+    class << self
+      def start
+        raise %(Socket file #{socket_file} already exists.) if running?
+
+        Process.daemon
+
+        pid_file.open 'w' do |pid|
+          pid.write Process.pid
+        end
+
+        Signal.trap(:KILL) { Server.clean }
+
+        new(socket_file).run
+      end
+
+      def stop
+        raise %(Server isn't running) unless running?
+
+        Process.kill :TERM, pid
+      end
+
+      def clean
+        File.unlink pid_file
+        File.unlink socket_file
+      end
+
+      def running?
+        socket_file.exist?
+      end
+
+      def client_process?
+        Process.pid != pid
+      end
+
+      def pid
+        Integer(pid_file.read)
+      end
+
+      def pid_file
+        Pathname.new(Cline.cline_dir).join('cline.pid')
+      end
+
+      def socket_file
+        Pathname.new(Cline.cline_dir).join('cline.sock')
+      end
+    end
+
+    def initialize(socket_file)
+      @socket_file = socket_file
+      @server      = UNIXServer.new(@socket_file.to_s)
+    end
+
+    def run
+      invoke_jobs
+
+      loop do
+        Thread.fork @server.accept do |socket|
+          request = socket.recv(120)
+
+          process socket, JSON.parse(request)
+
+          socket.close
+
+          GC.start
+        end
+      end
+    ensure
+      Server.clean
+    end
+
+    private
+
+    def process(io, args)
+      replace_current_io io
+
+      Command.start args
+    rescue Exception => e
+      warn %(#{e.class} #{e.message}\n#{e.backtrace.join($/)})
+    end
+
+    def replace_current_io(io)
+      io.sync = true
+
+      Thread.current[:stdout] = Thread.current[:stderr] = io
+    end
+
+    def invoke_jobs
+      Cline.jobs.each do |job|
+        Thread.fork(job, &:run)
+      end
+    end
+  end
+end