middleman-sculptor 0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb144c55d87bf80698a9f4f5bc27c10e5c3d0849
+  data.tar.gz: 649c58c85fd0a5d5d1abb02162dd5c200b07b81e
+SHA512:
+  metadata.gz: d9b30166947a96a53dabb60084378cb7ad5f3dd74d9454cacdf38f122f0db313fec61d8529fc14693a5b7b4bb0839b85942014141aeb03d688e1984d6775f5af
+  data.tar.gz: f4bb812b679077796f884183e4113e2b1e6a5f9b29f0753aec5be3f89fa9ab9a5aa8759fbde71664b8fee5102510a886adc2cde53b1be47c8c4a74752da25320

data/.editorconfig

@@ -0,0 +1,10 @@
+# editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+.bundle
+.config
+Gemfile.lock
+pkg/
+tmp
+build/
+.sass-cache
+.DS_Store

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/middleman-sculptor

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+
+require 'middleman-sculptor'
+
+Middleman::Sculptor::Cli::Base.start

data/bin/sculpt

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+
+require 'middleman-sculptor'
+
+Middleman::Sculptor::Cli::Base.start

data/lib/middleman-sculptor.rb

@@ -0,0 +1,16 @@
+require 'middleman-core'
+require 'middleman-sculptor/hash_dot_syntax'
+require 'middleman-sculptor/cli'
+require 'middleman-sculptor/resource_patch'
+require 'middleman-sculptor/sprockets_patch'
+
+begin
+  require "middleman-sculptor/template"
+rescue LoadError
+  # v4
+end
+
+::Middleman::Extensions.register(:sculptor) do
+  require 'middleman-sculptor/extension'
+  ::Middleman::SculptorExtension
+end

data/lib/middleman-sculptor/cli.rb

@@ -0,0 +1,57 @@
+require 'middleman-core/cli'
+
+require 'middleman-sculptor/cli/version'
+require 'middleman-sculptor/cli/init'
+
+module Middleman::Sculptor::Cli
+  class Base < Thor
+    @@middleman_classes = []
+
+    def self.exit_on_failure?
+      true
+    end
+
+    def self.add_middleman_task(klass)
+      klass.namespace "sculptor_#{klass.namespace}"
+      @@middleman_classes << klass
+    end
+
+    add_middleman_task Middleman::Cli::Init
+    # add_middleman_task Middleman::Cli::Server
+
+    def help(meth=nil, subcommand=false)
+      if meth && !self.respond_to?(meth)
+        klass, task = Thor::Util.find_class_and_task_by_namespace("sculptor_#{meth}:#{meth}")
+        klass.start(['-h', task].compact, shell: shell)
+      else
+        list = []
+        sculptor_classes = Thor::Util.thor_classes_in(Middleman::Sculptor::Cli)
+        classes = @@middleman_classes + sculptor_classes
+        classes.each do |thor_class|
+          list += thor_class.printable_tasks(false)
+        end
+        list.sort! { |a, b| a[0] <=> b[0] }
+
+        shell.say 'Tasks:'
+        shell.print_table(list, indent: 2, truncate: true)
+        shell.say
+      end
+    end
+
+    # Intercept missing methods and search subtasks for them
+    # @param [Symbol] meth
+    def method_missing(meth, *args)
+      meth = meth.to_s
+      meth = self.class.map[meth] if self.class.map.key?(meth)
+
+      klass, task = Thor::Util.find_class_and_task_by_namespace("sculptor_#{meth}:#{meth}")
+
+      if klass.nil?
+        raise Thor::Error, "Command '#{meth}' not found. Try 'middleman-sculptor help' for a list of commands."
+      else
+        args.unshift(task) if task
+        klass.start(args, shell: shell)
+      end
+    end
+  end
+end

data/lib/middleman-sculptor/cli/init.rb

@@ -0,0 +1,15 @@
+require 'middleman-core/cli'
+
+module Middleman::Cli
+  class Init < Thor
+    def init(name='.')
+      key = :sculptor
+      unless ::Middleman::Templates.registered.key?(key)
+        raise Thor::Error, "Unknown project template '#{key}'"
+      end
+
+      thor_group = ::Middleman::Templates.registered[key]
+      thor_group.new([name], options).invoke_all
+    end
+  end
+end

data/lib/middleman-sculptor/cli/version.rb

@@ -0,0 +1,12 @@
+require 'middleman-sculptor/version'
+
+module Middleman::Sculptor::Cli
+  class Version < Thor
+    namespace :sculptor_version
+
+    desc 'version', 'Show version'
+    def version
+      say "Sculptor #{Middleman::Sculptor::VERSION} (Middleman #{Middleman::VERSION})"
+    end
+  end
+end

data/lib/middleman-sculptor/extension.rb

@@ -0,0 +1,13 @@
+require 'middleman-sculptor/helpers/resources'
+require 'middleman-sculptor/helpers/model'
+require 'middleman-sculptor/helpers/outliner'
+
+module Middleman
+  class SculptorExtension < Extension
+    self.defined_helpers = [
+      Middleman::Sculptor::Helpers::Resources,
+      Middleman::Sculptor::Helpers::Model,
+      Middleman::Sculptor::Helpers::Outliner
+    ]
+  end
+end

data/lib/middleman-sculptor/hash_dot_syntax.rb

@@ -0,0 +1,6 @@
+# Allow keys dot syntax
+class Hash
+  def method_missing(sym, *args)
+    fetch(sym) { fetch(sym.to_s) { super } }
+  end
+end

data/lib/middleman-sculptor/helpers/model.rb

@@ -0,0 +1,110 @@
+require 'open-uri'
+# require 'nokogiri'
+
+module Middleman::Sculptor
+  module Helpers
+    module Model
+      def model(*options, &block)
+        id = options.first.is_a?(String) && options.shift || nil
+        options = options.first || {}
+        if block_given?
+          html = capture_html(&block)
+          metadata = options
+        end
+
+        if url = options[:url]
+          # Remote URL
+          if url.start_with?('http')
+            result = grab_remote(url, options[:css], options)
+            metadata = options
+            html = result.to_html
+          # Assume local path
+          else
+            html = partial(relative_dir(current_page.path, url).to_s)
+          end
+        end
+
+        if metadata
+          options.reverse_merge!(metadata.symbolize_keys!)
+        end
+
+        options[:html] = html
+        options[:id] = id
+
+        models = {}
+        models[id] = {
+          iframe: options[:iframe] || false,
+          html: html
+        }
+
+        current_resource.add_metadata({ models: models })
+
+        partial('glyptotheque/model', locals: options)
+      end
+
+      def imodel(location=nil, options={}, &block)
+        options[:iframe] = true
+        model(location, options, &block)
+      end
+
+      def model_source(type, &block)
+        source_code = capture_html(&block)
+        partial('glyptotheque/model-source', locals: { source_type: type, source_code: source_code })
+      end
+
+      private
+
+      def grab_remote(url, css, options)
+        puts "Fetching from #{url}"
+
+        css ||= 'body'
+
+        selector_index_pair = css.split(/\s+#(\d+)$/)
+
+        if options[:pretty] == true
+          doc = Nokogiri::XML(open(url), &:noblanks)
+        else
+          doc = Nokogiri::HTML(open(url), &:noblanks)
+        end
+
+        result = doc.css(selector_index_pair[0])
+        puts "Matching CSS: `#{selector_index_pair[0]}` (found #{pluralize(result.count, 'element')})"
+
+        # Select element with specified index e.g. `.selector #1`
+        if selector_index_pair[1]
+          puts "Select index #{selector_index_pair[1].to_i} from the list"
+          result = result[selector_index_pair[1].to_i]
+        end
+
+        @root_url = "#{URI(url).scheme}://#{URI(url).host}/"
+
+        if result.class == Nokogiri::XML::NodeSet
+          result.css('[src]').map do |e|
+            e.set_attribute('src', parse_relative_url(url, e.attr('src')))
+          end
+        elsif result.class == Nokogiri::XML::Element
+          result.set_attribute('src', parse_relative_url(url, result.attr('src'))) if result.attr('src')
+        end
+
+        if !result || result.is_a?(Array) && result.empty?
+          raise "Selector `#{selector_index_pair[0]}`#{selector_index_pair[1] ? '(index: ' + selector_index_pair[1] + ')': ''} not found at remote location`#{url}`"
+        end
+
+        return result
+      end
+
+      def parse_relative_url(url, path)
+        is_root = path.match(/^\/[^\/].*/)
+        if is_root
+          path.sub(/^\/(.*)/, @root_url + $1)
+        elsif path.match(/^\.{1,2}\//)
+          relative_dir(url, path).to_s
+        elsif path.match(/^\/\//)
+          "#{URI(url).scheme}:#{path}"
+        else
+          path
+        end
+      end
+    end
+  end
+end

data/lib/middleman-sculptor/helpers/outliner.rb

@@ -0,0 +1,44 @@
+require 'open-uri'
+require 'nokogiri'
+
+module Middleman::Sculptor
+  module Helpers
+    module Outliner
+      def outline(&block)
+        html = capture_html(&block)
+        doc = Nokogiri::HTML.fragment(html, encoding='utf-8')
+
+        elements = parse_elements(doc.children)
+
+        partial('glyptotheque/model-outline', locals: { elements: elements })
+      end
+
+      private
+
+      def parse_elements(elements)
+        result = []
+
+        elements.each do |e|
+          text = e.xpath('text()').text
+
+          next unless e.element?
+
+          class_name = e.attributes['class'] && e.attributes['class'].value
+          id = e.attributes['id'] && e.attributes['id'].value
+          attributes = e.attributes.reject {|k| k == 'class' || k == 'id' }
+
+          result << {
+            el_name: e.name,
+            class_name: class_name,
+            id: id,
+            attrs: attributes.values.map { |a| { name: a.name, value: a.value } },
+            children: parse_elements(e.children),
+            text: text
+          }
+        end
+
+        return result
+      end
+    end
+  end
+end

data/lib/middleman-sculptor/helpers/resources.rb

@@ -0,0 +1,155 @@
+require 'rest-client'
+require 'oj'
+
+module Middleman::Sculptor
+  module Helpers
+    module Resources
+      def include_javascripts(javascripts)
+        include_assets(:javascript_include_tag, javascripts)
+      end
+
+      def include_stylesheets(stylesheets)
+        include_assets(:stylesheet_link_tag, stylesheets)
+      end
+
+      def resource_file(resource)
+        resource.path.split('/').last.gsub(resource.ext, '')
+      end
+
+      def resource_dir(resource)
+        resource.url.split('/').last
+      end
+
+      def resources_for(dir, ext: 'html', exclude_indexes: false, sort_by: nil, ignore: nil, allow_hidden: false)
+        filtered = sitemap.resources
+          .reject  {|r| r.url == dir}                      # Exclude main directory index
+          .select  {|r| r.url.start_with?(dir)}            # Select files in the given dir
+
+        collect_resources(filtered,
+          { ext: ext, exclude_indexes: exclude_indexes, sort_by: sort_by, ignore: ignore, allow_hidden: allow_hidden}
+        )
+      end
+
+      def resource_tree(dir, ext: 'html', data_fields: [:title], exclude_indexes: false, sort_by: nil, ignore: nil)
+        resources_for(dir, ext: ext, exclude_indexes: exclude_indexes, sort_by: sort_by, ignore: ignore)
+          .map { |r| parse_resource(r, {
+              ext: ext,
+              data_fields: data_fields,
+              exclude_indexes: exclude_indexes,
+              sort_by: sort_by,
+              ignore: ignore
+            })
+          }
+          .reject { |r| r[:parent] != '/' }  # Remove non-root directories from the root
+      end
+
+      def local_data(path)
+        current_path =  current_resource.path
+        if current_resource.metadata.page.has_key? :local_url
+          current_path = current_resource.metadata.page.local_url
+        end
+        result = sitemap.find_resource_by_path(relative_dir(current_path, path).to_s)
+        raise "#{path} not found" unless result
+
+        case result.ext
+        when '.yaml', '.yml'
+          result = YAML.load(result.render)
+        when '.json'
+          result = Oj.load(result.render)
+        end
+
+        result
+      end
+
+      # Use in layouts, in templates either Frontmatter or this method can be used
+      def append_class(block_name, appended_classes='')
+        current_page_classes = current_page.data[block_name] || ''
+        existing_classes_a = current_page_classes.split(' ')
+        appended_classes_a = appended_classes.split(' ')
+        classes = existing_classes_a.concat(appended_classes_a).reverse.join(' ')
+        content_for(block_name, classes)
+      end
+
+      def get(url, options = {})
+        begin
+          result = RestClient.get(url, options)
+        rescue => e
+          raise "GET - #{e.message}: '#{url}'"
+        end
+
+        Oj.load(result)
+      end
+
+      def post(url, params = {}, headers = {})
+        begin
+          result = RestClient.post(url, params, headers)
+        rescue => e
+          raise "POST - #{e.message}: '#{url}'"
+        end
+
+        Oj.load(result)
+      end
+
+      private
+
+      def collect_resources(resources, options)
+        resources
+          .select  {|r| r.ext == ".#{options[:ext]}"}      # Select only files with specified extension
+          .sort_by {|r| r.url }                            # Sort by url (default)
+          .sort_by {|r| r.data[options[:sort_by]] || -1}   # Sort by `sort_by` param
+          .reject  {|r|                                    # Reject hidden (Front matter)
+            r.data.hidden unless options[:allow_hidden]
+          }
+          .reject  {|r|                                    # Exclude all directory indexes
+            options[:exclude_indexes] ? r.directory_index? : false
+          }
+          .reject  {|r| ignore ? r.url.match(options[:ignore]) : false }  # Ignore URLs matching pattern (if provided)
+          .reject  {|r| r.path.end_with? ("-isolated#{r.ext}")}         # Ignore proxied '-isolated' mode pages
+          .reject  {|r| r.path.start_with? ("glyptotheque/")}             # Ignore Sculptor’s partials
+      end
+
+      def parse_resource(r, options)
+        data = {}
+        data[:path] = url_for("/#{r.path}")
+        data[:url] = r.url
+
+        # Add parent to top-level pages (not containing `/` in path)
+        if /^((?!\/).)*$/.match r.path
+          data[:parent] = '/'
+        end
+
+        if r.children.any?
+          data[:children] = collect_resources(r.children, options).map { |c| parse_resource(c, options) }
+          if r.parent
+            data[:parent] = r.parent.url
+          end
+        end
+
+
+        options[:data_fields].each do |field|
+          data[field] = r.data[field]
+          if field == :title && !r.data.title
+            data[field] = resource_dir(r)
+          end
+        end
+        data
+      end
+
+      def include_assets(asset_tag, assets)
+        return unless assets
+        assets = assets.split(/,\s*/) if assets.is_a? String
+        resource_path = current_page.metadata && current_page.metadata.page[:local_url] || current_page.path
+        Array(assets).map { |a|
+          path = a.start_with?('http') ? a : relative_dir(resource_path, a)
+          "\n" + method(asset_tag).call(path)
+        }.join
+      end
+
+      # Constructs path relative to base path (first argument)
+      def relative_dir(path, *args)
+        relative_path = args ? args.join('/') : ''
+        Pathname(path).dirname.join(relative_path)
+      end
+    end
+  end
+end