docks_app 0.0.1

data/lib/docks/helpers/path_helper.rb

@@ -0,0 +1,94 @@
+module Docks
+  module Helpers
+    module Path
+      def docks_path(symbol, options = {})
+        @path_cache ||= {}
+
+        postfixed_symbol = "#{symbol}#{"-#{options[:language]}" if options.fetch(:language, false)}"
+        return @path_cache[postfixed_symbol] unless @path_cache[postfixed_symbol].nil?
+
+        if search_result = @pattern.find(symbol)
+          @path_cache[postfixed_symbol] = "##{search_result.symbol_id}"
+        elsif search_result = @pattern_library.find(symbol)
+          @path_cache[postfixed_symbol] = relative_pattern_path(search_result.pattern.name, anchor: search_result.symbol.nil? ? nil : search_result.symbol.symbol_id)
+        elsif path = Docks::SymbolSources.path_for(symbol, options)
+          @path_cache[postfixed_symbol] = path
+        end
+
+        @path_cache[postfixed_symbol]
+      end
+
+      def relative_asset_path(asset)
+        (Docks.config.destination + asset).relative_path_from(Docks.current_render_destination)
+      end
+
+      def stylesheet_link_tag(stylesheet)
+        pathname = Pathname.new(stylesheet)
+        path = if pathname.absolute?
+          pathname.to_path
+        else
+          relative_asset_path(File.join(Docks.config.asset_folders.styles, "#{pathname.extname.length > 0 ? stylesheet.sub(/#{pathname.extname}$/, "") : stylesheet}.css"))
+        end
+
+        "<link rel='stylesheet' type='text/css' href='#{path}'>"
+      end
+
+      def docks_stylesheet(stylesheet = :main)
+        return unless Docks.config.use_theme_assets
+        postfix = (stylesheet.to_sym == :main ? "" : "-#{stylesheet.to_s}")
+        stylesheet_link_tag("docks#{postfix}.css")
+      end
+
+      def docks_javascript(script = :main)
+        return unless Docks.config.use_theme_assets
+        postfix = (script.to_sym == :main ? "" : "_#{script.to_s}")
+        javascript_include_tag("docks#{postfix}.js")
+      end
+
+      def javascript_include_tag(script)
+        pathname = Pathname.new(script)
+        path = if pathname.absolute?
+          pathname.to_path
+        else
+          relative_asset_path(File.join(Docks.config.asset_folders.scripts, "#{pathname.extname.length > 0 ? script.sub(/#{pathname.extname}$/, "") : script}.js"))
+        end
+
+        "<script src='#{path}'></script>"
+      end
+
+      def compiled_style_tags
+        content = Array(Docks.config.compiled_assets)
+          .select { |asset| Docks::Languages.language_for(asset).kind_of?(Docks::Languages::CSS) }
+          .map { |asset| stylesheet_link_tag(asset) }
+          .join("\n")
+
+        content.strip.empty? ? nil : content
+      end
+
+      def compiled_script_tags
+        content = Array(Docks.config.compiled_assets)
+          .select { |asset| Docks::Languages.language_for(asset).kind_of?(Docks::Languages::JavaScript) }
+          .map { |asset| javascript_include_tag(asset) }
+          .join("\n")
+
+        content.strip.empty? ? nil : content
+      end
+
+      def pattern_path(pattern, options = {})
+        pattern = pattern.name if pattern.kind_of?(Containers::Pattern)
+
+        file = "index.html"
+        file << "##{options[:anchor]}" if options.fetch(:anchor, false)
+
+        Docks.config.destination + File.join(Docks.config.mount_at, pattern.to_s, file)
+      end
+
+      private
+
+      def relative_pattern_path(pattern, options = {})
+        path = relative_asset_path(pattern_path(pattern, options)).to_s
+        path
+      end
+    end
+  end
+end

data/lib/docks/helpers/render_helper.rb

@@ -0,0 +1,87 @@
+require "erb"
+require "active_support/core_ext/string/output_safety"
+
+module Docks
+  module Helpers
+    module Render
+      include ::ERB::Util
+
+      def render_everything
+        render_everything_for(@pattern)
+        @pattern.symbols.each { |symbol| render_everything_for(symbol) }
+      end
+
+      private
+
+      def render_everything_for(symbol, options = {})
+        case symbol
+        when Containers::Base
+          options[:language] = symbol.source.nil? ? nil : symbol.source.language_code
+          render_markup(symbol)
+
+          symbol.each do |k, v|
+            next if v.nil?
+
+            if k == :description
+              symbol[k] = render_description(v, options)
+            else
+              symbol[k] = render_everything_for(v, options)
+            end
+          end
+
+          if symbol.respond_to?(:members)
+            symbol.members.each { |member| render_everything_for(member, options) }
+          end
+
+        when Array
+          symbol.map! { |each_symbol| render_everything_for(each_symbol, options) }
+
+        when OpenStruct
+          symbol.each do |k, v|
+            next if v.nil?
+
+            if k == :description
+              symbol.description = render_description(v, options)
+            else
+              symbol.send("#{k.to_s}=".to_sym, render_everything_for(v, options))
+            end
+          end
+        end
+
+        symbol
+      end
+
+      def render_markup(symbol)
+        markup, helper = symbol.markup, symbol.helper
+        return if markup.nil? && helper.nil?
+        symbol.markup = render(inline: (helper || markup), layout: false)
+      end
+
+      def render_description(description, options = {})
+        @example_count ||= 0
+        description.gsub! /(href\s*=\s*['"])@link\s([^'"]*)(.)/ do |match|
+          "#{$1}#{docks_path($2, options)}#{$3}"
+        end
+
+        render(layout: false, inline: description.gsub(/<fenced_code_block[^>]*>(.*?)<\/fenced_code_block>/m) { |match|
+          @example_count += 1
+          code = $1.dup
+          has_demo = match.include?("data-has-demo")
+          language = match.match(/data\-language=["']([^'"]*)/).captures.first
+
+          code_details = []
+          code_details << { code: code, language: language, label: "Helper" }
+
+          if has_demo
+            code_details << { code: render(inline: code, layout: false), language: "html", label: "Markup" }
+          end
+
+          docks_code_block code: code_details,
+                           hideable?: has_demo,
+                           id: "code-block--example-#{@example_count}",
+                           demo?: has_demo
+        })
+      end
+    end
+  end
+end

data/lib/docks/helpers.rb

@@ -0,0 +1,19 @@
+Dir[File.expand_path("../helpers/*.rb", __FILE__)].each do |helper|
+  require helper
+end
+
+module Docks
+  module Helpers
+    def self.add_helpers_to(renderer)
+      return unless renderer.respond_to?(:helpers)
+
+      renderer.helpers(*bundled_helpers)
+      renderer.helpers(*Docks.config.helpers)
+      renderer
+    end
+
+    def self.bundled_helpers
+      @bundled_helpers ||= constants.map { |const| const_get(const) }
+    end
+  end
+end

data/lib/docks/languages/base_language.rb

@@ -0,0 +1,17 @@
+require_relative "../languages.rb"
+
+module Docks
+  module Languages
+    class Base
+      include Singleton
+
+      def self.type; nil end
+      def self.extensions; nil end
+      def self.symbol_sources; nil end
+
+      def load_stub(file); nil end
+      def parser; nil end
+      def renderer; nil end
+    end
+  end
+end

data/lib/docks/languages/coffeescript_language.rb

@@ -0,0 +1,30 @@
+require_relative "base_language.rb"
+require_relative "../parsers/coffeescript_parser.rb"
+
+module Docks
+  module Languages
+    class CoffeeScript < Base
+      def self.type; Docks::Types::Languages::SCRIPT end
+      def self.extensions; %w(coffee coffeescript) end
+
+      def parser; Docks::Parsers::CoffeeScript.instance end
+
+      def signature_for(symbol)
+        is_class = symbol.symbol_type == Types::Symbol::CLASS
+        return unless is_class || [Types::Symbol::MIXIN, Types::Symbol::FUNCTION, Types::Symbol::FACTORY].include?(symbol.symbol_type)
+        params = symbol.fetch(:params, [])
+
+        presentation = if is_class
+          "class #{symbol.name}\n  constructor: "
+        elsif symbol.respond_to?(:method?) && symbol.method?
+          symbol.static? ? "#{symbol.for}.#{symbol.name} = " : "#{symbol.name}: "
+        else
+          "#{symbol.name} = "
+        end
+
+        presentation << "(#{params.map { |param| "#{param.name}#{" = #{param.default}" if param.default}" }.join(", ")}) " unless params.empty?
+        "#{presentation}-> # ..."
+      end
+    end
+  end
+end

data/lib/docks/languages/common_types/markup_language.rb

@@ -0,0 +1,71 @@
+module Docks
+  module Languages
+    module Common
+      module Markup
+        # TODO: empty arguments
+        private
+
+        def functionize_helper(helper_name, arguments, options = {})
+          arguments = normalize_arguments(arguments)
+          start_with = options[:start_with] || ""
+          end_with = options[:end_with] || ""
+
+          index = 0
+          arguments_length = arguments.length
+
+          function_string = arguments.inject("#{start_with}#{helper_name} ") do |func, argument|
+            index += 1
+
+            unless index == 1
+              func << ", "
+            end
+
+            stringified = if index == arguments_length && argument.kind_of?(Hash)
+              stringify_val(argument, join_with: ",\n#{" " * func.length}").sub(/\A[^\{]*\{ /, "").sub(/ \}[^\}]*\z/m, "")
+            else
+              stringify_val(argument)
+            end
+
+            func << stringified
+            func
+          end
+
+          "#{function_string}#{end_with}"
+        end
+
+        def normalize_arguments(arguments)
+          arguments.kind_of?(Array) ? arguments : [(arguments[:arguments] || arguments["arguments"] || [arguments])].flatten
+        end
+
+        def stringify_val(val, options = {})
+          if val.kind_of?(String)
+            "\"#{val}\""
+          elsif val.kind_of?(Hash)
+            options[:join_with] ||= ", "
+            "{ #{val.map { |k, v| "#{(!k.kind_of?(String) && simple_symbol?(k)) ? "#{k}:" : "#{stringify_val(k)} =>"} #{stringify_val(v)}" }.join(options[:join_with])} }"
+          elsif val.kind_of?(Array)
+            options[:join_with] ||= ", "
+            "[#{val.map { |v| stringify_val(v) }.join(options[:join_with])}]"
+          elsif val.nil?
+            "nil"
+          elsif val.kind_of?(Symbol)
+            val = val.to_s
+            if simple_symbol?(val)
+              ":#{val}"
+            else
+              ":\"#{val}\""
+            end
+          elsif val.kind_of?(Numeric)
+            val.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1_').reverse
+          else
+            val.to_s
+          end
+        end
+
+        def simple_symbol?(symbol)
+          symbol.to_s.split(" ").length == 1
+        end
+      end
+    end
+  end
+end

data/lib/docks/languages/css_language.rb

@@ -0,0 +1,13 @@
+require_relative "base_language.rb"
+require_relative "../parsers/css_parser.rb"
+
+module Docks
+  module Languages
+    class CSS < Base
+      def self.type; Docks::Types::Languages::STYLE end
+      def self.extensions; %w(css) end
+
+      def parser; Docks::Parsers::CSS.instance end
+    end
+  end
+end

data/lib/docks/languages/erb_language.rb

@@ -0,0 +1,21 @@
+require_relative "base_language.rb"
+require_relative "common_types/markup_language.rb"
+
+require_relative "../renderers/erb_renderer.rb"
+
+module Docks
+  module Languages
+    class ERB < Base
+      include Common::Markup
+
+      def self.type; Docks::Types::Languages::MARKUP end
+      def self.extensions; %w(erb) end
+
+      def helper_markup_for(helper_name, arguments)
+        functionize_helper(helper_name, arguments, start_with: "<%= ", end_with: " %>")
+      end
+
+      def renderer; Docks::Renderers::ERB.new end
+    end
+  end
+end

data/lib/docks/languages/haml_language.rb

@@ -0,0 +1,21 @@
+require_relative "base_language.rb"
+require_relative "common_types/markup_language.rb"
+
+require_relative "../renderers/haml_renderer.rb"
+
+module Docks
+  module Languages
+    class Haml < Base
+      include Common::Markup
+
+      def self.type; Docks::Types::Languages::MARKUP end
+      def self.extensions; %w(haml) end
+
+      def helper_markup_for(helper_name, arguments)
+        functionize_helper(helper_name, arguments, start_with: "= ")
+      end
+
+      def renderer; Docks::Renderers::Haml.new end
+    end
+  end
+end

data/lib/docks/languages/html_language.rb

@@ -0,0 +1,10 @@
+require_relative "base_language.rb"
+
+module Docks
+  module Languages
+    class HTML < Base
+      def self.type; Docks::Types::Languages::MARKUP end
+      def self.extensions; %w(html) end
+    end
+  end
+end

data/lib/docks/languages/javascript_language.rb

@@ -0,0 +1,42 @@
+require_relative "base_language.rb"
+require_relative "../parsers/javascript_parser.rb"
+require_relative "../symbol_sources/jquery_symbol_source.rb"
+require_relative "../symbol_sources/mdn_symbol_source.rb"
+
+module Docks
+  module Languages
+    class JavaScript < Base
+      def self.type; Docks::Types::Languages::SCRIPT end
+      def self.extensions; %w(js) end
+      def self.symbol_sources; [SymbolSources::JQuery, SymbolSources::MDN] end
+
+      def parser; Docks::Parsers::JavaScript.instance end
+
+      def signature_for(symbol)
+        return unless [Types::Symbol::MIXIN, Types::Symbol::FUNCTION, Types::Symbol::FACTORY, Types::Symbol::CLASS].include?(symbol.symbol_type)
+        params = symbol.fetch(:params, []).map do |param|
+          text = ""
+          text << "[" if param.optional
+          text << param.name
+          text << " = #{param.default}" if param.default
+          text << "]" if param.optional
+          text
+        end
+
+        presentation = if symbol.respond_to?(:method?) && symbol.method?
+          if symbol.static?
+            "#{symbol.for}.#{symbol.name} = function"
+          elsif symbol.belongs_to.instance_of?(Containers::Klass)
+            "#{symbol.for}.prototype.#{symbol.name} = function"
+          else
+            "#{symbol.name}: function"
+          end
+        else
+          "function #{symbol.name}"
+        end
+
+        "#{presentation}(#{params.join(", ")}) { /* ... */ }"
+      end
+    end
+  end
+end

data/lib/docks/languages/json_language.rb

@@ -0,0 +1,18 @@
+require_relative "base_language.rb"
+
+module Docks
+  module Languages
+    class JSON < Base
+      def self.type; Docks::Types::Languages::STUB end
+      def self.extensions; %w(json) end
+
+      def initialize
+        require "json"
+      end
+
+      def load_stub(file)
+        ::JSON::load(File.read(file).force_encoding("UTF-8"))
+      end
+    end
+  end
+end

data/lib/docks/languages/less_language.rb

@@ -0,0 +1,33 @@
+require_relative "base_language.rb"
+require_relative "../parsers/less_parser.rb"
+
+module Docks
+  module Languages
+    class Less < Base
+      def self.type; Docks::Types::Languages::STYLE end
+      def self.extensions; %w(less) end
+
+      def signature_for(symbol)
+        return unless symbol.kind_of?(Containers::Mixin)
+
+        directive = clean_presentation(symbol.name, ".")
+        params = symbol.fetch(:param, []).map do |param|
+          name, default = param.name, param.default
+          param_string = clean_presentation(name)
+          param_string << ": #{default}" if default
+          param_string
+        end
+
+        "#{directive}(#{params.join(", ")}) { /* ... */ }"
+      end
+
+      def parser; Docks::Parsers::Less.instance end
+
+      protected
+
+      def clean_presentation(symbol, prefix = "@")
+        "#{prefix unless symbol.start_with?(prefix)}#{symbol}"
+      end
+    end
+  end
+end

data/lib/docks/languages/markdown_language.rb

@@ -0,0 +1,10 @@
+require_relative "base_language.rb"
+
+module Docks
+  module Languages
+    class Markdown < Base
+      def self.type; Docks::Types::Languages::DESCRIPTION end
+      def self.extensions; %w(md markdown) end
+    end
+  end
+end

data/lib/docks/languages/sass_language.rb

@@ -0,0 +1,36 @@
+require_relative "base_language.rb"
+require_relative "../parsers/sass_parser.rb"
+require_relative "../symbol_sources/sass_symbol_source.rb"
+
+module Docks
+  module Languages
+    class Sass < Base
+      def self.type; Docks::Types::Languages::STYLE end
+      def self.extensions; %w(scss sass) end
+      def self.symbol_sources; SymbolSources::Sass end
+
+      def signature_for(symbol)
+        return unless [Types::Symbol::FUNCTION, Types::Symbol::MIXIN].include?(symbol.symbol_type)
+        directive = "@#{symbol.symbol_type == Types::Symbol::FUNCTION ? "function" : "mixin"} #{symbol.name}"
+
+        params = symbol.fetch(:params, []).map do |param|
+          name, default = param.name, param.default
+          param_string = variable_presentation(name)
+          param_string << ": #{default}" if default
+          param_string
+        end
+
+        "#{directive}(#{params.join(", ")}) { /* ... */ }"
+      end
+
+      def parser; Docks::Parsers::Sass.instance end
+
+      protected
+
+      def variable_presentation(symbol, type = :variable)
+        prefix = type == :variable ? "$" : "%"
+        "#{prefix unless symbol.start_with?(prefix)}#{symbol}"
+      end
+    end
+  end
+end

data/lib/docks/languages/slim_language.rb

@@ -0,0 +1,21 @@
+require_relative "base_language.rb"
+require_relative "common_types/markup_language.rb"
+
+require_relative "../renderers/slim_renderer.rb"
+
+module Docks
+  module Languages
+    class Slim < Base
+      include Common::Markup
+
+      def self.type; Docks::Types::Languages::MARKUP end
+      def self.extensions; %w(slim) end
+
+      def helper_markup_for(helper_name, arguments)
+        functionize_helper(helper_name, arguments, start_with: "== ")
+      end
+
+      def renderer; Docks::Renderers::Slim.new end
+    end
+  end
+end

data/lib/docks/languages/stylus_language.rb

@@ -0,0 +1,26 @@
+require_relative "base_language.rb"
+require_relative "../parsers/stylus_parser.rb"
+
+module Docks
+  module Languages
+    class Stylus < Base
+      def self.type; Docks::Types::Languages::STYLE end
+      def self.extensions; %w(styl) end
+
+      def signature_for(symbol)
+        return unless [Types::Symbol::FUNCTION, Types::Symbol::MIXIN].include?(symbol.symbol_type)
+
+        params = symbol.fetch(:params, []).map do |param|
+          default = param.default
+          param_string = param.name
+          param_string << " = #{default}" if default
+          param_string
+        end
+
+        "#{symbol.name}(#{params.join(", ")}) // ..."
+      end
+
+      def parser; Docks::Parsers::Stylus.instance end
+    end
+  end
+end

data/lib/docks/languages/yaml_language.rb

@@ -0,0 +1,18 @@
+require_relative "base_language.rb"
+
+module Docks
+  module Languages
+    class YAML < Base
+      def self.type; Docks::Types::Languages::STUB end
+      def self.extensions; %w(yml yaml) end
+
+      def initialize
+        require "yaml"
+      end
+
+      def load_stub(file)
+        ::YAML::load_file(file)
+      end
+    end
+  end
+end