docks_app 0.0.1

data/lib/docks/containers/pattern_container.rb

@@ -0,0 +1,168 @@
+require_relative "base_container.rb"
+
+module Docks
+  module Containers
+    class Pattern < Base
+      extend Forwardable
+
+      def self.type; Types::Symbol::PATTERN end
+
+      SYMBOL_SOURCES = [
+        Types::Languages::STYLE,
+        Types::Languages::SCRIPT
+      ]
+
+      attr_accessor :modified, :files, :name
+      def_delegators :@symbols, :to_s, :inspect, :to_json
+
+      def initialize(pattern_details = {})
+        super
+        @name = @details.delete(:name)
+        @symbols = {}
+        @files = []
+
+        SYMBOL_SOURCES.each do |source|
+          @symbols[source] = []
+        end
+      end
+
+      def add(source, symbols)
+        symbols = [symbols].flatten
+        symbols.each do |symbol|
+          symbol.belongs_to = self
+        end
+
+        pattern_symbol, regular_symbols = symbols.partition { |symbol| !symbol.pattern.nil? }
+
+        unless pattern_symbol.empty?
+          pattern_symbol = pattern_symbol.first
+          pattern_symbol[Tags::Title.instance.name] ||= pattern_symbol.delete(Tags::Pattern.instance.name)
+          @details.merge!(pattern_symbol.to_h)
+        end
+
+        @symbols[source].concat(regular_symbols)
+      end
+
+      def remove(remove_symbol)
+        SYMBOL_SOURCES.each do |symbol_source|
+          @symbols[symbol_source].delete_if { |symbol| symbol == remove_symbol }
+        end
+      end
+
+      def valid?
+        !@details.values.compact.empty? || SYMBOL_SOURCES.any? { |source| !@symbols[source].empty? }
+      end
+
+      def ==(other_pattern)
+        self.class == other_pattern.class && @symbols == other_pattern.instance_variable_get(:@symbols)
+      end
+
+      def title
+        fetch(Tags::Title.instance.name, name.capitalize)
+      end
+
+      def group
+        fetch(Tags::Group.instance.name, Types::Symbol::COMPONENT.capitalize)
+      end
+
+      def structure_symbols
+        @symbols[Types::Languages::STYLE]
+      end
+
+      alias_method :style_symbols, :structure_symbols
+
+      def has_structure?
+        structure_symbols.length > 0
+      end
+
+      def behavior_symbols
+        @symbols[Types::Languages::SCRIPT]
+      end
+
+      alias_method :script_symbols, :behavior_symbols
+
+      def has_behavior?
+        behavior_symbols.length > 0
+      end
+
+      Containers::TOP_LEVEL_SYMBOLS.each do |symbol|
+        define_method(symbol.pluralize.to_sym) do |options = {}|
+          symbols_of_type(symbol, options)
+        end
+      end
+
+      def symbols
+        @symbols.values.flatten
+      end
+
+      def find(descriptor)
+        super || find_in_symbols(descriptor)
+      end
+
+      def demos
+        return @demos unless @demos.nil?
+
+        @demos = []
+        components.each do |component|
+          @demos << Demo.new(component) if component.has_demo?
+
+          component.variations.each do |variation|
+            @demos << Demo.new(variation) if variation.demo_type == Types::Demo::OWN
+          end
+        end
+
+        @demos
+      end
+
+      alias_method :demo, :demos
+
+      def summary
+        return self if summarized?
+
+        summary = super
+        summary.group = group
+        summary.title = title
+        summary.instance_variable_set(:@symbols, Hash[@symbols.map { |type, symbols| [type, symbols.map(&:summary)] }])
+        summary
+      end
+
+      def symbols_of_type(type, options = {})
+        type = type.to_s
+        included = options[:include].nil? ? SYMBOL_SOURCES : [options[:include]].flatten
+        excluded = options[:exclude].nil? ? [] : Array(options[:exclude])
+
+        SYMBOL_SOURCES.inject([]) do |matches, source|
+          if included.include?(source) && !excluded.include?(source)
+            new_results = @symbols[source].select do |symbol|
+              symbol.symbol_type.to_s == type
+            end
+
+            matches.concat(new_results)
+          end
+
+          matches
+        end
+      end
+
+      protected
+
+      def matches_exactly?(descriptor)
+        descriptor.symbol.nil? && descriptor.pattern == name
+      end
+
+      def find_in_symbols(descriptor)
+        descriptor = Descriptor.new(descriptor)
+        find_result = false
+
+        SYMBOL_SOURCES.each do |source|
+          @symbols[source].each do |symbol|
+            find_result = symbol.find(descriptor)
+            break if find_result
+          end
+        end
+
+        find_result
+      end
+    end
+  end
+end

data/lib/docks/containers/pattern_library_container.rb

@@ -0,0 +1,77 @@
+module Docks
+  module Containers
+    class PatternLibrary
+      attr_reader :patterns
+
+      def initialize
+        @patterns = {}
+        @summary = false
+      end
+
+      def <<(pattern)
+        @patterns[pattern.name.to_s] ||= pattern
+      end
+
+      def [](pattern_name)
+        @patterns[Docks.pattern_id(pattern_name)]
+      end
+
+      def has_pattern?(pattern_name)
+        !self[pattern_name].nil?
+      end
+
+      def to_json; @patterns.to_json end
+
+      def group_by(grouper, &block)
+        grouped_patterns = {}
+        grouper = grouper.to_sym
+
+        @patterns.each do |name, pattern|
+          grouper_value = pattern.send(grouper)
+          next if grouper_value.nil?
+          grouped_patterns[grouper_value] ||= []
+          grouped_patterns[grouper_value] << pattern
+        end
+
+        if block_given?
+          grouped_patterns.each(&block)
+        else
+          grouped_patterns
+        end
+      end
+
+      def groups(&block)
+        group_by(:group, &block)
+      end
+
+      def find(descriptor)
+        descriptor = Descriptor.new(descriptor, assume: :pattern)
+        pattern = @patterns[descriptor.pattern]
+        return false if pattern.nil?
+
+        symbol = pattern.find(descriptor)
+        symbol = nil if !symbol || symbol == pattern
+        ::OpenStruct.new(pattern: pattern, symbol: symbol)
+      end
+
+      def summarized?; @summary end
+      alias_method :summary?, :summarized?
+
+      def summary
+        return self if summarized?
+
+        summary = self.class.new
+        summary.instance_variable_set(:@summary, true)
+        summary.instance_variable_set(:@patterns, Hash[@patterns.map { |name, pattern| [name, pattern.summary] }])
+        summary
+      end
+      alias_method :summarize, :summary
+
+      def summary!
+        @summary = true
+        @patterns = Hash[@patterns.map { |name, pattern| [name, pattern.summary] }]
+      end
+      alias_method :summarize!, :summary!
+    end
+  end
+end

data/lib/docks/containers/state_container.rb

@@ -0,0 +1,9 @@
+require_relative "variation_container.rb"
+
+module Docks
+  module Containers
+    class State < Variation
+      def self.type; Docks::Types::Symbol::STATE end
+    end
+  end
+end

data/lib/docks/containers/symbol_container.rb

@@ -0,0 +1,77 @@
+require_relative "base_container.rb"
+
+module Docks
+  module Containers
+    class Symbol < Base
+      attr_accessor :belongs_to, :properties, :methods
+
+      def self.type; "symbol" end
+
+      def self.from_symbol(symbol)
+        return if self == symbol.class
+        new(symbol.to_h)
+      end
+
+      def initialize(symbol_hash = {})
+        super
+        self[:symbol_type] = self.class.type
+        @properties = []
+        @methods = []
+      end
+
+      def private?; fetch(:access, nil) == Docks::Types::Access::PRIVATE end
+      def public?; !private? end
+
+      def member?
+        self[:property] == true || self[:method] == true
+      end
+
+      def members; @methods + @properties end
+
+      def has_members?; !members.empty? end
+
+      def add_member(symbol)
+        symbol.for = fetch(:name)
+        symbol.belongs_to = self
+        symbol.static = true
+
+        if symbol.kind_of?(Variable)
+          symbol.property = true
+          @properties << symbol
+        else
+          symbol.method = true
+          @methods << symbol
+        end
+      end
+
+      def add_members(*symbols)
+        symbols.each { |symbol| add_member(symbol) }
+      end
+
+      def find(descriptor)
+        descriptor = Descriptor.new(descriptor)
+        return self if matches_exactly?(descriptor)
+
+        members.find { |member| member.find(descriptor) } || false
+      end
+
+      def symbol_id
+        "#{fetch(:symbol_type)}-#{fetch(:name)}"
+      end
+
+      def to_descriptor
+        descriptor = ""
+        descriptor << "#{belongs_to.name}::" unless belongs_to.nil?
+        descriptor << fetch(:name)
+        descriptor
+      end
+
+      def summary
+        summary = super
+        summary.properties = @properties.map(&:summary)
+        summary.methods = @methods.map(&:summary)
+        summary
+      end
+    end
+  end
+end

data/lib/docks/containers/variable_container.rb

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

data/lib/docks/containers/variant_container.rb

@@ -0,0 +1,9 @@
+require_relative "variation_container.rb"
+
+module Docks
+  module Containers
+    class Variant < Variation
+      def self.type; Docks::Types::Symbol::VARIANT end
+    end
+  end
+end

data/lib/docks/containers/variation_container.rb

@@ -0,0 +1,38 @@
+require_relative "symbol_container.rb"
+
+module Docks
+  module Containers
+    class Variation < Symbol
+      def self.type; "variation" end
+
+      def initialize(variation_hash = {})
+        super
+        set_defaults
+      end
+
+      def has_demo?
+        [Types::Demo::OWN, Types::Demo::JOINT].include?(demo_type)
+      end
+
+      protected
+
+      def matches_exactly?(descriptor)
+        super || (descriptor.member? && descriptor.member == fetch(:name) && descriptor.symbol == fetch(:for, nil))
+      end
+
+      def set_defaults
+        self[:active] = false if self[:active].nil?
+        self[:demo_type] ||= Types::Demo::SELECT
+
+        [:activate_with, :preclude, :set_by, :include_with].each do |defaults_to_array|
+          value = self[defaults_to_array]
+          self[defaults_to_array] = case value
+            when NilClass then []
+            when Array then value
+            else [value]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docks/containers.rb

@@ -0,0 +1,25 @@
+module Docks
+  module Containers
+    TOP_LEVEL_SYMBOLS = [
+      Types::Symbol::COMPONENT,
+      Types::Symbol::CLASS,
+      Types::Symbol::FACTORY,
+      Types::Symbol::FUNCTION,
+      Types::Symbol::MIXIN,
+      Types::Symbol::VARIABLE
+    ]
+
+    @@container_associations = Hash.new
+
+    def self.container_for(type = nil)
+      if @@container_associations.empty?
+        constants.each do |const|
+          klass = const_get(const)
+          @@container_associations[klass.type.to_sym] = klass if klass.respond_to?(:type)
+        end
+      end
+
+      type.nil? ? Symbol : @@container_associations.fetch(type.to_sym, Symbol)
+    end
+  end
+end

data/lib/docks/descriptor.rb

@@ -0,0 +1,60 @@
+module Docks
+  class Descriptor
+    PATTERN = /^([^:]*)::/
+    INSTANCE_MEMBER = /#(.*)/
+    STATIC_MEMBER = /\.(.*)/
+    LOCAL_MEMBER = /~(.*)/
+    MEMBERS = [:instance_member, :static_member, :local_member]
+
+    attr_reader :pattern, :symbol
+    attr_reader *MEMBERS
+
+    def self.new(descriptor_string, options = {})
+      descriptor_string.kind_of?(self) ? descriptor_string : super
+    end
+
+    def initialize(descriptor_string, options)
+      parse(descriptor_string, options)
+    end
+
+    def member?
+      MEMBERS.any? { |member_type| !self.send(member_type).nil? }
+    end
+
+    def member
+      MEMBERS.each do |member_type|
+        member = self.send(member_type)
+        return member unless member.nil?
+      end
+
+      nil
+    end
+
+    private
+
+    def parse(string, options)
+      string = string.sub(PATTERN) do
+        @pattern = Docks.pattern_id($1)
+        ""
+      end
+
+      string = string.sub(INSTANCE_MEMBER) do
+        @instance_member = $1
+        ""
+      end
+
+      string = string.sub(STATIC_MEMBER) do
+        @static_member = $1
+        ""
+      end
+
+      string = string.sub(LOCAL_MEMBER) do
+        @local_member = $1
+        ""
+      end
+
+      @symbol = string
+      @pattern, @symbol = @symbol, nil if options[:assume] == :pattern && @pattern.nil?
+    end
+  end
+end

data/lib/docks/errors.rb

@@ -0,0 +1,5 @@
+module Docks
+  class NoPatternError < StandardError; end
+  class NoTemplateError < StandardError; end
+  class NoAssetError < StandardError; end
+end

data/lib/docks/group.rb

@@ -0,0 +1,66 @@
+module Docks
+  @pattern_id = lambda do |filename|
+    File.basename(filename).split('.').first.split(/(\-\-|__)/).first.sub(/^_+/, '').gsub(/(\s|\-|_)+/, '_')
+  end
+
+  def self.pattern_id(filename = nil, &block)
+    return nil unless filename.kind_of?(String)
+    @pattern_id.call(filename)
+  end
+
+  def self.pattern_id=(block)
+    return if block.call("foo").nil?
+    @pattern_id = block
+  end
+
+  class Grouper
+    def self.group(globs)
+      files = file_list_from_globs(globs)
+      groups = {}
+      return groups if files.empty?
+
+      # Cycle through all files identified by the glob, then assign them to
+      # the group matching their group ID.
+      files.each do |filename|
+        if should_include_file?(filename)
+          identifier = Docks.pattern_id(filename)
+          groups[identifier] ||= []
+          groups[identifier] << filename
+        end
+      end
+
+      groups
+    end
+
+    def self.source_files_of_type(type)
+      return @source_files_by_type[type] unless @source_files_by_type.nil?
+
+      files = {}
+      files[Docks::Types::Languages::MARKUP] = []
+      files[Docks::Types::Languages::STYLE] = []
+      files[Docks::Types::Languages::SCRIPT] = []
+      files[Docks::Types::Languages::STUB] = []
+      files[Docks::Types::Languages::DESCRIPTION] = []
+
+      file_list_from_globs(Docks.config.sources).each do |filename|
+        files[Docks::Languages.file_type(filename)] << filename
+      end
+
+      @source_files_by_type = files
+      @source_files_by_type[type]
+    end
+
+
+
+    private
+
+    def self.should_include_file?(filename)
+      Docks::Languages.extensions.include?(File.extname(filename)[1..-1]) &&
+        !filename.include?('.min.')
+    end
+
+    def self.file_list_from_globs(globs)
+      Array(globs).map { |glob| Dir.glob(glob) }.flatten
+    end
+  end
+end

data/lib/docks/helpers/github_helper.rb

@@ -0,0 +1,29 @@
+module Docks
+  module Helpers
+    module Github
+      def has_github?
+        !(Docks.config.github_repo.nil? || Docks.config.github_repo.empty? || @pattern.files.empty?)
+      end
+
+      def github_url(file)
+        "#{github_root_url}/blob/master/#{url_encode(file).gsub("%2F", "/").sub(/^\//, "")}"
+      end
+
+      def github_issue_message
+        root = Docks.config.root.to_s
+        files = @pattern.files.map { |file| file.sub(root, "") }
+
+        file_checklist = relative_pattern_files.map { |file| "- [#{@pattern.files.length == 1 ? "x" : " "}] [#{file}](#{github_url(file)})" }.join("\n")
+        "\n\n\n---\n\nThis issue is related to the following files:\n\n#{file_checklist}"
+      end
+
+      def relative_pattern_files
+        @relative_pattern_files ||= @pattern.files.map { |file| file.sub(Docks.config.root.to_s, "") }
+      end
+
+      def github_root_url
+        @github_root_url ||= Docks.config.github_repo.sub(/(.)\/?$/, '\1')
+      end
+    end
+  end
+end