foxpage 0.1.0

data/lib/fox_page/app_template/config/boot.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "bundler"
+Bundler.setup :default
+
+require "foxpage"

data/lib/fox_page/app_template/config/environment.rb.tt

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "./application"
+
+App.initialize!

data/lib/fox_page/app_template/config/routes.rb.tt

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+App.draw_routes do
+  # This defines the landing page of your website.
+  root "home#index"
+
+  # Additional routes can be created by using `map`.
+  # For example to map `/projects` to the index method of ProjectsController,
+  # you can do this:
+  #
+  # map "/projects" => "projects#index"
+end

data/lib/fox_page/app_template/config/site.yml.tt

@@ -0,0 +1,41 @@
+---
+# This file defines everything that's available via `App.config` in your
+# website.
+#
+# Here are some site defaults:
+site:
+  title: <%= name.inspect %>
+  description: |-
+    Another site created with FoxPage.
+  url: "https://example.com"  # the base hostname & protocol for your site
+
+  # You can also add your own items here.  For example, here is what a list of
+  # social media sites could look like:
+  #
+  # social_media:
+  #   - name: GitHub
+  #     css_class: github
+  #     url: "https://github.com/<yourusername>"
+  #   - name: Mastodon
+  #     css_class: mastodon
+  #     url: "https://ruby.social/@<yourusername>"
+  #
+  # In a view, you can then iterate over it like this:
+  #
+  #   - App.config.site.social_media.each do |site|
+  #     %a{class: site.css_class, href: site.url}= site.name
+
+# This list defines all the assets that should be built.  By default it only
+# includes the main application style sheet.
+#
+# All image assets will be added to the assets pipeline automatically.
+#
+# To use an asset in a view, you can use the `assets_path` helper, e.g:
+#
+#    %img{src: asset_path("lisp-alien.png")}
+#
+# For style sheets, you can use the `stylesheet_link_tag` helper:
+#
+#    = stylesheet_link_tag("application.css")
+assets:
+  - application.css

data/lib/fox_page/app_template/gems.rb.tt

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "foxpage", "~> <%= FoxPage::VERSION %>"
+
+group :development do
+  gem "rubocop"
+end

data/lib/fox_page/application.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "forwardable"
+require "yaml"
+
+module FoxPage
+  class Application
+    include Singleton
+
+    prepend AppParts::Builder
+    prepend AppParts::Configuration
+    prepend AppParts::Routes
+    prepend AppParts::Server
+    prepend AppParts::Sprockets
+
+    def initialize!
+      AppParts.initializers_for(self.class).each do |proc|
+        instance_eval(&proc)
+      end
+    end
+
+    # delegate _ALL_ the things!
+    self.class.extend Forwardable
+    (instance.public_methods - Object.methods)
+      .reject { |x| x.to_s.start_with?("_") }
+      .each do |meth|
+      self.class.def_delegator :instance, meth
+    end
+  end
+end

data/lib/fox_page/builders/assets.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "sprockets"
+
+module FoxPage
+  module Builders
+    module Assets
+      def build_assets
+        all_assets.each do |asset|
+          puts "ASSET\t#{asset}"
+          app.sprockets.manifest.compile(asset)
+        end
+      end
+
+      private
+
+      def all_assets
+        app.config.assets + image_assets
+      end
+
+      def image_assets
+        image_assets_path = app.root.join("app/assets/images")
+        Dir.glob("#{image_assets_path}/**/*.{png,jpg,gif,jpeg}")
+           .map { |full_path| full_path.sub(%r{\A#{image_assets_path}/}, "") }
+      end
+    end
+  end
+end

data/lib/fox_page/builders/file_copy.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module FoxPage
+  module Builders
+    module FileCopy
+      def copy_public_files
+        puts "COPY\tpublic/* => #{OUTPUT_DIRECTORY}/"
+        FileUtils.cp_r public_path, output_path
+      end
+
+      private
+
+      def public_path
+        app.root.join("public", ".")
+      end
+
+      def output_path
+        app.root.join(OUTPUT_DIRECTORY)
+      end
+    end
+  end
+end

data/lib/fox_page/builders/pages.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "tilt"
+require "fileutils"
+
+module FoxPage
+  module Builders
+    module Pages
+      using Refinements::Camelize
+
+      def build_pages
+        app.routes.each do |path, route|
+          puts "PAGE\t#{path} => #{route.base_name}"
+
+          target_directory = File.join(output_directory, path)
+          FileUtils.mkdir_p(target_directory)
+
+          File.open(File.join(target_directory, "index.html"), "w") do |f|
+            f.puts render_route(route)
+          end
+        end
+      end
+
+      def render_route(route)
+        controller = spiced_controller(route).new
+        controller.method(route.method_name).call
+
+        layout = Tilt.new(layout_path(controller))
+        page = Tilt.new(page_path(route))
+
+        controller.instance_eval do
+          layout.render(self) { page.render(self) }
+        end
+      end
+
+      # for the sake of keeping the original classes sane while building, we
+      # create a subclass of the original dynamically and inject common helpers
+      # to it and also run before_actions
+      def spiced_controller(route) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/LineLength
+        Class.new(route.controller).tap do |klass| # rubocop:disable Metrics/BlockLength, Metrics/LineLength
+          klass.include(Helpers::AppHelper.new(app))
+          klass.include(Helpers::AssetsHelper)
+          klass.include(Helpers::RenderHelper)
+
+          # include global ApplicationHelper if possible
+          begin
+            klass.include(ApplicationHelper)
+          rescue NameError # rubocop:disable Lint/HandleExceptions
+            # we don't have a global ApplicationHelper... which is fine
+          end
+
+          # find a controller-specific helper class and include it if we can
+          begin
+            helper = Kernel.const_get("#{route.base_name}_helper".camelize)
+            klass.include(helper)
+          rescue NameError # rubocop:disable Lint/HandleExceptions
+            # same difference
+          end
+
+          klass.define_method(:inspect) do |*args|
+            # report that we are actually the controller, not some random
+            # anonymous class
+            # append a + to it to indicate that it's different than an ordinary
+            # class instance
+            super(*args).sub(/#<Class:[^>]+>/, "#{route.controller}+")
+          end
+
+          klass.define_singleton_method(:inspect) do
+            # for .ancestors to show up correctly
+            "#{route.controller}+"
+          end
+
+          klass.define_method(:to_s) do |*args|
+            # irb uses this method for displaying in the prompt
+            super(*args).sub(/#<Class:[^>]+>/, "#{route.controller}+")
+          end
+
+          # inject filters
+          route.controller.public_instance_methods(false).each do |method|
+            klass.define_method(method) do |*args|
+              # @__before_actions is set on the original class -- use it from
+              # that one
+              route.controller.instance_variable_get(:@__before_actions)&.each do |action| # rubocop:disable Metrics/LineLength
+                send(action)
+              end
+              super(*args)
+            end
+          end
+        end
+      end
+
+      def layout_path(controller)
+        File
+          .join(views_path, controller.class.layout)
+          .tap(&method(:validate_file_exists))
+      end
+
+      def page_path(route)
+        Dir
+          .glob(
+            File.join(views_path, route.base_name, "#{route.method_name}.*")
+          )
+          .first
+          .tap { |file| validate_file_exists(file, route) }
+      end
+
+      def views_path
+        @views_path ||= app.root.join("app", "views")
+      end
+
+      def validate_file_exists(file, route = nil)
+        return if file && File.exist?(file)
+
+        error_message = if route
+                          "template for #{route.base_name}##{route.method_name}"
+                        else
+                          "layout template"
+                        end
+
+        raise ArgumentError, "Could not find #{error_message}"
+      end
+    end
+  end
+end

data/lib/fox_page/cli.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module FoxPage
+  class Cli < Thor
+    desc "build", "Builds your website"
+    def build
+      app = require_application
+
+      app.build
+    end
+
+    desc "server", "Runs a server for quick development"
+    def server
+      app = require_application
+
+      app.server.start
+    end
+
+    register FoxPage::Generator,
+             "new", "new NAME",
+             "Create a new FoxPage website"
+
+    private
+
+    def require_application
+      require File.join(Bundler.root, "config", "environment")
+
+      ObjectSpace.each_object(Class).find do |klass|
+        klass.superclass == FoxPage::Application
+      end
+    end
+  end
+end

data/lib/fox_page/controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FoxPage
+  class Controller
+    DEFAULT_LAYOUT = "layouts/default.haml"
+    private_constant :DEFAULT_LAYOUT
+
+    def self.layout
+      DEFAULT_LAYOUT
+    end
+
+    def self.before_action(method_name)
+      @__before_actions ||= []
+      @__before_actions << method_name
+    end
+  end
+end

data/lib/fox_page/generator.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module FoxPage
+  class Generator < Thor::Group
+    include Thor::Actions
+
+    argument :name, type: :string, desc: "The name of your website"
+
+    def self.source_root
+      File.join(__dir__, "app_template")
+    end
+
+    def create_application
+      Dir[File.join(self.class.source_root, "**/*.tt")]
+        .map { |path| path.sub(self.class.source_root + "/", "") }
+        .each do |path|
+        template(path,
+                 File.join(name,
+                           path.sub(/\.tt$/, "")
+                               .gsub(/__dot__/, ".")))
+      end
+    end
+
+    def run_bundle
+      Dir.chdir(name) do
+        system("bundle install")
+        system("bundle binstubs foxpage")
+      end
+    end
+
+    def init_git_repo
+      Dir.chdir(name) do
+        system("git init")
+        system("git add .")
+      end
+    end
+  end
+end

data/lib/fox_page/helpers/app_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FoxPage
+  module Helpers
+    # the AppHelper module builder injects the core FoxPage::Application
+    # instance to the method `app`
+    class AppHelper < Module
+      def initialize(app)
+        @__app = app
+        define_method(:app) do
+          app
+        end
+      end
+
+      def inspect
+        "#{self.class.name}(#{@__app.class})"
+      end
+    end
+  end
+end

data/lib/fox_page/helpers/assets_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "sprockets"
+
+module FoxPage
+  module Helpers
+    module AssetsHelper
+      def asset_path(source)
+        File.join("/assets", app.sprockets.manifest.assets[source])
+      end
+
+      def stylesheet_link_tag(source)
+        %(<link rel="stylesheet" href=#{asset_path(source).inspect} />)
+      end
+    end
+  end
+end

data/lib/fox_page/helpers/render_helper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module FoxPage
+  module Helpers
+    module RenderHelper
+      def render(view)
+        full_path = Dir.glob(app.root.join("app/views/#{view}.*")).first
+
+        unless full_path
+          raise ArgumentError, "Could not find template for #{view}"
+        end
+
+        Tilt.new(full_path).render(self)
+      end
+    end
+  end
+end

data/lib/fox_page/refinements/camelize.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module FoxPage
+  module Refinements
+    module Camelize
+      refine String do
+        def camelize
+          split("_").map(&:capitalize).join
+        end
+      end
+    end
+  end
+end

data/lib/fox_page/refinements/to_deep_open_struct.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module FoxPage
+  module Refinements
+    module ToDeepOpenStruct
+      refine Array do
+        def to_deep_ostruct
+          map do |value|
+            next value unless value.is_a?(Hash) || value.is_a?(Array)
+
+            value.to_deep_ostruct
+          end
+        end
+      end
+
+      refine Hash do
+        def to_deep_ostruct
+          OpenStruct.new(
+            dup.tap do |hash|
+              hash.each do |key, value|
+                next unless value.is_a?(Hash) || value.is_a?(Array)
+
+                hash[key] = value.to_deep_ostruct
+              end
+            end
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fox_page/router.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module FoxPage
+  class Router
+    using Refinements::Camelize
+
+    def self.draw_routes(&block)
+      new.draw_routes(&block)
+    end
+
+    attr_reader :routes
+
+    def initialize
+      @routes = {}
+    end
+
+    def draw_routes(&block)
+      instance_eval(&block)
+      routes
+    end
+
+    def root(target)
+      routes["/"] = parse_target(target)
+    end
+
+    def map(mapping)
+      mapping.each do |path, target|
+        routes[path] = parse_target(target)
+      end
+    end
+
+    private
+
+    def parse_target(target)
+      base_name, method_name = target.split("#")
+      controller = Kernel.const_get("#{base_name}_controller".camelize)
+      method_name = method_name.to_sym
+
+      validate_controller_method(controller, method_name)
+
+      OpenStruct.new(
+        base_name: base_name,
+        controller: controller,
+        method_name: method_name
+      )
+    end
+
+    def validate_controller_method(controller, method_name)
+      return if controller.instance_methods.include?(method_name)
+
+      raise ArgumentError, "#{controller} does not define ##{method_name}"
+    end
+  end
+end

data/lib/fox_page/server.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "listen"
+require "webrick"
+
+module FoxPage
+  class Server
+    def initialize(app)
+      @app = app
+      @listener = Listen.to(app.root.join("app"),
+                            app.root.join("public"),
+                            &method(:handle_modified_app))
+      @server = WEBrick::HTTPServer.new(
+        BindAddress: ENV.fetch("APP_BIND", "127.0.0.1"),
+        Port: ENV.fetch("APP_PORT", 3000).to_i,
+        DocumentRoot: app.root.join(OUTPUT_DIRECTORY)
+      )
+    end
+
+    def start
+      puts "==> Starting up development server at " \
+           "http://#{@server.config[:BindAddress]}:#{@server.config[:Port]}"
+
+      trap "INT" do
+        @server.shutdown
+      end
+
+      @app.build
+      @listener.start
+      @server.start
+    end
+
+    def handle_modified_app(_modified, _added, _removed)
+      reload_code
+      @app.build
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      # need to rescue Exception as syntax errors may cause the builds to break
+      puts "!!! An error occurred while building the app"
+      puts e.full_message
+    end
+
+    def reload_code
+      @app.code_loader.reload
+      @app.reload_routes!
+    end
+  end
+end

data/lib/fox_page/site_builder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module FoxPage
+  class SiteBuilder
+    include Builders::Assets
+    include Builders::FileCopy
+    include Builders::Pages
+
+    def self.build(app)
+      new(app).build
+    end
+
+    attr_reader :app, :output_directory
+
+    def initialize(app)
+      @app = app
+      @output_directory = app.root.join(OUTPUT_DIRECTORY)
+    end
+
+    def build
+      puts "==> Building site #{App.config.site&.title}"
+
+      FileUtils.mkdir_p output_directory
+
+      build_assets
+      build_pages
+      copy_public_files
+    end
+  end
+end

data/lib/fox_page/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FoxPage
+  VERSION = "0.1.0"
+end

data/lib/fox_page.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bundler"
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+begin
+  loader.ignore Bundler.root
+rescue Bundler::GemfileNotFound # rubocop:disable Lint/HandleExceptions
+  # don't care ...
+end
+loader.setup
+
+require_relative "./fox_page/version"
+
+module FoxPage
+  class Error < StandardError; end
+
+  OUTPUT_DIRECTORY = "_site"
+end

data/lib/foxpage.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "./fox_page"