middleman-robots 1.3.2 → 1.3.6

data/lib/middleman-robots/generator.rb

@@ -1,42 +1,28 @@
-require 'middleman-robots/group'
+# frozen_string_literal: true
+
+require 'middleman-robots/generators/blocks'
+require 'middleman-robots/generators/sitemap_uri'
 
 module Middleman
   module Robots
     # Robots Text Generator Class
     class Generator
+      attr_accessor :rules, :sitemap_uri
+
       def initialize(rules, sitemap_uri)
         @rules = rules
         @sitemap_uri = sitemap_uri
       end
 
       def process
-        blocks  = block_text
-        sitemap = sitemap_text
+        text = [
+          Generators::Blocks.new(rules).text,
+          Generators::SitemapUri.new(sitemap_uri).text
+        ].compact.join "\n\n"
 
-        if !blocks.empty? && !sitemap.empty?
-          blocks + "\n" + sitemap
-        elsif !blocks.empty?
-          blocks
-        elsif !sitemap.empty?
-          sitemap
-        else
-          ''
-        end
+        text += "\n" if text.present?
+        text
       end
-
-      private
-        def block_text
-          return '' if @rules.empty?
-          data = []
-          @rules.each do |rule|
-            data << Group.new(rule).text
-          end
-          data.join("\n")
-        end
-
-        def sitemap_text
-          @sitemap_uri ? "Sitemap: #{@sitemap_uri}" : ''
-        end
     end
   end
 end

data/lib/middleman-robots/generators/block.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+module Middleman
+  module Robots
+    module Generators
+      # Block
+      #
+      # Generating Block in robots.txt
+      class Block
+        attr_accessor :rule
+
+        def initialize(rule)
+          @rule = rule
+        end
+
+        def text
+          [
+            user_agent,
+            disallow,
+            allow
+          ].compact.join("\n")
+        end
+
+        private
+
+        def user_agent
+          user_agent = rule[:user_agent].presence || rule['user-agent'].presence || '*'
+          if !user_agent.is_a?(String) && !user_agent.nil?
+            raise ArgumentError, '`user_agent` or `user-agent` option must be String or nil'
+          end
+
+          "User-Agent: #{user_agent}"
+        end
+
+        def disallow
+          return nil if rule[:disallow].nil?
+          unless rule[:disallow].is_a? Array
+            raise ArgumentError, '`disallow` option must be Array or nil'
+          end
+
+          rule[:disallow].map { |path| "Disallow: #{File.join('/', path)}" }
+        end
+
+        def allow
+          return nil if rule[:allow].nil?
+          raise ArgumentError, '`allow` option must be Array or nil' unless rule[:allow].is_a? Array
+
+          rule[:allow].map { |path| "Allow: #{File.join('/', path)}" }
+        end
+      end
+    end
+  end
+end

data/lib/middleman-robots/generators/blocks.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'middleman-robots/generators/block'
+
+module Middleman
+  module Robots
+    module Generators
+      # Blocks
+      #
+      # Collection of ::Middleman::Robots::Generators::Block
+      class Blocks
+        def initialize(rules)
+          @rules = rules
+          @groups = @rules.map { |rule| Block.new(rule) } if @rules.present?
+        end
+
+        def text
+          return nil if @groups.nil?
+
+          @groups.map(&:text).join "\n\n"
+        end
+      end
+    end
+  end
+end

data/lib/middleman-robots/generators/sitemap_uri.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+module Middleman
+  module Robots
+    module Generators
+      class SitemapUri
+        attr_accessor :uri
+
+        def initialize(uri)
+          @uri = uri
+        end
+
+        def text
+          return nil if uri.blank?
+          raise ArgumentError, 'sitemap_uri must be string or nil' unless uri.is_a? String
+
+          "Sitemap: #{uri}"
+        end
+      end
+    end
+  end
+end

data/lib/middleman-robots/version.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Middleman
   # Middleman robots module
   module Robots
-    VERSION = '1.3.2'
+    VERSION = '1.3.6'
   end
 end

data/lib/middleman_extension.rb

@@ -1,2 +1,3 @@
-require "middleman-robots"
+# frozen_string_literal: true
 
+require 'middleman-robots'

data/middleman-robots.gemspec

@@ -1,30 +1,33 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'middleman-robots/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "middleman-robots"
+  spec.name          = 'middleman-robots'
   spec.version       = Middleman::Robots::VERSION
-  spec.authors       = ["Yuya Matsushima"]
-  spec.email         = ["terra@e2esound.com"]
-  spec.summary       = %q{Generate robots.txt by config.rb.}
-  spec.description   = %q{Generate robots.txt by config.rb.}
-  spec.homepage      = "https://github.com/yterajima/middleman-robots"
-  spec.license       = "MIT"
+  spec.authors       = ['Yuya Matsushima']
+  spec.email         = ['terra@e2esound.com']
+  spec.summary       = 'Generate robots.txt by config.rb.'
+  spec.description   = 'middleman-robots create robots.txt includes Allow or Disallow and sitemap path.'
+  spec.homepage      = 'https://github.com/yterajima/middleman-robots'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
   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.required_ruby_version = '>= 2.0.0'
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.6.0'
 
-  spec.add_runtime_dependency "middleman", ">= 4.0"
+  spec.add_runtime_dependency 'middleman-cli', '>= 4.0', '<= 4.4'
+  spec.add_runtime_dependency 'middleman-core', '>= 4.0', '<= 4.4'
 
-  spec.add_development_dependency "cucumber", ">= 1.3"
-  spec.add_development_dependency "capybara", ["~> 2.5.0"]
-  spec.add_development_dependency "aruba", ">= 0.6"
-  spec.add_development_dependency "bundler", ">= 1.5"
-  spec.add_development_dependency "rake", ">= 10"
+  spec.add_development_dependency 'aruba', '>= 0.14.3'
+  spec.add_development_dependency 'bundler', '>= 1.16'
+  spec.add_development_dependency 'capybara', '>= 2.18.0'
+  spec.add_development_dependency 'cucumber', '>= 3.1.0'
+  spec.add_development_dependency 'rake', '>= 12.3'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop', '>= 0.52.1'
 end
-

data/spec/lib/middleman-robots/generator_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'middleman-robots/generator'
+
+RSpec.describe Middleman::Robots::Generator do
+  describe '#process' do
+    subject { Middleman::Robots::Generator.new(rules, sitemap_uri).process }
+
+    context 'with all options' do
+      let(:rules) do
+        [
+          {
+            user_agent: 'Googlebot',
+            disallow: %w[
+              tmp/*
+              /something/dir/file_disallow.html
+            ],
+            allow: %w[
+              allow/*
+              /something/dir/file_allow.html
+            ]
+          },
+          {
+            user_agent: 'Googlebot-Image',
+            disallow: %w[
+              tmp/*
+              /something/dir/file_disallow.html
+            ],
+            allow: %w[
+              allow/*
+              /something/dir/file_allow.html
+            ]
+          }
+        ]
+      end
+      let(:sitemap_uri) { 'http://example.com/sitemap.xml' }
+      let(:expected) do
+        <<~ROBOTS
+          User-Agent: Googlebot
+          Disallow: /tmp/*
+          Disallow: /something/dir/file_disallow.html
+          Allow: /allow/*
+          Allow: /something/dir/file_allow.html
+
+          User-Agent: Googlebot-Image
+          Disallow: /tmp/*
+          Disallow: /something/dir/file_disallow.html
+          Allow: /allow/*
+          Allow: /something/dir/file_allow.html
+
+          Sitemap: http://example.com/sitemap.xml
+        ROBOTS
+      end
+
+      it { is_expected.to eq expected }
+    end
+
+    context 'without options' do
+      let(:rules) { nil }
+      let(:sitemap_uri) { nil }
+
+      it { is_expected.to be_empty }
+    end
+  end
+end

data/spec/lib/middleman-robots/generators/block_spec.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'middleman-robots/generators/block'
+
+RSpec.describe Middleman::Robots::Generators::Block do
+  describe '#text' do
+    subject { described_class.new(rule).text }
+
+    context 'with all options' do
+      let(:rule) do
+        {
+          user_agent: 'GoogleBot',
+          disallow: %w[tmp/* /someting/dir/disallow.html],
+          allow: %w[allow/* /someting/dir/allow.html]
+        }
+      end
+      let(:expected) do
+        expected = <<~ROBOTS
+          User-Agent: GoogleBot
+          Disallow: /tmp/*
+          Disallow: /someting/dir/disallow.html
+          Allow: /allow/*
+          Allow: /someting/dir/allow.html
+        ROBOTS
+        expected.chomp
+      end
+
+      it { is_expected.to eq expected }
+    end
+
+    context 'without option' do
+      let(:rule) { {} }
+
+      it { is_expected.to eq 'User-Agent: *' }
+    end
+
+    context 'with user_agent value is' do
+      context 'Middleman-Bot' do
+        let(:rule) { { user_agent: 'Middleman-Bot' } }
+
+        it { is_expected.to eq "User-Agent: #{rule[:user_agent]}" }
+      end
+
+      context 'nil' do
+        let(:rule) { { user_agent: nil } }
+
+        it { is_expected.to eq 'User-Agent: *' }
+      end
+
+      context 'empty' do
+        let(:rule) { { user_agent: '' } }
+
+        it { is_expected.to eq 'User-Agent: *' }
+      end
+
+      context 'ERROR when' do
+        subject { -> { described_class.new(rule).text } }
+
+        context 'Array' do
+          let(:rule) { { user_agent: %w[a b] } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+
+        context 'Numeric' do
+          let(:rule) { { user_agent: 1_000 } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+
+        context 'Symbol' do
+          let(:rule) { { user_agent: :user_agent } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+      end
+    end
+
+    context 'with disallow value is' do
+      context 'single Array' do
+        let(:rule) { { disallow: %w[/tmp/*] } }
+        let(:expected) do
+          expected = <<~ROBOTS
+            User-Agent: *
+            Disallow: /tmp/*
+          ROBOTS
+          expected.chomp
+        end
+
+        it { is_expected.to eq expected }
+      end
+
+      context 'multiple Array' do
+        let(:rule) { { disallow: %w[/tmp/* /something/disallow.html] } }
+        let(:expected) do
+          expected = <<~ROBOTS
+            User-Agent: *
+            Disallow: /tmp/*
+            Disallow: /something/disallow.html
+          ROBOTS
+          expected.chomp
+        end
+
+        it { is_expected.to eq expected }
+      end
+
+      context 'nil' do
+        let(:rule) { { disallow: nil } }
+
+        it { is_expected.to eq 'User-Agent: *' }
+      end
+
+      context 'ERROR when' do
+        subject { -> { described_class.new(rule).text } }
+
+        context 'empty' do
+          let(:rule) { { disallow: '' } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+
+        context 'String' do
+          let(:rule) { { disallow: 'string' } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+
+        context 'Numeric' do
+          let(:rule) { { disallow: 1_000 } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+
+        context 'Symbol' do
+          let(:rule) { { disallow: :disallow } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+      end
+    end
+
+    context 'when allow value is' do
+      context 'single Array' do
+        let(:rule) { { allow: %w[/tmp/*] } }
+        let(:expected) do
+          expected = <<~ROBOTS
+            User-Agent: *
+            Allow: /tmp/*
+          ROBOTS
+          expected.chomp
+        end
+
+        it { is_expected.to eq expected }
+      end
+
+      context 'multiple Array' do
+        let(:rule) { { allow: %w[/tmp/* /something/allow.html] } }
+        let(:expected) do
+          expected = <<~ROBOTS
+            User-Agent: *
+            Allow: /tmp/*
+            Allow: /something/allow.html
+          ROBOTS
+          expected.chomp
+        end
+
+        it { is_expected.to eq expected }
+      end
+
+      context 'nil' do
+        let(:rule) { { allow: nil } }
+
+        it { is_expected.to eq 'User-Agent: *' }
+      end
+
+      context 'ERROR when' do
+        subject { -> { described_class.new(rule).text } }
+
+        context 'empty' do
+          let(:rule) { { allow: '' } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+
+        context 'String' do
+          let(:rule) { { allow: 'string' } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+
+        context 'Numeric' do
+          let(:rule) { { allow: 1_000 } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+
+        context 'Symbol' do
+          let(:rule) { { allow: :disallow } }
+
+          it { is_expected.to raise_error ArgumentError }
+        end
+      end
+    end
+  end
+end