docks_app 0.0.1

data/lib/docks/languages.rb

@@ -0,0 +1,103 @@
+require "set"
+
+module Docks
+  module Types
+    module Languages
+      MARKUP      = :markup
+      SCRIPT      = :script
+      STYLE       = :style
+      STUB        = :stub
+      DESCRIPTION = :description
+    end
+  end
+
+  module Languages
+    def self.language_for(file)
+      language = @languages[extension_for_file(file)]
+      language.nil? ? nil : language.instance
+    end
+
+    def self.register_bundled_languages
+      bundled_languages.each { |language| register(language) }
+    end
+
+    def self.register(language)
+      Array(language.extensions).each do |extension|
+        @extensions[language.type].add(extension)
+        @languages[extension] = language
+      end
+
+      Array(language.symbol_sources).each do |source|
+        SymbolSources.register(source)
+      end
+    end
+
+    def self.<<(language)
+      register(language)
+    end
+
+    def self.extensions
+      @extensions.values.inject([]) { |all, all_of_type| all.concat(all_of_type.to_a) }
+    end
+
+    Docks::Types::Languages.constants.each do |const|
+      type = Docks::Types::Languages.const_get(const)
+      define_singleton_method("#{type}_extensions") { @extensions[type].to_a }
+    end
+
+    def self.most_common_markup_language
+      markup_files = Grouper.source_files_of_type(Types::Languages::MARKUP)
+      return if markup_files.empty?
+      most_common = markup_files.map { |file| extension_for_file(file) }.group_by { |ext| ext }.values.max_by(&:size).first
+      language_for(most_common)
+    end
+
+    def self.file_type(file)
+      extension = extension_for_file(file)
+      type = nil
+
+      @extensions.each do |extensions_type, the_extensions|
+        if the_extensions.include?(extension)
+          type = extensions_type
+          break
+        end
+      end
+
+      type
+    end
+
+    def self.supported_file?(file)
+      extensions.include?(extension_for_file(file))
+    end
+
+    def self.extension_for_file(file)
+      file.to_s.split(".").last
+    end
+
+    private
+
+    def self.bundled_languages
+      if @bundled_languages.nil?
+        bundled = constants.select do |const|
+          klass = const_get(const)
+          Class === klass && !(klass.eql?(Base))
+        end
+
+        @bundled_languages = bundled.map { |const| const_get(const) }
+      end
+
+      @bundled_languages
+    end
+
+    def self.clean
+      @languages = Hash.new
+      @bundled_languages = nil
+      @extensions = Types::Languages.constants.inject(Hash.new) do |exts, const|
+        exts[Types::Languages.const_get(const)] = Set.new
+        exts
+      end
+    end
+
+    clean
+  end
+end

data/lib/docks/markdown.rb

@@ -0,0 +1,18 @@
+require "redcarpet"
+
+module Docks
+  module Markdown
+    class Renderer < Redcarpet::Render::HTML
+      def block_code(code, language)
+        return nil unless language
+        "<fenced_code_block #{"data-has-demo='true'" unless (language =~ /demo/).nil?} data-language='#{language.sub(/_?demo/, "")}'>#{code}</fenced_code_block>"
+      end
+
+      def link(href, title, content)
+        href = "@link #{content.gsub(/<[^>]*>/, "").strip}" if href.strip == "@link"
+        content = "<span>#{content}</span>" unless content.strip.start_with?("<")
+        "<a href=\"#{href}\"#{" title=\"#{title}\"" unless title.nil?}>#{content}</a>"
+      end
+    end
+  end
+end

data/lib/docks/messenger.rb

@@ -0,0 +1,69 @@
+module Docks
+  module Messenger
+    @@quiet = false
+    @@header = nil
+
+    def self.quiet
+      @@quiet = true
+      self
+    end
+
+    def self.show
+      @@quiet = false
+      self
+    end
+
+    def self.puts(message); puts message end
+    def self.warn(message); puts yellow("Warning: #{message}") end
+    def self.error(message); puts red("Error: #{message}") end
+    def self.succeed(message); puts green(message) end
+
+    def self.created(*files)
+      puts 'Created the following files and directories:'
+      created_files files
+    end
+
+    def self.created_files(*files)
+      files.flatten.each do |file|
+        puts "  #{file}"
+        if File.directory? file
+          created_files Dir["#{file}/*"]
+        end
+      end
+    end
+
+    def self.file(file, action = :updated)
+      unless @@header.nil?
+        puts "\n#{@@header}"
+        puts "-" * @@header.length
+        @@header = nil
+      end
+
+      file = file.to_s.sub((Docks.config.root || Pathname.pwd).to_s, "").sub(/^\//, "")
+
+      case action
+      when :updated then puts "Updated #{file}"
+      when :created then puts green("Created #{file}")
+      when :deleted then puts red("Deleted #{file}")
+      end
+    end
+
+    def self.file_header(header)
+      @@header = header
+    end
+
+    def self.puts(str)
+      return if @@quiet
+      super(str)
+    end
+
+    def self.colorize(color, str)
+      "\e[#{color}m#{str}\e[0m"
+    end
+
+    def self.yellow(str); colorize(33, str) end
+    def self.red(str); colorize(31, str) end
+    def self.green(str); colorize(32, str) end
+  end
+end
+

data/lib/docks/naming_conventions/base_naming_convention.rb

@@ -0,0 +1,9 @@
+require "singleton"
+
+module Docks
+  module NamingConventions
+    class Base
+      include Singleton
+    end
+  end
+end

data/lib/docks/naming_conventions/bem_naming_convention.rb

@@ -0,0 +1,45 @@
+require_relative "base_naming_convention.rb"
+
+module Docks
+  module NamingConventions
+    class BEM < Base
+      STATEFUL_WORDS = %w(is)
+
+      def base_component(component_name)
+        component_name.split("--").first.split("__").first
+      end
+
+      def base_component?(component_name)
+        component_name == base_component(component_name)
+      end
+
+      def component(component_name)
+        component_name.gsub(/--[^_]*/, "")
+      end
+
+      def parent_component(component_name)
+        component_name = component(component_name)
+        component_name.sub(/__[^_]*$/, "")
+      end
+
+      def clean_variation_name(variation_name, component_name)
+        return variation_name if disconnected_state?(variation_name)
+        variation_name = variation_name.sub(Regexp.new("^(?:#{component_name})?(?:--)?"), "")
+        "#{component_name}--#{variation_name}"
+      end
+
+      def state?(state_name)
+        state_name = state_name.split("--").last
+        STATEFUL_WORDS.any? { |word| state_name.start_with?(word) }
+      end
+
+      def variant?(variant_name)
+        variant_name.split("--").length > 1 && !state?(variant_name)
+      end
+
+      def disconnected_state?(state_name)
+        state?(state_name) && !state_name.include?("--")
+      end
+    end
+  end
+end

data/lib/docks/naming_conventions/suit_naming_convention.rb

@@ -0,0 +1,45 @@
+require_relative "base_naming_convention.rb"
+
+module Docks
+  module NamingConventions
+    class SUIT < Base
+      STATEFUL_WORDS = %w(is)
+
+      def base_component(component_name)
+        component_name.split("-").first
+      end
+
+      def base_component?(component_name)
+        component_name == base_component(component_name)
+      end
+
+      def component(component_name)
+        component_name.gsub(/--[^\-]*/, "")
+      end
+
+      def parent_component(component_name)
+        component_name = component(component_name)
+        component_name.sub(/-[^\-]*$/, "")
+      end
+
+      def clean_variation_name(variation_name, component_name)
+        return variation_name if disconnected_state?(variation_name)
+        variation_name = variation_name.sub(Regexp.new("^(?:#{component_name})?(?:--)?"), "")
+        "#{component_name}--#{variation_name}"
+      end
+
+      def state?(state_name)
+        state_name = state_name.split("--").last
+        STATEFUL_WORDS.any? { |word| state_name.start_with?(word) }
+      end
+
+      def variant?(variant_name)
+        variant_name.split("--").length > 1 && !state?(variant_name)
+      end
+
+      def disconnected_state?(state_name)
+        state?(state_name) && !state_name.include?("--")
+      end
+    end
+  end
+end

data/lib/docks/naming_conventions.rb

@@ -0,0 +1,21 @@
+Dir[File.expand_path("../naming_conventions/*.rb", __FILE__)].each do |convention|
+  require convention
+end
+
+module Docks
+  module NamingConventions
+    def self.for(convention)
+      if [String, ::Symbol].include?(convention.class)
+        convention = convention.to_sym
+        begin
+          convention = const_get(convention).instance
+        rescue NameError
+        end
+      else
+        convention = convention.instance if convention.kind_of?(Class)
+      end
+
+      convention.kind_of?(Base) ? convention : nil
+    end
+  end
+end

data/lib/docks/ostruct.rb

@@ -0,0 +1,17 @@
+require "ostruct"
+
+module Docks
+  class OpenStruct < ::OpenStruct
+    def to_json(options = nil)
+      @table.to_json(options)
+    end
+
+    def as_json(options = nil)
+      @table.as_json(options)
+    end
+
+    def each(&block)
+      @table.each(&block)
+    end
+  end
+end

data/lib/docks/parser.rb

@@ -0,0 +1,86 @@
+module Docks
+  class Parser
+    def self.parse(files)
+      files = Array(files).select { |file| File.exists?(file) }
+
+      pattern = Containers::Pattern.new(name: Docks.pattern_id(files.first))
+      pattern.files = files
+      pattern.modified = files.map { |file| File.mtime(file) }.max
+
+      files.each do |file|
+        next unless parseable?(file)
+        pattern.add(Languages.file_type(file), parse_file(file))
+      end
+
+      Process.process(pattern)
+      pattern
+    end
+
+    def self.register(parser, options)
+      match = options.delete(:for) || options.delete(:match)
+      @custom_parsers.push(parser: parser, for: match)
+    end
+
+    def self.parse_block(content, language)
+      store_current_details("foo.#{language}") do
+        symbol = Docks.current_parser.parse_comment_block(content)
+        Process.process(symbol)
+      end
+    end
+
+    private
+
+    def self.parseable?(file)
+      File.exists?(file) && Languages.supported_file?(file) && !parser_for(file).nil?
+    end
+
+    def self.parser_for(file)
+      parser = @custom_parsers.reverse_each.find { |custom_parser| custom_parser[:for] =~ file }
+
+      if parser.nil?
+        language = Languages.language_for(file)
+        language.nil? ? nil : language.parser
+      else
+        parser[:parser].instance
+      end
+    end
+
+    def self.parse_file(file)
+      store_current_details(file) do
+        symbols = Docks.current_parser.parse(file)
+        symbols.map { |symbol| Process.process(symbol) }
+      end
+    end
+
+    def self.store_current_details(file)
+      Docks.current_file = file
+      Docks.current_parser = parser_for(file)
+      Docks.current_language = Languages.language_for(file)
+      Docks.current_pattern = Docks.pattern_id(file)
+
+      symbol = yield
+
+      Docks.current_file = nil
+      Docks.current_parser = nil
+      Docks.current_language = nil
+      Docks.current_pattern = nil
+
+      symbol
+    end
+
+    def self.clean
+      @custom_parsers = []
+    end
+
+    clean
+  end
+
+  def self.current_file; @current_file end
+  def self.current_file=(file); @current_file = file end
+  def self.current_language; @current_language end
+  def self.current_language=(language); @current_language = language end
+  def self.current_parser; @current_parser end
+  def self.current_parser=(parser); @current_parser = parser end
+  def self.current_pattern; @current_pattern end
+  def self.current_pattern=(pattern); @current_pattern = pattern.to_s end
+end

data/lib/docks/parsers/base_parser.rb

@@ -0,0 +1,128 @@
+module Docks
+  module Parsers
+    class Base
+      include Singleton
+
+      attr_accessor :comment_pattern,
+                    :comment_line_pattern,
+                    :pattern_block_extractor,
+                    :symbol_block_extractor
+
+      def initialize
+        @comment_pattern = /#/
+        setup_regexes
+      end
+
+      def parse(file)
+        symbols = []
+        file_contents, file_given = if File.exists?(file)
+          [File.read(file).gsub(/\r\n?/, "\n"), true]
+        else
+          [file, false]
+        end
+
+        # Get rid of the page block and, in the process, add the page block
+        # to the set of parse results.
+        lines_from_pattern_block = 0
+        file_contents.sub!(@pattern_block_extractor) do |page_comment_block|
+          start_line_number = $`.lines.count + 1
+          lines_from_pattern_block = page_comment_block.lines.count
+          page_comment_block.sub!(/#{@comment_pattern}\*\s*/, '')
+
+          index = page_comment_block.index(/^\s*(?:#{@first_non_code_line_pattern}|#{@comment_pattern}\*$)/m)
+          parseable_block, replacement = page_comment_block, ""
+
+          if index
+            index -= 1
+            parseable_block = page_comment_block[0...index]
+            replacement = page_comment_block[index..-1]
+            lines_from_pattern_block -= replacement.lines.count
+          end
+
+          symbol = parse_comment_block(parseable_block)
+          symbol.source = OpenStruct.new(file: file, language_code: Languages.extension_for_file(file), line_number: start_line_number) if file_given
+          symbols << symbol
+
+          replacement
+        end
+
+        # Scan through each symbols comment block and add it to the list of parsed symbols.
+        last_match_position = 0
+        while (match = file_contents.match(@symbol_block_extractor, last_match_position))
+          symbol_details = symbol_details_from_first_line(match[:first_line])
+          symbol = Containers.container_for(symbol_details[:symbol_type]).new(symbol_details)
+          parse_comment_block(match[:comments], symbol)
+
+          symbol.source = OpenStruct.new(file: file, language_code: Languages.extension_for_file(file), line_number: lines_from_pattern_block + match.pre_match.lines.count + match[0].lines.count) if file_given
+          symbols << symbol
+
+          last_match_position = match.offset(0).last
+        end
+
+        symbols
+      end
+
+      def parse_comment_block(comment_block, symbol = Containers::Symbol.new)
+        if @tag_pattern.nil?
+          supported_tags = Tags.supported_parseable_tags.sort! { |a, b| b.length <=> a.length }
+          @tag_pattern = /(?:\s*@(?<tag>#{supported_tags.join("|")}) ?)?(?<text>.*)/
+        end
+
+        last_tag = nil
+
+        comment_block.sub(/#{@comment_pattern}\*\s*/, '').gsub(@comment_line_pattern, "").strip.split("\n").each do |comment_line|
+          line_details = comment_line.match(@tag_pattern)
+          next if line_details.nil? || line_details[:text].nil?
+
+          tag, text = line_details[:tag], line_details[:text]
+
+          if tag.nil?
+            if last_tag.nil?
+              # No tag and no previous tag — must be description
+              symbol[Tags::Description] ||= []
+              symbol[Tags::Description] << text
+            else
+              # No tag, but has a previous tag — bundle with last tag. As discussed below,
+              # multiple_allowed tags will be represented by an array of arrays, so append
+              # this line to the last array within the main array. Otherwise, just append
+              # the text to the main array.
+              (symbol[last_tag].first.kind_of?(Array) ? symbol[last_tag].last : symbol[last_tag]) << text
+            end
+          else
+            # New tag declaration
+            tag = tag.to_sym
+            tag_handler = Tags.tag_for(tag)
+            multiline = tag_handler.multiline?
+            last_tag = multiline ? tag : nil
+
+            # If multiple tags are allowed, each one (the tag declaration, plus the following lines)
+            # should be in an array inside the main array for that tag. Otherwise, the array
+            # for the tag should only contain strings. If only one of that tag is available per tag,
+            # overwrite the existing content. Non-multiline comments are always as minimally-Array-ed
+            # as possible (if only one is allowed per file, the tag value will be the line. Otherwise,
+            # it is added to a single-dimensional array).
+            if tag_handler.multiple_allowed?
+              symbol[tag] ||= []
+              symbol[tag] << (multiline ? [text] : text)
+            else
+              symbol[tag] = multiline ? [text] : text
+            end
+          end
+        end
+
+        symbol
+      end
+
+      protected
+
+      def setup_regexes
+        return if @comment_pattern.nil?
+
+        @first_non_code_line_pattern ||= /\w/
+        @pattern_block_extractor ||= /^ *#{@comment_pattern}\*(.*?@(?:page|pattern).*?)^\s*#{@comment_pattern}\*/m
+        @symbol_block_extractor ||= /^ *#{@comment_pattern}\*(?<comments>.*?)^[^#{@comment_pattern}]*?(?<first_line>#{@first_non_code_line_pattern}[^\n]*)/m
+        @comment_line_pattern ||= /^ *#{@comment_pattern} ?/m
+      end
+    end
+  end
+end

data/lib/docks/parsers/coffeescript_parser.rb

@@ -0,0 +1,30 @@
+require_relative "base_parser.rb"
+
+module Docks
+  module Parsers
+    class CoffeeScript < Base
+      def initialize
+        @comment_pattern = /#/
+        @first_non_code_line_pattern = /[\w\$]/
+        setup_regexes
+      end
+
+      def symbol_details_from_first_line(first_code_line)
+        first_code_line.strip!
+
+        type = case first_code_line
+          when /^class/ then Docks::Types::Symbol::CLASS
+          when /^.*?[\-\=]\>/ then Docks::Types::Symbol::FUNCTION
+          else Docks::Types::Symbol::VARIABLE
+        end
+
+        clean_first_line = first_code_line.split(/[=:,]/).first.gsub(/class\s+/, "").split(".").last.strip
+        bracket_check = clean_first_line.split(/['"]/)
+
+        name = bracket_check.length > 1 ? bracket_check[-2] : clean_first_line
+
+        { name: name, symbol_type: type }
+      end
+    end
+  end
+end

data/lib/docks/parsers/css_parser.rb

@@ -0,0 +1,27 @@
+require_relative "base_parser.rb"
+
+module Docks
+  module Parsers
+    class CSS < Base
+
+      def initialize
+        @comment_pattern = /(?:\/\*|\*\/?)/
+        @first_non_code_line_pattern = /[\.#\w\[@]/
+        setup_regexes
+      end
+
+      def symbol_details_from_first_line(first_code_line)
+        first_code_line.strip!
+
+        type = case first_code_line
+          when /(\.|\-\-)?(?:is|js)\-/ then Docks::Types::Symbol::STATE
+          when /\-\-(?:[a-zA-Z][\-_]?)*/ then Docks::Types::Symbol::VARIANT
+          else Docks::Types::Symbol::COMPONENT
+        end
+
+        name = first_code_line.match(/^\s*[\.#]([^\s\:\.#]*)/).captures.first
+        { name: name, symbol_type: type }
+      end
+    end
+  end
+end

data/lib/docks/parsers/javascript_parser.rb

@@ -0,0 +1,30 @@
+require_relative "base_parser.rb"
+
+module Docks
+  module Parsers
+    class JavaScript < Base
+      def initialize
+        @comment_pattern = /(?:\/\/|\/\*|\*\/?)/
+        @first_non_code_line_pattern = /[\w\$]/
+        setup_regexes
+      end
+
+      def symbol_details_from_first_line(first_code_line)
+        first_code_line.strip!
+
+        type = case first_code_line
+          when /^class/ then Docks::Types::Symbol::CLASS
+          when /(?:function|=>)/ then Docks::Types::Symbol::FUNCTION
+          else Docks::Types::Symbol::VARIABLE
+        end
+
+        clean_first_line = first_code_line.split(/[=:,\(]/).first.split(/[\.\s]/).last.strip
+        bracket_check = clean_first_line.split(/['"]/)
+
+        name = bracket_check.length > 1 ? bracket_check[-2] : clean_first_line
+
+        { name: name, symbol_type: type }
+      end
+    end
+  end
+end

data/lib/docks/parsers/less_parser.rb

@@ -0,0 +1,22 @@
+require_relative "sass_parser.rb"
+
+module Docks
+  module Parsers
+    class Less < Sass
+      def symbol_details_from_first_line(first_code_line)
+        first_code_line.strip!
+
+        type = case first_code_line
+          when /^.[^\(]*\(/ then Docks::Types::Symbol::MIXIN
+          when /^@/ then Docks::Types::Symbol::VARIABLE
+          when /(\.|\-\-)?(?:is|js)\-/ then Docks::Types::Symbol::STATE
+          when /\-\-(?:[a-zA-Z][\-_]?)*/ then Docks::Types::Symbol::VARIANT
+          else Docks::Types::Symbol::COMPONENT
+        end
+
+        name = first_code_line.match(/^\s*&?[\.#]?\s*(@?[^\s\(\:]*)/).captures.first
+        { name: name, symbol_type: type }
+      end
+    end
+  end
+end

data/lib/docks/parsers/sass_parser.rb

@@ -0,0 +1,31 @@
+require_relative "base_parser.rb"
+
+module Docks
+  module Parsers
+    class Sass < Base
+
+      def initialize
+        @comment_pattern = /(?:\/\/|\/\*|\*\/?)/
+        @first_non_code_line_pattern = /[\$=+\.#\w\[&@]/
+        setup_regexes
+      end
+
+      def symbol_details_from_first_line(first_code_line)
+        first_code_line = first_code_line.strip
+
+        type = case first_code_line
+          when /^@function/ then Docks::Types::Symbol::FUNCTION
+          when /^@mixin/, /^=/ then Docks::Types::Symbol::MIXIN
+          when /^%/ then Docks::Types::Symbol::PLACEHOLDER
+          when /^\$/ then Docks::Types::Symbol::VARIABLE
+          when /(\.|\-\-)?(?:is|js)\-/ then Docks::Types::Symbol::STATE
+          when /\-\-(?:[a-zA-Z][\-_]?)*/ then Docks::Types::Symbol::VARIANT
+          else Docks::Types::Symbol::COMPONENT
+        end
+
+        name = first_code_line.match(/^=?@?(?:(?:function|mixin)\s*)?&?[\.#]?\s*([\$%]?[^\s\(\:]*)/).captures.first
+        { name: name, symbol_type: type }
+      end
+    end
+  end
+end