middleman-presentation-core 0.16.0.alpha

data/lib/middleman-presentation-core/component.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # A component
+    class Component
+      include Comparable
+
+      attr_reader :name, :resource_locator, :version, :importable_files, :loadable_files, :ignorable_files, :output_paths
+
+      # Create new component
+      #
+      # @param [String] resource_locator
+      #   The locator to look for the resource, e.g. http://example.org/test or latest
+      #
+      # @param [String] name (nil)
+      #   Alternative name for the resource, otherwise the base name of the resource_locator's path is used: http://example.org/test => test
+      #
+      # @param [String] github
+      #   Name of github repository, e.g. <account>/<repository>
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(
+        resource_locator: nil,
+        version: nil,
+        name: nil,
+        github: nil,
+        importable_files: [],
+        loadable_files: [],
+        ignorable_files: [],
+        output_paths: []
+      )
+
+        @name               = name
+        @resource_locator   = resource_locator
+        @version            = version
+        @github             = github
+        @loadable_files     = Array(loadable_files).map { |o| Regexp.new o }
+        @importable_files   = Array(importable_files).map { |o| Regexp.new o }
+        @ignorable_files    = Array(ignorable_files).map { |o| Regexp.new o }
+        @output_paths       = Array(output_paths)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Return path to component
+      #
+      # If root directory is set, it will be prepended to name.
+      def path
+        fail NoMethodError, :path
+      end
+
+      # Base path for component
+      #
+      # The path where the component can be found.
+      def base_path
+        fail NoMethodError, :base_path
+      end
+
+      # Configure accessor for root directory
+      def root_directory
+        fail NoMethodError, :root_directory
+      end
+
+      # Configure accessor for root directory
+      def root_directory=(*)
+        fail NoMethodError, :root_directory=
+      end
+
+      # Should middleman-presentation fetch the component
+      def fetchable?
+        false
+      end
+
+      # Return resource locator
+      #
+      # @return [String]
+      #   The resource locator
+      def resource_locator
+        @resource_locator.to_s
+      end
+
+      # @private
+      def <=>(other)
+        name.to_s <=> other.name.to_s
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/components_manager.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Component Manager
+    #
+    # It know about all frontend components. Information about all frontend
+    # components is used when building `application.js` and `application.scss`
+    # during website build and when creating the `bower.json`-file on
+    # presentation-creation.
+    #
+    # It normally gets the information about available components from
+    # `plugins`.
+    class ComponentsManager
+      private
+
+      attr_reader :bower_directory, :cache
+
+      public
+
+      def initialize(cache: Cache.new(store: Set.new))
+        @cache           = cache
+        @bower_directory = nil
+      end
+
+      # Return available frontend components
+      def available_components
+        components.to_a
+      end
+
+      def bower_directory=(value)
+        @bower_directory = value
+        cache.mark_dirty
+      end
+
+      # Return components
+      #
+      # Will used cached results until a new component is added
+      def components
+        cache.each { |c| c.root_directory = bower_directory }
+
+        cache.to_a
+      end
+
+      # Iterate over all fetchable components
+      def each_fetchable_component(&block)
+        components = self.components.select(&:fetchable?)
+
+        return components.each unless block_given?
+
+        components.each do |c|
+          block.call(c, c.equal?(components.last))
+        end
+      end
+
+      # Iterate over all fetchable components
+      def each_nonfetchable_component(&block)
+        components = self.components.select { |c| !c.fetchable? }
+
+        return components.each unless block_given?
+
+        components.each do |c|
+          block.call(c, c.equal?(components.last))
+        end
+      end
+
+      # Add component
+      def add(c)
+        unless c.respond_to? :root_directory=
+          Middleman::Presentation.logger.error Middleman::Presentation.t('errors.invalid_component', argument: c)
+          return
+        end
+
+        cache.add c
+      end
+
+      # List installed plugins
+      def to_s
+        data = components.sort.reduce([]) do |a, e|
+          a << {
+            name: e.name,
+            path: e.path,
+            base_path: e.base_path,
+            resource_locator: e.resource_locator,
+            version: e.version,
+            loadable_files: e.loadable_files,
+            importable_files: e.importable_files,
+            ignorable_files: e.ignorable_files,
+            output_paths: e.output_paths
+          }
+        end
+
+        List.new(data).to_s(fields: [:name, :path, :base_path, :resource_locator, :version, :importable_files, :loadable_files, :ignorable_files, :output_paths], vertical: true)
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/configuration_file.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Find the config.rb of middleman
+    class ConfigurationFile
+      extend Forwardable
+
+      def_delegators :@file_finder, :directory, :file
+
+      def initialize(raise_error: true)
+        @file_finder = FeduxOrgStdlib::RecursiveFileFinder.new(file_name: 'config.rb', raise_error: raise_error)
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/css_class_extracter.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Extract css classes from html files
+    class CssClassExtracter
+      # Extracted css class
+      class CssClass
+        attr_reader :name, :files
+
+        def initialize(name:, files: [])
+          @name  = name
+          @files = files.to_a
+        end
+      end
+
+      def extract(paths, ignore: [])
+        classes = build(paths)
+        classes.delete_if { |klass| ignore.include? klass }.sort_by { |klass, _| klass }.map { |klass, files| CssClass.new(name: klass, files: files) }
+      end
+
+      private
+
+      def build(paths)
+        paths.each_with_object({}) do |f, a|
+          page = Nokogiri::HTML(open(f))
+
+          page.traverse do |n|
+            if n['class']
+              klasses = n['class'].split(/ /)
+
+              klasses.each do |k|
+                a[k] ||= Set.new
+                a[k] << File.basename(f)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/custom_template.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Custom template for a new slide
+    class CustomTemplate < FeduxOrgStdlib::FileTemplate
+      def application_name
+        'middleman-presentation'
+      end
+
+      def fallback_template_directory
+        File.expand_path('../../../templates/slides', __FILE__)
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/erb_template.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Erb template for a new slide
+    class ErbTemplate < FeduxOrgStdlib::FileTemplate
+      def application_name
+        'middleman-presentation'
+      end
+
+      def fallback_template_directory
+        File.expand_path('../../../templates/slides', __FILE__)
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/errors.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # if fixture cannot be found by name
+    class FixtureNotFoundError < StandardError; end
+
+    # if plugin cannot be found by name
+    class PluginNotFoundError < StandardError; end
+  end
+end

data/lib/middleman-presentation-core/existing_slide.rb

@@ -0,0 +1,92 @@
+# encoding
+module Middleman
+  module Presentation
+    # Used for slides which already exist in file system
+    class ExistingSlide
+      include ComparableSlide
+
+      attr_reader :path
+
+      private
+
+      attr_reader :base_path
+
+      public
+
+      # Create Existin slide object
+      def initialize(path, base_path: nil)
+        @path      = Pathname.new(path)
+
+        base_path = @path.dirname if base_path.blank?
+        @base_path = Pathname.new(base_path)
+      end
+
+      # Relative path inside source directory
+      def relative_path
+        path.relative_path_from(base_path)
+      end
+
+      # Group of slide
+      def group
+        @group ||= extract_group
+      end
+
+      # Filename of slide, e.g 01.html.erb
+      def file_name
+        path.basename
+      end
+
+      # Does slide really exist in filesystem
+      def exist?
+        path.exist?
+      end
+
+      # Render slide
+      def render(&block)
+        result = []
+        result << "<!-- #{relative_path} -->"
+        result << block.call(path).to_s
+
+        result.join("\n")
+      end
+
+      # String representation of slide
+      def to_s
+        path.to_s
+      end
+
+      # Return partial path of existing slide
+      def partial_path
+        dirname, base = relative_path.split
+
+        base = base.basename('.*') until base.extname.blank?
+
+        dirname + base
+      end
+
+      # Return base name for slide
+      def base_name
+        base = relative_path.basename
+
+        base = base.basename('.*') until base.extname.blank?
+
+        base.to_s
+      end
+
+      # Return ext name for slide
+      def ext_name
+        file_name.to_s.gsub(/^([^.]+)\./, '.')
+      end
+
+      private
+
+      def extract_group
+        group  = relative_path.dirname.basename
+
+        return nil if group == relative_path.dirname
+
+        group.to_s
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/frontend_component.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # A frontend component
+    #
+    # It represents a bower component. A bower component can contain
+    # JavaScript-files, stylesheets, images, fonts, ... . A frontend component
+    # know where to get a bower component from, which version of the component
+    # is required and which JavaScript-files and stylesheets should be includes
+    # in "javascripts/application.js" and "stylesheets"application.scss".
+    class FrontendComponent < Component
+      attr_accessor :root_directory
+
+      # Create new frontend component
+      #
+      # @see [Component] For all other params
+      #
+      # @param [String] root_directory
+      #   The directory where all frontend components can be found
+      def initialize(**args)
+        super(**args)
+
+        @resource_locator = if @resource_locator =~ /\A#{URI.regexp}\z/
+                              Addressable::URI.heuristic_parse @resource_locator
+                            elsif @github
+                              Addressable::URI.heuristic_parse format('https://github.com/%s.git', @github)
+                            elsif version
+                              Class.new do
+                                attr_reader :to_s
+
+                                def initialize(value)
+                                  @to_s = value
+                                end
+                              end.new(version)
+                            else
+                              nil
+                            end
+        fail ArgumentError, Middleman::Presentation.t('errors.undefined_arguments', arguments: %w(resource_locator github version).to_list) if @resource_locator.blank?
+
+        @name = if version
+                  name
+                elsif name.blank?
+                  File.basename(@resource_locator.path)
+                else
+                  name
+                end
+
+        fail ArgumentError, Middleman::Presentation.t('errors.argument_error', argument: :name, value: @name) if @name.blank?
+
+        @root_directory = root_directory
+      end
+
+      # Return path to component
+      #
+      # If root directory is set, it will be prepended to name.
+      def path
+        args = []
+        args << root_directory if root_directory
+        args << name.to_s
+
+        Pathname.new(File.join(*args))
+      end
+
+      # Base path for component
+      def base_path
+        path.dirname
+      end
+
+      # Should middleman-presentation fetch the component
+      def fetchable?
+        true
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/group_template.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Template for a group of slides
+    class GroupTemplate < FeduxOrgStdlib::FileTemplate
+      def application_name
+        'middleman-presentation'
+      end
+
+      def fallback_template_directory
+        File.expand_path('../../../templates/slides', __FILE__)
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/helpers_manager.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Manager for helper modules
+    class HelpersManager
+      private
+
+      attr_reader :presentation_helpers
+
+      public
+
+      def initialize(_creator: PresentationHelper)
+        @presentation_helpers = []
+      end
+
+      # Add helpers
+      def add(*modules, &block)
+        presentation_helpers.concat PresentationHelper.parse(modules)
+        presentation_helpers << PresentationHelper.new(block) if block_given?
+      end
+
+      # Return available helpers
+      def available_helpers
+        presentation_helpers.reduce(Module.new) { |a, e| a.include e.to_module }
+      end
+
+      # Show helper modules
+      def to_s
+        data = presentation_helpers.sort.reduce([]) do |a, e|
+          a << { name: e.name, type: e.type, available_methods: e.available_methods.to_list }
+        end
+
+        List.new(data).to_s(fields: [:name, :type, :available_methods])
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/ignore_file.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # The ignore file uses to ignore slides
+    #
+    # @see [Transformers::IgnoreSlides]
+    class IgnoreFile
+      private
+
+      attr_reader :unignore, :ignore, :path
+
+      protected
+
+      attr_writer :unignore, :ignore
+
+      public
+
+      def initialize(path)
+        @unignore = @ignore = /^!$/
+        @path = path
+
+        parse_file(path) if File.exist? path
+      end
+
+      def ignore?(slide)
+        return false unless File.exist? path
+
+        slide.match?(ignore) && !slide.match?(unignore)
+      end
+
+      private
+
+      def parse_file(path)
+        File.readlines(path).each do |l|
+          next if l =~ /^#/
+          l = l.chomp.sub(/\s*#.*/, '')
+
+          if l =~ /^!/
+            self.unignore = Regexp.union(
+              unignore,
+              Regexp.new(
+                l.sub(/^!/, '')
+              )
+            )
+          else
+            self.ignore = Regexp.union(ignore, Regexp.new(l))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/liquid_template.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Liquid template for creating slides
+    class LiquidTemplate < FeduxOrgStdlib::FileTemplate
+      def application_name
+        'middleman-presentation'
+      end
+
+      def fallback_template_directory
+        File.expand_path('../../../templates/slides', __FILE__)
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/list.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    class List < FeduxOrgStdlib::List
+    end
+  end
+end

data/lib/middleman-presentation-core/locale_configurator.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Configuration for language on cli
+    class LocaleConfigurator
+      private
+
+      attr_reader :pattern, :detector, :detected_locale, :logger
+
+      public
+
+      def initialize(
+        path:,
+        default_locale: nil,
+        enforce_available_locales: true,
+        detector: FeduxOrgStdlib::ShellLanguageDetector.new,
+        logger: FeduxOrgStdlib::Logging::Logger.new
+      )
+        @pattern         = File.join(path, '*.yml')
+        @detector        = detector
+        @detected_locale = detect_locale(overwrite: default_locale)
+        @logger          = logger
+
+        I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+        I18n.load_path = locale_files
+        I18n.backend.load_translations
+
+        I18n.default_locale            = @detected_locale
+        I18n.available_locales         = available_locales
+        I18n.enforce_available_locales = enforce_available_locales
+      end
+
+      def use_locale(l)
+        l = l.to_sym
+
+        if l.blank?
+          logger.warn I18n.t('errors.use_empty_locale', codes: available_locales.to_list, fallback_locale: detected_locale)
+          return
+        end
+
+        unless valid_locale?(l)
+          logger.warn I18n.t('errors.use_invalid_locale', codes: available_locales.to_list, fallback_locale: detected_locale)
+          return
+        end
+
+        I18n.locale = l
+      end
+
+      def available_locales
+        locale_files.map { |f| File.basename(f, '.yml').to_sym }
+      end
+
+      def t(*args, &block)
+        I18n.t(*args, &block)
+      end
+
+      def validate_and_return_locale(l)
+        return l.to_sym if valid_locale? l
+
+        logger.warn I18n.t('errors.use_invalid_locale', codes: available_locales.to_list, fallback_locale: detected_locale)
+
+        detected_locale
+      end
+
+      private
+
+      def valid_locale?(l)
+        available_locales.include? l.to_sym
+      end
+
+      def detect_locale(overwrite:)
+        options = {}
+        options[:allowed] = available_locales
+        options[:overwrite] = overwrite.to_sym if overwrite
+
+        detector.detect(**options).language_code
+      end
+
+      def locale_files
+        @locale_files ||= Dir.glob(pattern)
+      end
+    end
+  end
+end

data/lib/middleman-presentation-core/logger.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Logger
+    class Logger < FeduxOrgStdlib::Logging::Logger
+    end
+  end
+end