twitter-vanity-suite 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 84f468803d3ecf4d21b55672fb369cae26690d6f
-  data.tar.gz: 6c2f73fa13610f2b91fcfbac8efc6571cd599a58
+  metadata.gz: 796f4561f08b8abd32e4e80be99be9bdfba20d77
+  data.tar.gz: f557e7886e21838d21004d8fe1849a47b2399479
 SHA512:
-  metadata.gz: 2ebfd25e15c003a6d33885356fbfef0c65e0df9733e5ca1fb971cb8854990b1c3a9ca4ef680ba876c54b70d4bf0948cb184e64600afaaa65f09ab005d2957efe
-  data.tar.gz: b06c135da818f6216b763528f2b4ecd45e4b0d366eb37c51a0870053f725ad5fb8f2430a5185bcbe077a5c91d5e0e208c1742feddd559fca307a72e4b1312235
+  metadata.gz: 2375e785bdaa027a8b480f940d7d269375e4fc4d01fac60e7cd7bd2c7a7059f212b95155071eb29e1f6c2a5e711ada2b9afe9a3e55ebccba5c7fde0da6277d86
+  data.tar.gz: 6a7507c9ff71dbd6b6116b5dabfe4abe6a2d85d246ad4e745bfe9bd8e1ddcb0e06cb3a5d4ce58b57acba39aacb885f9335fb15a1631af016b8e25cc986b4ecbd

data/bin/twitter-algebra

@@ -0,0 +1,390 @@
+#!/usr/bin/env ruby
+# Usage: twitter-algebra <expression>
+#
+# There are three types of sets twitter-algebra knows how to work with at the
+# moment:
+#
+#   A.following - returns the set of users @A follows on twitter
+#
+#   A.followers - returns the set of users that follow @A on twitter
+#
+#   {A, B, C}   - returns a set containing the users @A, @B, and @C
+#
+# You may use the following operators in your expression:
+#
+#   A & B - returns the intersection of sets A and B, ie. twitter users present
+#           in both sets
+#
+#   A | B - returns the union of sets A and B, ie. twitter users present in
+#           either (or both) sets
+#
+#   ~A    - returns the complement of set A, ie. twitter users *not* present in
+#           the set
+#
+# You can combine the sets and operators described above in any way you like, for
+# example:
+#
+#   charliesome.following & ~dhh.followers
+#
+#     - lists users @charliesome follows who do not follow @dhh
+#
+#   charliesome.followers & (metrotrains.followers | yarratrams.followers)
+#
+#     - lists users that follow @charliesome as well as @metrotrains or
+#       @yarratrams (or both!)
+#
+#   charliesome.following | ~charliesome.following
+#
+#     - literally every user on twitter
+
+require_relative "../lib-internal/common"
+
+class Token
+  attr_reader :type, :value
+
+  def initialize(type, value)
+    @type = type
+    @value = value
+  end
+end
+
+class Lexer
+  TOKENS = [
+    [:BAREWORD,     /[a-z0-9_]+/],
+    [:DOT,          /\./],
+    [:INTERSECTION, /&/],
+    [:UNION,        /\|/],
+    [:COMPLEMENT,   /~/],
+    [:OPEN_PAREN,   /\(/],
+    [:CLOSE_PAREN,  /\)/],
+    [:OPEN_BRACE,   /\{/],
+    [:CLOSE_BRACE,  /\}/],
+    [:COMMA,        /,/],
+    [:WHITESPACE,   /\s+/],
+  ]
+
+  def initialize(string)
+    @scanner = StringScanner.new(string)
+    @tokens = []
+  end
+
+  def lex
+    until scanner.eos?
+      tokens << next_token
+    end
+    tokens.reject! { |token| token.type == :WHITESPACE }
+    tokens << Token.new(:END, "")
+  end
+
+private
+  attr_reader :scanner, :tokens
+
+  def next_token
+    TOKENS.each do |type, regexp|
+      if str = scanner.scan(regexp)
+        return Token.new(type, str)
+      end
+    end
+    raise SyntaxError, "Unexpected character: #{scanner.getch.inspect}"
+  end
+end
+
+module Algebra
+  class Set
+    attr_reader :values
+
+    def initialize(values)
+      @values = values.uniq
+    end
+
+    def &(other)
+      if other.is_a?(Complement)
+        Set.new(values - other.values)
+      else
+        Set.new(values & other.values)
+      end
+    end
+
+    def |(other)
+      if other.is_a?(Complement)
+        Complement.new(other.values - values)
+      else
+        Set.new(values | other.values)
+      end
+    end
+
+    def ~
+      Complement.new(values)
+    end
+  end
+
+  class Complement
+    attr_reader :values
+
+    def initialize(values)
+      @values = values.uniq
+    end
+
+    def &(other)
+      if other.is_a?(Complement)
+        Complement.new(values | other.values)
+      else
+        Complement.new(other.values - values)
+      end
+    end
+
+    def |(other)
+      if other.is_a?(Complement)
+        Complement.new(values & other.values)
+      else
+        Complement.new(values - other.values)
+      end
+    end
+
+    def ~
+      Set.new(values)
+    end
+  end
+end
+
+module AST
+  module LoadableSet
+    def load_data(threads)
+      threads[key] ||= Thread.start {
+        fetch_data
+      }
+    end
+
+    def evaluate(data)
+      Algebra::Set.new(data[key])
+    end
+  end
+
+  class Followers
+    include LoadableSet
+
+    attr_reader :handle
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    def fetch_data
+      $client.follower_ids(handle).to_a
+    end
+
+    def key
+      "#{handle}.followers"
+    end
+  end
+
+  class Following
+    include LoadableSet
+
+    attr_reader :handle
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    def fetch_data
+      $client.friend_ids(handle).to_a
+    end
+
+    def key
+      "#{handle}.following"
+    end
+  end
+
+  class HandleSet
+    include LoadableSet
+
+    attr_reader :handles
+
+    def initialize(handles)
+      @handles = handles.map(&:downcase)
+    end
+
+    def key
+      "{#{handles.sort.join(",")}}"
+    end
+
+    def fetch_data
+      $client.users(handles).map(&:id)
+    end
+  end
+
+  class Binary
+    attr_reader :left, :right
+
+    def initialize(left, right)
+      @left = left
+      @right = right
+    end
+
+    def load_data(threads)
+      left.load_data(threads)
+      right.load_data(threads)
+    end
+  end
+
+  class Intersection < Binary
+    def evaluate(data)
+      left.evaluate(data) & right.evaluate(data)
+    end
+  end
+
+  class Union < Binary
+    def evaluate(data)
+      left.evaluate(data) | right.evaluate(data)
+    end
+  end
+
+  class Complement
+    attr_reader :set
+
+    def initialize(set)
+      @set = set
+    end
+
+    def load_data(threads)
+      set.load_data(threads)
+    end
+
+    def evaluate(data)
+      ~set.evaluate(data)
+    end
+  end
+end
+
+class Parser
+  def initialize(tokens)
+    @tokens = tokens
+  end
+
+  def parse
+    expr = expression
+    expect_token(:END)
+    expr
+  end
+
+private
+  attr_reader :tokens
+
+  def peek_token
+    tokens.first
+  end
+
+  def next_token
+    tokens.shift
+  end
+
+  def expect_token(type)
+    token = next_token
+    if token.type != type
+      raise SyntaxError, "Expected #{type}, saw #{token.value.inspect}"
+    end
+    token
+  end
+
+  def expression
+    binary_expression
+  end
+
+  BINARY_OPERATORS = {
+    :UNION        => AST::Union,
+    :INTERSECTION => AST::Intersection,
+  }
+
+  def binary_expression
+    left = primary_expression
+    while klass = BINARY_OPERATORS[peek_token.type]
+      next_token
+      left = klass.new(left, primary_expression)
+    end
+    left
+  end
+
+  def primary_expression
+    case peek_token.type
+    when :COMPLEMENT
+      complement_expression
+    when :OPEN_PAREN
+      parenthesized_expression
+    when :OPEN_BRACE
+      handle_set_expression
+    when :BAREWORD
+      handle_expression
+    else
+      raise SyntaxError, "Unexpected #{peek_token.value.inspect}"
+    end
+  end
+
+  def complement_expression
+    expect_token(:COMPLEMENT)
+    AST::Complement.new(primary_expression)
+  end
+
+  def parenthesized_expression
+    expect_token(:OPEN_PAREN)
+    expr = expression
+    expect_token(:CLOSE_PAREN)
+    expr
+  end
+
+  COMMANDS = {
+    "followers" => AST::Followers,
+    "following" => AST::Following,
+  }
+
+  def handle_set_expression
+    expect_token(:OPEN_BRACE)
+    handles = []
+    while peek_token.type != :CLOSE_BRACE
+      handles << expect_token(:BAREWORD).value
+      break if peek_token.type == :CLOSE_BRACE
+      expect_token(:COMMA)
+    end
+    expect_token(:CLOSE_BRACE)
+    AST::HandleSet.new(handles)
+  end
+
+  def handle_expression
+    handle = expect_token(:BAREWORD).value
+    expect_token(:DOT)
+    command = expect_token(:BAREWORD).value
+    if klass = COMMANDS[command]
+      klass.new(handle)
+    else
+      raise SyntaxError, "Unknown command #{command.inspect}"
+    end
+  end
+end
+
+expr = ARGV.first
+tokens = Lexer.new(expr).lex
+ast = Parser.new(tokens).parse
+
+threads = {}
+data = {}
+ast.load_data(threads)
+threads.each do |data_name, thread|
+  data[data_name] = thread.value
+end
+
+result_set = ast.evaluate(data)
+complement = result_set.is_a?(Algebra::Complement)
+
+if result_set.values.empty?
+  # printing to stderr so we don't mess up scripts that we might be piping
+  # into
+  if complement
+    $stderr.puts "(everybody)"
+  else
+    $stderr.puts "(nobody)"
+  end
+else
+  $client.users(result_set.values).each do |user|
+    puts "#{complement ? "NOT " : ""}#{user.screen_name}"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twitter-vanity-suite
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Charlie Somerville
@@ -27,6 +27,7 @@ dependencies:
 description: 'my personal set of command line twitter tools '
 email: charlie@charliesomerville.com
 executables:
+- twitter-algebra
 - twitter-delete
 - twitter-hist-ids
 - twitter-intersect
@@ -34,6 +35,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/twitter-algebra
 - bin/twitter-delete
 - bin/twitter-hist-ids
 - bin/twitter-intersect