concerto_simple_rss 0.7 → 0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7621d623a546cb35b8ac6671dbdba81f570ebfb
-  data.tar.gz: 6a1ac67eb1add40753f8eb0d73f5c43e9d7badbc
+  metadata.gz: aa7e279123911a7477853d01e1ac97f6a9a9d6b9
+  data.tar.gz: 9f34f22652616db1752b96f52431aef37809d6c0
 SHA512:
-  metadata.gz: 8d139ccbfe054efd6cc6ad626958354bd2de718e1651cc091f8ef24e30cb4a45257520e94ba8c8c02633b42978fcae2bb4e9f3bd3e1e9158ba86fa0d3f701a58
-  data.tar.gz: 475cba55dc73ca805b7511242bc08d8b9dc5d7e009f7d233eb31a9e91e4db18a0426343e468497f89438fdbebcd1a982febe6450e8bea2496e0100b6b3ceaef6
+  metadata.gz: d3052c45ead7cabeb914416882979d34fcec3f207ad5d906acc6aaecf08d28101c7d4a92b43dbd67346032dac7b083c8ad50d3867ee9c6dc10fa8ae687804254
+  data.tar.gz: 6a341b98a8a0471de16426be656a717b9d0306f080710581adc41c8720080c8acecbc44c25eb23e4189814e619cb0ccf3fbb1f2e4ba0e22f4db023e8809f3409

data/app/assets/javascripts/concerto_simple_rss/simple_rss.js

@@ -12,6 +12,8 @@ function previewSimpleRss() {
   var url = $('input#simple_rss_config_url').data('url');
   if (url) {
     rss_url = $('input#simple_rss_config_url').val();
+    userid = $('input#simple_rss_config_url_userid').val();
+    password = $('input#simple_rss_config_url_password').val();
     output_format = $('select#simple_rss_config_output_format').val();
     max_items = $('input#simple_rss_config_max_items').val();
     reverse_order = $('select#simple_rss_config_reverse_order').val();
@@ -22,6 +24,8 @@ function previewSimpleRss() {
     }
     $("#preview_div").load(url, { data: { 
       url: rss_url, 
+      url_userid: userid,
+      url_password: password,
       output_format: output_format, 
       max_items: max_items,
       reverse_order: reverse_order,
@@ -40,6 +44,8 @@ function initializeSimpleRssHandlers() {
     // on blur and change of url, display format, reverse_order, max items, and xsl
     // not on keyup (poor man's debouncing technique?)
     $('input#simple_rss_config_url').on('blur', previewSimpleRss);
+    $('input#simple_rss_config_url_userid').on('blur', previewSimpleRss);
+    $('input#simple_rss_config_url_password').on('blur', previewSimpleRss);
     $('select#simple_rss_config_output_format').on('change', previewSimpleRss);
     $('input#simple_rss_config_max_items').on('blur', previewSimpleRss);
     $('select#simple_rss_config_reverse_order').on('change', previewSimpleRss);

data/app/models/simple_rss.rb

@@ -1,137 +1,176 @@
 class SimpleRss < DynamicContent
+  require 'base64'
 
   DISPLAY_NAME = 'RSS Feed'
 
   validate :validate_config, :validate_feed
 
+  # Load a configuration hash.
+  # Converts the JSON data stored for the content into the configuration.
+  # Called during `after_find`.
+  def load_config
+    j = JSON.load(self.data)
+    
+    # decrypt fields
+    unless j.blank?
+      encrypted_userid = Base64.decode64(j['url_userid_enc']) unless j['url_userid_enc'].blank?
+      encrypted_password = Base64.decode64(j['url_password_enc']) unless j['url_password_enc'].blank?
+
+      j['url_userid'] = (encrypted_userid.blank? ? "" : encrypted_userid.decrypt)
+      j['url_password'] = (encrypted_password.blank? ? "" : encrypted_password.decrypt)
+    end 
+
+    self.config = j
+  end
+
+  # Prepare the configuration to be saved.
+  # Compress the config hash back into JSON to be stored in the database.
+  # Called during `before_validation`.
+  def save_config
+    j = self.config.deep_dup
+
+    # encrypt fields
+    j['url_userid_enc'] = (j['url_userid'].blank? ? "" : Base64.encode64(j['url_userid'].encrypt))
+    j['url_password_enc'] = (j['url_password'].blank? ? "" : Base64.encode64(j['url_password'].encrypt))
+    j.delete 'url_userid'
+    j.delete 'url_password'
+    self.data = JSON.dump(j)
+  end
+
   def build_content
     contents = []
 
     url = self.config['url']
-    type, feed_title, rss, raw = fetch_feed(url)
-    
-    if (["RSS", "ATOM"].include? type) && !feed_title.blank?
-      # it is a valid feed
-      if !self.config['reverse_order'].blank? && self.config['reverse_order'] == '1'
-        rss.items.reverse!
-      end
-      feed_items = rss.items
-      if !self.config['max_items'].blank? && self.config['max_items'].to_i > 0
-        feed_items = feed_items.first(self.config['max_items'].to_i)
-      end
-      case self.config['output_format']
-      when 'headlines'
-        feed_items.each_slice(5).with_index do |items, index|
-          htmltext = HtmlText.new()
-          htmltext.name = "#{feed_title} (#{index+1})"
-          htmltext.data = sanitize("<h1>#{feed_title}</h1> #{items_to_html(items, type)}")
-          contents << htmltext
+    unless url.blank?
+      url_userid = self.config['url_userid']
+      url_password = self.config['url_password']
+      type, feed_title, rss, raw = fetch_feed(url, url_userid, url_password)
+      
+      if (["RSS", "ATOM"].include? type) && !feed_title.blank?
+        # it is a valid feed
+        if !self.config['reverse_order'].blank? && self.config['reverse_order'] == '1'
+          rss.items.reverse!
         end
-      when 'detailed'
-        feed_items.each_with_index do |item, index|
-          htmltext = HtmlText.new()
-          htmltext.name = "#{feed_title} (#{index+1})"
-          htmltext.data = sanitize(item_to_html(item, type))
-          contents << htmltext
-        end
-      when 'xslt'
-        require 'rexml/document'
-        require 'xml/xslt'
-
-        #XML::XSLT.registerErrorHandler { |string| puts string }
-        xslt = XML::XSLT.new()
-        begin
-          xslt.xml = REXML::Document.new(raw)
-        rescue REXML::ParseException => e
-          Rails.logger.error("Unable to parse incoming feed: #{e.message}")
-          raise "Unable to parse incoming feed. "
-        rescue => e
-          raise e
+        feed_items = rss.items
+        if !self.config['max_items'].blank? && self.config['max_items'].to_i > 0
+          feed_items = feed_items.first(self.config['max_items'].to_i)
         end
+        case self.config['output_format']
+        when 'headlines'
+          feed_items.each_slice(5).with_index do |items, index|
+            htmltext = HtmlText.new()
+            htmltext.name = "#{feed_title} (#{index+1})"
+            htmltext.data = sanitize("<h1>#{feed_title}</h1> #{items_to_html(items, type)}")
+            contents << htmltext
+          end
+        when 'detailed'
+          feed_items.each_with_index do |item, index|
+            htmltext = HtmlText.new()
+            htmltext.name = "#{feed_title} (#{index+1})"
+            htmltext.data = sanitize(item_to_html(item, type))
+            contents << htmltext
+          end
+        when 'xslt'
+          require 'rexml/document'
+          require 'xml/xslt'
 
-        begin
-          xslt.xsl = REXML::Document.new(self.config['xsl'])
-        rescue REXML::ParseException => e
-          Rails.logger.error("Unable to parse Xsl: #{e.message}")
-          # fmt is <rexml::parseexception: message :> trace ... so just pull out the message
-          s = e.message
-          msg_stop = s.index(">")
-          s = s.slice(23, msg_stop - 23) if !msg_stop.nil?
-          raise "Unable to parse Xsl.  #{s}"
-        rescue => e
-          raise e
-        end
+          #XML::XSLT.registerErrorHandler { |string| puts string }
+          xslt = XML::XSLT.new()
+          begin
+            xslt.xml = REXML::Document.new(raw)
+          rescue REXML::ParseException => e
+            Rails.logger.error("Unable to parse incoming feed: #{e.message}")
+            raise "Unable to parse incoming feed. "
+          rescue => e
+            raise e
+          end
 
-        # add a replace [gsub] function for more powerful transforms.  You can use this in a transform
-        # by adding the bogus namespace http://concerto.functions
-        # A nodeset comes in as an array of REXML::Elements 
-        XML::XSLT.registerExtFunc("http://concerto.functions", "replace") do |nodes, pattern, replacement|
-          result = xslt_replace(nodes, pattern, replacement)
-          result
-        end
+          begin
+            xslt.xsl = REXML::Document.new(self.config['xsl'])
+          rescue REXML::ParseException => e
+            Rails.logger.error("Unable to parse Xsl: #{e.message}")
+            # fmt is <rexml::parseexception: message :> trace ... so just pull out the message
+            s = e.message
+            msg_stop = s.index(">")
+            s = s.slice(23, msg_stop - 23) if !msg_stop.nil?
+            raise "Unable to parse Xsl.  #{s}"
+          rescue => e
+            raise e
+          end
 
-        XML::XSLT.registerExtFunc("http://schemas.concerto-signage.org/functions", "replace") do |nodes, pattern, replacement|
-          result = xslt_replace(nodes, pattern, replacement)
-          result
-        end
+          # add a replace [gsub] function for more powerful transforms.  You can use this in a transform
+          # by adding the bogus namespace http://concerto.functions
+          # A nodeset comes in as an array of REXML::Elements 
+          XML::XSLT.registerExtFunc("http://concerto.functions", "replace") do |nodes, pattern, replacement|
+            result = xslt_replace(nodes, pattern, replacement)
+            result
+          end
 
-        data = xslt.serve()
-        # xslt.serve does always return a string with ASCII-8BIT encoding regardless of what the actual encoding is
-        data = data.force_encoding(xslt.xml.encoding) if data
-
-        # try to load the transformed data as an xml document so we can see if there are 
-        # mulitple content-items that we need to parse out, if we cant then treat it as one content item
-        begin
-          data_xml = REXML::Document.new('<root>' + data + '</root>')
-          nodes = REXML::XPath.match(data_xml, "//content-item")
-          # if there are no content-items then add the whole result (data) as one content
-          if nodes.count == 0
-            htmltext = HtmlText.new()
-            htmltext.name = "#{feed_title}"
-            htmltext.data = sanitize(data)
-            contents << htmltext
-          else
-            # if there are any content-items then add each one as a separate content
-            # and strip off the content-item wrapper
-            nodes.each do |n|
+          XML::XSLT.registerExtFunc("http://schemas.concerto-signage.org/functions", "replace") do |nodes, pattern, replacement|
+            result = xslt_replace(nodes, pattern, replacement)
+            result
+          end
+
+          data = xslt.serve()
+          # xslt.serve does always return a string with ASCII-8BIT encoding regardless of what the actual encoding is
+          data = data.force_encoding(xslt.xml.encoding) if data
+
+          # try to load the transformed data as an xml document so we can see if there are 
+          # mulitple content-items that we need to parse out, if we cant then treat it as one content item
+          begin
+            data_xml = REXML::Document.new('<root>' + data + '</root>')
+            nodes = REXML::XPath.match(data_xml, "//content-item")
+            # if there are no content-items then add the whole result (data) as one content
+            if nodes.count == 0
               htmltext = HtmlText.new()
               htmltext.name = "#{feed_title}"
-              htmltext.data = sanitize(n.to_s.gsub(/^\s*\<content-item\>/, '').gsub(/\<\/content-item\>\s*$/,''))
+              htmltext.data = sanitize(data)
               contents << htmltext
+            else
+              # if there are any content-items then add each one as a separate content
+              # and strip off the content-item wrapper
+              nodes.each do |n|
+                htmltext = HtmlText.new()
+                htmltext.name = "#{feed_title}"
+                htmltext.data = sanitize(n.to_s.gsub(/^\s*\<content-item\>/, '').gsub(/\<\/content-item\>\s*$/,''))
+                contents << htmltext
+              end
             end
-          end
-        rescue => e
-          # maybe the html was not xml compliant-- this happens frequently in rss feed descriptions
-          # look for another separator and use it, if it exists
-
-          if data.include?("</content-item>")
-            # if there are any content-items then add each one as a separate content
-            # and strip off the content-item wrapper
-            data.split("</content-item>").each do |n|
+          rescue => e
+            # maybe the html was not xml compliant-- this happens frequently in rss feed descriptions
+            # look for another separator and use it, if it exists
+
+            if data.include?("</content-item>")
+              # if there are any content-items then add each one as a separate content
+              # and strip off the content-item wrapper
+              data.split("</content-item>").each do |n|
+                htmltext = HtmlText.new()
+                htmltext.name = "#{feed_title}"
+                htmltext.data = sanitize(n.sub("<content-item>", ""))
+                contents << htmltext if !htmltext.data.strip.blank?
+              end
+
+            else
+              Rails.logger.error("unable to parse resultant xml, assuming it is one content item #{e.message}")
+              # raise "unable to parse resultant xml #{e.message}"
+              # add the whole result as one content
               htmltext = HtmlText.new()
               htmltext.name = "#{feed_title}"
-              htmltext.data = sanitize(n.sub("<content-item>", ""))
-              contents << htmltext if !htmltext.data.strip.blank?
+              htmltext.data = sanitize(data)
+              contents << htmltext
             end
-
-          else
-            Rails.logger.error("unable to parse resultant xml, assuming it is one content item #{e.message}")
-            # raise "unable to parse resultant xml #{e.message}"
-            # add the whole result as one content
-            htmltext = HtmlText.new()
-            htmltext.name = "#{feed_title}"
-            htmltext.data = sanitize(data)
-            contents << htmltext
           end
+        else
+          raise ArgumentError, 'Unexpected output format for RSS feed.'
         end
+      elsif type == "ERROR"
+        raise rss
       else
-        raise ArgumentError, 'Unexpected output format for RSS feed.'
+        Rails.logger.error("could not fetch #{type} feed for #{feed_title} at #{url}")
+        raise "Unexpected feed format for #{url}."
       end
-    else
-      Rails.logger.error("could not fetch #{type} feed for #{feed_title} at #{url}")
-      raise "Unexpected feed format for #{url}."
     end
-
+    
     return contents
   end
 
@@ -162,7 +201,8 @@ class SimpleRss < DynamicContent
   end    
 
   # fetch the feed, return the type, title, and contents (parsed) and raw feed (unparsed)
-  def fetch_feed(url)
+  def fetch_feed(url, url_userid, url_password)
+    require 'encryptor'
     require 'rss'
     require 'open-uri'
 
@@ -171,28 +211,35 @@ class SimpleRss < DynamicContent
     rss = nil
     feed = nil
 
-    begin
-      # cache same url for 1 minute to alleviate redundant calls when previewing
-      feed = Rails.cache.fetch(url, :expires_in => 1.minute) do
-        open(url).read()
-      end
-
-      rss = RSS::Parser.parse(feed, false, true)
-      raise "feed could not be parsed" if rss.nil?
-    rescue => e
-      # cant parse rss or url is bad
-      Rails.logger.debug("unable to fetch or parse feed - #{url}, #{e.message}")
-      rss = e.message
-    else
-      type = rss.feed_type.upcase
+    unless url.blank?
+      begin
+        # cache same url for 1 minute to alleviate redundant calls when previewing
+        feed = Rails.cache.fetch(url, :expires_in => 1.minute) do
+          if url_userid.blank? or url_password.blank?
+            open(url).read()
+          else
+            open(url, http_basic_authentication: [url_userid, url_password]).read()
+          end
+        end
 
-      case type
-      when "RSS"
-        title = rss.channel.title
-      when "ATOM"
-        title = rss.title.content
+        rss = RSS::Parser.parse(feed, false, true)
+        raise "feed could not be parsed" if rss.nil?
+      rescue => e
+        # cant parse rss or url is bad
+        Rails.logger.debug("unable to fetch or parse feed - #{url}, #{e.message}")
+        rss = e.message
+        type = "ERROR"
       else
-        #title = "unknown feed type"
+        type = rss.feed_type.upcase
+
+        case type
+        when "RSS"
+          title = rss.channel.title
+        when "ATOM"
+          title = rss.title.content
+        else
+          #title = "unknown feed type"
+        end
       end
     end
 
@@ -238,16 +285,18 @@ class SimpleRss < DynamicContent
   # Simple RSS processing needs a feed URL and the format of the output content.
   def self.form_attributes
     attributes = super()
-    attributes.concat([:config => [:url, :output_format, :reverse_order, :max_items, :xsl, :sanitize_tags]])
+    attributes.concat([:config => [:url, :url_userid, :url_password, :output_format, :reverse_order, :max_items, :xsl, :sanitize_tags]])
   end
 
   # if the feed is valid we store the title in config
   def validate_feed
     url = self.config['url']
+    url_userid = self.config['url_userid']
+    url_password = self.config['url_password']
     unless url.blank? 
-      Rails.logger.debug("looking up feed title for #{url}")    
+      Rails.logger.debug("looking up feed title for #{url}")
 
-      type, title = fetch_feed(url)
+      type, title = fetch_feed(url, url_userid, url_password)
       if (["RSS", "ATOM"].include? type) && !title.blank?
         self.config['title'] = title
       else
@@ -270,11 +319,13 @@ class SimpleRss < DynamicContent
         errors.add(:base, "XSL Markup can't be blank when using the XSLT Display Format")
       else
         url = self.config['url']
+        url_userid = self.config['url_userid']
+        url_password = self.config['url_password']
         unless url.blank? 
           require 'rexml/document'
           require 'xml/xslt'
 
-          type, title, rss, raw = fetch_feed(url)
+          type, title, rss, raw = fetch_feed(url, url_userid, url_password)
           if ["RSS", "ATOM"].include? type
             begin
               xslt = XML::XSLT.new()
@@ -295,6 +346,8 @@ class SimpleRss < DynamicContent
     begin
       o = SimpleRss.create()
       o.config['url'] = data[:url]
+      o.config['url_userid'] = data[:url_userid]
+      o.config['url_password'] = data[:url_password]
       o.config['output_format'] = data[:output_format]
       o.config['max_items'] = data[:max_items]
       o.config['reverse_order'] = data[:reverse_order]

data/app/views/contents/simple_rss/_form_top.html.erb

@@ -6,9 +6,26 @@
       <%= config.label :url %>
       <div class="input">
         <%= config.url_field :url, :placeholder => 'http://feeds.bbci.co.uk/news/rss.xml', :class => "input-xxlarge", :value => @content.config['url'], "data-url" => preview_contents_path %>
-        <div><small>You can verify an RSS feed at <a href="http://validator.w3.org/feed/" target="_blank">http://validator.w3.org/feed/</a></small></div>
       </div>
     </div>
+
+    <div class="row-fluid">
+      <div class="span6">
+        <div class="clearfix span6">
+          <%= label_tooltip "simple_rss", :url_userid, t("activerecord.attributes.simple_rss.config_url_userid"), tip: t("basic_auth_tip") %>
+          <div class="input">
+            <%= config.text_field :url_userid, :class => "input-medium", autocomplete: :off %>
+          </div>
+        </div>
+        <div class="clearfix span6">
+          <%= config.label :url_password, t("activerecord.attributes.simple_rss.config_url_password") %>
+          <div class="input">
+            <%= config.password_field :url_password, :class => "input-medium", autocomplete: :off %>
+          </div>
+        </div>
+      </div>
+    </div>
+
     <div class="clearfix">
       <%= config.label :output_format, 'Display Format' %>
       <div class="input">

data/config/locales/en.yml

@@ -0,0 +1,7 @@
+en:
+  activerecord:
+    attributes:
+      simple_rss:
+        config_url_userid: "Basic Auth Id"
+        config_url_password: "Password"
+  basic_auth_tip: "Leave the User Id and Password blank if the URL does not require Basic HTTP Authentication."

data/lib/concerto_simple_rss/engine.rb

@@ -1,9 +1,13 @@
 module ConcertoSimpleRss
   class Engine < ::Rails::Engine
+    require 'encryptor'
+    
     isolate_namespace ConcertoSimpleRss
 
     initializer "register content type" do |app|
       app.config.content_types << SimpleRss
+
+      Encryptor.default_options.merge!(key: ENV["SECRET_KEY_BASE"])
     end
   end
 end

data/lib/concerto_simple_rss/version.rb

@@ -1,3 +1,3 @@
 module ConcertoSimpleRss
-  VERSION = "0.7"
+  VERSION = "0.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concerto_simple_rss
 version: !ruby/object:Gem::Version
-  version: '0.7'
+  version: '0.8'
 platform: ruby
 authors:
 - Brian Michalski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-10 00:00:00.000000000 Z
+date: 2015-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: encryptor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby-xslt
   requirement: !ruby/object:Gem::Requirement
@@ -57,6 +71,7 @@ files:
 - app/views/contents/simple_rss/_render_grid.html.erb
 - app/views/contents/simple_rss/_render_tile.html.erb
 - app/views/contents/simple_rss/_tab_icon.html.erb
+- config/locales/en.yml
 - config/routes.rb
 - lib/concerto_simple_rss.rb
 - lib/concerto_simple_rss/engine.rb
@@ -113,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: RSS Dynamic Concerto for Concerto 2.