docks_app 0.0.1

data/lib/docks/tags/state_tag.rb

@@ -0,0 +1,21 @@
+require_relative "variation_tag.rb"
+
+module Docks
+  module Tags
+    class State < Variation
+      def initialize
+        @name = :state
+        @parseable = true
+        @synonyms = [:states]
+        @multiple_allowed = true
+      end
+
+      def process(symbol)
+        symbol[@name].map! do |state|
+          state = break_apart_variation_details(state)
+          Containers::State.new(state)
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/static_tag.rb

@@ -0,0 +1,14 @@
+module Docks
+  module Tags
+    class Static < Base
+      def initialize
+        @name = :static
+        @multiline = false
+      end
+
+      def process(symbol)
+        symbol[@name] = true
+      end
+    end
+  end
+end

data/lib/docks/tags/subcomponent_tag.rb

@@ -0,0 +1,68 @@
+module Docks
+  module Tags
+    class Subcomponent < Base
+      def initialize
+        @name = :subcomponent
+        @multiple_allowed = true
+        @parseable = false
+      end
+
+      def setup_post_processors
+        after_each_pattern(:middle) do |pattern|
+          join_subcomponents_to_parent(pattern)
+        end
+      end
+
+      private
+
+      def join_subcomponents_to_parent(pattern)
+        @components = pattern.components.dup
+        @new_components = []
+
+        @components.each do |component|
+          parent_component = find_parent_component(component)
+          next if parent_component.nil?
+
+          parent_component.subcomponents << component unless parent_component.subcomponents.include?(component)
+          pattern.remove(component)
+        end
+
+        pattern.add(:style, @new_components)
+        @components = @new_components = nil
+        pattern
+      end
+
+      def find_parent_component(component)
+        parent_component_name = Docks.config.naming_convention.parent_component(component.name)
+        return if parent_component_name == component.name
+
+        created_component = false
+        parent_component = nil
+        (@components + @new_components).each do |possible_parent|
+          parent_component = possible_parent.find(parent_component_name)
+          break if parent_component
+        end
+
+        unless parent_component
+          parent_component = Containers::Component.new(name: parent_component_name)
+          created_component = true
+        end
+
+        # Create all necessary ancestors
+        last_parent = parent_component
+        grandparent = find_parent_component(parent_component)
+
+        if created_component && grandparent.nil? && !@new_components.include?(parent_component)
+          @new_components << parent_component
+        end
+
+        loop do
+          break if grandparent.nil? || grandparent.subcomponents.include?(last_parent)
+          grandparent.subcomponents << last_parent
+          grandparent = find_parent_component(grandparent)
+        end
+        parent_component
+      end
+    end
+  end
+end

data/lib/docks/tags/subtitle_tag.rb

@@ -0,0 +1,11 @@
+module Docks
+  module Tags
+    class Subtitle < Base
+      def initialize
+        @name = :subtitle
+        @synonyms = [:tagline]
+        @multiline = false
+      end
+    end
+  end
+end

data/lib/docks/tags/symbol_type_tag.rb

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

data/lib/docks/tags/throws_tag.rb

@@ -0,0 +1,30 @@
+module Docks
+  module Tags
+    class Throws < Base
+      def initialize
+        @name = :throws
+        @synonyms = [:throw, :exception]
+        @multiple_allowed = true
+      end
+
+      def process(symbol)
+        symbol.update(@name) do |throws|
+          Array(throws).map do |a_throw|
+            a_throw = multiline_description(a_throw) do |first_line|
+              if match = first_line.match(/\s*\{(?<type>[^\}]*)\}(?:\s*\-?\s*(?<description>.*))?/)
+                description = match[:description]
+
+                {
+                  types: split_types(match[:type]),
+                  description: description.nil? || description.length == 0 ? nil : match[:description]
+                }
+              end
+            end
+
+            OpenStruct.new(a_throw)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/title_tag.rb

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

data/lib/docks/tags/type_tag.rb

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

data/lib/docks/tags/value_tag.rb

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

data/lib/docks/tags/variant_tag.rb

@@ -0,0 +1,21 @@
+require_relative "variation_tag.rb"
+
+module Docks
+  module Tags
+    class Variant < Variation
+      def initialize
+        @name = :variant
+        @synonyms = [:modifier]
+        @parseable = true
+        @multiple_allowed = true
+      end
+
+      def process(symbol)
+        symbol[@name].map! do |variant|
+          variant = break_apart_variation_details(variant)
+          Containers::Variant.new(variant)
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags/variation_tag.rb

@@ -0,0 +1,136 @@
+require_relative "base_tag.rb"
+
+module Docks
+  module Tags
+    class Variation < Base
+      def initialize
+        @name = :variation
+        @parseable = false
+        @multiple_allowed = true
+      end
+
+      def setup_post_processors
+        after_each_pattern(:early) do |pattern|
+          join_variations_to_components(pattern)
+          clean_variation_names(pattern)
+        end
+
+        after_each_pattern(:late) do |pattern|
+          pattern.components.each { |component| mirror_preclusions(component) }
+        end
+      end
+
+      protected
+
+      def mirror_preclusions(component)
+        variations = component.variations
+        variations.each do |variation|
+          precludes = variation.precludes
+          name = variation.name
+
+          variations.select { |other| precludes.include?(other.name) }.each do |other|
+            other.precludes << name unless other.precludes.include?(name)
+          end
+        end
+
+        component.subcomponents.each { |subcomponent| mirror_preclusions(subcomponent) }
+      end
+
+      def clean_variation_names(pattern)
+        pattern.components.each do |component|
+          clean_component_variation_names(component)
+        end
+      end
+
+      def clean_component_variation_names(component)
+        component.variations.each do |variation|
+          component_name = component.name
+          variation.name = Docks.config.naming_convention.clean_variation_name(variation.name, component_name)
+
+          [:activate_with, :precludes].each do |need_name_fix|
+            variation[need_name_fix].map! { |item| Docks.config.naming_convention.clean_variation_name(item, component_name) }
+          end
+        end
+
+        component.subcomponents.each { |subcomponent| clean_component_variation_names(subcomponent) }
+      end
+
+      def join_variations_to_components(pattern)
+        orphan_variations = pattern.symbols_of_type(Types::Symbol::STATE) + pattern.symbols_of_type(Types::Symbol::VARIANT)
+        @new_components = []
+        @components = pattern.components
+
+        orphan_variations.each do |variation|
+          component = component_for_variation(pattern, variation)
+          component[variation.symbol_type] << variation
+          pattern.remove(variation)
+        end
+
+        pattern.add(:style, @new_components)
+        @new_components = @components = nil
+        pattern
+      end
+
+      def component_for_variation(pattern, variation)
+        component_name = Docks.config.naming_convention.component(variation.name)
+
+        component = nil
+        (@components + @new_components).each do |check_component|
+          component = check_component.find(component_name)
+          break if component
+        end
+
+        if component.nil?
+          component = Containers::Component.new(name: component_name)
+          @new_components << component
+        end
+
+        component
+      end
+
+      def break_apart_variation_details(content)
+        content = Array(content) unless content.kind_of?(Array)
+
+        multiline_description(content) do |item|
+          match = item.match(/\s*\.?(?<class>[\$a-zA-Z\-\_]*)(?:\s*(?<details>\(.*\)))?(?:\s*\-?\s*(?<description>.*))?/m)
+          return nil if match.nil?
+
+          description = match[:description]
+          result = {
+            name: match[:class],
+            description: description.nil? || description.length == 0 ? nil : match[:description],
+            activate_with: [],
+            precludes: [],
+            set_by: [],
+            include_with: [],
+            demo_type: Docks::Types::Demo::DEFAULT,
+            javascript_action: nil,
+            active: false
+          }
+
+          unless match[:details].nil?
+            details = parenthetical_options(match[:details], :demo_type)
+            result.merge!(details)
+
+            result[:demo_type] = ensure_valid_demo_type(result[:demo_type])
+            result[:active] = stringy_boolean(result[:active])
+
+            [
+              :activate_with,
+              :precludes,
+              :include_with
+            ].each do |array_param|
+              result[array_param] = split_on_characters(result[array_param], "\s\|")
+            end
+
+            result[:set_by] = split_on_top_level_parens_commas_and_pipes(result[:set_by]).map do |setter|
+              name_and_parenthetical(setter, :setter, :constant)
+            end
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/docks/tags.rb

@@ -0,0 +1,103 @@
+module Docks
+  module Tags
+    def self.tag_for(tag)
+      @tags[base_tag_name(tag)]
+    end
+
+    def self.base_tag_name(tag)
+      tag = tag.instance.name if tag.instance_of?(Class)
+      tag = tag.name if tag.kind_of?(Base)
+      tag = tag.to_sym
+
+      found = @synonyms[tag]
+      return found if found
+    end
+
+    def self.register_bundled_tags
+      bundled_tags.each { |tag| register(tag) }
+    end
+
+    def self.register(tag)
+      tag = tag.instance
+      tag.setup_post_processors
+
+      return false if tag.name.nil?
+      tag_name = tag.name.to_sym
+      @tags[tag_name] = tag
+
+      [tag_name, tag.synonyms].flatten.each do |synonym|
+        @synonyms[synonym.to_sym] = tag_name
+        @synonyms[synonym.to_s.pluralize.to_sym] = tag_name if tag.multiple_allowed?
+      end
+
+      true
+    end
+
+    def self.<<(tag)
+      register(tag)
+    end
+
+    def self.join_synonymous_tags(hash)
+      final_hash = {}
+      hash.each do |tag, value|
+        tag = tag.to_s.singularize.to_sym
+        base_tag = @synonyms[tag]
+
+        next if base_tag.nil?
+
+        if final_hash[base_tag].nil?
+          # No previous result for this tag or its synonyms. This effectively
+          # includes all non-multiple-allowed tags.
+          begin
+            final_hash[base_tag] = value.clone
+          rescue TypeError
+            final_hash[base_tag] = value
+          end
+        else
+          # All tags that could have previously-included synonym tags must be
+          # multiple-allowed tags. All multiple-allowed tags have new arrays
+          # for each declared tag.
+          final_hash[base_tag].concat(value)
+        end
+      end
+
+      final_hash
+    end
+
+    def self.has_tag?(tag)
+      !tag_for(tag).nil?
+    end
+
+    def self.supported_tags
+      @synonyms.keys
+    end
+
+    def self.supported_parseable_tags
+      supported_tags.select { |tag| tag_for(tag).parseable? }
+    end
+
+
+    private
+
+    def self.bundled_tags
+      if @bundled_tags.nil?
+        bundled = constants.select do |const|
+          klass = const_get(const)
+          Class === klass && !(klass.eql?(Base))
+        end
+
+        @bundled_tags = bundled.map { |const| const_get(const) }
+      end
+
+      @bundled_tags
+    end
+
+    def self.clean
+      @tags = {}
+      @synonyms = {}
+      @bundled_tags = nil
+    end
+
+    clean
+  end
+end

data/lib/docks/templates.rb

@@ -0,0 +1,122 @@
+module Docks
+  module Templates
+    class Template
+      attr_reader :path, :layout
+
+      def self.new(name, options = {})
+        name.kind_of?(self) ? name : super
+      end
+
+      def initialize(name, options = {})
+        @path = name
+        @matcher = options[:matches] || options[:for]
+        @layout = options[:layout]
+      end
+
+      def layout
+        @layout || Templates.default_layout
+      end
+
+      def matches?(id)
+        !(@matcher =~ id).nil?
+      end
+    end
+
+    def self.demo; @demo_template end
+    def self.demo=(template); @demo_template = Template.new(template, layout: "demo") end
+
+    def self.default; @default_template end
+    def self.fallback; default end
+    def self.default=(template); @default_template = Template.new(template) end
+    def self.fallback=(template); self.default = template end
+
+    def self.default_layout; @default_layout end
+    def self.default_layout=(layout); @default_layout = layout end
+
+    def self.register(template, options = {})
+      if template.kind_of?(Hash)
+        register_from_hash(template)
+      else
+        @templates << Template.new(template, options)
+      end
+    end
+
+    def self.<<(template)
+      register(template)
+    end
+
+    def self.template_for(id)
+      id = id.name if id.kind_of?(Containers::Pattern)
+
+     @templates.reverse_each do |template|
+        return template if template.matches?(id)
+      end
+
+      fallback
+    end
+
+    def self.search_for_template(template, options = {})
+      return unless template.kind_of?(String) || template.kind_of?(Pathname)
+      return template if File.exists?(template)
+
+      if options[:must_be].nil?
+        in_root = loose_search_for(template)
+        return in_root unless in_root.nil?
+      end
+
+      in_specific = loose_search_for(File.join("#{(options[:must_be] || :partial).to_s.sub(/s$/, '')}{s,}", template))
+      return in_specific unless in_specific.nil?
+
+      raise Docks::NoTemplateError, "No #{options[:must_be] || "template"} matching '#{template}' was found. Make sure that you have a template by that name in the '#{options[:must_be].nil? ? Docks.config.asset_folders.templates : options[:must_be].to_s.pluralize}' folder of your pattern library's assets (or in a subdirectory of that folder), or provide a full path to the desired file."
+    end
+
+    def self.last_template_update
+      @last_modified ||= begin
+        templates = Dir[Docks.config.templates + "**/*.*"]
+        templates.map { |template| File.mtime(template) }.sort.last
+      end
+    end
+
+    private
+
+    def self.register_from_hash(templates)
+      if fallback = templates.delete("default") || templates.delete("fallback")
+        self.fallback = fallback
+      end
+
+      if demo = templates.delete("demo")
+        self.demo = demo
+      end
+
+      templates.each do |match, template|
+        register(template, for: Regexp.new(match.to_s))
+      end
+    end
+
+    def self.loose_search_for(path)
+      return if path.nil?
+      path = Docks.config.templates + path
+      path_pieces = path.to_s.sub(File.extname(path), "").split("/")
+      path_pieces[path_pieces.length - 1] = "{_,}#{path_pieces.last}"
+      Dir.glob("#{path_pieces.join("/")}.*").first
+    end
+
+    def self.clean
+      @demo_template = Template.new("demo", layout: (rails? ? "docks/demo" : "demo"))
+      @default_template = Template.new("pattern")
+      @default_layout = rails? ? "docks/pattern" : "pattern"
+      @templates = []
+    end
+
+    def self.rails?
+      defined?(Rails)
+    end
+
+    clean
+  end
+
+  def self.template_for(id); Templates.template_for(id) end
+  def self.current_render_destination; @current_render_destination end
+  def self.current_render_destination=(destination); @current_render_destination = destination end
+  def self.component_template_path; Pathname.new(File.expand_path("../../template/assets/templates/components", __FILE__)) end
+end

data/lib/docks/themes.rb

@@ -0,0 +1,19 @@
+module Docks
+  module Themes
+    def self.for(theme)
+      if [String, ::Symbol].include?(theme.class)
+        begin
+          require "docks_theme_#{theme.to_s.downcase}"
+          theme = theme.to_sym
+          theme = const_get(theme).instance
+        rescue LoadError, NameError
+          theme = false
+        end
+      else
+        theme = theme.instance if theme.kind_of?(Class)
+      end
+
+      theme
+    end
+  end
+end

data/lib/docks/types.rb

@@ -0,0 +1,26 @@
+module Docks
+  module Types
+    module Symbol
+      COMPONENT   = "component"
+      VARIANT     = "variant"
+      STATE       = "state"
+      MIXIN       = "mixin"
+      PLACEHOLDER = "placeholder"
+      FUNCTION    = "function"
+      VARIABLE    = "variable"
+      CLASS       = "class"
+      FACTORY     = "factory"
+      PATTERN     = "pattern"
+      DEMO        = "demo"
+    end
+
+    module Demo
+      SELECT      = "select"
+      JOINT       = "joint"
+      OWN         = "own"
+      NONE        = "none"
+      HIDDEN      = NONE
+      DEFAULT     = SELECT
+    end
+  end
+end

data/lib/docks/version.rb

@@ -0,0 +1,3 @@
+module Docks
+  VERSION = "0.0.1"
+end

data/lib/docks.rb

@@ -0,0 +1,37 @@
+require "yaml"
+require "json"
+require "pathname"
+require "fileutils"
+require "ostruct"
+require "singleton"
+
+require "redcarpet"
+require "active_support/inflector"
+
+module Docks
+  ASSETS_DIR = "pattern_library_assets"
+  CONFIG_FILE = "docks_config.*"
+end
+
+require File.join(File.dirname(__FILE__), "docks", "types.rb")
+require File.join(File.dirname(__FILE__), "docks", "configuration.rb")
+Dir[File.join(File.dirname(__FILE__), "docks", "*.rb")].each { |file| require file }
+
+require File.join(File.dirname(__FILE__), "docks", "parsers/base_parser.rb")
+Dir[File.join(File.dirname(__FILE__), "docks", "parsers/*.rb")].each { |file| require file }
+
+Dir[File.join(File.dirname(__FILE__), "docks", "renderers/*.rb")].each { |file| require file }
+
+Dir[File.join(File.dirname(__FILE__), "docks", "themes/*.rb")].each { |file| require file }
+
+require File.join(File.dirname(__FILE__), "docks", "languages/base_language.rb")
+Dir[File.join(File.dirname(__FILE__), "docks", "languages/*.rb")].each { |file| require file }
+
+require File.join(File.dirname(__FILE__), "docks", "tags/base_tag.rb")
+Dir[File.join(File.dirname(__FILE__), "docks", "tags/*.rb")].each { |file| require file }
+
+Dir[File.join(File.dirname(__FILE__), "docks", "containers/*.rb")].each { |file| require file }
+
+require File.join(File.dirname(__FILE__), "docks", "descriptor.rb")
+
+Dir[File.join(File.dirname(__FILE__), "docks", "helpers.rb")].each { |file| require file }

data/spec/fixtures/build/scripts/bar/bar_2.js

@@ -0,0 +1 @@
+bar_2

data/spec/fixtures/build/scripts/bar.js

@@ -0,0 +1 @@
+baz

data/spec/fixtures/build/styles/foo/foo-2.css

@@ -0,0 +1 @@
+foo-2

data/spec/fixtures/build/styles/foo.css

@@ -0,0 +1 @@
+foo

data/spec/fixtures/build/templates/baz/baz_2.erb

@@ -0,0 +1 @@
+baz_2

data/spec/fixtures/build/templates/baz.erb

@@ -0,0 +1 @@
+baz