docks_app 0.0.1

data/lib/docks/configuration.rb

@@ -0,0 +1,217 @@
+require "singleton"
+require "pathname"
+
+require_relative "cache.rb"
+require_relative "templates.rb"
+require_relative "tags.rb"
+require_relative "symbol_sources.rb"
+require_relative "naming_conventions.rb"
+require_relative "themes.rb"
+
+module Docks
+  class Configuration
+    include Singleton
+
+    ROOT_DEPENDENT_PATHS = [
+      :sources,
+      :destination,
+      :cache_location,
+      :templates,
+      :helpers
+    ]
+
+    # Key details — these are required
+    attr_accessor :sources, :destination, :theme
+
+    # Locations
+    attr_accessor :root, :cache_location, :templates, :asset_folders
+
+    # Random assortment of other stuff
+    attr_accessor :github_repo, :mount_at, :helpers, :compiled_assets,
+                  :naming_convention, :pattern_id, :paginate, :use_theme_assets
+
+    # Stateful stuff
+    attr_reader :configured
+
+    def initialize
+      restore_defaults
+    end
+
+    def root=(new_root)
+      @root = new_root.kind_of?(Pathname) ? new_root : Pathname.new(new_root)
+    end
+
+    def asset_folders=(new_asset_folders)
+      new_asset_folders.each do |type, dir|
+        @asset_folders.send("#{type}=".to_sym, dir)
+      end
+
+      @asset_folders
+    end
+
+    def naming_convention=(new_naming_convention)
+      @naming_convention = NamingConventions.for(new_naming_convention)
+      @naming_convention
+    end
+
+    def theme=(new_theme)
+      @theme = Themes.for(new_theme)
+      @theme
+    end
+
+    def github_repo
+      return nil if @github_repo.nil? || @github_repo.empty?
+      "https://github.com/#{@github_repo.split("/")[-2..-1].join("/")}"
+    end
+
+    def paginate?
+      !!@paginate
+    end
+
+    def pattern_id(*args)
+      Docks.pattern_id(*args)
+    end
+
+    def pattern_id=(block)
+      Docks.pattern_id = block
+    end
+
+    def finalize
+      @configured = true
+    end
+
+    def custom_languages
+      yield Languages
+    end
+
+    def custom_tags
+      yield Tags
+    end
+
+    def custom_templates
+      yield Templates
+    end
+
+    def custom_templates=(custom_templates)
+      Templates.register(custom_templates)
+    end
+
+    def custom_symbol_sources
+      yield SymbolSources
+    end
+
+    def custom_parsers
+      yield Parser
+    end
+
+    ROOT_DEPENDENT_PATHS.each do |path|
+      define_method(path) do
+        paths = instance_variable_get("@#{path.to_s}".to_sym)
+        return if paths.nil?
+
+        if paths.kind_of?(Array)
+          paths.map { |a_path| make_path_absolute(a_path) }
+        else
+          make_path_absolute(paths)
+        end
+      end
+    end
+
+    def restore_defaults
+      @configured = false
+      @sources = [
+        "styles/**/*.{css,scss,sass,less,styl}",
+        "scripts/**/*.{js,coffee,coffeescript}"
+      ]
+      @compiled_assets = []
+      @github_repo = ""
+      @paginate = :pattern
+      @naming_convention = NamingConventions::BEM.instance
+      @helpers = []
+
+      @theme = Themes.for("API")
+      @use_theme_assets = true
+
+      @root = Pathname.pwd
+      @cache_location = ".#{Docks::Cache::DIR}"
+
+      @templates = "#{Docks::ASSETS_DIR}/templates"
+      @custom_templates = {
+        fallback: "pattern",
+        demo: "demo"
+      }
+
+      @destination = "public"
+      @asset_folders = OpenStruct.new(scripts: "scripts", styles: "styles")
+
+      @mount_at = "pattern-library"
+    end
+
+    private
+
+    def make_path_absolute(path)
+      pathname = path.kind_of?(Pathname) ? path : Pathname.new(path)
+      if pathname.absolute?
+        pathname
+      else
+        @root + pathname
+      end
+    end
+  end
+
+
+  @configuration = Configuration.instance
+
+  def self.config
+    @configuration
+  end
+
+  def self.configure_with(configurer)
+    if configurer.kind_of?(Hash)
+      configure do |config|
+        configurer.each do |key, val|
+          key = "#{key}=".to_sym
+          config.send(key, val) if config.respond_to?(key)
+        end
+      end
+
+      return
+    end
+
+    configurer = Dir[configurer].first
+
+    unless File.exists?(configurer)
+      Messenger.error("No configuration file could be found.")
+      exit
+    end
+
+    if File.extname(configurer) =~ /rb/
+      self.class_eval(File.read(configurer))
+    else
+      Languages.register_bundled_languages
+      language = Languages.language_for(configurer)
+      configure_with(language.load_stub(configurer)) unless language.nil?
+    end
+  end
+
+  def self.configure
+    unless block_given?
+      return configure_with(CONFIG_FILE)
+    end
+
+    pre_configuration unless @configuration.configured
+    yield @configuration
+    post_configuration
+  end
+
+  private
+
+  def self.pre_configuration
+    Tags.register_bundled_tags
+    Languages.register_bundled_languages
+  end
+
+  def self.post_configuration
+    @configuration.finalize
+  end
+end

data/lib/docks/containers/base_container.rb

@@ -0,0 +1,103 @@
+require "forwardable"
+require_relative "../tags.rb"
+require_relative "../descriptor.rb"
+
+module Docks
+  module Containers
+
+    # Public: the base container for symbols. This class should be inherited
+    # from for all other symbol containers. Its most important feature is that
+    # it normalizes synonymous tags so that any tag can be called on a
+    # container and the result will be returned as expected.
+
+    class Base
+      extend Forwardable
+      def_delegators :@details, :to_s, :inspect, :to_json, :each
+
+      def initialize(details = {})
+        if details.kind_of?(Base)
+          details.delete(:symbol_type)
+          details = details.to_h
+        end
+
+        details = Tags.join_synonymous_tags(details)
+        @details = details
+        @summary = false
+      end
+
+      def to_h; @details end
+      alias_method :to_hash, :to_h
+
+      def ==(other_container)
+        self.class == other_container.class && @details == other_container.instance_variable_get(:@details)
+      end
+
+      def update(tag)
+        self[tag] = yield(self[tag])
+        self
+      end
+
+      def [](tag)
+        fetch(tag, nil)
+      end
+
+      def []=(tag, new_value)
+        tag = Tags.base_tag_name(tag)
+        @details[tag] = new_value unless tag.nil?
+      end
+
+      def delete(tag)
+        @details.delete(Tags.base_tag_name(tag))
+      end
+
+      def fetch(tag, *args)
+        @details.fetch(Tags.base_tag_name(tag), *args)
+      end
+
+      def tags
+        @details.keys.map { |tag| Tags.tag_for(tag) }
+      end
+
+      def method_missing(meth, *args, &block)
+        stripped = meth.to_s.sub("=", "").to_sym
+        has_tag = Tags.has_tag?(stripped)
+
+        if stripped != meth && has_tag
+          self[stripped] = args.first
+        elsif has_tag
+          fetch(meth, nil)
+        else
+          super(meth, *args, &block)
+        end
+      end
+
+      def respond_to?(meth)
+        Tags.has_tag?(meth.to_s.sub("=", "")) || super
+      end
+
+      def summarized?; @summary end
+      alias_method :summary?, :summarized?
+
+      def summary
+        summary = self.class.new(name: self.name)
+        summary.instance_variable_set(:@summary, true)
+        summary
+      end
+
+      def find(descriptor)
+        descriptor = Descriptor.new(descriptor)
+        matches_exactly?(descriptor) && self
+      end
+
+      protected
+
+      def matches?(descriptor)
+        fetch(:name, nil) == descriptor.symbol
+      end
+
+      def matches_exactly?(descriptor)
+        !descriptor.member? && matches?(descriptor)
+      end
+    end
+  end
+end

data/lib/docks/containers/class_container.rb

@@ -0,0 +1,39 @@
+require_relative "symbol_container.rb"
+
+module Docks
+  module Containers
+
+    # Public: a container for Class symbols.
+
+    class Klass < Symbol
+      # Public: the type of symbols that should be encapsulated by this
+      # container. This is compared against a symbol's `symbol_type` to
+      # determine which container to use.
+      #
+      # Returns the type String.
+
+      def self.type; Docks::Types::Symbol::CLASS end
+
+      def public_methods; methods.select { |meth| meth.public? } end
+      def private_methods; methods.select { |meth| meth.private? } end
+
+      def static_methods; methods.select { |meth| meth.static? } end
+      def instance_methods; methods.reject { |meth| meth.static? } end
+
+      def public_properties; properties.select { |prop| prop.public? } end
+      def private_properties; properties.select { |prop| prop.private? } end
+
+      def static_properties; properties.select { |prop| prop.static? } end
+      def instance_properties; properties.reject { |prop| prop.static? } end
+
+      def instance_members; instance_methods + instance_properties end
+      def static_members; static_methods + static_properties end
+
+      def add_member(symbol)
+        static = symbol.static?
+        super
+        symbol.static = static
+      end
+    end
+  end
+end

data/lib/docks/containers/component_container.rb

@@ -0,0 +1,92 @@
+require_relative "symbol_container.rb"
+
+module Docks
+  module Containers
+
+    # Public: a container for Component symbols.
+
+    class Component < Symbol
+
+      # Public: the type of symbols that should be encapsulated by this
+      # container. This is compared against a symbol's `symbol_type` to
+      # determine which container to use.
+      #
+      # Returns the type String.
+
+      def self.type; Docks::Types::Symbol::COMPONENT end
+
+      def initialize(component_hash = {})
+        super
+
+        self[:states] ||= []
+        self[:variants] ||= []
+        self[:subcomponents] ||= []
+        self[:included_symbols] ||= []
+      end
+
+      def subcomponents(options = {}, &block)
+        subcomponents = if options.fetch(:recursive, false)
+          recursive_subcomponents
+        else
+          self[:subcomponents]
+        end
+
+        block_given? ? subcomponents.each(&block) : subcomponents
+      end
+
+      alias_method :subcomponent, :subcomponents
+
+      def has_demo?
+        !((markup || "") + (helper || "")).empty?
+      end
+
+      def variations(&block)
+        variations = states + variants
+        block_given? ? variations.each(&block) : variations
+      end
+
+      def find(descriptor)
+        super || find_in_members(descriptor)
+      end
+
+      def summary
+        summary = super
+
+        [:states, :variants, :subcomponents].each do |property|
+          summary[property] = fetch(property, []).map(&:summary)
+        end
+
+        summary
+      end
+
+      protected
+
+      def recursive_subcomponents
+        self[:subcomponents].inject([]) do |all_subcomponents, subcomponent|
+          all_subcomponents << subcomponent
+          all_subcomponents.concat(subcomponent.recursive_subcomponents)
+        end
+      end
+
+      def find_in_members(descriptor)
+        descriptor = Descriptor.new(descriptor)
+
+        found = if !(descriptor.member? && descriptor.symbol != fetch(:name, nil))
+          possible_variation_name = descriptor.member || descriptor.symbol
+          variations.find { |variation| variation.find(descriptor) } || false
+        else
+          false
+        end
+
+        return found if found
+
+        # Can't do a regular #find since each component searches its subcomponents
+        subcomponents.each do |subcomponent|
+          break if found = subcomponent.find(descriptor)
+        end
+
+        found
+      end
+    end
+  end
+end

data/lib/docks/containers/demo_container.rb

@@ -0,0 +1,105 @@
+require_relative "base_container.rb"
+
+module Docks
+  module Containers
+
+    # Public: a container for demos. This is a special type of container in
+    # that it does not correspond directly to a symbol from the parse results.
+    # Instead, it encapsulates and provides helper methods for sets of
+    # components that require a demo.
+
+    class Demo
+
+      # Public: the type of symbols that should be encapsulated by this
+      # container. This is compared against a symbol's `symbol_type` to
+      # determine which container to use.
+      #
+      # Returns the type String.
+
+      def self.type; Docks::Types::Symbol::DEMO end
+
+      attr_reader :component, :name
+
+      # Public: initializes a new demo.
+
+      def initialize(component)
+        @component = component
+        @name = component.name
+      end
+
+      # Public: collects all variations on the components that are being demo'ed
+      # that were specified to be "select" types. The optional options Hash
+      # allows you to choose whether or not to group the result by base class
+      # (using the `group_by_component` key of `true`), in which case the
+      # result will be a Hash of Arrays where the keys are the base classes.
+      # Otherwise, a simple Array of variation symbols is returned.
+      #
+      # options - A hash of options. Defaults to {}.
+      #
+      # Returns a Hash or Array of "select"-type variations, depending on the
+      # value of the `group_by_component` option.
+
+      def select_variations(options = {})
+        variations_of_type(Docks::Types::Demo::SELECT, options)
+      end
+
+      # Public: collects all the variations of the demo'ed components that
+      # should be presented as joint demos.
+      #
+      # Returns an Array of "joint"-type variations.
+
+      def joint_variations
+        variations_of_type(Docks::Types::Demo::JOINT)
+      end
+
+
+
+      private
+
+      # Private: Collects all variations of components in this demo whose
+      # `demo_type` has been set to the passed `type`.
+      #
+      # type    - a String of the demo type to search for.
+      # options - an optional options Hash. Default is {}.
+      #
+      # Returns a Hash or Array of variations matching the passed type,
+      # depending on the value of the `group_by_component` option.
+
+      def variations_of_type(type, options = {})
+        group_by_component = options[:group_by_component]
+        matches = group_by_component ? {} : []
+
+        return matches unless @component.symbol_type == Docks::Types::Symbol::COMPONENT
+
+        ([@component] + @component.subcomponents + @component.included_symbols).each do |a_component|
+          if demo_type = a_component.demo_type
+            next unless demo_type == type
+
+            if group_by_component
+              matches[a_component.base_class] ||= []
+              matches[a_component.base_class] << a_component
+            else
+              matches << a_component
+            end
+
+            next
+          end
+
+          component_name = a_component.name
+          a_component.variations.each do |v|
+            next unless v.demo_type == type
+
+            if group_by_component
+              matches[component_name] ||= []
+              matches[component_name] << v
+            else
+              matches.push << v
+            end
+          end
+        end
+
+        matches
+      end
+    end
+  end
+end

data/lib/docks/containers/factory_container.rb

@@ -0,0 +1,12 @@
+require_relative "class_container.rb"
+
+module Docks
+  module Containers
+
+    # Public: a container for Factory symbols.
+
+    class Factory < Klass
+      def self.type; Docks::Types::Symbol::FACTORY end
+    end
+  end
+end

data/lib/docks/containers/function_container.rb

@@ -0,0 +1,46 @@
+require_relative "symbol_container.rb"
+
+module Docks
+  module Containers
+    # Public: a container for Function symbols.
+
+    class Function < Symbol
+      def self.type; Docks::Types::Symbol::FUNCTION end
+
+      def static?; fetch(:static, false) end
+      def instance?; !static? end
+      def method?; fetch(:method, false) end
+
+      def symbol_id
+        return super unless method?
+        "method-#{"static-" if static?}#{self[:for]}-#{self[:name]}"
+      end
+
+      def to_descriptor
+        return super unless method?
+        "#{belongs_to.to_descriptor}#{static? ? "." : "#"}#{fetch(:name)}"
+      end
+
+      def summary
+        summary = super
+        summary.static = static?
+        summary.method = method?
+        summary.for = fetch(:for, nil)
+        summary
+      end
+
+      protected
+
+      def matches_exactly?(descriptor)
+        name = fetch(:name, nil)
+        is_method = method?
+
+        matches = (!is_method && super) ||
+          (is_method && instance? && descriptor.instance_member == name) ||
+          (is_method && static? && descriptor.static_member == name)
+
+        matches && self
+      end
+    end
+  end
+end

data/lib/docks/containers/mixin_container.rb

@@ -0,0 +1,19 @@
+require_relative "symbol_container.rb"
+
+module Docks
+  module Containers
+
+    # Public: a container for Mixin symbols.
+
+    class Mixin < Symbol
+
+      # Public: the type of symbols that should be encapsulated by this
+      # container. This is compared against a symbol's `symbol_type` to
+      # determine which container to use.
+      #
+      # Returns the type String.
+
+      def self.type; Docks::Types::Symbol::MIXIN end
+    end
+  end
+end