akane 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: da68e17edf6170994c230591963faaa2f127ce0a
+  data.tar.gz: 112e4fd65c01fbd1bc45c5bf35fab09824482e42
+SHA512:
+  metadata.gz: 4029d0d629134c6b7e27bafdcfc72747ef7ae104b97a4c303b2175278384c298b6b993169442f2fabe76aa57c322f5438e0f88b1c2e657127da78fb273a86833
+  data.tar.gz: 60e2d7f0b8387798df35547b334e1e8b9dc40300f3c6a05455cbaa0d4f86dff0d201654477e741b1fb346dcf137d6fa18e2fab08daa2b662e9551e4315b75766

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+akane.yml

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in akane.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Shota Fukumori (sora_h)
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,27 @@
+# Akane
+
+Log your timeline
+
+## Requirements
+
+- Ruby 2.0.0 or later
+
+## Installation
+
+    $ gem install akane
+
+## Usage
+
+TBD
+
+## Todo
+
+* REST API fallbacking
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/akane.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'akane/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "akane"
+  spec.version       = Akane::VERSION
+  spec.authors       = ["Shota Fukumori (sora_h)"]
+  spec.email         = ["her@sorah.jp"]
+  spec.description   = %q{Log the timeline}
+  spec.summary       = %q{Log your timeline to something}
+  spec.homepage      = "https://github.com/sorah/akane"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "tweetstream", "~> 2.6.0"
+  spec.add_dependency "elasticsearch", "~> 0.4.1"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+  spec.add_development_dependency "simplecov"
+end

data/bin/akane

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'akane'
+require 'akane/cli'
+
+exit Akane::CLI.run(ARGV)

data/lib/akane.rb

@@ -0,0 +1,5 @@
+require "akane/version"
+
+module Akane
+  # Your code goes here...
+end

data/lib/akane/cli.rb

@@ -0,0 +1,83 @@
+require 'akane/manager'
+require 'akane/config'
+
+module Akane
+  class CLI
+    class << self
+      def run(*args)
+        self.new(*args).run
+      end
+    end
+
+    def initialize(args)
+      @args = args
+      @options = nil
+    end
+
+    def start
+      config.logger.info 'Starting...'
+      manager = Akane::Manager.new(config)
+      manager.run
+    end
+
+    def help
+      puts <<-EOH
+Usage:
+  akane COMMAND [ARGS]
+
+Common commands:
+
+  akane start        - start akari
+
+Common options:
+
+  -c, --config=FILE  - Specify config file name to use
+
+      EOH
+      0
+    end
+
+    def run
+      if @args.include?('--help')
+        @command = :help
+      else
+        @command = (@args.shift || :help).to_sym
+      end
+
+      result = if self.respond_to?(@command)
+                 self.__send__(@command)
+               else
+                 self.help
+               end
+
+      result.kind_of?(Numeric) ? result : 0
+    end
+
+    private
+
+    def config
+      @config ||= Akane::Config.new(options[:config])
+    end
+
+    def option_parser
+      @option_parser ||= OptionParser.new.tap do |opt|
+        opt.on_tail('--help', 'Show this message') { help; exit 0 }
+        opt.on_tail('-c CONF', '--config=CONF', 'Specify configuration file (default: ./akane.yml)') do |conf|
+          @options[:config] = conf
+        end
+      end
+    end
+
+    def parse_options
+      return @options if @options
+      @options = {config: './akane.yml'}
+      yield option_parser if block_given?
+      option_parser.parse!(@args)
+    end
+
+    def options
+      parse_options unless @options
+      @options
+    end
+  end
+end

data/lib/akane/config.rb

@@ -0,0 +1,25 @@
+require 'yaml'
+require 'logger'
+
+module Akane
+  class Config
+    def initialize(file_or_hash)
+      @hash = case file_or_hash
+              when String
+                YAML.load_file(file_or_hash)
+              when Hash
+                file_or_hash
+              else
+                raise ArgumentError, 'file_or_hash is not Hash or String'
+              end
+    end
+
+    def [](k)
+      @hash[k.to_s]
+    end
+
+    def logger
+      Logger.new(@hash["log"] || $stdout)
+    end
+  end
+end

data/lib/akane/manager.rb

@@ -0,0 +1,97 @@
+require 'eventmachine'
+require 'akane/config'
+require 'akane/recorder'
+require 'akane/receivers/stream'
+
+module Akane
+  class Manager
+    def initialize(config)
+      @config = config
+      @logger = config.logger
+    end
+
+    def prepare
+      @logger.info 'Preparing'
+      @receivers = @config["accounts"].map do |name, credential|
+        Akane::Receivers::Stream.new(
+          consumer: {token: @config["consumer"]["token"], secret: @config["consumer"]["secret"]},
+          account: {token: credential["token"], secret: credential["secret"]},
+          logger: @config.logger
+        ).tap do |receiver|
+          @logger.info "Preparing... receiver - #{receiver.class}"
+          receiver.on_tweet(  &(method(:on_tweet).to_proc.curry[name]))
+          receiver.on_message(&(method(:on_message).to_proc.curry[name]))
+          receiver.on_event(  &(method(:on_event).to_proc.curry[name]))
+          receiver.on_delete( &(method(:on_delete).to_proc.curry[name]))
+        end
+      end
+
+      @storages = @config["storages"].flat_map do |definition|
+        case definition
+        when Hash
+          definition.map do |kind, config|
+            [kind, config]
+          end
+        when String
+          [[definition, {}]]
+        end
+      end.map do |kind, config|
+        @logger.info "Preparing... storgae - #{kind}"
+        require "akane/storages/#{kind}"
+        Akane::Storages.const_get(kind.gsub(/(?:\A|_)(.)/) { $1.upcase }).new(
+          config: config,
+          logger: @config.logger
+        )
+      end
+
+      @recorder = Akane::Recorder.new(@storages, logger: @config.logger)
+
+      @logger.info "Prepared with #{@storages.size} storage(s) and #{@receivers.size} receiver(s)"
+    end
+
+    def start
+      @logger.info "Starting receivers..."
+      @receivers.each(&:start)
+      @logger.info "Starting recorder..."
+      if EM.reactor_running?
+        EM.defer { @recorder.run }
+      else
+        @recorder.run
+      end
+    end
+
+    def run
+      @logger.info "Running..."
+      self.prepare()
+
+      if EM.reactor_running?
+        start()
+      else
+        @logger.info "Diving into Eventmachine"
+        EM.epoll
+        EM.kqueue
+        EM.run do
+          start()
+        end
+      end
+    end
+
+    private
+
+    def on_tweet(account, tweet)
+      @recorder.record_tweet(account, tweet)
+    end
+
+    def on_message(account, message)
+      @recorder.record_message(account, message)
+    end
+
+    def on_event(account, event)
+      @recorder.record_event(account, event)
+    end
+
+    def on_delete(account, user_id, tweet_id)
+      @recorder.mark_as_deleted(account, user_id, tweet_id)
+    end
+  end
+end

data/lib/akane/receivers/abstract_receiver.rb

@@ -0,0 +1,47 @@
+module Akane
+  module Receivers
+    class AbstractReceiver
+      def initialize(consumer: raise(ArgumentError, 'missing consumer'),
+                     account:  raise(ArgumentError, 'missing account'),
+                     logger: Logger.new($stdout),
+                     config: {})
+        @consumer = consumer
+        @account = account
+        @logger = logger
+        @config = config
+
+        @hooks = {}
+      end
+
+      def start
+        raise NotImplementedError
+      end
+
+      def stop
+        raise NotImplementedError
+      end
+
+      def running?
+        raise NotImplementedError
+      end
+
+      def on(kind, &block)
+        (@hooks[kind] ||= []) << block
+        self
+      end
+
+      def on_tweet(&block) on(:tweet, &block) end
+      def on_delete(&block) on(:delete, &block) end
+      def on_message(&block) on(:message, &block) end
+      def on_event(&block) on(:event, &block) end
+
+      private
+
+      def invoke(kind, *args)
+        return unless @hooks[kind]
+        @hooks[kind].each { |hook| hook.call(*args) }
+        self
+      end
+    end
+  end
+end

data/lib/akane/receivers/stream.rb

@@ -0,0 +1,63 @@
+require 'akane/receivers/abstract_receiver'
+require 'tweetstream'
+
+module Akane
+  module Receivers
+    class Stream < AbstractReceiver
+      def initialize(*)
+        super
+        @running = false
+      end
+
+      def running?() @running end
+
+      def stream
+        @stream ||= TweetStream::Client.new(
+          auth_method: :oauth,
+          consumer_key: @consumer[:token],
+          consumer_secret: @consumer[:secret],
+          oauth_token: @account[:token],
+          oauth_token_secret: @account[:secret]
+        ).tap { |stream|
+          stream.on_anything do |hash|
+            invoke(:event, hash) if hash["event"]
+          end
+
+          stream.on_timeline_status do |tweet|
+            invoke(:tweet, tweet)
+          end
+
+          stream.on_delete do |tweet_id, user_id|
+            invoke(:delete, user_id, tweet_id)
+          end
+
+          stream.on_direct_message do |message|
+            invoke(:message, message)
+          end
+
+          stream.on_inited do
+            @logger.info "Stream: inited"
+          end
+
+          stream.on_reconnect do
+            @logger.info "Stream: reconnected"
+          end
+        }
+      end
+
+      def start
+        @logger.info "Stream : Starting"
+        stream.userstream
+        @running = true
+        self
+      end
+
+      def stop
+        stream.stop_stream
+        @stream = nil
+        @running = false
+        self
+      end
+    end
+  end
+end