docks_app 0.0.1

data/lib/docks/tags/for_tag.rb

@@ -0,0 +1,23 @@
+module Docks
+  module Tags
+    class For < Base
+      def initialize
+        @name = :for
+        @multiline = false
+      end
+
+      def setup_post_processors
+        after_each_pattern(:late) do |pattern|
+          pattern.components.each { |component| set_for_on_component_variations(component) }
+        end
+      end
+
+      protected
+
+      def set_for_on_component_variations(component)
+        component.variations.each { |variation| variation.for = component.name }
+        component.subcomponents.each { |subcomponent| set_for_on_component_variations(subcomponent) }
+      end
+    end
+  end
+end

data/lib/docks/tags/group_tag.rb

@@ -0,0 +1,10 @@
+module Docks
+  module Tags
+    class Group < Base
+      def initialize
+        @name = :group
+        @multiline = false
+      end
+    end
+  end
+end

data/lib/docks/tags/helper_tag.rb

@@ -0,0 +1,13 @@
+module Docks
+  module Tags
+    class Helper < Base
+      def initialize
+        @name = :helper
+      end
+
+      def process(symbol)
+        symbol.update(@name) { |helper| helper.join("\n") }
+      end
+    end
+  end
+end

data/lib/docks/tags/include_with_tag.rb

@@ -0,0 +1,57 @@
+module Docks
+  module Tags
+    class IncludeWith < Base
+      def initialize
+        @name = :include_with
+        @multiline = false
+        @multiple_allowed = true
+      end
+
+      def process(symbol)
+        symbol.update(@name) do |include_with|
+          Array(include_with).map { |with| split_on_commas_spaces_and_pipes(with) }.flatten
+        end
+      end
+
+      def setup_post_processors
+        after_each_pattern(:late) do |pattern|
+          components = pattern.components
+          components.each { |component| find_and_associate_inclusion(component, components) }
+        end
+      end
+
+      private
+
+      def find_and_associate_inclusion(component, components)
+        include_withs = component.fetch(:include_with, [])
+        unless include_withs.empty?
+          components.each do |other|
+            next unless include_withs.include?(other.name)
+            other.included_symbols ||= []
+            other.included_symbols << component
+          end
+        end
+
+        component.variations do |variation|
+          include_withs = variation.fetch(:include_with, [])
+          next if include_withs.empty?
+          components.each do |other|
+            next unless include_withs.include?(other.name)
+            other.included_symbols ||= []
+            other.included_symbols << variation
+          end
+        end
+
+        component.subcomponents { |subcomponent| find_and_associate_inclusion(subcomponent, components) }
+      end
+    end
+
+    class IncludedSymbol < Base
+      def initialize
+        @name = :included_symbol
+        @parseable = false
+        @multiple_allowed = true
+      end
+    end
+  end
+end

data/lib/docks/tags/javascript_action_tag.rb

@@ -0,0 +1,10 @@
+module Docks
+  module Tags
+    class JavascriptAction < Base
+      def initialize
+        @name = :javascript_action
+        @multiline = false
+      end
+    end
+  end
+end

data/lib/docks/tags/link_tag.rb

@@ -0,0 +1,18 @@
+module Docks
+  module Tags
+    class Link < Base
+      def initialize
+        @name = :link
+        @synonyms = [:see]
+        @multiline = false
+        @multiple_allowed = true
+      end
+
+      def process(symbol)
+        symbol.update(@name) do |links|
+          Array(links).map { |link| OpenStruct.new name_and_parenthetical(link, :url, :caption) }
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/markup_tag.rb

@@ -0,0 +1,106 @@
+module Docks
+  module Tags
+    class Markup < Base
+      def initialize
+        @name = :markup
+      end
+
+      def process(symbol)
+        symbol.update(@name) { |markup| markup.join("\n") }
+      end
+
+      def setup_post_processors
+        after_each_pattern(:late) do |pattern|
+          components = pattern.components
+          associate_content_from_external_files(components)
+          clean_up_helper_and_markup(components)
+          prepare_variation_markup(components)
+          pattern
+        end
+      end
+
+      protected
+
+      def associate_content_from_external_files(components)
+        markup_files = Grouper.source_files_of_type(Types::Languages::MARKUP)
+        stub_files = Grouper.source_files_of_type(Types::Languages::STUB)
+
+        components.each do |component|
+          name = component.name
+          id = Docks.pattern_id(name)
+
+          if component.markup.nil? && !markup_files.empty?
+            markup_file = markup_files.find do |file|
+              name == File.basename(file, ".*").sub(/^_+/, "") || id == Docks.pattern_id(file)
+            end
+
+            component.markup = File.read(markup_file) unless markup_file.nil?
+          end
+
+          if component.markup.nil? && !component.helper.nil? && !stub_files.empty?
+            markup_language = Languages.most_common_markup_language || Languages::ERB.instance
+            next unless markup_language.respond_to?(:helper_markup_for)
+
+            stub_file = stub_files.find do |file|
+              name == File.basename(file, ".*").sub(/^_+/, "") || id == Docks.pattern_id(file)
+            end
+
+            stub = stub_file.nil? ? nil : Languages.language_for(stub_file).load_stub(stub_file)
+            component.helper = markup_language.helper_markup_for(component.helper, stub) unless stub.nil?
+          end
+        end
+      end
+
+      def clean_up_helper_and_markup(components)
+        components.each do |component|
+          markup, helper = component.markup, component.helper
+          if markup && helper && markup.include?(helper)
+            component.helper = component.markup
+            component.markup = nil
+          end
+        end
+      end
+
+      def prepare_variation_markup(components)
+        components.each do |component|
+          next unless component.has_demo?
+          markup, helper = component.markup, component.helper
+
+          component.variations do |variation|
+            next unless variation.has_demo?
+            next if variation.helper || variation.markup
+
+            if helper
+              update_helper_for_variation(helper, variation)
+            elsif markup
+              update_markup_for_variation(markup, variation)
+            end
+          end
+        end
+      end
+
+      def update_markup_for_variation(markup, variation)
+        variation.markup = markup.gsub(/class\s*=\s*['"][^'"]*#{Docks.config.naming_convention.component(variation.name)}[\s'"]/) do |match|
+          "#{match[0...-1]} #{variation.name}#{match[-1]}"
+        end
+      end
+
+      def update_helper_for_variation(helper, variation)
+        variation.set_by.each do |set_by|
+          update_found = false
+          new_helper = helper.gsub(/#{Regexp.escape(set_by[:setter].sub(/^:/, ""))}(:\s*|\s*=>\s*)([:a-zA-Z_]*)/) do |match|
+            update_found = true
+            value = set_by[:constant] || "true"
+            join = $1.dup
+            "#{set_by[:setter].sub(/^:/, "")}#{join}#{value}"
+          end
+
+          if update_found
+            variation.helper = new_helper
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/member_tag.rb

@@ -0,0 +1,37 @@
+require_relative "base_tag.rb"
+
+module Docks
+  module Tags
+    class Member < Base
+      def initialize
+        @name = :variation
+        @parseable = false
+        @multiple_allowed = true
+      end
+
+      def setup_post_processors
+        after_each_pattern(:middle) do |pattern|
+          last_object = nil
+          script_symbols = pattern.script_symbols
+
+          script_symbols.each do |symbol|
+            is_member = symbol.member?
+            for_symbol = symbol.for
+
+            if for_symbol
+              matching_symbol = script_symbols.find { |symbol| symbol.name == for_symbol }
+            end
+
+            last_object = symbol if last_object.nil? && !is_member
+            next if last_object.nil? || (for_symbol && !matching_symbol)
+
+            (matching_symbol || last_object).add_member(symbol) if is_member || for_symbol
+            last_object = symbol if !is_member
+          end
+
+          pattern.script_symbols.delete_if(&:member?)
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/method_tag.rb

@@ -0,0 +1,18 @@
+require_relative "member_tag.rb"
+
+module Docks
+  module Tags
+    class Method < Member
+      def initialize
+        @name = :method
+        @multiline = false
+        @multiple_allowed = false
+      end
+
+      def process(symbol)
+        symbol[@name] = true
+        Containers::Function.from_symbol(symbol)
+      end
+    end
+  end
+end

data/lib/docks/tags/name_tag.rb

@@ -0,0 +1,10 @@
+module Docks
+  module Tags
+    class Name < Base
+      def initialize
+        @name = :name
+        @multiline = false
+      end
+    end
+  end
+end

data/lib/docks/tags/object_tag.rb

@@ -0,0 +1,15 @@
+module Docks
+  module Tags
+    class Object < Base
+      def initialize
+        @name = :object
+        @multiline = false
+      end
+
+      def process(symbol)
+        symbol[@name] = true
+        symbol.type = "Object"
+      end
+    end
+  end
+end

data/lib/docks/tags/param_tag.rb

@@ -0,0 +1,94 @@
+module Docks
+  module Tags
+    class Param < Base
+      def initialize
+        @name = :param
+        @synonyms = [:arg, :argument, :parameter]
+        @multiple_allowed = true
+      end
+
+      def process(symbol)
+        symbol.update(@name) do |params|
+          params = Array(params).map do |param|
+            param = multiline_description(param) { |first_line| proccess_first_line_of_param(first_line) }
+            OpenStruct.new(param)
+          end
+
+          join_sub_params(params)
+        end
+      end
+
+      private
+
+      PROP_MATCHER = /(?<base>\w+)(?:\.(?<name>\w+)|\[\s*['"](?<name>\w+))/
+      NAME_MATCHER = /(?<optional>\[)?(?<name>[^\s=\]]*)[\s=\]]*/
+
+      def proccess_first_line_of_param(first_line)
+        first_line = first_line.strip
+        result = {
+          multiple: false,
+          types: Array.new,
+          optional: false,
+          description: nil
+        }
+
+        if type_match = first_line.match(/^\{([^\}]*)\}\s*/)
+          result[:types] = split_types(type_match.captures.first)
+          first_line = first_line.sub(type_match.to_s, "")
+        end
+
+        first_line.sub!(/([^=\s])\[\]/, '\1')
+        name_match = first_line.match(NAME_MATCHER)
+        result[:optional] = !name_match[:optional].nil?
+        result[:name] = name_match[:name]
+        first_line = first_line.sub(name_match.to_s, "")
+
+        result[:name].sub!(/^\.{3}/) do
+          result[:multiple] = true
+          ""
+        end
+
+        description_match = first_line.match(/\s*\-\s*(.*)/)
+        result[:description] = description_match.nil? ? nil : description_match.captures.first
+        first_line.sub!(description_match.to_s, "") unless description_match.nil?
+
+        default_match = first_line.match(/(.*)\]\s*/)
+        result[:default] = default_match.nil? ? nil : default_match.captures.first
+        first_line = first_line.sub(default_match.to_s, "") unless default_match.nil?
+
+        result[:description] = first_line if result[:description].nil? && !first_line.empty?
+
+        result
+      end
+
+      def join_sub_params(params)
+        final_params = []
+
+        params.each do |param|
+          param.properties ||= []
+
+          if matches = param.name.match(PROP_MATCHER)
+            base_param_name, param.name = matches[:base], matches[:name]
+            base_param = final_params.find { |final_param| final_param.name == base_param_name }
+
+            if base_param.nil?
+              base_param = OpenStruct.new({
+                name: base_param_name,
+                types: ["Object"],
+                properties: []
+              })
+
+              final_params << base_param
+            end
+
+            base_param.properties << param
+          else
+            final_params << param
+          end
+        end
+
+        final_params
+      end
+    end
+  end
+end

data/lib/docks/tags/pattern_tag.rb

@@ -0,0 +1,21 @@
+module Docks
+  module Tags
+    class Pattern < Base
+      def initialize
+        @name = :pattern
+        @synonyms = [:page]
+        @multiline = false
+      end
+
+      def setup_post_processors
+        after_each_pattern(:middle) do |pattern|
+          name = pattern.name
+
+          pattern.symbols.each do |symbol|
+            symbol.pattern = name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/preclude_tag.rb

@@ -0,0 +1,17 @@
+module Docks
+  module Tags
+    class Preclude < Base
+      def initialize
+        @name = :preclude
+        @multiline = false
+        @multiple_allowed = true
+      end
+
+      def process(symbol)
+        symbol.update(@name) do |precludes|
+          Array(precludes).map { |preclude| split_on_commas_spaces_and_pipes(preclude) }.flatten
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/private_tag.rb

@@ -0,0 +1,15 @@
+module Docks
+  module Tags
+    class Private < Base
+      def initialize
+        @name = :private
+        @multiline = false
+      end
+
+      def process(symbol)
+        symbol.delete(@name)
+        symbol[Access] = Docks::Types::Access::PRIVATE
+      end
+    end
+  end
+end

data/lib/docks/tags/property_tag.rb

@@ -0,0 +1,18 @@
+require_relative "member_tag.rb"
+
+module Docks
+  module Tags
+    class Property < Member
+      def initialize
+        @name = :property
+        @multiline = false
+        @multiple_allowed = false
+      end
+
+      def process(symbol)
+        symbol[@name] = true
+        Containers::Variable.from_symbol(symbol)
+      end
+    end
+  end
+end

data/lib/docks/tags/public_tag.rb

@@ -0,0 +1,15 @@
+module Docks
+  module Tags
+    class Public < Base
+      def initialize
+        @name = :public
+        @multiline = false
+      end
+
+      def process(symbol)
+        symbol.delete(@name)
+        symbol[Access] = Docks::Types::Access::PUBLIC
+      end
+    end
+  end
+end

data/lib/docks/tags/require_tag.rb

@@ -0,0 +1,47 @@
+module Docks
+  module Tags
+    class Require < Base
+      def initialize
+        @name = :require
+        @multiline = false
+        @multiple_allowed = true
+
+        @require_associations = {}
+      end
+
+      def process(symbol)
+        symbol.update(@name) do |requires|
+          Array(requires).map { |a_require| split_on_commas_spaces_and_pipes(a_require) }.flatten
+        end
+
+        if requires = symbol[@name]
+          requires.each do |required|
+            @require_associations[required] ||= []
+            @require_associations[required] << symbol
+          end
+        end
+      end
+
+      def setup_post_processors
+        after_all(:late) do |pattern_library|
+          @require_associations.each do |descriptor, users|
+            if result = pattern_library.find(descriptor)
+              symbol = result.symbol || result.pattern
+              symbol[UsedBy] = users.map { |user| user.to_descriptor }
+            end
+          end
+
+          @require_associations = {}
+        end
+      end
+    end
+
+    class UsedBy < Base
+      def initialize
+        @name = :used_by
+        @synonyms = [:required_by, :used_in]
+        @parseable = false
+      end
+    end
+  end
+end

data/lib/docks/tags/returns_tag.rb

@@ -0,0 +1,31 @@
+module Docks
+  module Tags
+    class Returns < Base
+      def initialize
+        @name = :returns
+        @synonyms = [:return]
+      end
+
+      def process(symbol)
+        symbol.update(@name) do |returns|
+          returns = multiline_description(returns) do |first_line|
+            first_line.strip!
+            if match = first_line.match(/nothing\s*\-?\s*(?<description>.*)/i)
+              { description: match[:description] }
+
+            else
+              match = first_line.match(/\{?(?<type>[^\}\-]*)\}?(?:\s*\-?\s*(?<description>.*))?/)
+              {
+                types: split_types(match[:type].strip),
+                description: match[:description]
+              }
+            end
+          end
+
+          returns[:types] = nil if Array(returns[:types]).empty?
+          OpenStruct.new(returns)
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/set_by_tag.rb

@@ -0,0 +1,18 @@
+module Docks
+  module Tags
+    class SetBy < Base
+      def initialize
+        @name = :set_by
+        @multiline = false
+        @multiple_allowed = true
+      end
+
+      def process(symbol)
+        symbol.update(@name) do |set_bys|
+          set_bys = Array(set_bys).map { |set_by| split_on_top_level_parens_commas_and_pipes(set_by) }.flatten
+          set_bys.map { |set_by| OpenStruct.new name_and_parenthetical(set_by, :setter, :constant) }
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/signature_tag.rb

@@ -0,0 +1,35 @@
+module Docks
+  module Tags
+    class Signature < Base
+      def initialize
+        @name = :signature
+      end
+
+      def process(symbol)
+        symbol.update(@name) { |signature| signature.join("\n") }
+      end
+
+      def setup_post_processors
+        after_each_pattern(:late) do |pattern|
+          pattern.symbols.each { |symbol| add_signature(symbol) }
+        end
+      end
+
+      private
+
+      SYMBOL_TYPES_WITH_SIGNATURES = %w(class factory function mixin)
+
+      def add_signature(symbol)
+        return unless source = symbol.source
+        language = Languages.language_for(source.file)
+        return unless language
+
+        if !symbol.signature && SYMBOL_TYPES_WITH_SIGNATURES.include?(symbol.symbol_type)
+          symbol.signature = language.signature_for(symbol)
+        end
+
+        symbol.methods.each { |method| add_signature(method) }
+      end
+    end
+  end
+end

data/lib/docks/tags/since_tag.rb

@@ -0,0 +1,26 @@
+module Docks
+  module Tags
+    class Since < Base
+      def initialize
+        @name = :since
+        @synonyms = [:introduced_in]
+      end
+
+      def process(symbol)
+        symbol.update(@name) do |since|
+          since = multiline_description(since) do |first_line|
+            if match = first_line.match(/\s*(?<version>[0-9a-zA\.\-_]*)(?:\s+\-?\s*(?<description>.*))?/)
+              description = match[:description]
+              {
+                version: match[:version],
+                description: description.nil? || description.length == 0 ? nil : match[:description]
+              }
+            end
+          end
+
+          OpenStruct.new(since)
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/source_tag.rb

@@ -0,0 +1,12 @@
+require_relative "base_tag.rb"
+
+module Docks
+  module Tags
+    class Source < Base
+      def initialize
+        @name = :source
+        @parseable = false
+      end
+    end
+  end
+end