libertree-model 0.9.11

data/lib/libertree/model/profile.rb

@@ -0,0 +1,25 @@
+module Libertree
+  module Model
+    class Profile < Sequel::Model(:profiles)
+      def after_update
+        super
+        if self.member.local?
+          Libertree::Model::Job.create_for_forests(
+            {
+              task: 'request:MEMBER',
+              params: { 'username' => self.member.account.username, }
+            }
+          )
+        end
+      end
+
+      def member
+        @member ||= Member[ self.member_id ]
+      end
+
+      def self.search(query)
+        self.where("(to_tsvector('simple', description) || to_tsvector('english', description)) @@ plainto_tsquery(?)", query).or("name_display ILIKE '%' || ? || '%'", query)
+      end
+    end
+  end
+end

data/lib/libertree/model/remote-storage-connection.rb

@@ -0,0 +1,6 @@
+module Libertree
+  module Model
+    class RemoteStorageConnection < Sequel::Model(:remote_storage_connections)
+    end
+  end
+end

data/lib/libertree/model/river.rb

@@ -0,0 +1,249 @@
+module Libertree
+  module Model
+    class River < Sequel::Model(:rivers)
+      def account
+        @account ||= Account[self.account_id]
+      end
+
+      def should_contain?( post )
+        ! self.contains?(post) && ! post.hidden_by?(self.account) && self.matches_post?(post)
+      end
+
+      def contains?( post )
+        Libertree::DB.dbh[ "SELECT river_contains_post(?, ?)", self.id, post.id ].single_value
+      end
+
+      def add_post( post )
+        Libertree::DB.dbh[ "INSERT INTO river_posts ( river_id, post_id ) VALUES ( ?, ? )", self.id, post.id ].get
+      end
+
+      def posts( opts = {} )
+        time = Time.at( opts.fetch(:time, Time.now.to_f) ).strftime("%Y-%m-%d %H:%M:%S.%6N%z")
+        Post.s(%{SELECT * FROM posts_in_river(?,?,?,?,?,?)},
+               self.id,
+               self.account.id,
+               time,
+               opts[:newer],
+               opts[:order_by] == :comment,
+               opts.fetch(:limit, 30))
+      end
+
+      def parsed_query(override_cache=false)
+        return @parsed_query  if @parsed_query && ! override_cache
+
+        full_query = self.query
+        if ! self.appended_to_all
+          full_query += ' ' + self.account.rivers_appended.map(&:query).join(' ')
+          full_query.strip!
+        end
+
+        @parsed_query = Libertree::Query.new(full_query, self.account.id, self.id).parsed
+      end
+
+      def term_matches_post?(term, post, data)
+        case term
+        when 'flag'
+          # TODO: most of these are slow
+          case data
+          when 'forest'
+            true  # Every post is a post in the forest.  :forest is sort of a no-op term
+          when 'tree'
+            post.local?
+          when 'unread'
+            ! post.read_by?(self.account)
+          when 'liked'
+            post.liked_by? self.account.member
+          when 'commented'
+            post.commented_on_by? self.account.member
+          when 'subscribed'
+            self.account.subscribed_to? post
+          end
+        when 'contact-list'
+          data.last.include? post.member_id
+        when 'from'
+          post.member_id == data
+        when 'river'
+          data.matches_post?(post)
+        when 'visibility'
+          post.visibility == data
+        when 'word-count'
+          case data
+          when /^< ?([0-9]+)$/
+            n = $1.to_i
+            post.text.scan(/\S+/).count < n
+          when /^> ?([0-9]+)$/
+            n = $1.to_i
+            post.text.scan(/\S+/).count > n
+          end
+        when 'spring'
+          data.includes?(post)
+        when 'via'
+          post.via == data
+        when 'tag'
+          post.hashtags.include? data
+        when 'phrase', 'word'
+          /(?:^|\b|\s)#{Regexp.escape(data)}(?:\b|\s|$)/i === post.text
+        end
+      end
+
+      def matches_post?(post, ignore_keys=[])
+        # Negations: Must not satisfy any of the conditions
+        # Requirements: Must satisfy every required condition
+        # Regular terms: Must satisfy at least one condition
+
+        conditions = {
+          negations:    [],
+          requirements: [],
+          regular:      []
+        }
+
+        query = self.parsed_query
+        keys = query.keys - ignore_keys
+        keys.each do |term|
+          test = lambda {|data| term_matches_post?(term, post, data)}
+          query[term].keys.each do |group|
+            conditions[group] += query[term][group].map(&test)
+          end
+        end
+
+        conditions[:negations].none? &&
+          conditions[:requirements].all? &&
+          (conditions[:regular].count > 0 ? conditions[:regular].any? : true)
+      end
+
+      def refresh_posts( n = 512 )
+        # delete posts early to avoid confusion about posts that don't
+        # match the new query
+        DB.dbh[ "DELETE FROM river_posts WHERE river_id = ?", self.id ].get
+
+        # TODO: this is slow despite indices.
+        #posts = Post.where{|p| ~Sequel.function(:post_hidden_by_account, p.id, account.id)}
+
+        # get posts that are not hidden by account and get cracking
+        posts = Post.filter_by_query(self.parsed_query, self.account, Post.not_hidden_by(account))
+
+        # get up to n posts
+        # this is faster than using find_all on the set
+        count = 0
+        matching = []
+        posts.reverse_order(:id).each do |post|
+          break  if count >= n
+
+          if res = self.matches_post?(post, ['flag', 'word', 'phrase', 'tag', 'visibility', 'from', 'via'])
+            count += 1
+            matching << post
+          end
+        end
+
+        if matching.any?
+          DB.dbh[ "INSERT INTO river_posts SELECT ?, id FROM posts WHERE id IN ?", self.id, matching.map(&:id)].get
+        end
+      end
+
+      # @param params Untrusted parameter Hash.  Be careful, this input usually comes from the outside world.
+      def revise( params )
+        self.label = params['label'].to_s
+        self.query = params['query'].to_s
+
+        n = River.num_appended_to_all
+        self.appended_to_all = !! params['appended_to_all']
+        if River.num_appended_to_all != n || self.appended_to_all
+          job_data = {
+            task: 'river:refresh-all',
+            params: {
+              'account_id' => self.account_id,
+            }.to_json
+          }
+          existing_jobs = Job.pending_where(
+            %{
+              task = ?
+              AND params = ?
+            },
+            job_data[:task],
+            job_data[:params]
+          )
+          if existing_jobs.empty?
+            Job.create job_data
+          end
+        end
+
+        if ! self.appended_to_all
+          Libertree::Model::Job.create(
+            task: 'river:refresh',
+            params: {
+              'river_id' => self.id,
+            }.to_json
+          )
+        end
+        self.save
+      end
+
+      def delete_cascade(force=false)
+        if ! force && self.appended_to_all
+          Libertree::Model::Job.create(
+            task: 'river:refresh-all',
+            params: {
+              'account_id' => self.account_id,
+            }.to_json
+          )
+        end
+        DB.dbh["SELECT delete_cascade_river(?)", self.id].get
+      end
+
+      def self.num_appended_to_all
+        self.where(:appended_to_all).count
+      end
+
+      def self.create(*args)
+        n = River.num_appended_to_all
+        river = super
+
+        if River.num_appended_to_all != n
+          Libertree::Model::Job.create(
+            task: 'river:refresh-all',
+            params: {
+              'account_id' => river.account_id,
+            }.to_json
+          )
+        end
+
+        if ! river.appended_to_all
+          Libertree::Model::Job.create(
+            task: 'river:refresh',
+            params: {
+              'river_id' => river.id,
+            }.to_json
+          )
+        end
+
+        river
+      end
+
+      def home?
+        self.home
+      end
+
+      def to_hash
+        {
+          'id'    => self.id,
+          'label' => self.label,
+          'query' => self.query,
+        }
+      end
+
+      def being_processed?
+        !! Job[
+          task: 'river:refresh',
+          params: %|{"river_id":#{self.id}}|,
+          time_finished: nil
+        ]
+      end
+
+      def mark_all_posts_as_read
+        DB.dbh[ %{SELECT mark_all_posts_in_river_as_read_by(?,?)},
+                self.id,
+                self.account.id ].get
+      end
+    end
+  end
+end

data/lib/libertree/model/server.rb

@@ -0,0 +1,35 @@
+module Libertree
+  module Model
+    class Server < Sequel::Model(:servers)
+      @@own_domain = nil
+
+      def self.own_domain=(domain)
+        @@own_domain = domain
+      end
+
+      def self.own_domain
+        @@own_domain
+      end
+
+      def name_display
+        self.domain || self.ip || "(unknown)"
+      end
+
+      def forests
+        Forest.s(
+          %{
+            SELECT
+              f.*
+            FROM
+                forests f
+              , forests_servers fs
+            WHERE
+              fs.server_id = ?
+              AND f.id = fs.forest_id
+          },
+          self.id
+        )
+      end
+    end
+  end
+end

data/lib/libertree/model/session-account.rb

@@ -0,0 +1,10 @@
+module Libertree
+  module Model
+    class SessionAccount < Sequel::Model(:sessions_accounts)
+      set_primary_key [:sid]
+      def account
+        @account ||= Account[self.account_id]
+      end
+    end
+  end
+end

data/lib/libertree/model/url-expansion.rb

@@ -0,0 +1,6 @@
+module Libertree
+  module Model
+    class UrlExpansion < Sequel::Model(:url_expansions)
+    end
+  end
+end

data/lib/libertree/model.rb

@@ -0,0 +1,48 @@
+require 'libertree/db'
+require_relative 'compat'
+Sequel::Model.plugin :dirty
+Sequel::Model.plugin :compat
+Sequel::Model.unrestrict_primary_key
+Sequel::Model.plugin :json_serializer
+
+Libertree::DB.dbh.extension :pg_array
+Sequel.extension :pg_array_ops
+
+require_relative 'query'
+
+require_relative 'model/is-remote-or-local'
+require_relative 'model/has-searchable-text'
+require_relative 'model/has-display-text'
+
+require_relative 'model/account'
+require_relative 'model/account-settings'
+require_relative 'model/chat-message'
+require_relative 'model/comment'
+require_relative 'model/comment-like'
+require_relative 'model/contact-list'
+require_relative 'model/file'
+require_relative 'model/forest'
+require_relative 'model/embed-cache'
+require_relative 'model/ignored-member'
+require_relative 'model/invitation'
+require_relative 'model/group'
+require_relative 'model/group-member'
+require_relative 'model/job'
+require_relative 'model/member'
+require_relative 'model/message'
+require_relative 'model/node'
+require_relative 'model/node_affiliation'
+require_relative 'model/node_subscription'
+require_relative 'model/notification'
+require_relative 'model/pool'
+require_relative 'model/pool-post'
+require_relative 'model/post'
+require_relative 'model/post-hidden'
+require_relative 'model/post-like'
+require_relative 'model/post-revision'
+require_relative 'model/profile'
+require_relative 'model/river'
+require_relative 'model/remote-storage-connection'
+require_relative 'model/server'
+require_relative 'model/session-account'
+require_relative 'model/url-expansion'

data/lib/libertree/query.rb

@@ -0,0 +1,167 @@
+module Libertree
+  class Query
+    private
+    class ParseError < StandardError; end
+
+    def patterns
+      {
+        'phrase'       => /(?<sign>[+-])?"(?<arg>[^"]+)"/,
+        'from'         => /(?<sign>[+-])?:from ("(?<arg>.+?)"|(?<arg>[^ ]+))/,
+        'river'        => /(?<sign>[+-])?:river "(?<arg>.+?)"/,
+        'contact-list' => /(?<sign>[+-])?:contact-list "(?<arg>.+?)"/,
+        'via'          => /(?<sign>[+-])?:via "(?<arg>.+?)"/,
+        'visibility'   => /(?<sign>[+-])?:visibility (?<arg>[a-z-]+)/,
+        'word-count'   => /(?<sign>[+-])?:word-count ?(?<arg>(?<comp>[<>]) ?(?<num>[0-9]+))/,
+        'spring'       => /(?<sign>[+-])?:spring (?<arg>"(?<spring_name>.+?)" "(?<handle>.+?)")/,
+        'flag'         => /(?<sign>[+-])?:(?<arg>forest|tree|unread|liked|commented|subscribed)/,
+        'tag'          => /(?<sign>[+-])?#(?<arg>\S+)/,
+        'word'         => /(?<sign>[+-])?(?<arg>\S+)/,
+      }
+    end
+
+    def check_resource(res, term, &block)
+      err = if res.is_a? Array
+              res.any?(&:nil?)
+            else
+              res.nil?
+            end
+      if err
+        if @fail_on_error
+          fail ParseError, term
+        end
+      else
+        yield(*res)
+      end
+    end
+
+    # We need the river id only to prevent self-referential river
+    # queries.  For general purpose queries this is not required.
+    def initialize(query, account_id, river_id=nil, fail_on_error=false)
+      @fail_on_error = fail_on_error
+      @parsed_query = Hash.new
+      @parsed_query.default_proc = proc do |hash,key|
+        hash[key] = {
+          :negations    => [],
+          :requirements => [],
+          :regular      => []
+        }
+      end
+
+      scanner = StringScanner.new(query)
+      until scanner.eos? do
+        scanner.skip(/\s+/)
+        patterns.each_pair do |key, pattern|
+          if term = scanner.scan(pattern)
+            match = term.match(pattern)
+            group = case match[:sign]
+                    when '+'
+                      :requirements
+                    when '-'
+                      :negations
+                    else
+                      :regular
+                    end
+
+            case key
+            when
+              'phrase',
+              'via',
+              'visibility',
+              'word-count',
+              'flag',
+              'tag'
+              @parsed_query[key][group] << match[:arg]
+            when 'from'
+              # TODO: eventually remove with_display_name check
+              member = (Model::Member.with_handle(match[:arg]) || Model::Member.with_display_name(match[:arg]))
+              check_resource(member, term) do |member|
+                @parsed_query[key][group] << member.id
+              end
+            when 'river'
+              river = Model::River[label: match[:arg], account_id: account_id]
+              check_resource(river, term) do |river|
+                @parsed_query[key][group] << river  if river_id && river.id != river_id
+              end
+            when 'contact-list'
+              list = Model::ContactList[ account_id: account_id, name: match[:arg] ]
+              check_resource(list, term) do |list|
+                ids = list.member_ids
+                @parsed_query[key][group] << [list.id, ids]  unless ids.empty?
+              end
+            when 'spring'
+              # TODO: eventually remove with_display_name check
+              member = (Model::Member.with_handle(match[:handle]) || Model::Member.with_display_name(match[:handle]))
+              pool = Model::Pool[ member_id: member.id, name: match[:spring_name], sprung: true ]  if member
+              check_resource([member, pool], term) do |list, pool|
+                @parsed_query[key][group] << pool
+              end
+            when 'word'
+              # Only treat a matched word as a simple word if it consists only of word
+              # characters.  This excludes URLs or other terms with special characters.
+              if match[:arg] =~ /^[[:word:]]+$/
+                @parsed_query['word'][group] << match[:arg]
+              else
+                @parsed_query['phrase'][group] << match[:arg]
+              end
+            end
+
+            # move on to the next term
+            next @parsed_query
+          end
+        end
+      end
+      @parsed_query
+    end
+
+    public
+    def parsed
+      @parsed_query.dup
+    end
+
+    def simple
+      tags = @parsed_query['tag'][:regular].map {|t| "##{t}"}
+      rest = @parsed_query.
+        select {|k| ['phrase', 'word'].include? k}.
+        flat_map {|h| h.last[:regular]}
+      (tags + rest).join(' ')
+    end
+
+    def to_s
+      res = []
+      apply_template = lambda do |template, groups|
+        res += groups[:negations].map    {|v| '-' + template.call(v)}
+        res += groups[:requirements].map {|v| '+' + template.call(v)}
+        res += groups[:regular].map      {|v|       template.call(v)}
+      end
+
+      @parsed_query.each_pair do |key, groups|
+        template = case key
+                   when 'phrase'
+                     lambda {|v| "\"%s\"" % v }
+                   when 'via'
+                     lambda {|v| ":via \"%s\"" % v }
+                   when 'visibility'
+                     lambda {|v| ":visibility %s" % v }
+                   when 'word-count'
+                     lambda {|v| ":word-count %s" % v }
+                   when 'flag'
+                     lambda {|v| ":%s" % v }
+                   when 'word'
+                     lambda {|v| v }
+                   when 'tag'
+                     lambda {|v| "#%s" % v }
+                   when 'from'
+                     lambda {|v| ":from %s" % Model::Member[v.to_i].handle }
+                   when 'river'
+                     lambda {|v| ":river \"%s\"" % Model::River[v.id.to_i].label }
+                   when 'contact-list'
+                     template = lambda {|v| ":contact-list \"%s\"" % Model::ContactList[v.first.to_i].name }
+                   when 'spring'
+                     lambda {|v| pool = Model::Pool[v.id.to_i]; ":spring \"%s\" \"%s\"" % [pool.name, pool.member.handle] }
+                   end
+        apply_template.call(template, groups)
+      end
+      res.join(' ')
+    end
+  end
+end

data/lib/libertree/render.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require 'nokogiri'
+require 'markdown'
+
+module Libertree
+  module Render
+    Options = [ :filter_html,
+                :smart,
+                :strike,
+                :autolink,
+                :hard_wrap,
+                :notes,
+                :codeblock,
+                :hashtags,
+                :usernames,
+                :spoilerblock
+              ]
+
+    def self.to_html_string(s, opts=Options)
+      return ''  if s.nil? or s.empty?
+      Markdown.new( s, *opts ).to_html.force_encoding('utf-8')
+    end
+
+    def self.to_html_nodeset(s, opts=Options)
+      Nokogiri::HTML.fragment(self.to_html_string(s, opts))
+    end
+  end
+end