twterm 1.3.0 → 2.0.0.beta1

data/lib/twterm/history/savable.rb

@@ -1,37 +0,0 @@
-module Twterm
-  module History
-    module Savable
-      include Base
-
-      def initialize
-        unless File.exist?(file)
-          @history = []
-          return
-        end
-
-        begin
-          @history = YAML.load(File.read(file)) || []
-        rescue
-          @history = []
-        end
-
-        Scheduler.new(300) { save }
-      end
-
-      def add(item)
-        @history << item unless @history.include?(item)
-        @history = history.take(1000)
-      end
-
-      def save
-        File.open(file, 'w', 0600) { |f| f.write(history.to_yaml) }
-      end
-
-      private
-
-      def file
-        fail NotImplementedError, 'file method must be implemented'
-      end
-    end
-  end
-end

data/lib/twterm/history/screen_name.rb

@@ -1,11 +0,0 @@
-module Twterm
-  module History
-    class ScreenName
-      include Singleton, Base
-
-      def history
-        User.all.map(&:screen_name)
-      end
-    end
-  end
-end

data/lib/twterm/promise.rb

@@ -1,143 +0,0 @@
-module Twterm
-  class Promise
-    def initialize
-      @state = :pending
-      @callbacks = []
-
-      Thread.new do
-        yield method(:resolve), method(:reject)
-      end if block_given?
-    end
-
-    def catch(on_rejected = nil, &block)
-      if on_rejected.is_a?(Proc) && block_given?
-        fail SyntaxError, 'both block arg and actual block given'
-      end
-
-      on_rejected ||= block
-      self.then(nil, on_rejected)
-    end
-
-    def reject(reason)
-      return if settled?
-
-      @state = :rejected
-      @reason = reason
-
-      callbacks.each do |cb|
-        cb.invoke_on_rejected(reason)
-      end
-      self
-    end
-
-    def rejected?
-      state.eql? :rejected
-    end
-
-    def resolve(value)
-      return if settled?
-
-      @state = :fulfilled
-      @value = value
-
-      callbacks.each do |cb|
-        cb.invoke_on_fulfilled(value)
-      end
-      self
-    end
-
-    def then(on_fulfilled = nil, on_rejected = nil, &block)
-      if (on_fulfilled.is_a?(Proc) || on_rejected.is_a?(Proc)) && block_given?
-        fail SyntaxError, 'both block arg and actual block given'
-      end
-
-      on_fulfilled ||= block
-      next_promise = Promise.new
-      callback = Callback.new(
-        self,
-        on_fulfilled.is_a?(Proc) ? on_fulfilled : nil,
-        on_rejected.is_a?(Proc) ? on_rejected : nil,
-        next_promise
-      )
-      @callbacks << callback
-
-      callback.invoke_on_fulfilled(@value) if fulfilled?
-      callback.invoke_on_rejected(@reason) if rejected?
-
-      next_promise
-    end
-
-    def self.resolve(value)
-      Promise.new { |resolve, _| resolve.(value) }
-    end
-
-    private
-
-    attr_reader :callbacks, :errorbacks, :next_promises, :state
-
-    def fulfilled?
-      state.eql? :fulfilled
-    end
-
-    def pending?
-      state.eql? :pending
-    end
-
-    def rejected?
-      state.eql? :rejected
-    end
-
-    def settled?
-      !pending?
-    end
-
-    class Callback
-      def initialize(promise, on_fulfilled, on_rejected, next_promise)
-        @promise = promise
-        @on_fulfilled, @on_rejected = on_fulfilled, on_rejected
-        @next_promise = next_promise
-      end
-
-      def has_on_fulfilled?
-        !on_fulfilled.nil?
-      end
-
-      def has_on_rejected?
-        !on_rejected.nil?
-      end
-
-      def invoke_on_fulfilled(value)
-        if has_on_fulfilled?
-          new_value = on_fulfilled.(value)
-          next_promise.resolve(new_value)
-        else
-          next_promise.resolve(value)
-        end
-      rescue => reason
-        next_promise.reject(reason)
-      end
-
-      def invoke_on_rejected(reason)
-        unless has_on_rejected?
-          if has_on_fulfilled?
-            next_promise.reject(reason)
-          else
-            raise reason unless has_on_fulfilled?
-          end
-          return
-        end
-
-        begin
-          new_value = on_rejected.(reason)
-          next_promise.resolve(new_value)
-        rescue => reason
-          next_promise.reject(reason)
-        end
-      end
-
-      private
-
-      attr_reader :promise, :on_fulfilled, :on_rejected, :next_promise
-    end
-  end
-end