tweetganic 0.0.1

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 brianpetro
+
+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,29 @@
+# Tweetganic
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tweetganic'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tweetganic
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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 @@
+require "bundler/gem_tasks"

data/bin/MyClass.rb

@@ -0,0 +1,344 @@
+
+  require 'tweetstream'
+  require 'twitter'
+  require 'net/http'
+  require 'json'
+  require 'uri'
+
+  # GET's settings from tweetganic server
+  def get_user_ctrls
+	  settings_response = Net::HTTP.get_response('tweetganic.herokuapp.com', "/settings/#{ARGV[0]}.json").body
+	  JSON.parse(settings_response)
+  end
+
+  # Action On/Off Controls
+  def favorite_ctrl(json)
+	  return false if json['favorite_ctrl'] == "false"
+	  return true if json['favorite_ctrl'] == "true"
+  end
+
+  def follow_ctrl(json)
+	  return false if json['follow_ctrl'] == "false"
+	  return true if json['follow_ctrl'] == "true"
+  end
+
+  def retweet_ctrl(json)
+	  return false if json['retweet_ctrl'] == "false"
+	  return true if json['retweet_ctrl'] == "true"
+  end
+
+  # Configure Twitter Connections
+  def twitter_config(c_key, c_secret, o_token, o_token_secret)
+	  TweetStream.configure do |config|
+		  config.consumer_key       = c_key
+		  config.consumer_secret    = c_secret
+		  config.oauth_token        = o_token
+		  config.oauth_token_secret = o_token_secret
+		  config.auth_method        = :oauth
+	  end
+
+	  Twitter.configure do |config|
+		  config.consumer_key       = c_key
+		  config.consumer_secret    = c_secret
+		  config.oauth_token        = o_token
+		  config.oauth_token_secret = o_token_secret
+	  end
+  end
+
+  class Numeric
+    def to_rad
+      self * Math::PI / 180
+    end
+  end
+
+  # Used to find distance for relativity. loc1 and loc2 are arrays of [latitude, longitude]
+  def distance loc1, loc2
+     lat1, lon1 = loc1
+     lat2, lon2 = loc2
+     dLat = (lat2-lat1).to_rad;
+     dLon = (lon2-lon1).to_rad;
+     a = Math.sin(dLat/2) * Math.sin(dLat/2) +
+         Math.cos(lat1.to_rad) * Math.cos(lat2.to_rad) *
+         Math.sin(dLon/2) * Math.sin(dLon/2);
+     c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+     d = 6371 * c; # Multiply by 6371 to get Kilometers
+  end
+  # Gets given points difference of distance, returns usable twitter loc geocode
+  def get_twit_loc_area(center, selected_radius)
+	  loc_adjust_by = distance([center[0],center[1]],[center[0]+0.01,center[1]+0.01])
+	  loc_adjusted = selected_radius/loc_adjust_by
+	  twitter_loc=[]
+	  twitter_loc << (center[1] - loc_adjusted/200.0).round(2)
+	  twitter_loc << (center[0] - loc_adjusted/200.0).round(2)
+	  twitter_loc << (center[1] + loc_adjusted/200.0).round(2)
+	  twitter_loc << (center[0] + loc_adjusted/200.0).round(2)
+	  return twitter_loc
+  end
+
+  # Is user using location?
+  def check_using_location(json)
+	  return false if json['using_location'] == "false"
+	  return true if json['using_location'] == "true"
+  end
+
+  # To Avoid Tweets with offsite Links
+  def check_avoiding_links(json)
+	  return false if json['avoid_promos'] == "false"
+	  return true if json['avoid_promos'] == "true"
+  end
+  # To avoid people you are following
+  def check_avoid_people_i_follow(json)
+	  return false if json['avoid_accounts_i_follow'] == "false"
+	  return true if json['avoid_accounts_i_follow'] == "true"
+  end
+  # To avoid tweets containing 'RT' as a word
+  def check_avoid_tweets_containing_rt(json)
+	  return false if json['avoid_tweets_with_rt'] == "false"
+	  return true if json['avoid_tweets_with_rt'] == "true"
+  end
+
+  def record_data(args)
+	  Net::HTTP.post_form(URI("http://tweetganic.herokuapp.com/raws.json"), args)
+  end
+
+  # Used to double filter twitters shitty(inaccurate) GPS search
+  def is_from_user_set_location(status, gen_coords)
+	  lat, lon = status.geo.coordinates
+	  if lat >= gen_coords[1] && lat <= gen_coords[3] && lon >= gen_coords[0] && lon <= gen_coords[2]
+		  return true
+	  else
+		  return false
+	  end
+  end
+
+  def is_my_friend(user_obj)
+  # status.user.following is DEPRECATED
+  # write method after array of friends is available
+  end
+
+  # Checks if two word lists contain matching words.
+  def matching_keywords(current, ref)
+	  if (current & ref).empty?
+		  return false
+	  else
+		  return true
+	  end
+  end
+
+
+  ## Twetganic Controller Variables
+  json = get_user_ctrls # Get json from tweetganic ctrls db
+
+  # Set Oauth Keys
+  c_key = json['consumer_key']
+  c_secret = json['consumer_secret']
+  o_token = json['oauth_token']
+  o_token_secret = json['oauth_token_secret']
+
+  avoiding_links=check_avoiding_links(json) # Does Tweet include third party url?
+  avoid_tweets_containing_rt=check_avoid_tweets_containing_rt(json) # Does Tweet text include 'RT'?
+  min_actions_before_re_engage=json['min_actions_before_re_engage'].to_i # How many other actionable users before a user can become actionable again?
+
+  keywords_raw = json['track'] # String of keywords extracted from JSON
+  keywords = keywords_raw.split(', ') # Parse Keywords into array/list
+
+  neg_keywords_raw=json['negative_keywords'] # String of negative keywords extracted from JSON
+  negative_keywords=neg_keywords_raw.split(', ') # Parse Negative Keywords into array/list
+
+  using_location=check_using_location(json) # Is user tracking locations?
+  if using_location # Set location vars if using location
+	  set_lat=json['center_lat'].to_f # Center latitude point for location tracking
+	  set_lon=json['center_lon'].to_f # Center longitude point for location tracking
+	  set_radius=json['radius_distance'].to_f # Distance from center point for location tracking
+	  location_keywords=json['location_keywords'].split(', ') # Additional keywords for filtering location tweets
+	  ## Generated for location tracking
+	  keyword_ref = location_keywords|keywords # Reference list of keywords and location_keywords, for matching (array)
+	  gen_coords=get_twit_loc_area([set_lat, set_lon], set_radius) # Generated Twitter location tracking coordinates
+  end
+
+  # Mains Switches for Actions
+  favorite_on = favorite_ctrl(json)
+  follow_on = follow_ctrl(json)
+  retweet_on = retweet_ctrl(json)
+
+  # Vars for Favoriting Action
+  favoriting_friends_min=json['favoriting_friends_min'].to_i
+  favoriting_friends_max=json['favoriting_friends_max'].to_i
+  favoriting_followers_min=json['favoriting_followers_min'].to_i
+  favoriting_followers_max=json['favoriting_followers_max'].to_i
+
+  # Vars for Following Action
+  following_friends_min=json['following_friends_min'].to_i
+  following_friends_max=json['following_friends_max'].to_i
+  following_followers_min=json['following_followers_min'].to_i
+  following_followers_max=json['following_followers_max'].to_i
+
+  # Vars for Retweeting Action
+  rt_friends_min=json['rt_friends_min'].to_i
+  rt_friends_max=json['rt_friends_max'].to_i
+  rt_followers_min=json['rt_followers_min'].to_i
+  rt_followers_max=json['rt_followers_max'].to_i
+
+  # Get random wait times and convert mins to seconds
+  favoriting_wait_min = (json['favoriting_wait_min'].to_i)*60
+  favoriting_wait_max = (json['favoriting_wait_max'].to_i)*60
+  following_wait_min = (json['following_wait_min'].to_i)*60
+  following_wait_max = (json['following_wait_max'].to_i)*60
+  rt_wait_min = (json['rt_wait_min'].to_i)*60
+  rt_wait_max = (json['rt_wait_max'].to_i)*60
+
+  ## Generated Variables For Tweet Processing
+  twitter_config(c_key, c_secret, o_token, o_token_secret) # Runs config for 'twitter' and 'tweetstream' gems
+
+  # Gets boundaries for initial filtering
+  friends_presets=[favoriting_friends_min, favoriting_friends_max, following_friends_min, following_friends_max, rt_friends_min, rt_friends_max]
+  followers_presets=[favoriting_followers_min, favoriting_followers_max, following_followers_min, following_followers_max, rt_followers_min, rt_followers_max]
+  min_friends=friends_presets.min
+  max_friends=friends_presets.max
+  min_followers=followers_presets.min
+  max_followers=followers_presets.max
+
+  start_time=Time.now.to_i # Start time equals run time
+  next_favorite_time=start_time # Set to favorite first eligible tweet
+  next_follow_time=start_time # Set to follow first eligible tweet
+  next_retweet_time=start_time # Set to retweet first eligible tweet
+
+  ## Vars Set By Twitter API Response
+  screen_name = Twitter.user.screen_name
+  user_id = Twitter.user.id
+
+  puts "### Welcome, #{screen_name} ###"
+  puts "Tracking:"
+  puts keywords
+  puts "Location Monitoring: #{using_location}"
+  puts "Center: Within #{set_radius}km of #{set_lat}, #{set_lon}" if using_location
+  puts "Bounds: #{gen_coords}" if using_location
+  puts "Consumer Key: #{c_key}"
+  puts "Consumer Secret: #{c_secret}"
+  puts "Oauth Token: #{o_token}"
+  puts "Oauth Secret: #{o_token_secret}"
+  puts "Avoiding Links: #{avoiding_links}"
+  puts "Avoiding Tweets Containing 'RT': #{avoid_tweets_containing_rt}"
+  puts "Avoids Re-engaging user before #{min_actions_before_re_engage} actions on others"
+  puts "Avoiding these negative keywords:"
+  puts negative_keywords
+  puts "Targets users with between #{min_friends} and #{max_friends} friends"
+  puts "Targets users with between #{min_followers} and #{max_followers} followers"
+
+  ## Fresh for running the script
+  i=0 # Tweets analysed this run
+  favorited=[] # Stores user_id's of users who were favorited
+  followed=[] # Stores user_id's of users who were followed
+  retweeted=[] # Stores user_id's of users who were retweeted
+  actionabled=[] # Stores user_id's of users who were declared actionable
+  recently_engaged=[] # Collection of recently engaged users for re-engage method
+
+  puts "Stream connecting..."
+  client = TweetStream::Client.new
+  puts "Stream Connnected."
+  client.filter({track: keywords, locations: gen_coords}) do |status|
+		  tweet_breakdown=status.text.split(' ')
+		  actionable=true
+		  favoritable=false
+		  followable=false
+		  retweetable=false
+		  dmable=false
+		  reportable=true
+		  tweet_score=0
+		  i=i+1
+		  tweeter_user_id=status.user.id
+		  tweet_id=status.id
+		  followers_count = status.user.followers_count.to_i
+		  friends_count = status.user.friends_count.to_i
+		  tweet_score = followers_count-friends_count
+		  puts ""
+		  puts "#{i}"
+		  puts "#{status.text}"
+
+		  if using_location # Runs 'double check' when running location because of Twitters inferior filtering methods
+			  if !status.geo.nil?
+				  actionable=false unless is_from_user_set_location(status, gen_coords)
+			  end
+			  # Double check keyword is causing non geoed to stop
+			  actionable=false unless matching_keywords(tweet_breakdown, keyword_ref)
+		  end
+		  ## Initial Validations for Speed, 'actionable=true' if they pass user set validations
+		  if avoid_tweets_containing_rt
+			  negative_keywords << "RT"
+		  end
+		  if avoiding_links
+			  actionable=false unless status.urls.empty?
+		  end
+		  actionable=false unless friends_count.between?(min_friends, max_friends)
+		  actionable=false unless followers_count.between?(min_followers, max_followers)
+		  actionable=false if recently_engaged.include?(tweeter_user_id)
+		  actionable=false if matching_keywords(tweet_breakdown, negative_keywords)
+
+		  if actionabled.count >=100 # Submit data when able to record 100 data points
+			  user_followers=Twitter.user.followers_count
+			  record_data({"data_id" => "1",
+									  "user_id" => "#{user_id}",
+									  "user_followers" => "#{user_followers}",
+									  "favorited" => "#{favorited}",
+									  "followed" => "#{followed}",
+									  "retweeted" => "#{retweeted}",
+									  "actionabled" => "#{actionabled}",
+									  "keywords" => "#{keywords_raw}",
+									  "negative_keywords" => "#{neg_keywords_raw}"
+									  })
+			  # Resets Lists of user_id's to submit in data
+			  favorited=[]
+			  followed=[]
+			  retweeted=[]
+			  actionabled=[]
+		  end
+
+		  if recently_engaged.count >= min_actions_before_re_engage
+			  recently_engaged=[]
+		  end
+
+		  if actionable
+			  puts "Actionable"
+			  actionabled << tweeter_user_id
+			  favoritable=true if favorite_on && friends_count.between?(favoriting_friends_min, favoriting_friends_max) && followers_count.between?(favoriting_followers_min, favoriting_followers_max)
+			  followable=true if follow_on && friends_count.between?(following_friends_min, following_friends_max) && followers_count.between?(following_followers_min, following_followers_max)
+			  retweetable=true if retweet_on && friends_count.between?(rt_friends_min, rt_friends_max) && followers_count.between?(rt_followers_min, rt_followers_max)
+
+			  if favoritable
+				  if Time.now.to_i >= next_favorite_time
+					  Twitter.favorite(tweet_id)
+					  next_favorite_time=(Time.now.to_i)+rand(favoriting_wait_min..favoriting_wait_max)
+					  favorited << tweeter_user_id
+					  recently_engaged << tweeter_user_id
+				  else
+					  puts "To Soon To Favorite"
+				  end
+			  end
+
+
+			  if followable
+				  if Time.now.to_i >= next_follow_time
+					  Twitter.follow(tweeter_user_id)
+					  next_follow_time=(Time.now.to_i)+rand(following_wait_min..following_wait_max)
+					  followed << tweeter_user_id
+					  recently_engaged << tweeter_user_id
+				  else
+					  puts "To Soon To Follow"
+				  end
+			  end
+
+
+			  if retweetable
+				  if Time.now.to_i >= next_retweet_time
+					  Twitter.retweet(tweet_id)
+					  next_retweet_time=(Time.now.to_i)+rand(rt_wait_min..rt_wait_max)
+					  retweeted << tweeter_user_id
+					  recently_engaged << tweeter_user_id
+				  else
+					  puts "To Soon To RT"
+				  end
+			  end
+		  else
+			  puts "NOT WORTHY"
+		  end
+  end

data/lib/tweetganic.rb

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

data/lib/tweetganic/version.rb

@@ -0,0 +1,3 @@
+module Tweetganic
+  VERSION = "0.0.1"
+end

data/tweetganic

@@ -0,0 +1,12 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'require_all'
+#make program output in real time so errors visible in VR.
+STDOUT.sync = true
+STDERR.sync = true
+
+#everything in these directories will be included
+my_path = File.expand_path(File.dirname(__FILE__))
+require_all Dir.glob(my_path + "/bin/**/*.rb")
+
+MyClass.new

data/tweetganic.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tweetganic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tweetganic"
+  spec.version       = Tweetganic::VERSION
+  spec.authors       = ["brianpetro"]
+  spec.email         = ["brian@plexm.com"]
+  spec.description   = %q{Run Tweetganic}
+  spec.summary       = %q{Runs Tweetganic}
+  spec.homepage      = ""
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "require"
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: tweetganic
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- brianpetro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: require
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Run Tweetganic
+email:
+- brian@plexm.com
+executables:
+- MyClass.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/MyClass.rb
+- lib/tweetganic.rb
+- lib/tweetganic/version.rb
+- tweetganic
+- tweetganic.gemspec
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Runs Tweetganic
+test_files: []