middleman-presentation-core 0.16.0.alpha

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+# Main
+module Middleman
+  # Presentation extension
+  module Presentation
+    @logger                      = Logger.new
+    @config                      = ApplicationConfig.new(merge_files: true)
+    @helpers_manager             = HelpersManager.new
+    @assets_manager              = AssetsManager.new
+    @components_manager          = ComponentsManager.new
+    @plugins_manager             = PluginsManager.new(creator: Plugin)
+    @locale_configurator         = LocaleConfigurator.new(path: File.expand_path('../../../locales', __FILE__), default_locale: @config.cli_language)
+    @debug_mode                  = false
+
+    class << self
+      attr_reader :config, :logger, :plugins_manager, :components_manager, :helpers_manager, :assets_manager, :locale_configurator
+
+      private
+
+      attr_accessor :debug_mode
+
+      public
+
+      def t(*args, &block)
+        locale_configurator.t(*args, &block)
+      end
+
+      def underline_character
+        '#'
+      end
+
+      def debug_mode_enabled?
+        debug_mode == true
+      end
+
+      def enable_debug_mode
+        self.debug_mode = true
+        Middleman::Presentation.config.debugging_libraries.each { |l| require l }
+      end
+
+      def stylable_files
+        paths = []
+
+        paths << '../../../templates/slides/*.tt'
+        paths << '../../../templates/predefined_slides.d/*.tt'
+
+        paths.concat ['../../../templates/source/'].product(%w(layout.erb index.html.erb)).map(&:join)
+
+        Rake::FileList.new(
+          paths.map { |f| File.expand_path(f, __FILE__) }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Markdown template to create new slides
+    class MarkdownTemplate < 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/middleman_environment.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Abstraction for middleman environment
+    class MiddlemanEnvironment
+      private
+
+      attr_reader :strict, :application_config
+
+      public
+
+      def initialize(strict: true)
+        @strict             = strict
+        @application_config = Middleman::Presentation.config
+      end
+
+      def root_path
+        @root_path ||= ConfigurationFile.new.directory
+      rescue Errno::ENOENT
+        raise Errno::ENOENT, Middleman::Presentation.t('errors.extension_not_activated') if strict
+
+        @root_path = Dir.getwd
+      end
+
+      def build_directory
+        application_config.build_directory
+      end
+
+      def build_path
+        File.join(sources_path, application_config.build_directory)
+      end
+
+      def stylesheets_directory
+        application_config.stylesheets_directory
+      end
+
+      def stylesheets_path
+        File.join(sources_path, application_config.stylesheets_directory)
+      end
+
+      def scripts_directory
+        application_config.scripts_directory
+      end
+
+      def scripts_path
+        File.join(sources_path, application_config.scripts_directory)
+      end
+
+      def images_directory
+        application_config.images_directory
+      end
+
+      def images_path
+        File.join(sources_path, application_config.images_directory)
+      end
+
+      def fonts_directory
+        application_config.fonts_directory
+      end
+
+      def fonts_path
+        File.join(sources_path, application_config.fonts_directory)
+      end
+
+      def sources_directory
+        application_config.sources_directory
+      end
+
+      def sources_path
+        File.join(root_path, application_config.sources_directory)
+      end
+
+      def slides_directory
+        File.join(application_config.sources_directory, application_config.slides_directory)
+      end
+
+      def slides_path
+        File.join(root_path, application_config.sources_directory, application_config.slides_directory)
+      end
+
+      def bower_directory
+        application_config.bower_directory
+      end
+
+      def bower_path
+        File.join(root_path, application_config.bower_directory)
+      end
+
+      private
+
+      def configuration_file
+        @configuration_file ||= ConfigurationFile.new
+      end
+
+      def server_instance
+        @server_instance ||= proc { ::Middleman::Application.server.inst }.call
+
+        fail Thor::Error, Middleman::Presentation.t('errors.extension_not_activated') unless @server_instance.extensions.key? :presentation
+
+        @server_instance
+      end
+
+      def presentation_instance
+        @presentation_instance ||= server_instance.extensions[:presentation]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Presentation extension
+    class MiddlemanExtension < Extension
+    end
+  end
+end
+
+::Middleman::Extensions.register(:presentation) do
+  ::Middleman::Presentation::MiddlemanExtension
+end

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

@@ -0,0 +1,131 @@
+# encoding: UTF-8
+require 'rack/test'
+
+Given /^a clean server$/ do
+  @initialize_commands = []
+end
+
+Given /^"([^\"]*)" feature is "([^\"]*)"$/ do |feature, state|
+  @initialize_commands ||= []
+
+  if state == 'enabled'
+    @initialize_commands << lambda { activate(feature.to_sym) }
+  end
+end
+
+Given /^"([^\"]*)" feature is "enabled" with "([^\"]*)"$/ do |feature, options_str|
+  @initialize_commands ||= []
+
+  options = eval("{#{options_str}}")
+
+  @initialize_commands << lambda { activate(feature.to_sym, options) }
+end
+
+Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, value|
+  @initialize_commands ||= []
+  @initialize_commands << lambda { set(variable.to_sym, value) }
+end
+
+Given /^current environment is "([^\"]*)"$/ do |env|
+  @current_env = env.to_sym
+end
+
+Given /^the Server is running$/ do
+  root_dir = File.expand_path(current_dir)
+  in_current_dir do
+
+    if File.exist?(File.join(root_dir, 'source'))
+      ENV['MM_SOURCE'] = 'source'
+    else
+      ENV['MM_SOURCE'] = ''
+    end
+
+    ENV['MM_ROOT'] = root_dir
+
+    initialize_commands = @initialize_commands || []
+    initialize_commands.unshift lambda {
+      set :environment, @current_env || :development
+      set :show_exceptions, false
+    }
+
+    in_current_dir do
+      @server_inst = Middleman::Application.server.inst do
+        initialize_commands.each do |p|
+          instance_exec(&p)
+        end
+      end
+    end
+
+    app_rack = @server_inst.class.to_rack_app
+    @browser = ::Rack::Test::Session.new(::Rack::MockSession.new(app_rack))
+  end
+end
+
+Given /^the Server is running at "([^\"]*)"$/ do |app_path|
+  step %(a fixture app "#{app_path}")
+  step %(the Server is running)
+end
+
+Given /^a template named "([^\"]*)" with:$/ do |name, string|
+  step %(a file named "source/#{name}" with:), string
+end
+
+When /^I go to "([^\"]*)"$/ do |url|
+  in_current_dir do
+    @browser.get(URI.escape(url))
+  end
+end
+
+Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
+  in_current_dir do
+    expect { @browser.get(URI.escape(url)) }.to_not raise_exception
+  end
+end
+
+Then /^the content type should be "([^\"]*)"$/ do |expected|
+  in_current_dir do
+    expect(@browser.last_response.content_type).to start_with(expected)
+  end
+end
+
+Then /^I should see "([^\"]*)"$/ do |expected|
+  in_current_dir do
+    expect(@browser.last_response.body).to include(expected)
+  end
+end
+
+Then /^I should see '([^\']*)'$/ do |expected|
+  in_current_dir do
+    expect(@browser.last_response.body).to include(expected)
+  end
+end
+
+Then /^I should see:$/ do |expected|
+  in_current_dir do
+    expect(@browser.last_response.body).to include(expected)
+  end
+end
+
+Then /^I should not see "([^\"]*)"$/ do |expected|
+  in_current_dir do
+    expect(@browser.last_response.body).to_not include(expected)
+  end
+end
+
+Then /^I should not see:$/ do |expected|
+  in_current_dir do
+    expect(@browser.last_response.body).to_not include(expected.chomp)
+  end
+end
+
+Then /^the status code should be "([^\"]*)"$/ do |expected|
+  in_current_dir do
+    expect(@browser.last_response.status).to eq expected.to_i
+  end
+end
+
+Then /^I should see "([^\"]*)" lines$/ do |lines|
+  in_current_dir do
+    expect(@browser.last_response.body.chomp.split($INPUT_RECORD_SEPARATOR).length).to eq(lines.to_i)
+  end
+end

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

@@ -0,0 +1,140 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # A slide
+    class NewSlide
+      include ComparableSlide
+
+      private
+
+      attr_reader :input, :name, :base_path, :slide_directory_path
+
+      public
+
+      def initialize(input, base_path:)
+        @input                = input.split(/:/)
+        @name                 = extract_name
+        @slide_directory_path = Pathname.new(base_path)
+        @base_path            = @slide_directory_path.dirname
+      end
+
+      # Return string representation of self
+      def to_s
+        path.to_s
+      end
+
+      def path
+        p = []
+        p << Pathname.new(group) unless group.blank?
+        p << file_name
+
+        # rubocop:disable Style/EachWithObject
+        p.reduce(slide_directory_path) do |a, e|
+          # rubocop:enable Style/EachWithObject
+          a += e
+
+          a
+        end
+      end
+
+      def group
+        @group ||= extract_group
+      end
+
+      # Return basename of slide
+      def base_name
+        File.basename(name).scan(/^([^.]+)(?:\..+)?/).flatten.first
+      end
+
+      def file_name
+        path = if type? :erb
+                 Pathname.new "#{base_name}.html.erb"
+               elsif type? :md
+                 Pathname.new "#{base_name}.html.md"
+               elsif type? :liquid
+                 Pathname.new "#{base_name}.html.liquid"
+               else
+                 Pathname.new("#{base_name}.html#{template.proposed_extname}")
+               end
+
+        Pathname.new(path)
+      end
+
+      # Write slide content to file
+      def write(**data)
+        FileUtils.mkdir_p path.dirname
+
+        File.open(path, 'wb') do |f|
+          f.write(content(**data))
+        end
+      end
+
+      # Does the slide exist
+      def exist?
+        path.exist?
+      end
+
+      # Generate slide content
+      #
+      # It either uses previously set content or generates content by using a
+      # predefined template
+      def content(**data)
+        Erubis::Eruby.new(template.content).result(data)
+      end
+
+      # Relative path of slide
+      def relative_path
+        path.relative_path_from(base_path)
+      end
+
+      private
+
+      def template
+        if type? :erb
+          ErbTemplate.new(working_directory: base_path.dirname)
+        elsif type? :md
+          MarkdownTemplate.new(working_directory: base_path.dirname)
+        elsif type? :liquid
+          LiquidTemplate.new(working_directory: base_path.dirname)
+        else
+          CustomTemplate.new(working_directory: base_path.dirname)
+        end
+      end
+
+      # Check type of slide
+      def type?(t)
+        type == t
+      end
+
+      # Determine type of slide
+      def type
+        return :erb    if extname? '.erb'
+        return :md     if extname? '.md', '.markdown', '.mkd'
+        return :liquid if extname? '.l', '.liquid'
+
+        :custom
+      end
+
+      # Return file extension
+      def extname
+        File.extname(name)
+      end
+
+      # Check if slide has given extensions
+      def extname?(*extensions)
+        extensions.any? { |e| extname == e }
+      end
+
+      def extract_name
+        input.last
+      end
+
+      # Extract group from name
+      def extract_group
+        return nil if input.size < 2 # no group given
+
+        input.first.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# Fixes bug in middleman
+module Middleman
+  # Renderers
+  module Renderers
+    # Sass
+    module Sass
+      # Template
+      class SassPlusCSSFilenameTemplate < ::Tilt::SassTemplate
+        def evaluate(context, _)
+          @context ||= context
+          @engine = ::Sass::Engine.new(data, sass_options)
+
+          begin
+            @engine.render
+          rescue ::Sass::SyntaxError => e
+            ::Sass::SyntaxError.exception_to_css(e)
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Plugin Api
+    module PluginApi
+      # Require some other plugin
+      #
+      # @param [String, Array] names
+      #   The name of the plugin which should be loaded. It also supports
+      #   multiple arguments or an array of plugin names.
+      #
+      # @example String
+      #
+      #   require_plugin 'name1'
+      #
+      # @example Multiple Arguments
+      #
+      #   require_plugin 'name1', 'name2'
+      #
+      # @example Arrays
+      #
+      #   require_plugin ['name1', 'name2']
+      #
+      def require_plugin(*names)
+        application.plugins_manager.activate_plugin(names)
+      end
+
+      # Add frontend component
+      #
+      # @param [Hash] component
+      #   The component which should be added
+      def add_component(component)
+        Middleman::Presentation.components_manager.add FrontendComponent.new(**component)
+      end
+
+      # Add helpers
+      #
+      # @example Add helpers via modules
+      #
+      # add_helpers MyModule1, MyModule2
+      #
+      # @example Add helpers via code block
+      #
+      # add_helpers do
+      #   def my_helper1
+      #     'my_helper1'
+      #   end
+      # end
+      def add_helpers(*m, &block)
+        Middleman::Presentation.helpers_manager.add(*m, &block)
+      end
+
+      # Add assets which should be imported
+      #
+      # @param [String] path
+      #   Directory where assets are stored
+      # def add_assets(path, output_paths: {}, importable_files: [], loadable_files: [], ignorable_files: [])
+      def add_assets(component)
+        Middleman::Presentation.components_manager.add AssetComponent.new(**component)
+      end
+
+      module_function :add_component, :add_helpers, :add_assets
+    end
+  end
+end

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

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

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Predefined slide templates directory
+    class PredefinedSlideTemplateDirectory < FeduxOrgStdlib::TemplateDirectory
+      def application_name
+        'middleman-presentation'
+      end
+
+      def fallback_template_directory
+        File.expand_path('../../../templates', __FILE__)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Container for helper methods which can be used in presentation slides
+    class PresentationHelper
+      include Comparable
+
+      private
+
+      attr_reader :helper_container
+
+      public
+
+      def initialize(helper_container)
+        fail TypeError, Middleman::Presentation.t('errors.invalid_helper_module') if !helper_container.is_a?(Module) && !helper_container.is_a?(Proc)
+
+        @helper_container = helper_container
+      end
+
+      # Return self as module
+      def to_module
+        if helper_container.is_a? Proc
+          mod = Module.new
+          mod.module_eval(&helper_container)
+
+          mod
+        else
+          helper_container
+        end
+      end
+
+      # Return name for container
+      def name
+        if helper_container.respond_to?(:name) && !helper_container.name.blank?
+          helper_container.name
+        else
+          '<Anonymous>'
+        end
+      end
+
+      # Type of helper
+      def type
+        if helper_container.is_a? Module
+          :MODULE
+        else
+          :PROC
+        end
+      end
+
+      # Return all available methods
+      def available_methods
+        instance_methods = to_module.instance_methods - Module.methods
+        klass_methods = (to_module.methods - Module.methods).map { |m| "self.#{m}" }
+
+        instance_methods + klass_methods
+      end
+
+      # Parse an array
+      def self.parse(*modules)
+        modules.flatten.map { |m| new(m) }
+      end
+
+      # @private
+      def <=>(other)
+        name <=> other.name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+# encoding: utf-8
+::Middleman::Extensions.register(:presentation) do
+  ::Middleman::Presentation::PresentationExtension
+end

data/lib/middleman-presentation-core/roles/comparable_by_name.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Middleman
+  module Presentation
+    # Included if class can be compared by name
+    module ComparableByName
+      include Comparable
+
+      # @private
+      def hash
+        name.hash
+      end
+
+      # @private
+      def eql?(other)
+        name.eql? other.name
+      end
+
+      # @private
+      def <=>(other)
+        name <=> other.name
+      end
+    end
+  end
+end