bridgetown-builder 0.14.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d55403ba9988ba7ef4f805e8f46f9bb1f3b6f5bf5571ba442372938fe11c3b7e
+  data.tar.gz: faf5ad6c2a5767522c00bf4618a8e3ff330f3b393cff018059e6fbf8bada5022
+SHA512:
+  metadata.gz: 286318aa0554d4e905bbea42ba651f0293378dfc3c0c0ae978b54428d62dcae1aa1fc3e07e58221e5b2a91609c0c0b4b58845d0428ecabdc1e60733f3f504278
+  data.tar.gz: cdb633657736552e5a7a1691019dca4788895fa8b148c4ab52ba45b7d93d621e72b8a82950a8cad75ee86d7eb70f42876788576dfd473ee91232fd36745c59bc

data/.rubocop.yml

@@ -0,0 +1,17 @@
+---
+inherit_from: ../.rubocop.yml
+
+AllCops:
+  Include:
+    - lib/**/*.rb
+    - spec/**/*.rb
+
+Metrics/AbcSize:
+  Exclude:
+    - lib/bridgetown-builder/dsl/*
+Metrics/MethodLength:
+  Exclude:
+    - lib/bridgetown-builder/dsl/*
+Metrics/ParameterLists:
+  Exclude:
+    - lib/bridgetown-builder/dsl/hooks.rb

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+task spec: :test
+require "rake/testtask"
+Rake::TestTask.new(:test) do |test|
+  test.libs << "lib" << "test"
+  test.pattern = "test/**/test_*.rb"
+  test.verbose = true
+end

data/bridgetown-builder.gemspec

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../bridgetown-core/lib/bridgetown-core/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "bridgetown-builder"
+  spec.version       = Bridgetown::VERSION
+  spec.author        = "Bridgetown Team"
+  spec.email         = "maintainers@bridgetownrb.com"
+  spec.summary       = "A Bridgetown plugin to provide a sophisticated DSL for writing plugins at a higher level of abstraction."
+  spec.homepage      = "https://github.com/bridgetownrb/bridgetown/tree/master/bridgetown-builder"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r!^(test|script|spec|features)/!) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency("bridgetown-core", Bridgetown::VERSION)
+end

data/lib/bridgetown-builder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "bridgetown-core"
+require "bridgetown-core/version"
+
+module Bridgetown
+  module Builders
+    autoload :PluginBuilder, "bridgetown-builder/plugin"
+    autoload :DocumentBuilder, "bridgetown-builder/document"
+    autoload :DocumentsGenerator, "bridgetown-builder/documents_generator"
+  end
+
+  autoload :Builder, "bridgetown-builder/builder"
+end
+
+Bridgetown::Hooks.register_one :site, :pre_read, priority: :low, reloadable: false do |site|
+  # SiteBuilder is the superclass sites can subclass to create any number of
+  # builders, but if the site hasn't defined it explicitly, this is a no-op
+  if defined?(SiteBuilder)
+    SiteBuilder.descendants.map do |c|
+      c.new(c.name, site)
+    end
+  end
+
+  # If the documents generator is in use, we need to add it at the top of the
+  # list so the site runs the generator before any others
+  if Bridgetown::Builders.autoload?(:DocumentsGenerator).nil? &&
+      !site.generators.first.is_a?(Bridgetown::Builders::DocumentsGenerator)
+    site.generators.unshift Bridgetown::Builders::DocumentsGenerator.new(site.config)
+  end
+end
+
+Bridgetown::Hooks.register_one :site, :pre_reload, reloadable: false do |site|
+  # Remove all anonymous generator classes so they can later get reloaded
+  site.converters.delete_if { |generator| generator.class.name.nil? }
+  site.generators.delete_if { |generator| generator.class.name.nil? }
+
+  unless Bridgetown::Builders.autoload? :DocumentsGenerator
+    Bridgetown::Builders::DocumentsGenerator.clear_documents_to_generate
+  end
+end

data/lib/bridgetown-builder/builder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  # Superclass for a website's SiteBuilder abstract class
+  class Builder < Bridgetown::Builders::PluginBuilder
+    class << self
+      def register
+        Bridgetown::Hooks.register_one :site, :pre_read, reloadable: false do |site|
+          new(name, site)
+        end
+      end
+    end
+
+    # Subclass is expected to implement #build
+    def initialize(name, current_site = nil)
+      super(name, current_site)
+      build
+    end
+
+    def inspect
+      name
+    end
+
+    def self.inherited(const)
+      (@children ||= Set.new).add const
+      catch_inheritance(const) do |const_|
+        catch_inheritance(const_)
+      end
+    end
+
+    def self.catch_inheritance(const)
+      const.define_singleton_method :inherited do |const_|
+        (@children ||= Set.new).add const_
+        yield const_ if block_given?
+      end
+    end
+
+    def self.descendants
+      @children ||= Set.new
+      out = @children.map(&:descendants)
+      out << self unless ["SiteBuilder", "Bridgetown::Builder"].include?(name)
+      Set.new(out).flatten
+    end
+  end
+end

data/lib/bridgetown-builder/document.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Builders
+    class DocumentBuilder
+      attr_reader :site
+
+      def initialize(site, path)
+        @site = site
+        @path = path
+        @data = ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      def front_matter(data)
+        @data.merge!(data)
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def _add_document_to_site
+        @collection = (@data[:collection] || :posts).to_s
+        collection = @site.collections[@collection]
+        unless collection
+          collection = Collection.new(@site, @collection)
+          collection.metadata["output"] = true
+          @site.collections[@collection] = collection
+        end
+
+        doc = Document.new(
+          File.join(collection.directory, @path),
+          site: @site,
+          collection: collection
+        )
+        doc.send(:merge_defaults)
+        doc.content = @data[:content]
+        @data.delete(:content)
+
+        if @path.start_with?("/")
+          pathname = Pathname.new(@path)
+          @data[:permalink] = File.join(
+            pathname.dirname,
+            pathname.basename.sub(pathname.extname, "")
+          ) + "/"
+        end
+
+        doc.merge_data!(@data)
+        doc.send(:read_post_data)
+
+        collection.docs << doc
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      # rubocop:disable Style/MissingRespondToMissing
+      def method_missing(key, value = nil)
+        if respond_to?(key)
+          super
+        else
+          @data[key] = value
+        end
+      end
+      # rubocop:enable Style/MissingRespondToMissing
+    end
+  end
+end

data/lib/bridgetown-builder/documents_generator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Builders
+    class DocumentsGenerator < Bridgetown::Generator
+      priority :high
+
+      def self.add(path, block)
+        @documents_to_generate ||= []
+        @documents_to_generate << [path, block]
+      end
+
+      class << self
+        attr_reader :documents_to_generate
+      end
+
+      def self.clear_documents_to_generate
+        @documents_to_generate = []
+      end
+
+      def generate(site)
+        self.class.documents_to_generate&.each do |doc_block|
+          path, block = doc_block
+          doc_builder = DocumentBuilder.new(site, path)
+          doc_builder.instance_exec(&block)
+          doc_builder._add_document_to_site
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-builder/dsl/generators.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Builders
+    module DSL
+      module Generators
+        def generator(method_name = nil, &block)
+          block = method(method_name) if method_name.is_a?(Symbol)
+          local_name = name # pull the name method into a local variable
+
+          new_gen = Class.new(Bridgetown::Generator) do
+            define_method(:_builder_block) { block }
+            define_singleton_method(:custom_name) { local_name }
+
+            attr_reader :site
+
+            def inspect
+              "#{self.class.custom_name} (Generator)"
+            end
+
+            def generate(_site)
+              _builder_block.call
+            end
+          end
+
+          first_low_priority_index = site.generators.find_index { |gen| gen.class.priority == :low }
+          site.generators.insert(first_low_priority_index || 0, new_gen.new(site.config))
+
+          functions << { name: name, generator: new_gen }
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-builder/dsl/hooks.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Builders
+    module DSL
+      module Hooks
+        def hook(
+          owner,
+          event,
+          method_name = nil,
+          priority: Bridgetown::Hooks::DEFAULT_PRIORITY,
+          &block
+        )
+          block = method(method_name) if method_name.is_a?(Symbol)
+
+          hook_block = Bridgetown::Hooks.register_one(owner, event, priority: priority, &block)
+          functions << { name: name, hook: [owner, event, priority, hook_block] }
+        end
+
+        def add_data(data_key)
+          hook(:site, :post_read) do
+            site.data[data_key] = yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-builder/dsl/http.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "faraday_middleware/redirect_limit_reached"
+require "faraday_middleware/response/follow_redirects"
+require "faraday_middleware/response/parse_json"
+
+module Bridgetown
+  module Builders
+    module DSL
+      module HTTP
+        def get(url, headers: {}, parse_json: true)
+          body = begin
+                   connection(parse_json: parse_json).get(url, headers: headers).body
+                 rescue Faraday::ParsingError
+                   Bridgetown.logger.error(
+                     "Faraday::ParsingError",
+                     "The response from #{url} did not contain valid JSON"
+                   )
+                   nil
+                 end
+          yield body
+        end
+
+        def connection(headers: {}, parse_json: true)
+          headers["Content-Type"] = "application/json" if parse_json
+
+          Faraday.new(headers: headers) do |faraday|
+            faraday.use FaradayMiddleware::FollowRedirects
+            faraday.use FaradayMiddleware::ParseJson if parse_json
+            yield faraday if block_given?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-builder/dsl/liquid.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Builders
+    module DSL
+      module Liquid
+        def liquid_filter(filter_name, method_name = nil, &block)
+          block = method(method_name) if method_name.is_a?(Symbol)
+
+          m = Module.new
+          m.send(:define_method, filter_name, &block)
+          ::Liquid::Template.register_filter(m)
+
+          functions << { name: name, filter: m }
+        end
+
+        def liquid_tag(tag_name, method_name = nil, as_block: false, &block)
+          block = method(method_name) if method_name.is_a?(Symbol)
+          local_name = name # pull the name method into a local variable
+
+          tag_class = as_block ? ::Liquid::Block : ::Liquid::Tag
+          tag = Class.new(tag_class) do
+            define_method(:_builder_block) { block }
+            define_singleton_method(:custom_name) { local_name }
+
+            def inspect
+              "#{self.class.custom_name} (Liquid Tag)"
+            end
+
+            attr_reader :content, :context
+
+            def render(context)
+              @context = context
+              @content = super if is_a?(::Liquid::Block)
+              _builder_block.call(@markup.strip, self)
+            end
+          end
+
+          ::Liquid::Template.register_tag tag_name, tag
+          functions << { name: name, tag: [tag_name, tag] }
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-builder/plugin.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "bridgetown-builder/dsl/generators"
+require "bridgetown-builder/dsl/hooks"
+require "bridgetown-builder/dsl/http"
+require "bridgetown-builder/dsl/liquid"
+module Bridgetown
+  module Builders
+    class PluginBuilder
+      include DSL::Generators
+      include DSL::Hooks
+      include DSL::HTTP
+      include DSL::Liquid
+
+      attr_accessor :functions, :name, :site, :config
+
+      def initialize(name, current_site = nil)
+        self.functions = Set.new
+        self.name = name
+        self.site = current_site || Bridgetown.sites.first
+
+        self.config = if defined?(self.class::CONFIG_DEFAULTS)
+                        Bridgetown::Utils.deep_merge_hashes(
+                          self.class::CONFIG_DEFAULTS.with_indifferent_access, site.config
+                        )
+                      else
+                        site.config
+                      end
+      end
+
+      def inspect
+        "#{name} (Hook)"
+      end
+
+      def doc(path, &block)
+        DocumentsGenerator.add(path, block)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: bridgetown-builder
+version: !ruby/object:Gem::Version
+  version: 0.14.0
+platform: ruby
+authors:
+- Bridgetown Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bridgetown-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+description: 
+email: maintainers@bridgetownrb.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Rakefile
+- bridgetown-builder.gemspec
+- lib/bridgetown-builder.rb
+- lib/bridgetown-builder/builder.rb
+- lib/bridgetown-builder/document.rb
+- lib/bridgetown-builder/documents_generator.rb
+- lib/bridgetown-builder/dsl/generators.rb
+- lib/bridgetown-builder/dsl/hooks.rb
+- lib/bridgetown-builder/dsl/http.rb
+- lib/bridgetown-builder/dsl/liquid.rb
+- lib/bridgetown-builder/plugin.rb
+homepage: https://github.com/bridgetownrb/bridgetown/tree/master/bridgetown-builder
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: A Bridgetown plugin to provide a sophisticated DSL for writing plugins at
+  a higher level of abstraction.
+test_files: []