nucleo-client 0.1.0

data/lib/nucleo/models/page_rank.rb

@@ -0,0 +1,28 @@
+module Nucleo
+  module Models
+    class PageRank
+      # Returns an instance of the PageRank domain model
+      #
+      # @param attributes [Hash]
+      #
+      # @return [Nucleo::Models::PageRank]
+      def initialize(attributes={})
+        @attributes = attributes
+      end
+
+      # Returns the numeric rank
+      #
+      # @return [Integer]
+      def rank
+        @attributes['rank'].to_i
+      end
+
+      # Returns the numeric rank max
+      #
+      # @return [Integer]
+      def rank_max
+        @attributes['rank_max'].to_i
+      end
+    end
+  end
+end

data/lib/nucleo/models/pages.rb

@@ -0,0 +1,40 @@
+module Nucleo
+  module Models
+    class Pages
+      include Enumerable
+
+      def initialize(collection)
+        @collection = Array(collection)
+      end
+
+      def self.all(site_id)
+        response_body = Nucleo::Requests::Page.all(site_id)
+
+        Nucleo::Models::Feed.for_record(response_body)
+      end
+
+      def self.retrieve(site_id, id)
+        response_body = Nucleo::Requests::Page.retrieve(site_id, id)
+
+        Nucleo::Models::Page.new(response_body)
+      end
+
+      def self.retrieve!(site_id, id)
+        response_body = Nucleo::Requests::Page.retrieve!(site_id, id)
+
+        Nucleo::Models::Page.new(response_body)
+      end
+
+      def each(&block)
+        internal_collection.each(&block)
+      end
+
+      private
+      def internal_collection
+        @collection.map do |r|
+          Nucleo::Models::Page.new(r)
+        end
+      end
+    end
+  end
+end

data/lib/nucleo/models/seo_score.rb

@@ -0,0 +1,28 @@
+module Nucleo
+  module Models
+    class SeoScore
+      # Returns an instance of the SeoScore domain model
+      #
+      # @param attributes [Hash]
+      #
+      # @return [Nucleo::Models::SeoScore]
+      def initialize(attributes={})
+        @attributes = attributes
+      end
+
+      # Returns the numeric score
+      #
+      # @return [Integer]
+      def score
+        @attributes['score'].to_i
+      end
+
+      # Returns an alpha grade
+      #
+      # @return [String]
+      def grade
+        @attributes['grade']
+      end
+    end
+  end
+end

data/lib/nucleo/models/site_feed.rb

@@ -0,0 +1,82 @@
+require File.expand_path('../feeds', __FILE__)
+
+module Nucleo
+  module Models
+    class SiteFeed
+      # Returns an instanc eof the Site Feed domain model
+      #
+      # @param attributes [Hash]
+      #
+      # @return [Nucleo::Models::SiteFeed]
+      def initialize(attributes={})
+        @attributes = attributes
+      end
+
+      def self.retrieve(id, params={})
+        response_body = Nucleo::Requests::SiteFeed.retrieve(id, params)
+
+        self.new(response_body)
+      end
+
+      # Returns the Analytics Pages domain model
+      #
+      # @return [Nucleo::Models::FeedTypes::Analytics::Pages]
+      def pages
+        if @attributes.has_key?('pages')
+          Nucleo::Models::FeedTypes::Analytics::Site::Pages.new(@attributes.fetch('pages', {}))
+        else
+          nil
+        end
+      end
+
+      # Returns true if there is an Analytics Pages domain model
+      #
+      # @return [Boolean]
+      def pages?
+        self.pages.present?
+      end
+
+      # Returns the Metrics as Feeds
+      #
+      # @return [Nucleo::Models::Feeds]
+      def metrics
+        Nucleo::Models::Feeds.new(@attributes.fetch('metrics', []))
+      end
+
+      # Returns true if there are any Metric feed items
+      #
+      # @return [Boolean]
+      def metrics?
+        self.metrics.any?
+      end
+
+      # Returns the Alerts as Feeds
+      #
+      # @return [Nucleo::Models::Feeds]
+      def alerts
+        Nucleo::Models::Feeds.new(@attributes.fetch('alerts', []))
+      end
+
+      # Returns true if there are any alert feed items
+      #
+      # @return [Boolean]
+      def alerts?
+        self.alerts.any?
+      end
+
+      # Returns the changes as Rules
+      #
+      # @return [Nucleo::Models::Rules]
+      def changes
+        Nucleo::Models::Rules.new(@attributes.fetch('changes', []))
+      end
+
+      # Returns true if there are any change rules
+      #
+      # @return [Boolean]
+      def changes?
+        self.changes.any?
+      end
+    end
+  end
+end

data/lib/nucleo/models/tag.rb

@@ -0,0 +1,48 @@
+module Nucleo
+  module Models
+    class Tag
+      include Comparable
+
+      def initialize(attributes={})
+        @attributes = attributes
+      end
+
+      def <=>(other)
+        self.length <=> other.length
+      end
+
+      # Returns the full tag content
+      #
+      # @return [String]
+      def full_tag
+        @attributes['full_tag']
+      end
+      alias :raw_content :full_tag
+
+      # Returns the tag content
+      #
+      # @return [String]
+      def tag_content
+        @attributes['tag_content']
+      end
+      alias :content :tag_content
+
+      # Returns the content length
+      #
+      # @return [Integer]
+      def content_length
+        @attributes['content_length'].to_i
+      end
+      alias :length :content_length
+
+      # Returns the HTML wrapped snippet
+      #
+      # @todo: Extract this to a view helper
+      #
+      # @return [String]
+      def snippet
+        "<p><code>%s</code></p>" % [CGI.escapeHTML(self.full_tag)]
+      end
+    end
+  end
+end

data/lib/nucleo/models/tags.rb

@@ -0,0 +1,35 @@
+module Nucleo
+  module Models
+    class Tags
+      include Enumerable
+
+      def initialize(collection)
+        @collection = Array(collection)
+      end
+
+      def each(&block)
+        internal_collection.each(&block)
+      end
+
+      # Returns true if there is a snipped
+      #
+      # @return [Boolean]
+      def has_snippet?
+        self.any?
+      end
+      alias :snippet? :has_snippet?
+
+      # Returns the code snippet
+      #
+      # @return [String]
+      def snippet
+        self.map(&:snippet).join("\n")
+      end
+
+      private
+      def internal_collection
+        @collection.map { |r| Nucleo::Models::Tag.new(r) }
+      end
+    end
+  end
+end

data/lib/nucleo/requests.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../requests/analyzer', __FILE__)
+require File.expand_path('../requests/page_alerts', __FILE__)
+require File.expand_path('../requests/site_feed', __FILE__)
+require File.expand_path('../requests/site_changes', __FILE__)
+require File.expand_path('../requests/page_changes', __FILE__)
+require File.expand_path('../requests/site', __FILE__)
+require File.expand_path('../requests/feed', __FILE__)
+require File.expand_path('../requests/page', __FILE__)
+require File.expand_path('../requests/check_js', __FILE__)
+
+module Nucleo
+  module Requests
+  end
+end

data/lib/nucleo/requests/analyzer.rb

@@ -0,0 +1,35 @@
+module Nucleo
+  module Requests
+    class Analyzer
+      def self.analyze!(attributes={})
+        route = Nucleo::Client.routes.route_for('analyzer')
+        url   = route.url_for
+
+        request_params = attributes
+
+        response = Nucleo::Client.post(url, MultiJson.dump(request_params))
+
+        unless response.success?
+          raise Nucleo::Errors::InvalidUriError.new("URL is invalid")
+        end
+
+        response.body
+      end
+
+      def self.analyze(attributes={})
+        route = Nucleo::Client.routes.route_for('analyzer')
+        url   = route.url_for
+
+        request_params = attributes
+
+        response = Nucleo::Client.post(url, MultiJson.dump(request_params))
+
+        if response.success?
+          response.body
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/nucleo/requests/check_js.rb

@@ -0,0 +1,56 @@
+module Nucleo
+  module Requests
+    class CheckJS
+
+      # Check if a url has the JS installed
+      #
+      # @param url [String] The url to check
+      #
+      # @return [JSON]
+      def self.retrieve(params={})
+        url = params[:url]
+
+        default_params = {
+          :url => url,
+        }
+
+        request_params = default_params.merge!(params)
+
+        route = Nucleo::Client.routes.route_for('util-checkjs')
+        url   = route.url_for(request_params)
+
+        request = Nucleo::Client.get(url)
+
+        request.on(:success) do |resp|
+          response_body = resp.body
+
+          if response_body.is_a?(Hash) && response_body.has_key?("errorType")
+            Nucleo::Client.configuration.logger.error do
+              "ERR: %s" % [response_body]
+            end
+
+            return {}
+          else
+            return response_body
+          end
+        end
+
+        request.on(:failure) do |resp|
+          Nucleo::Client.configuration.logger.error do
+            "App Error: %s" % [resp.body]
+          end
+
+          return {}
+        end
+
+        request.on(:server_error) do |resp|
+          Nucleo::Client.configuration.logger.error do
+            "Server Error: %s" % [resp.body]
+          end
+
+          return {}
+        end
+      end
+    end
+  end
+end

data/lib/nucleo/requests/feed.rb

@@ -0,0 +1,58 @@
+module Nucleo
+  module Requests
+    class Feed
+
+      # Retrieve a feed with the specified params
+      #
+      # @param site_id [String,Integer] The ID of the site for the feed
+      # @param max_feed_items [Integer] Max number of feed items
+      #
+      # @return [JSON]
+      def self.retrieve(site_id, params={})
+
+        default_params = {
+          :id             => site_id,
+          :max_feed_items => 10
+        }
+
+        request_params = default_params.merge!(params)
+
+        route = Nucleo::Client.routes.route_for('site-feed')
+        url   = route.url_for(request_params)
+
+        request = Nucleo::Client.get(url)
+
+        request.on(:success) do |resp|
+          response_body = resp.body
+
+          if response_body.is_a?(Hash) && response_body.has_key?("errorType")
+            Nucleo::Client.configuration.logger.error do
+              "ERR: %s" % [response_body]
+            end
+
+            return []
+          else
+            return response_body
+          end
+        end
+
+        request.on(:failure) do |resp|
+          Nucleo::Client.configuration.logger.error do
+            "App Error: %s" % [resp.body]
+          end
+
+          return []
+        end
+
+        request.on(:server_error) do |resp|
+          Nucleo::Client.configuration.logger.error do
+            "Server Error: %s" % [resp.body]
+          end
+
+          return []
+        end
+      end
+    end
+  end
+end
+

data/lib/nucleo/requests/page.rb

@@ -0,0 +1,113 @@
+module Nucleo
+  module Requests
+    class Page
+      def self.all(site_id)
+        route = Nucleo::Client.routes.route_for('site-pages')
+        url   = route.url_for(id: site_id)
+
+        request = Nucleo::Client.get(url)
+
+        request.on(:success) do |resp|
+          response_body = resp.body
+
+          if response_body.is_a?(Hash) && response_body.has_key?("errorType")
+            Nucleo::Client.configuration.logger.error do
+              "ERR: %s" % [response_body]
+            end
+
+            return []
+          else
+            return response_body
+          end
+        end
+
+        request.on(:failure) do |resp|
+          Nucleo::Client.configuration.logger.error do
+            "App Error: %s" % [resp.body]
+          end
+
+          return []
+        end
+
+        request.on(:server_error) do |resp|
+          Nucleo::Client.configuration.logger.error do
+            "Server Error: %s" % [resp.body]
+          end
+
+          return []
+        end
+      end
+
+      def self.retrieve!(site_id, id)
+        route = Nucleo::Client.routes.route_for('site-page-detail')
+        url   = route.url_for(site_id: site_id, id: id)
+
+        request = Nucleo::Client.get(url)
+
+        request.on(:success) do |resp|
+          response_body = resp.body
+
+          if response_body.is_a?(Hash) && response_body.has_key?("errorType")
+            msg = "Could not page with id %s" % [id]
+            raise Nucleo::Errors::RecordNotFound.new(msg) and return
+          else
+            # We need to merge in the `page` to be the root object
+            page_object = response_body.fetch('page', {})
+
+            response_body = response_body.merge!(page_object)
+
+            return response_body
+          end
+        end
+
+        request.on(:failure, :server_error) do |resp|
+          msg = "Could not find page with id %s" % [id]
+          raise Nucleo::Errors::RecordNotFound.new(msg) and return
+        end
+      end
+
+      def self.retrieve(site_id, id)
+        route = Nucleo::Client.routes.route_for('site-page-detail')
+        url   = route.url_for(site_id: site_id, id: id)
+
+        request = Nucleo::Client.get(url)
+
+        request.on(:success) do |resp|
+          response_body = resp.body
+
+          if response_body.is_a?(Hash) && response_body.has_key?("errorType")
+            Nucleo::Client.configuration.logger.error do
+              "ERR: %s" % [response_body]
+            end
+
+            return []
+          else
+            # We need to merge in the `page` to be the root object
+            page_object = response_body.fetch('page', {})
+
+            response_body = response_body.merge!(page_object)
+
+            return response_body
+          end
+        end
+
+        request.on(:failure) do |resp|
+          Nucleo::Client.configuration.logger.error do
+            "App Error: %s" % [resp.body]
+          end
+
+          return []
+        end
+
+        request.on(:server_error) do |resp|
+          Nucleo::Client.configuration.logger.error do
+            "Server Error: %s" % [resp.body]
+          end
+
+          return []
+        end
+      end
+    end
+  end
+end
+