bwkfanboy 1.4.1 → 2.0.0

data/lib/bwkfanboy/meta.rb

@@ -1,6 +1,9 @@
 module Bwkfanboy
-  module Meta
+  module Meta # :nodoc:
     NAME = 'bwkfanboy'
-    VERSION = '1.4.1'
+    VERSION = '2.0.0'
+    AUTHOR = 'Alexander Gromnitsky'
+    EMAIL = 'alexander.gromnitsky@gmail.com'
+    HOMEPAGE = 'http://github.com/gromnitsky/' + NAME
   end
 end

data/lib/bwkfanboy/plugin.rb

@@ -0,0 +1,247 @@
+require 'msgpack'
+require 'nokogiri'
+
+module Bwkfanboy
+
+  # Helpers for plugin authors.
+  module BH
+    extend self
+
+    # FIXME: clean unsafe html for 'html' content_type
+    def clean t
+      return '' unless t
+      t
+    end
+
+    # Tries to parse _s_ string as a date.
+    # Return the result in ISO 8601 format.
+    def date(t)
+      DateTime.parse(BH.clean(t)).iso8601
+    rescue
+      DateTime.now.iso8601
+    end
+
+    # See test_plugin.rb
+    def all_set? t
+      return false unless t
+      
+      if t.is_a?(Array)
+        return false if t.size == 0
+        
+        t.each {|i|
+          return false unless i
+          return false if i.to_s.strip.size == 0
+        }
+      end
+
+      return false if t.to_s.strip.size == 0
+      true
+    end
+    
+  end
+
+  class PluginException < StandardError
+    def initialize msg
+      super msg
+    end
+
+    alias :orig_to_s :to_s
+    # looks clumsy
+    def to_s
+      "plugin: #{orig_to_s}"
+    end
+  end
+
+  class PluginInvalidName < PluginException
+  end
+
+  class PluginNotFound < PluginException
+  end
+
+  class PluginNoOptions < PluginException
+  end
+  
+  # Requires defined 'parse(streams)' method in plugin.
+  #
+  # Raises only PluginException on purpose.
+  class Plugin
+    include Enumerable
+
+    MAX_ENTRIES = 128
+    NAME_RE = /^[a-zA-Z0-9-]+$/
+
+    # [path]    an array
+    # [name]    plugin's name (without .rb extension)
+    # [opt]     an array
+    # [&block]  you can examine the Plugin object there
+    def initialize path, name, opt, &block
+      @path = path
+      raise PluginInvalidName, "name doesn't match #{NAME_RE}" unless validName?(name)
+      @name = name
+      @origin = nil # a path where plugin was found
+      @syslib = File.dirname __FILE__
+
+      # Variables for plugin authours
+      @opt = (opt && opt.map(&:to_s)) || []
+      @uri = []
+      @enc = 'UTF-8'
+      @version = 1
+      @copyright = ''
+      @title = ''
+      @content_type = ''
+
+      @data = []
+      load &block
+    end
+
+    attr_accessor :origin
+    attr_accessor :uri, :enc, :version, :copyright, :title, :content_type
+
+    def validName? name
+      name =~ NAME_RE
+    end
+    
+    def each &b
+      @data.each &b
+    end
+
+    def << obj
+      return @data if full?
+      
+      ['title', 'link', 'updated', 'author', 'content'].each {|idx|
+        obj[idx] &&= BH.clean obj[idx]
+        raise PluginException, "empty '#{idx}' in the entry #{obj.inspect}" if obj[idx].size == 0
+      }
+      
+      @data << obj
+    end
+
+    def full?
+      @data.size >= MAX_ENTRIES
+    end
+    
+    def [] index
+      @data[index]
+    end
+
+    def size
+      @data.size
+    end
+
+    def pack stream = ''
+      # hopefully, urf8 will survive
+      MessagePack.pack export, stream
+    end
+
+    def export
+      {
+        'channel' => {
+          'updated' => entryMostRecent,
+          'id' => @uri.to_s,
+          'author' => @copyright,
+          'title' => @title,
+          'link' => @uri.first,
+          'x_entries_content_type' => @content_type,
+        },
+        'x_entries' => @data
+      }
+    end
+
+    # We can do this while adding a new entry, not here
+    def entryMostRecent
+      return nil if @data.size == 0
+      
+      max = DateTime.parse @data.sample['updated']
+      @data.each {|idx|
+        cur = DateTime.parse idx['updated']
+        max = cur if max < cur
+      }
+
+      return max.iso8601
+    end
+    
+    def load
+      raise PluginException, 'invalid search path' unless @path && @path.respond_to?(:each)
+      
+      p = nil
+      @path.each {|idx|
+        contents = Dir.glob "#{idx}/*.rb"
+        pos = contents.index "#{idx}/#{@name}.rb"
+        if pos && p = contents[pos]
+          @origin = idx
+          break
+        end
+      }
+
+      raise PluginNotFound, "'#{@name}' not found" unless p
+      
+      begin
+        instance_eval File.read(p)
+      rescue Exception
+        raise PluginException, "'#{@name}' failed to parse: #{$!}"
+      end
+
+      unless BH.all_set?(uri)
+        raise PluginException, 'uri must be an array of strings' if @opt.size != 0
+        raise PluginNoOptions, 'don\'t we forget about additional options?'
+      end
+      raise PluginException, 'enc is unset' unless BH.all_set?(enc)
+      raise PluginException, 'version must be an integer' unless BH.all_set?(version)
+      raise PluginException, 'copyright is unset' unless BH.all_set?(copyright)
+      raise PluginException, 'title is unset' unless BH.all_set?(title)
+      raise PluginException, 'content_type is unset' unless BH.all_set?(content_type)
+
+      # use this, for example, to print a message to user that loading
+      # was fine
+      yield self if block_given?
+    end
+
+    # Runs loaded plugin's parser
+    def run_parser streams
+      ok = streams ? true : false
+      streams.each {|i| ok = false unless i.respond_to?(:eof) } if streams
+      raise PluginException, 'parser expects a valid array of IO objects' unless ok
+
+      begin
+        parse streams
+      rescue Exception
+        raise PluginException, "'#{@name}' failed to parse: #{$!}"
+      end
+
+      check
+    end
+      
+    def check
+      raise PluginException, "it ain't grab anything" if @data.size == 0
+    end
+
+  end
+
+  module PluginInfo
+    extend self
+    
+    def about path, name, opt
+      p = Plugin.new path, name, opt
+      r = {}
+      ['title', 'version', 'copyright', 'uri'].each {|idx|
+        r[idx] = p.send(idx)
+      }
+      r
+    end
+
+    def getList path
+      r = []
+      path.each {|idx|
+        dir = idx.to_s
+        e = { dir => [] }
+        Dir.glob("#{dir}/*.rb").each {|file|
+          e[dir] << File.basename(file, '.rb')
+        }
+        r << e
+      }
+
+      r
+    end
+    
+  end
+end

data/lib/bwkfanboy/plugin_skeleton.erb

@@ -1,30 +1,26 @@
-# This is a skeleton for a <%= Bwkfanboy::Meta::NAME %> <%= Bwkfanboy::Meta::VERSION %> plugin.  To understand how
-# plugins work please read doc/plugins.rdoc file from <%= Bwkfanboy::Meta::NAME %>'s
+# This is a skeleton for a <%= Meta::NAME %> <%= Meta::VERSION %> plugin.  To understand how
+# plugins work please read doc/plugins.rdoc file from <%= Meta::NAME %>'s
 # distribution.
 
-require 'nokogiri'
-
-class Page < Bwkfanboy::Parse
-  module Meta
-    URI = 'http://example.org/news'
-    ENC = 'UTF-8'
-    VERSION = 1
-    COPYRIGHT = '(c) <%= DateTime.now.year %> <%= Etc.getpwuid(Process.euid)[:gecos] %>'
-    TITLE = "News from example.org"
-    CONTENT_TYPE = 'html'
-  end
+@uri << 'http://example.org/news'
+@enc = 'UTF-8'
+@version = 1
+@copyright = '(c) <%= DateTime.now.year %> <%= Etc.getpwuid(Process.euid)[:gecos] %>'
+@title = "News from example.org"
+@content_type = 'html'
   
-  def myparse(stream)
-    # read 'stream' IO object and parse it
-    doc = Nokogiri::HTML(stream, nil, Meta::ENC)
-    doc.xpath("XPATH QUERY").each {|i|
-      t = clean(i.xpath("XPATH QUERY").text())
-      l = clean(i.xpath("XPATH QUERY").text())
-      u = date(i.xpath("XPATH QUERY").text())
-      a = clean(i.xpath("XPATH QUERY").text())
-      c = clean(i.xpath("XPATH QUERY").text())
+def parse streams
+  streams.each do |io|
+    doc = Nokogiri::HTML io, nil, @enc
+    doc.xpath("XPATH QUERY").each {|idx|
+      t = idx.xpath("XPATH QUERY").text
+      l = idx.xpath("XPATH QUERY").text
+      u = BH.date idx.xpath("XPATH QUERY").text
+      a = idx.xpath("XPATH QUERY").text
+      c = idx.xpath("XPATH QUERY").text
       
-      self << { title: t, link: l, updated: u, author: a, content: c }
+      self << { 'title' => t, 'link' => l, 'updated' => u,
+        'author' => a, 'content' => c }
     }
   end
 end

data/lib/bwkfanboy/server.rb

@@ -0,0 +1,73 @@
+require 'logger'
+require 'haml'
+require 'sinatra/base'
+require 'json'
+
+require_relative 'home'
+require_relative 'utils'
+require_relative '../../etc/sinatra'
+
+module Bwkfanboy
+  class MyApp < Sinatra::Base
+    MySinatraConfig.read self
+    
+    set :home, Home.new
+    set :public_folder, CliUtils::DIR_LIB_SRC.parent.parent + 'public'
+    set :views, CliUtils::DIR_LIB_SRC.parent.parent + 'views'
+
+    use Rack::Deflater
+
+    def getOpts opts
+      return [] unless opts
+      opts.gsub! /\s+/, ' '
+      opts.strip.split ' '
+    end
+    
+    # List all plugins
+    get '/' do
+      list = PluginInfo.getList settings.home.conf[:plugins_path]
+      haml :list, locals: {
+        meta: Meta,
+        list: list
+      }
+    end
+
+    get %r{/info/([a-zA-Z0-9_-]+)} do |plugin|
+      cache_control :no_cache
+      opts = getOpts params['o']
+      begin
+        PluginInfo.about(settings.home.conf[:plugins_path], plugin, opts).to_json
+      rescue PluginInvalidName, PluginNoOptions
+        halt 400, $!.to_s
+      rescue PluginNotFound
+        halt 404, $!.to_s
+      rescue PluginException
+        halt 500, $!.to_s
+      end
+    end
+    
+    get %r{/([a-zA-Z0-9_-]+)} do |plugin|
+      begin
+        opts = getOpts params['o']
+        r = Utils.atom(settings.home.conf[:plugins_path], plugin, opts).to_s
+
+        # Search for <updated> tag and set Last-Modified header
+        if (m = r.match('<updated>(.+?)</updated>'))
+          headers 'Last-Modified' => DateTime.parse(m.to_s).httpdate
+        end
+        content_type 'application/atom+xml; charset=UTF-8'
+        headers 'Content-Disposition' => "inline; filename=\"#{Meta::NAME}-#{plugin}.xml"
+
+        r
+      rescue PluginInvalidName, PluginNoOptions
+        halt 400, $!.to_s
+      rescue PluginNotFound
+        halt 404, $!.to_s
+      rescue FetchException, PluginException, GeneratorException
+        halt 500, $!.to_s
+      end
+    end
+   
+    run! if app_file == $0
+  end
+end

data/lib/bwkfanboy/utils.rb

@@ -1,148 +1,58 @@
-require 'optparse'
-require 'logger'
+require 'erb'
+require 'digest/md5'
+require 'etc'
 
-require 'open4'
-require 'active_support/core_ext/module/attribute_accessors'
-
-require_relative 'meta'
+require_relative 'cliutils'
+require_relative 'fetch'
+require_relative 'plugin'
+require_relative 'generator'
 
 module Bwkfanboy
-  module Meta
-    USER_AGENT = "#{NAME}/#{VERSION} (#{RUBY_PLATFORM}; N; #{Encoding.default_external.name}; #{RUBY_ENGINE}; rv:#{RUBY_VERSION}.#{RUBY_PATCHLEVEL})"
-    PLUGIN_CLASS = 'Page'
-    DIR_TMP = "/tmp/#{Meta::NAME}/#{ENV['USER']}"
-    DIR_LOG = "#{DIR_TMP}/log"
-    LOG_MAXSIZE = 64*1024
-    PLUGIN_NAME = /^[ a-zA-Z0-9_-]+$/
-    PLUGIN_OPTS = /^[ a-zA-Z'"0-9_-]+$/
-  end
-  
   module Utils
-    mattr_accessor :cfg, :log
-
-    self.cfg = Hash.new()
-    cfg[:verbose] = 0
-    cfg[:log] = "#{Meta::DIR_LOG}/general.log"
-
-    def self.warnx(t)
-      m = File.basename($0) +" warning: "+ t + "\n";
-      $stderr.print(m);
-      log.warn(m.chomp) if log
-    end
-
-    def self.errx(ec, t)
-      m = File.basename($0) +" error: "+ t + "\n"
-      $stderr.print(m);
-      log.error(m.chomp) if log
-      exit(ec)
-    end
+    extend self
 
-    def self.veputs(level, t)
-      if cfg[:verbose] >= level then
-#        p log
-        log.info(t.chomp) if log
-        print(t)
+    # [template]     a full path to a .erb file
+    # [desiredName]  a future skeleton name
+    def skeletonCreate template, desiredName
+      t = ERB.new File.read template
+      t.filename = template # to report errors relative to this file
+      begin
+        md5_system = Digest::MD5.hexdigest t.result(binding)
+      rescue Exception
+        CliUtils.errx EX_SOFTWARE, "cannot read the template: #{$!}"
       end
-    end
-
-    def self.vewarnx(level, t)
-      warnx(t) if cfg[:verbose] >= level
-    end
 
-    # Logs and pidfiles the other temporal stuff sits here
-    def self.dir_tmp_create()
-      if ! File.writable?(Meta::DIR_TMP) then
+      if ! File.exists?(desiredName)
+        # create a new skeleton
         begin
-          t = '/'
-          Meta::DIR_TMP.split('/')[1..-1].each {|i|
-            t += i + '/'
-            Dir.mkdir(t) if ! Dir.exists?(t)
-          }
+          File.open(desiredName, 'w+') { |fp| fp.puts t.result(binding) }
         rescue
-          warnx("cannot create/open directory #{Meta::DIR_TMP} for writing")
+          CliUtils.errx EX_IOERR, "cannot write the skeleton: #{$!}"
+        end
+      else
+        # warn a careless user
+        if md5_system != Digest::MD5.file(desiredName).hexdigest
+          CliUtils.warnx "#{desiredName} already exists"
+          return false
         end
       end
-    end
-    
-    def self.log_start()
-      dir_tmp_create()
-      begin
-        Dir.mkdir(Meta::DIR_LOG) if ! File.writable?(Meta::DIR_LOG)
-        log = Logger.new(cfg[:log], 2, Meta::LOG_MAXSIZE)
-      rescue
-        warnx("cannot open log #{cfg[:log]}");
-        return nil
-      end
-      log.level = Logger::DEBUG
-      log.datetime_format = "%H:%M:%S"
-      log.info("#{$0} starting")
-      log
-    end
-    self.log = log_start()
-    
-    # Loads (via <tt>require()</tt>) a Ruby code from _path_ (the full path to
-    # the file). <em>class_name</em> is the name of the class to check
-    # for existence after successful plugin loading.
-    def self.plugin_load(path, class_name)
-      begin
-        require(path)
-        # TODO get rid of eval()
-        fail "class #{class_name} isn't defined" if (! eval("defined?#{class_name}") || ! eval(class_name).is_a?(Class) )
-      rescue LoadError
-        errx(1, "cannot load plugin '#{path}' #{$!}");
-      rescue Exception
-        errx(1, "plugin '#{path}' has errors: #{$!}\n\nBacktrace:\n\n#{$!.backtrace.join("\n")}")
-      end
-    end
 
-     # Get possible options for the parser.
-    def self.plugin_opts(a)
-      opt = a.size >= 2 ? a[1..-1] : ''
+      true
     end
 
+    # Do all the work of reading the plugin, parsing and generating the
+    # atom feed.
+    # FIXME: ensure all streams are closed
+    def atom pluginsPath, name, opt
+      p = Plugin.new pluginsPath, name, opt
+      streams = Fetch.openStreams p.uri
+      p.run_parser(streams)
     
-    # Parses command line options. _arr_ is an array of options (usually
-    # +ARGV+). _banner_ is a help string that describes what your
-    # program does.
-    #
-    # If _o_ is non nil function parses _arr_ immediately, otherwise it
-    # only creates +OptionParser+ object and return it (if _simple_ is
-    # false). See <tt>bwkfanboy</tt> script for examples.
-    def self.cl_parse(arr, banner, o = nil, simple = false)
-      if ! o then 
-        o = OptionParser.new
-        o.banner = banner
-        o.on('-v', 'Be more verbose.') { |i| Bwkfanboy::Utils.cfg[:verbose] += 1 }
-        o.on('-V', 'Show version & exit.') { |i|
-          puts Bwkfanboy::Meta::VERSION
-          exit 0
-        }
-        return o if ! simple
-      end
+      r = Generator.atom p.export
+      Fetch.closeStreams streams
 
-      begin
-        o.parse!(arr)
-      rescue
-        Bwkfanboy::Utils.errx(1, $!.to_s)
-      end
-    end
-
-    # used in CGI and WEBrick examples
-    def self.cmd_run(cmd)
-      so = sr = ''
-      status = Open4::popen4(cmd) { |pid, stdin, stdout, stderr|
-        so = stdout.read
-        sr = stderr.read
-      }
-      [status.exitstatus, sr, so]
-    end
-
-    def self.gem_dir_system
-      t = ["#{File.dirname(File.expand_path($0))}/../lib/#{Meta::NAME}",
-           "#{Gem.dir}/gems/#{Meta::NAME}-#{Meta::VERSION}/lib/#{Meta::NAME}"]
-      t.each {|i| return i if File.readable?(i) }
-      raise "both paths are invalid: #{t}"
+      r
     end
     
-  end # utils
+  end
 end