lookbooklet 0.0.1

data/lib/booklet/node.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+module Booklet
+  class Node < Booklet::Object
+    include Enumerable
+    include Comparable
+    include Values
+
+    prop :ref, String, :positional, reader: :public do |value|
+      value.to_s unless value.nil?
+    end
+
+    attr_reader :parent
+    protected attr_writer :parent
+
+    after_initialize do
+      @parent = nil
+      @children = []
+    end
+
+    def ref_path
+      @ref_path ||= [ancestors&.map(&:ref)&.reverse, ref].flatten.compact.join("/")
+    end
+
+    # @!group Ancestry
+
+    def root
+      root = self
+      root = root.parent until root.root?
+      root
+    end
+
+    def root?
+      parent.nil?
+    end
+
+    def ancestors
+      return nil if root?
+
+      ancestors = []
+      prev_parent = parent
+      while prev_parent
+        ancestors << prev_parent
+        prev_parent = prev_parent.parent
+      end
+      ancestors
+    end
+
+    # @!endgroup
+
+    # @!group Descendants
+
+    def children(&block)
+      if block_given?
+        @children.each(&block)
+        self
+      else
+        @children.clone
+      end
+    end
+
+    delegate :[], to: :children
+
+    def children?
+      children.any?
+    end
+
+    def depth
+      ancestors&.size || 0
+    end
+
+    def descendants
+      filter { _1 != self }
+    end
+
+    def first_child
+      @children.first
+    end
+
+    def last_child
+      @children.last
+    end
+
+    def first_child?
+      self == first_child
+    end
+
+    def last_child?
+      self == last_child
+    end
+
+    def has_child?(node)
+      children.find { _1.ref == node.ref && _1.type == node.type }
+    end
+
+    def leaf?
+      !children?
+    end
+
+    def branch?
+      !leaf?
+    end
+
+    # @!endgroup
+
+    # @!group Siblings
+
+    def siblings
+      siblings = root? ? [] : parent.children.filter { _1 != self }
+      if block_given?
+        children.each(&block)
+        self
+      else
+        siblings
+      end
+    end
+
+    def first_sibling
+      root? ? self : parent.children.first
+    end
+
+    def first_sibling?
+      self == first_sibling
+    end
+
+    def last_sibling
+      root? ? self : parent.children.last
+    end
+
+    def last_sibling?
+      self == last_sibling
+    end
+
+    def next_sibling
+      return nil if root?
+
+      position = parent.children.index(self)
+      parent.children.at(position + 1) if position
+    end
+
+    def previous_sibling
+      return nil if root?
+
+      position = parent.children.index(self)
+      parent.children.at(position - 1) if position&.positive?
+    end
+
+    # @!endgroup
+
+    # @!group Adding children
+
+    def add(node)
+      validate_child!(node)
+
+      @children << node
+      node.parent = self
+      node
+    end
+
+    alias_method :<<, :add
+
+    def validate_child!(node)
+      raise ArgumentError, "Only Node instances can be added as children" unless node.is_a?(Node)
+      raise ArgumentError, "`#{node.ref}` is already a child of node `#{ref}`" if has_child?(node)
+      raise ArgumentError, "`#{node.ref}` is already attached to another node" unless node.root?
+
+      raise ArgumentError, "Parent node does not accept children" if valid_child_types.nil?
+
+      unless valid_child_types.include?(node.type)
+        raise TypeError, "Invalid node type '#{node.type}' - must be one of [#{valid_child_types.join(", ")}]"
+      end
+    end
+
+    def push(*children)
+      children.each { add(_1) }
+      self
+    end
+
+    # @!endgroup
+
+    # @!group Iteration
+
+    def each_node
+      return to_enum unless block_given?
+
+      node_stack = [self]
+      until node_stack.empty?
+        current = node_stack.shift
+        next unless current
+        yield current
+        node_stack = current.children.concat(node_stack)
+      end
+
+      self if block_given?
+    end
+
+    protected alias_method :each, :each_node
+
+    # @!endgroup
+
+    # @!group Comparison
+
+    def <=>(other)
+      return nil if other.nil? || !other.is_a?(Node)
+
+      self_index = root.each_node.to_a.index(self)
+      other_index = root.each_node.to_a.index(other)
+
+      return nil if other_index.nil?
+
+      other_index <=> self_index
+    end
+
+    # @!group Visting
+
+    def accept(visitor)
+      class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        def accept(visitor)
+        	visitor.visit_#{type}(self)
+        end
+      RUBY
+
+      accept(visitor)
+    end
+
+    # @!endgroup
+
+    # @!group Type & type checking
+
+    def type
+      @type ||= NodeType(self.class)
+    end
+
+    def method_missing(name, ...)
+      if name.end_with?("?")
+        type.public_send(name)
+      elsif name.start_with?("each_")
+        filter_type = name.to_s.delete_prefix("each_")
+        filter { _1.type == filter_type }
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, ...)
+      name.end_with?("?") || name.start_with?("each_") || super
+    end
+
+    # @!endgroup
+
+    # @!group Utilities
+
+    def inspect
+      "#<#{self.class.name} @ref=#{ref}>"
+    end
+
+    # @!endgroup
+
+    # @!group Child type constraints
+
+    class_attribute :valid_child_types,
+      instance_predicate: false,
+      default: []
+
+    class_attribute :file_matcher,
+      instance_reader: false,
+      instance_writer: false,
+      instance_predicate: false,
+      default: lambda { false }
+
+    def permit_child_types(*args)
+      args.flatten!
+      self.valid_child_types = args.map { NodeType(_1) } unless args.first.nil?
+    end
+
+    class << self
+      def permit_child_types(*args)
+        args.flatten!
+        self.valid_child_types = args.map { NodeType(_1) } unless args.first.nil?
+      end
+
+      def type
+        NodeType.new(self)
+      end
+
+      def match(&block)
+        self.file_matcher = block
+      end
+
+      def matches?(file)
+        file_matcher.call(file)
+      end
+    end
+
+    permit_child_types Node
+  end
+end

data/lib/booklet/nodes/anon_node.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Booklet
+  class AnonNode < Node
+    include Locatable
+
+    match { true } # fallback entity node type
+  end
+end

data/lib/booklet/nodes/asset_node.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Booklet
+  class AssetNode < Node
+    include Locatable
+
+    MIME_TYPES = %w[text/css text/javascript]
+
+    match do |file|
+      return if file.directory?
+
+      file.mime_type.in?(MIME_TYPES) || file.mime_type.start_with?("image/")
+    end
+  end
+end

data/lib/booklet/nodes/directory_node.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Booklet
+  class DirectoryNode < Node
+    include Locatable
+
+    permit_child_types FileNode, DirectoryNode
+
+    def name
+      file.basename
+    end
+
+    alias_method :label, :name
+
+    delegate :file?, :directory?, :ext, :ext?, :dirname, :basename, :path_segments, :mime_type, :to_pathname, :contents, to: :file
+  end
+end

data/lib/booklet/nodes/document_node.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Booklet
+  class DocumentNode < Node
+    include Locatable
+
+    match do |file|
+      file.ext?(".md", ".md.erb")
+    end
+  end
+end

data/lib/booklet/nodes/file_node.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Booklet
+  class FileNode < Node
+    include Locatable
+
+    def name
+      file.basename
+    end
+
+    alias_method :label, :name
+
+    delegate :file?, :directory?, :ext, :ext?, :dirname, :basename, :path_segments, :mime_type, :to_pathname, :contents, to: :file
+  end
+end

data/lib/booklet/nodes/folder_node.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Booklet
+  class FolderNode < Node
+    include Locatable
+
+    match do |file|
+      file.directory?
+    end
+
+    permit_child_types [FolderNode, SpecNode, DocumentNode, AssetNode, AnonNode]
+  end
+end

data/lib/booklet/nodes/prose_node.rb

@@ -0,0 +1,7 @@
+module Booklet
+  class ProseNode < Node
+    prop :snippet, TextSnippet, :positional, reader: :public, writer: :public do |value|
+      TextSnippet.new(value)
+    end
+  end
+end

data/lib/booklet/nodes/scenario_node.rb

@@ -0,0 +1,13 @@
+module Booklet
+  class ScenarioNode < Node
+    prop :notes, _Nilable(TextSnippet), reader: :public, writer: :public
+    prop :source, CodeSnippet, reader: :public, writer: :public
+    prop :parameters, Array, reader: :public, writer: :public, default: [].freeze
+
+    alias_method :name, :ref
+
+    def label
+      name.titleize
+    end
+  end
+end

data/lib/booklet/nodes/spec_node.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Booklet
+  class SpecNode < Node
+    include Locatable
+
+    prop :notes, _Nilable(TextSnippet), reader: :public, writer: :public
+
+    permit_child_types :prose, :scenario
+
+    match do |file|
+      file.ext?(".rb") && file.name.end_with?("_preview")
+    end
+
+    def scenarios
+      filter(&:scenario?)
+    end
+  end
+end

data/lib/booklet/object.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Booklet
+  class Object < Literal::Object
+    include ActiveSupport::Callbacks
+    include Values
+    include Helpers
+
+    define_callbacks :initialize
+
+    def after_initialize
+      run_callbacks :initialize
+    end
+
+    class << self
+      include Values
+
+      def after_initialize(&)
+        set_callback :initialize, :after, &
+      end
+    end
+  end
+end

data/lib/booklet/options.rb

@@ -0,0 +1,31 @@
+require "active_support/ordered_options"
+
+module Booklet
+  class Options < ActiveSupport::InheritableOptions
+    def to_h
+      transform_values(&self.class.transformer)
+    end
+
+    class << self
+      def new(options)
+        super(options.transform_values(&transformer))
+      end
+
+      protected def convert_value(value, wrap = true)
+        if !wrap && value.respond_to?(:to_h)
+          value.to_h
+        elsif wrap && value.respond_to?(:to_h)
+          new(value.to_h)
+        elsif value.is_a?(Array)
+          value.map { convert_value(_1, wrap) }
+        else
+          value
+        end
+      end
+
+      protected def transformer
+        method(:convert_value)
+      end
+    end
+  end
+end

data/lib/booklet/value.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Booklet
+  class Value < Literal::Data
+    include Comparable
+    include Values
+    include Helpers
+
+    def ==(other)
+      return nil if !other.is_a?(self.class)
+      value == other.value
+    end
+
+    alias_method :eql?, :==
+  end
+end

data/lib/booklet/values/code_snippet.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Booklet
+  class CodeSnippet < Value
+    prop :raw, String, :positional, reader: :protected
+
+    prop :lang, Symbol, reader: :public, default: :plain do |value|
+      value.to_s.underscore.to_sym unless value.nil?
+    end
+
+    prop :location, _Nilable(SourceLocation), reader: :public do |value|
+      if value.is_a?(Array)
+        SourceLocation(*value)
+      elsif value.is_a?(String) || value.is_a?(Pathname)
+        SourceLocation(value)
+      end
+    end
+
+    def value
+      strip_indent(raw)
+    end
+
+    alias_method :to_s, :value
+  end
+end

data/lib/booklet/values/method_snippet.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Booklet
+  class MethodSnippet < CodeSnippet
+    prop :name, String, reader: :public
+
+    def body
+      extract_method_body(raw)
+    end
+
+    alias_method :value, :body
+    alias_method :to_s, :body
+
+    protected def extract_method_body(source)
+      source = strip_indent(source)
+      output = source.sub(/^def \w+\s?(\([^)]+\))?/m, "").split("\n")[0..-2].join("\n")
+      strip_whitespace(output)
+    end
+  end
+end

data/lib/booklet/values/node_type.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Booklet
+  class NodeType < Value
+    prop :type, _Class(Booklet::Node), :positional, reader: :public do |value|
+      if value.is_a?(String) || value.is_a?(Symbol)
+        value = "#{value}_node" unless value.downcase == "node"
+        "Booklet::#{value.classify}".constantize
+      else
+        value
+      end
+    end
+
+    def name
+      @type.name.to_s.demodulize.underscore.delete_suffix("_node")
+    end
+
+    alias_method :value, :type
+    alias_method :to_s, :name
+
+    delegate :to_sym, to: :name
+    delegate :pluralize, to: :name
+
+    def enquirer
+      ActiveSupport::StringInquirer.new(name)
+    end
+
+    # def entity?
+    #   @type < EntityNode
+    # end
+
+    def file?
+      @type < FileNode
+    end
+
+    def method_missing(name, ...)
+      name.end_with?("?") ? enquirer.public_send(name) : super
+    end
+
+    def respond_to_missing?(name, ...)
+      name.end_with?("?") || super
+    end
+
+    def ==(other)
+      case other
+      when NodeType
+        type == other.type
+      when Class
+        type == other
+      else
+        name == other.to_s
+      end
+    end
+  end
+end

data/lib/booklet/values/parser_result.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Booklet
+  class ParserResult < Value
+    prop :path, Pathname
+    prop :files, DirectoryNode
+    prop :entities, FolderNode
+    prop :warnings, Array, default: [].freeze
+    prop :errors, Array, default: [].freeze
+  end
+end

data/lib/booklet/values/source_location.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Booklet
+  class SourceLocation < Value
+    prop :path, Pathname, :positional, reader: :public do |value|
+      Pathname(value.to_s) unless value.nil?
+    end
+
+    prop :line, _Nilable(Integer), :positional, reader: :public
+
+    def value
+      [path.to_s, line].join(":")
+    end
+
+    alias_method :to_s, :value
+  end
+end

data/lib/booklet/values/text_snippet.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Booklet
+  class TextSnippet < Value
+    include Values
+
+    prop :raw, String, :positional, reader: :protected
+
+    prop :format, Symbol, reader: :public, default: :markdown do |value|
+      value.to_s.underscore.to_sym unless value.nil?
+    end
+
+    prop :options, Hash, :**, reader: :protected
+
+    def value
+      strip_whitespace(raw)
+    end
+
+    alias_method :to_s, :value
+  end
+end

data/lib/booklet/values.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Booklet
+  module Values
+    def NodeRef(...)
+      NodeRef.new(...)
+    end
+
+    def NodeName(...)
+      NodeName.new(...)
+    end
+
+    def NodeType(...)
+      NodeType.new(...)
+    end
+
+    def Snippet(...)
+      Snippet.new(...)
+    end
+
+    def MethodSnippet(...)
+      MethodSnippet.new(...)
+    end
+
+    def SourceLocation(...)
+      SourceLocation.new(...)
+    end
+
+    extend self
+  end
+end

data/lib/booklet/version.rb

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