view_spec 0.0.0 → 0.0.1

data/lib/view_spec/config.rb

@@ -8,14 +8,33 @@ module ViewSpec
       config.preview_controller.is_a?(String) ? config.preview_controller.constantize : config.preview_controller
     end
 
+    def preview_controller_name
+      preview_controller = config.preview_controller.is_a?(Class) ? config.preview_controller.name : config.preview_controller
+      preview_controller.underscore.sub(/_controller$/, "")
+    end
+
     class << self
       def defaults
         ActiveSupport::OrderedOptions.new.merge!({
-          spec_paths: ["#{Rails.root}/view_specs"],
+          spec_paths: ["#{Rails.root}/test/view_specs"],
           spec_files: [],
           spec_file_suffix: "_vspec",
-          preview_controller: "ApplicationController",
-          preview_layout: "application"
+
+          preview_controller: "ViewSpecPreviewsController",
+          preview_layout: nil,
+          preview_route: "rails/view_spec/previews",
+          show_previews: Rails.env.development? || Rails.env.test?,
+
+          markdown_extensions: {
+            tables: true,
+            fenced_code_blocks: true,
+            disable_indented_code_blocks: true,
+            strikethrough: true,
+            highlight: true,
+            with_toc_data: true,
+            lax_spacing: true,
+            escape_html: false
+          }
         })
       end
     end
@@ -25,5 +44,9 @@ module ViewSpec
     def config
       @config ||= self.class.defaults
     end
+
+    def constantize(arg)
+      arg.is_a?(String) ? arg.constantize : arg
+    end
   end
 end

data/lib/view_spec/context.rb

@@ -0,0 +1,40 @@
+module ViewSpec
+  class Context
+    def initialize(entry, defaults = {})
+      @entry = entry
+
+      defaults.to_h.each do |key, value|
+        instance_variable_set(:"@#{key}", value) if respond_to?(key, true)
+      end
+    end
+
+    def entries
+      @entries ||= EntryCollection.new
+    end
+
+    private
+
+    def cascading_values
+      self.class.cascading_attrs.map do |key|
+        value = send(key)
+        value = (value.is_a?(Hash) || value.is_a?(Array)) ? value.dup : value
+        [key, value]
+      end.to_h
+    end
+
+    def caller_lang(location, fallback = nil)
+      lineno = location&.lineno if location.present?
+      lineno ? @entry.source_file.lang_from_line(lineno, fallback) : fallback
+    end
+
+    class << self
+      def cascading_attr(name)
+        cascading_attrs << name.to_sym
+      end
+
+      def cascading_attrs
+        @cascading_attrs ||= []
+      end
+    end
+  end
+end

data/lib/view_spec/dsl/controller.rb

@@ -4,12 +4,17 @@ module ViewSpec
       extend ActiveSupport::Concern
 
       included do
-        lookup_attr :controller
+        cascading_attr :controller
       end
 
       def controller(value = nil)
         @controller = value unless value.nil?
-        controller = @controller || @outer_scope&.controller || ViewSpec.config.preview_controller
+        controller_class(@controller || ViewSpec.config.preview_controller)
+      end
+
+      private
+
+      def controller_class(controller)
         controller.is_a?(String) ? controller.camelize.constantize : controller
       end
     end

data/lib/view_spec/dsl/groups.rb

@@ -4,11 +4,11 @@ module ViewSpec
       extend ActiveSupport::Concern
 
       def groups
-        entries.filter { _1.is_a?(Group) }
+        GroupCollection.new(entries.filter { _1.type == :group }.to_a)
       end
 
       def group(name, &block)
-        entries << Group.new(name, lookup_attrs, &block)
+        entries << Group.new(name, @entry, cascading_values, &block)
         entries.last
       end
     end

data/lib/view_spec/dsl/layout.rb

@@ -4,13 +4,19 @@ module ViewSpec
       extend ActiveSupport::Concern
 
       included do
-        lookup_attr :layout
+        cascading_attr :layout
       end
 
       def layout(value = nil)
         @layout = value unless value.nil?
         @layout ||= ViewSpec.config.preview_layout
       end
+
+      private
+
+      def determine_layout(value = false)
+        (value == true) ? layout : value
+      end
     end
   end
 end

data/lib/view_spec/dsl/notes.rb

@@ -0,0 +1,22 @@
+module ViewSpec
+  module DSL
+    module Notes
+      extend ActiveSupport::Concern
+
+      def notes(str = nil)
+        if str.nil?
+          @notes
+        else
+          executable = ExecutableString.new(str, caller_lang(caller_locations(1..1)&.first, :md))
+          @notes = Note.new(@entry, executable)
+        end
+      end
+
+      private
+
+      def notes?
+        notes.present?
+      end
+    end
+  end
+end

data/lib/view_spec/dsl/params.rb

@@ -3,34 +3,44 @@ module ViewSpec
     module Params
       extend ActiveSupport::Concern
 
+      included do
+        cascading_attr :params_data
+      end
+
       def param(name, cast_type = nil, **options)
-        param_definitions << {name:, cast_type:, options:}
+        params_data[name] = ParamData.new(cast_type, options)
       end
 
-      def params
-        raise ":params cannot be accessed outside of the preview context"
+      def params_data
+        @params_data ||= {}
       end
 
+      private
+
       def resolve_params(values_hash = {})
-        values_hash = values_hash.to_h.with_indifferent_access
-        param_set = ParamSet.new
+        values_hash = values_hash.to_h.deep_symbolize_keys
+        return values_hash unless params_data.is_a?(Hash)
 
-        param_definitions.each do |props|
-          value = values_hash[props[:name]]
-          param_set.add(props[:name], props[:cast_type], value:, **props[:options])
+        param_set = ParamSet.new
+        params_data.each do |key, param|
+          value = values_hash[key]
+          param_set.add(key, param.cast_type, value:, **param.options)
         end
 
-        other_params = values_hash.reject { param_set.include?(_1) }
-        param_set.add(other_params)
-
         param_set
       end
 
-      private
-
-      def param_definitions
-        @param_definitions ||= []
+      def validate_params(values_hash = {})
+        required = resolve_params(values_hash).reject { _2.default? }
+        missing_names = required.map(&:first).reject { values_hash.key?(_1) }
+        if missing_names.any?
+          raise "Missing #{"param".pluralize(missing_names.size)} value for #{missing_names.join(", ")}"
+        else
+          true
+        end
       end
+
+      ParamData = Struct.new(:cast_type, :options)
     end
   end
 end

data/lib/view_spec/dsl/preview.rb

@@ -0,0 +1,25 @@
+module ViewSpec
+  module DSL
+    module Preview
+      extend ActiveSupport::Concern
+
+      def preview(tpl = nil, &block)
+        return @preview if tpl.nil? && !block_given?
+
+        @preview = if block
+          ExecutableProc.new(block)
+        elsif tpl.is_a?(String)
+          ExecutableString.new(tpl, caller_lang(caller_locations(1..1)&.first, :erb))
+        else
+          raise "Invalid preview argument (must be string or block)"
+        end
+      end
+
+      private
+
+      def preview?
+        preview.present?
+      end
+    end
+  end
+end

data/lib/view_spec/dsl/scenarios.rb

@@ -2,19 +2,19 @@ module ViewSpec
   module DSL
     module Scenarios
       extend ActiveSupport::Concern
-
-      def scenarios(include_grouped: false)
-        entries.map do |entry|
+      def scenarios(flatten: false)
+        items = entries.map do |entry|
           if entry.type == :scenario
             entry
-          elsif include_grouped && entry.type == :group
-            entry.scenarios
+          elsif flatten && entry.type == :group
+            entry.scenarios.to_a
           end
         end.compact.flatten
+        ScenarioCollection.new(items.to_a)
       end
 
       def scenario(name, &block)
-        entries << Scenario.new(name, lookup_attrs, &block)
+        entries << Scenario.new(name, @entry, cascading_values, &block)
         entries.last
       end
     end

data/lib/view_spec/dsl/tests.rb

@@ -0,0 +1,18 @@
+module ViewSpec
+  module DSL
+    module Tests
+      extend ActiveSupport::Concern
+
+      def tests(&block)
+        @tests = block if block
+        @tests
+      end
+
+      private
+
+      def tests?
+        tests.present?
+      end
+    end
+  end
+end

data/lib/view_spec/dsl/title.rb

@@ -5,7 +5,7 @@ module ViewSpec
 
       def title(value = nil)
         @title = value unless value.nil?
-        @title ||= @subject&.to_title
+        @title
       end
     end
   end

data/lib/view_spec/engine.rb

@@ -7,8 +7,27 @@ module ViewSpec
     config.view_spec = ViewSpec.config
 
     config.after_initialize do |app|
+      opts = app.config.view_spec
+
+      if opts.show_previews
+        app.routes.prepend do
+          get(
+            opts.preview_route,
+            to: "#{opts.preview_controller_name}#index",
+            as: :view_spec_previews,
+            internal: true
+          )
+
+          get(
+            "#{opts.preview_route}/*spec@:entry",
+            to: "#{opts.preview_controller_name}#preview",
+            as: :view_spec_preview,
+            internal: true
+          )
+        end
+      end
+
       if !app.config.cache_classes
-        opts = config.view_spec
         reloader = Reloader.new(opts.spec_files, opts.spec_paths) do
           ViewSpec.load!
         end

data/lib/view_spec/entry.rb

@@ -0,0 +1,62 @@
+module ViewSpec
+  class Entry
+    delegate :type, to: :class
+
+    def initialize(subject, parent, context_defaults = {}, &block)
+      @context_defaults = context_defaults.to_h
+      @subject = Subject.new(subject)
+      @parent = parent
+
+      context.instance_exec(&block) if block
+    end
+
+    def title
+      if context.respond_to?(:title)
+        context.title || @subject.to_title
+      else
+        @subject.to_title
+      end
+    end
+
+    def short_identifier
+      @subject.to_short_identifier
+    end
+
+    alias_method :name, :short_identifier
+
+    def spec
+      @parent ? @parent.spec : self
+    end
+
+    def source_file
+      spec.source_file
+    end
+
+    def to_partial_path
+      "view_specs/#{type}"
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      context.respond_to?(name, true) || super
+    end
+
+    def method_missing(name, ...)
+      context.respond_to?(name, true) ? context.send(name, ...) : super
+    end
+
+    private
+
+    def context
+      @context ||= begin
+        context_class = "#{self.class.name}Context".constantize
+        context_class.new(self, @context_defaults)
+      end
+    end
+
+    class << self
+      def type
+        @type ||= name.demodulize.underscore.to_sym
+      end
+    end
+  end
+end

data/lib/view_spec/entry_collection.rb

@@ -0,0 +1,11 @@
+module ViewSpec
+  class EntryCollection
+    include Collection
+
+    def find(name = nil, &block)
+      return items.find(&block) if name.nil?
+
+      find_where({name: name.to_s}) || find_where({subject: name})
+    end
+  end
+end

data/lib/view_spec/error.rb

@@ -1,4 +1,8 @@
 module ViewSpec
   class Error < StandardError
   end
+
+  class NoPreviewError < StandardError; end
+
+  class NoTestsError < StandardError; end
 end

data/lib/view_spec/executable_proc.rb

@@ -0,0 +1,32 @@
+module ViewSpec
+  class ExecutableProc
+    def initialize(proc)
+      @executable = proc
+    end
+
+    def source
+      CGI.unescapeHTML inner_source.strip_heredoc.strip
+    end
+
+    def lang
+      :ruby
+    end
+
+    def to_proc
+      @executable
+    end
+
+    alias_method :raw, :to_proc
+
+    private
+
+    def inner_source
+      source = @executable.source.strip_heredoc
+      if source.match?(/^(\w+)\s*\{/)
+        source.match(/^(\w+)\s*\{(.*)\}\s?$/m)[2]
+      elsif source.match?(/^(\w+)\s*do/)
+        source.match(/^(\w+)\s*do(.*)end\s?$/m)[2]
+      end
+    end
+  end
+end

data/lib/view_spec/executable_string.rb

@@ -0,0 +1,23 @@
+module ViewSpec
+  class ExecutableString
+    attr_reader :lang
+
+    def initialize(str, lang = nil)
+      @str = str
+      @executable = lambda { render inline: str, type: lang || :erb }
+      @lang = lang
+    end
+
+    def source
+      CGI.unescapeHTML @str.strip_heredoc.strip
+    end
+
+    def to_proc
+      @executable
+    end
+
+    def raw
+      @str
+    end
+  end
+end

data/lib/view_spec/group.rb

@@ -1,24 +1,28 @@
 module ViewSpec
-  class Group < DSL::Context
-    include DSL::Title
-    include DSL::Layout
-    include DSL::Scenarios
-    include DSL::Controller
+  class Group < Entry
+    def preview(**options)
+      GroupPreview.new(self, **options)
+    end
 
-    def short_identifier
-      @subject.to_short_identifier
+    def preview?
+      scenarios.any? { _1.preview? }
     end
 
-    def spec
-      @outer_scope
+    def notes
+      if context.notes.present? || scenarios.filter { _1.notes? }.any?
+        ViewSpec.config.preview_controller.render(
+          partial: "view_specs/group/notes",
+          locals: {group: self, notes: context.notes}
+        )
+      end
     end
 
-    def to_param
-      short_identifier
+    def notes?
+      notes.present?
     end
 
-    def to_partial_path
-      "view_spec/group"
+    def to_param
+      short_identifier
     end
   end
 end

data/lib/view_spec/group_collection.rb

@@ -0,0 +1,4 @@
+module ViewSpec
+  class GroupCollection < EntryCollection
+  end
+end

data/lib/view_spec/group_context.rb

@@ -0,0 +1,10 @@
+module ViewSpec
+  class GroupContext < Context
+    include DSL::Title
+    include DSL::Notes
+    include DSL::Layout
+    include DSL::Params
+    include DSL::Scenarios
+    include DSL::Controller
+  end
+end

data/lib/view_spec/group_preview.rb

@@ -0,0 +1,52 @@
+module ViewSpec
+  class GroupPreview < Preview
+    PARTIAL_PATHS = {
+      raw: "view_specs/group/raw",
+      source: "view_specs/group/source",
+      preview: "view_specs/group/preview"
+    }
+
+    def initialize(entry, partial: nil, **options)
+      @partial = partial
+      super(entry, **options)
+    end
+
+    def call(view_context = nil)
+      render_in_layout(:preview, view_context).html_safe
+    end
+
+    def raw(view_context = nil)
+      html = render_in_layout(:raw, view_context)
+      CGI.unescapeHTML(html)
+    end
+
+    def source(view_context = nil)
+      render_in_layout(:source, view_context)
+    end
+
+    def lang
+      @entry.scenarios&.first&.preview&.lang || :ruby
+    end
+
+    alias_method :to_s, :call
+    alias_method :to_str, :call
+
+    private
+
+    attr_reader :assigns
+
+    def partial_for_format(format)
+      @partial.nil? ? PARTIAL_PATHS[format.to_sym] : @partial
+    end
+
+    def render_in_layout(format, view_context = nil)
+      @_output ||= {}
+      @_output[format] ||= begin
+        partial = partial_for_format(format)
+        locals = {group: @entry, params:}
+
+        renderer.render(partial:, locals:, assigns:, layout:).strip
+      end
+    end
+  end
+end

data/lib/view_spec/markdown.rb

@@ -0,0 +1,20 @@
+module ViewSpec
+  class Markdown
+    def initialize
+      renderer = ViewSpec::MarkdownRenderer.new
+      @markdown = Redcarpet::Markdown.new(renderer, extensions)
+    end
+
+    def render(text = nil, &block)
+      text ||= block&.call
+
+      @markdown.render(text).html_safe unless text.nil?
+    end
+
+    private
+
+    def extensions
+      ViewSpec.config.markdown_extensions || {}
+    end
+  end
+end

data/lib/view_spec/markdown_renderer.rb

@@ -0,0 +1,13 @@
+module ViewSpec
+  class MarkdownRenderer < Redcarpet::Render::HTML
+    HTML_ELEMENT_MATCHER = /^(<([a-z\-]+)(?:\s[^>]*)?>((?:(?!<\/([a-z\-]+)>).)*)<\/([a-z\-]+)>)$/m
+
+    def paragraph(content)
+      if HTML_ELEMENT_MATCHER.match?(content.strip)
+        content.html_safe
+      else
+        "<p>#{content}</p>".html_safe
+      end
+    end
+  end
+end

data/lib/view_spec/minitest/tests.rb

@@ -0,0 +1,27 @@
+module ViewSpec
+  module Minitest
+    module Tests
+      extend ActiveSupport::Concern
+
+      included do
+        # Execute tests in a Minitest test context.
+        # Tests are grouped by spec and scenario using nested classes.
+        ViewSpec.specs.each do |spec|
+          scenarios = spec.scenarios(flatten: true).filter(&:tests?)
+          if scenarios.any?
+            class_options = {base_class: ViewSpec::TestCase}
+            Utils.create_class(spec.lookup_path, self, **class_options) do
+              scenarios.each do |scenario|
+                test_case_name = "#{scenario.short_identifier.camelize}Test"
+                test_case_class = Utils.create_class(test_case_name, self, **class_options) do
+                  define_method(:scenario) { scenario }
+                end
+                test_case_class.instance_exec(&scenario.tests)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end