foxpage 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7eb6f55b4154a03fc2be9a3a623bedfbf03b4436fab184377b66d11310df899
-  data.tar.gz: 20b6e0f2ee86a2064afc07eb84ac812347895db02638be7ce9441c16ae1c675c
+  metadata.gz: 98eb0f68d2163136732589c5da391975f8164e5c4e985dccd0bd24e893bc3045
+  data.tar.gz: e45d62a4c2a508010d066eab5fe822f8bc0a740c89b219a08d5a93e587b1ed8d
 SHA512:
-  metadata.gz: a1ca9bb683c35b9b3bc661b288072a2cfe73d5e4eb01f517ea0e48cd0ee3fa1ccc31954c0028237cc490fb903ed227eadd01548edcf3e2161df40ff4ae768e2d
-  data.tar.gz: ff733675525bf7fc4f31c593a6bc13670e71fea8349e7c1ae9ba06979e2476bff2104968990970be7c0aca03365dd965a0d0de80e2ca614992ab7d0c972c9754
+  metadata.gz: e6ae9e51e8c3defd140e169df2d9126e2227922af918dab4d4cdd69ed356214e680850f941f15d450b9656b130fc2a8ec03321864060f42eebe0d86dac33eeb3
+  data.tar.gz: 6dd3289ed9aba23e9b74f14fcdbc46d902f9ce4ed05c291b20707525b5061a6666ff2cd60f9dd15c238c8dfac866e4315a09dcb225ffa5b2d5672133e1024bf7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    foxpage (0.1.0)
+    foxpage (0.2.0)
       haml (~> 5.1)
       listen (~> 3.1)
       sassc (~> 2.0)
@@ -18,7 +18,7 @@ GEM
     concurrent-ruby (1.1.5)
     diff-lcs (1.3)
     ffi (1.11.1)
-    haml (5.1.1)
+    haml (5.1.2)
       temple (>= 0.8.0)
       tilt
     jaro_winkler (1.5.2)
@@ -57,18 +57,17 @@ GEM
       unicode-display_width (>= 1.4.0, < 1.6)
     ruby-progressbar (1.10.1)
     ruby_dep (1.5.0)
-    sassc (2.0.1)
+    sassc (2.2.1)
       ffi (~> 1.9)
-      rake
-    sprockets (4.0.0.beta9)
+    sprockets (4.0.0.beta10)
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)
-    temple (0.8.1)
+    temple (0.8.2)
     thor (0.20.3)
-    tilt (2.0.9)
+    tilt (2.0.10)
     unicode-display_width (1.5.0)
     webrick (1.4.2)
-    zeitwerk (2.1.6)
+    zeitwerk (2.1.10)
 
 PLATFORMS
   ruby

data/lib/fox_page/app_parts/configuration.rb

@@ -25,6 +25,7 @@ module FoxPage
         # Set up application code loader
         @code_loader = Zeitwerk::Loader.new.tap do |loader|
           loader.push_dir(@root.join("app/controllers"))
+          loader.push_dir(@root.join("app/models"))
           loader.push_dir(@root.join("app/helpers"))
           loader.enable_reloading
           loader.setup

data/lib/fox_page/builders/assets.rb

@@ -20,7 +20,7 @@ module FoxPage
 
       def image_assets
         image_assets_path = app.root.join("app/assets/images")
-        Dir.glob("#{image_assets_path}/**/*.{png,jpg,gif,jpeg}")
+        Dir.glob("#{image_assets_path}/**/*.{png,jpg,gif,jpeg,svg}")
            .map { |full_path| full_path.sub(%r{\A#{image_assets_path}/}, "") }
       end
     end

data/lib/fox_page/builders/models.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FoxPage
+  module Builders
+    module Models
+      def load_models
+        inject_app_to_models
+      end
+
+      private
+
+      def inject_app_to_models
+        return if already_injected?
+
+        FoxPage::Model.instance_variable_set(:@__app, app)
+      end
+
+      def already_injected?
+        FoxPage::Model.instance_variable_get(:@__app)
+      end
+    end
+  end
+end

data/lib/fox_page/builders/pages.rb

@@ -7,36 +7,66 @@ module FoxPage
   module Builders
     module Pages
       using Refinements::Camelize
+      using Refinements::Constantize
 
       def build_pages
         app.routes.each do |path, route|
-          puts "PAGE\t#{path} => #{route.base_name}"
+          if route.generate_all
+            model = route.generate_all.camelize.constantize
 
-          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)
+            model.all.each do |item|
+              target_path = format(path, id: item.id)
+              build_single_page(target_path, route, id: item.id)
+            end
+            next
           end
+
+          build_single_page(path, route)
+        end
+      end
+
+      def build_single_page(target_path, route, params = {})
+        if params.empty?
+          params_log_str = ""
+        else
+          params_log_str = "(#{params.inspect})"
+          route = route.dup
+          route.params = OpenStruct.new(route.params.to_h.merge(params))
+        end
+
+        puts "PAGE\t#{target_path} => #{route.base_name}##{route.method_name}#{params_log_str}"
+
+        target_file = File.join(output_directory, target_path)
+        unless route.single_file
+          FileUtils.mkdir_p(target_file)
+          target_file = File.join(target_file, "index.html")
+        end
+
+        File.open(target_file, "w") do |f|
+          f.puts render_route(route, target_path)
         end
       end
 
-      def render_route(route)
-        controller = spiced_controller(route).new
+      def render_route(route, path)
+        controller = spiced_controller(route, path).new
         controller.method(route.method_name).call
 
-        layout = Tilt.new(layout_path(controller))
+        layout = layout_for(controller, route)
         page = Tilt.new(page_path(route))
 
         controller.instance_eval do
-          layout.render(self) { page.render(self) }
+          if layout
+            layout.render(self) { page.render(self) }
+          else
+            page.render(self)
+          end
         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
+      def spiced_controller(route, path) # 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)
@@ -57,6 +87,18 @@ module FoxPage
             # same difference
           end
 
+          klass.define_method(:params) do
+            route.params
+          end
+
+          klass.define_method(:current_path) do
+            path
+          end
+
+          klass.define_method(:current_controller_name) do
+            route.base_name
+          end
+
           klass.define_method(:inspect) do |*args|
             # report that we are actually the controller, not some random
             # anonymous class
@@ -89,9 +131,18 @@ module FoxPage
         end
       end
 
-      def layout_path(controller)
+      def layout_for(controller, route)
+        layout = controller.class.superclass.instance_variable_get(:@__use_layout_for)&.[](route.method_name)
+        return if layout == false
+
+        Tilt.new(layout_path(controller, layout))
+      end
+
+      def layout_path(controller, layout)
+        layout ||= controller.class.layout
+
         File
-          .join(views_path, controller.class.layout)
+          .join(views_path, layout)
           .tap(&method(:validate_file_exists))
       end
 

data/lib/fox_page/controller.rb

@@ -13,5 +13,38 @@ module FoxPage
       @__before_actions ||= []
       @__before_actions << method_name
     end
+
+    # Instructs the site builder to generate pages for all records of `model`.
+    def self.generate_all(model)
+      @__generate_all = model
+    end
+
+    def self.use_layout(layout)
+      @__use_layout = layout
+    end
+
+    def self.method_added(method_name)
+      return unless @__generate_all.nil? || @__use_layout.nil?
+
+      set_method_option(method_name, "generate_all")
+      set_method_option(method_name, "use_layout")
+    end
+
+    def self.set_method_option(method_name, option)
+      ivar_name = :"@__#{option}"
+      ivar_for_name = :"@__#{option}_for"
+
+      ivar_val = instance_variable_get(ivar_name)
+      return if ivar_val.nil?
+
+      instance_variable_set(ivar_name, nil)
+      unless instance_variable_get(ivar_for_name)
+        instance_variable_set(ivar_for_name, {})
+      end
+
+      instance_variable_get(ivar_for_name)[method_name] = ivar_val
+    end
+
+    private_class_method :set_method_option
   end
 end

data/lib/fox_page/helpers/render_helper.rb

@@ -3,14 +3,14 @@
 module FoxPage
   module Helpers
     module RenderHelper
-      def render(view)
+      def render(view, params = {})
         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)
+        Tilt.new(full_path).render(self, params)
       end
     end
   end

data/lib/fox_page/model.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module FoxPage
+  class Model
+    using Refinements::Camelize
+    using Refinements::Pluralize
+    using Refinements::Singularize
+    using Refinements::ToDeepOpenStruct
+    using Refinements::Underscore
+
+    @__data = []
+
+    VALID_STORAGE_TYPES = %i[yaml dir].freeze
+    DEFAULT_STORAGE_TYPE = :yaml
+    private_constant :VALID_STORAGE_TYPES
+    private_constant :DEFAULT_STORAGE_TYPE
+
+    def self.[](storage_type = DEFAULT_STORAGE_TYPE, storage_type_opts = {})
+      unless VALID_STORAGE_TYPES.include?(storage_type)
+        raise ArgumentError,
+              "type must be one of #{VALID_STORAGE_TYPES.join(',')}"
+      end
+
+      @__tmp_storage_type = storage_type
+      @__tmp_storage_type_opts = storage_type_opts
+
+      self
+    end
+
+    def self.inherited(subclass)
+      set_ivar_if_unset subclass, :storage_type, DEFAULT_STORAGE_TYPE
+      set_ivar_if_unset subclass, :storage_type_opts, {}
+
+      subclass.reload_all(@__app)
+    end
+
+    def self.set_ivar_if_unset(subclass, ivar, default)
+      target_ivar = :"@__#{ivar}"
+      return if subclass.instance_variable_get(target_ivar)
+
+      tmp_ivar = :"@__tmp_#{ivar}"
+      value = instance_variable_get tmp_ivar
+      instance_variable_set tmp_ivar, nil
+
+      subclass.instance_variable_set target_ivar, value || default
+    end
+    private_class_method :set_ivar_if_unset
+
+    def self.reload_all(app)
+      data_name = name.to_s.underscore.pluralize
+      puts "MODEL\t#{data_name}"
+
+      case @__storage_type
+      when :yaml
+        @__data = YAML.load_file(
+          app.root.join("data", data_name + ".yml")
+        ).to_deep_ostruct.map { |ostruct| new(ostruct) }
+      when :dir
+        default_opts = { extension: :md }
+        opts = default_opts.merge(@__storage_type_opts)
+        files = Dir[app.root.join("data", data_name, "*.#{opts.fetch(:extension)}")]
+
+        @__data = files.map do |fn|
+          id = File.basename(fn, ".#{opts.fetch(:extension)}")
+          content = IO.read(fn)
+
+          front_matter = {}
+          if content =~ /\A(---\n.*\n)^(?:---)\s*$\n?/m
+            content = Regexp.last_match.post_match
+            front_matter = YAML.safe_load(Regexp.last_match[1], [Time])
+          end
+
+          new front_matter.merge(id: id, content: content).to_deep_ostruct
+        end
+      end
+    end
+
+    # e.g. in ProjectCategory: has_many :projects, referenced_by: nil
+    #
+    # nil = default of self.class.name underscored
+    def self.has_many(what, referenced_by: nil) # rubocop:disable Naming/PredicateName, Metrics/LineLength
+      referenced_by ||= name.to_s.underscore
+      association_class = Kernel.const_get(what.to_s.singularize.camelize)
+
+      define_method(what.to_s) do
+        association_class.where(referenced_by => name.to_s)
+      end
+    end
+
+    # e.g. in Project: belongs_to :project_category, referenced_by: :name
+    def self.belongs_to(what, referenced_by: :name)
+      association_class = Kernel.const_get(what.to_s.camelize)
+
+      define_method("__#{what}_value") do
+        @__ostruct[what]
+      end
+
+      define_method(what) do
+        association_class.find(referenced_by => public_send("__#{what}_value"))
+      end
+    end
+
+    # define a parser method for attributes
+    # @example
+    #   require "time"
+    #
+    #   class BlogPost < FoxPage::Model[:dir]
+    #     def_parser :date do |date|
+    #       Time.parse(date)
+    #     end
+    #   end
+    #
+    #   # in the blog posts' front matter:
+    #   # ---
+    #   # title: foo
+    #   # date: Sat 13 Jul 13:38:43 CEST 2019
+    #   # ---
+    #
+    #   # then, anywhere else:
+    #   blog_post.date        # => 2019-07-13 13:38:43 +0200
+    #   blog_post.date.class  # => Time
+    def self.def_parser(attribute, &parser)
+      define_method(attribute) do
+        parser.call(@__ostruct[attribute])
+      end
+    end
+
+    def self.all
+      @__data
+    end
+
+    def self.each(&block)
+      @__data.each(&block)
+    end
+
+    def self.find(filter)
+      @__data.find do |object|
+        filter.all? do |key, value|
+          value_key_name = "__#{key}_value"
+          key = value_key_name if object.respond_to?(value_key_name)
+
+          object.public_send(key) == value
+        end
+      end
+    end
+
+    def self.where(filter)
+      @__data.select do |object|
+        filter.all? do |key, value|
+          value_key_name = "__#{key}_value"
+          key = value_key_name if object.respond_to?(value_key_name)
+
+          object.public_send(key) == value
+        end
+      end
+    end
+
+    def initialize(ostruct)
+      @__ostruct = ostruct
+    end
+
+    def method_missing(method, *args, &block)
+      hash_ostruct = @__ostruct.to_h
+      return super unless hash_ostruct.key?(method.to_sym)
+
+      hash_ostruct[method.to_sym]
+    end
+
+    def respond_to_missing?(method, *)
+      return true if @__ostruct.to_h.key?(method.to_sym)
+
+      super
+    end
+  end
+end

data/lib/fox_page/refinements/camelize.rb

@@ -8,6 +8,12 @@ module FoxPage
           split("_").map(&:capitalize).join
         end
       end
+
+      refine Symbol do
+        def camelize
+          to_s.camelize.to_sym
+        end
+      end
     end
   end
 end

data/lib/fox_page/refinements/constantize.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module FoxPage
+  module Refinements
+    module Constantize
+      refine String do
+        def constantize
+          Kernel.const_get(self)
+        end
+      end
+
+      refine Symbol do
+        def constantize
+          to_s.constantize
+        end
+      end
+    end
+  end
+end

data/lib/fox_page/refinements/pluralize.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FoxPage
+  module Refinements
+    module Pluralize
+      refine String do
+        def pluralize
+          return sub(/y$/, "ies") if end_with?("y")
+
+          "#{self}s"
+        end
+      end
+    end
+  end
+end

data/lib/fox_page/refinements/singularize.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FoxPage
+  module Refinements
+    module Singularize
+      refine String do
+        def singularize
+          return sub(/ies$/, "y") if end_with?("ies")
+
+          sub(/s$/, "")
+        end
+      end
+    end
+  end
+end

data/lib/fox_page/refinements/underscore.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module FoxPage
+  module Refinements
+    module Underscore
+      refine String do
+        def underscore
+          gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+        end
+      end
+
+      refine Symbol do
+        def underscore
+          to_s.underscore.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/fox_page/router.rb

@@ -21,36 +21,90 @@ module FoxPage
       routes
     end
 
-    def root(target)
-      routes["/"] = parse_target(target)
+    def root(target, params: {})
+      routes["/"] = parse_target(target, params: params)
     end
 
-    def map(mapping)
+    def map(mapping, params: {}, single_file: false)
       mapping.each do |path, target|
-        routes[path] = parse_target(target)
+        routes[path] = parse_target(target, params: params, single_file: single_file)
+      end
+    end
+
+    RESOURCE_ACTIONS = %i[index show].freeze
+
+    def resources(name, path: name, only: RESOURCE_ACTIONS)
+      actions = only.map(&:to_sym)
+      base_name = name.to_s
+      controller = controller_for(base_name)
+      base_path = "/#{path}"
+
+      # show action needs some additional stuff to make it work
+      # since we have to know all the ids beforehand
+      if actions.delete :show
+        method_name = :show
+        validate_controller_method(controller, method_name)
+        route_path = "#{base_path}/%<id>s"
+
+        routes[route_path] = make_target(
+          base_name: base_name,
+          controller: controller,
+          method_name: method_name,
+          params: {},
+          generate_all: controller.instance_variable_get(:@__generate_all_for)&.[](method_name)
+        )
+      end
+
+      actions.each do |action|
+        method_name = action
+        validate_controller_method(controller, method_name)
+        route_path = method_name == :index ? base_path : "#{base_path}/#{method_name}"
+
+        routes[route_path] = make_target(
+          base_name: base_name,
+          controller: controller,
+          method_name: method_name
+        )
       end
     end
 
     private
 
-    def parse_target(target)
+    def parse_target(target, params: {}, single_file: false)
       base_name, method_name = target.split("#")
-      controller = Kernel.const_get("#{base_name}_controller".camelize)
+      controller = controller_for(base_name)
       method_name = method_name.to_sym
 
       validate_controller_method(controller, method_name)
 
-      OpenStruct.new(
+      make_target(
         base_name: base_name,
         controller: controller,
-        method_name: method_name
+        method_name: method_name,
+        params: params,
+        single_file: single_file
       )
     end
 
+    def controller_for(base_name)
+      Kernel.const_get("#{base_name}_controller".camelize)
+    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
+
+    def make_target(base_name:, controller:, method_name:, params: {}, generate_all: nil, single_file: false)
+      OpenStruct.new(
+        base_name: base_name,
+        controller: controller,
+        method_name: method_name,
+        params: OpenStruct.new(params),
+        generate_all: generate_all,
+        single_file: single_file
+      )
+    end
   end
 end

data/lib/fox_page/server.rb

@@ -8,6 +8,7 @@ module FoxPage
     def initialize(app)
       @app = app
       @listener = Listen.to(app.root.join("app"),
+                            app.root.join("data"),
                             app.root.join("public"),
                             &method(:handle_modified_app))
       @server = WEBrick::HTTPServer.new(

data/lib/fox_page/site_builder.rb

@@ -6,6 +6,7 @@ module FoxPage
   class SiteBuilder
     include Builders::Assets
     include Builders::FileCopy
+    include Builders::Models
     include Builders::Pages
 
     def self.build(app)
@@ -24,6 +25,7 @@ module FoxPage
 
       FileUtils.mkdir_p output_directory
 
+      load_models
       build_assets
       build_pages
       copy_public_files

data/lib/fox_page/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foxpage
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Georg Gadinger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-03 00:00:00.000000000 Z
+date: 2019-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -228,6 +228,7 @@ files:
 - lib/fox_page/application.rb
 - lib/fox_page/builders/assets.rb
 - lib/fox_page/builders/file_copy.rb
+- lib/fox_page/builders/models.rb
 - lib/fox_page/builders/pages.rb
 - lib/fox_page/cli.rb
 - lib/fox_page/controller.rb
@@ -235,8 +236,13 @@ files:
 - lib/fox_page/helpers/app_helper.rb
 - lib/fox_page/helpers/assets_helper.rb
 - lib/fox_page/helpers/render_helper.rb
+- lib/fox_page/model.rb
 - lib/fox_page/refinements/camelize.rb
+- lib/fox_page/refinements/constantize.rb
+- lib/fox_page/refinements/pluralize.rb
+- lib/fox_page/refinements/singularize.rb
 - lib/fox_page/refinements/to_deep_open_struct.rb
+- lib/fox_page/refinements/underscore.rb
 - lib/fox_page/router.rb
 - lib/fox_page/server.rb
 - lib/fox_page/site_builder.rb