styledown2 2.0.0.pre5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4eaad569e5408829bb0289e13088fe4638a65d8a
+  data.tar.gz: d3c45314499459d4667aa06f911b4a2cf815977d
+SHA512:
+  metadata.gz: dbd4d66a476871d50a819bc7e2e942575f1fb04310595ec9f72de7d634f9964a4e6d22ce99b5a89838771f3a114fcac6e72be81be7ba557fb0ae9348274999ac
+  data.tar.gz: 74a62fe9d0020462a1f948923fecd32a417987b3558584611db43f12aaa6b7bf55055f6c2291dab6a7237f3a2a3f92724c3914027397278151f27034b07007e3

data/.gitignore

@@ -0,0 +1,2 @@
+/Gemfile.lock
+/pkg

data/Gemfile

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

data/README.md

@@ -0,0 +1,57 @@
+# Styledown for Ruby
+
+> Write maintainable CSS styleguides using Markdown
+
+Ruby implementation for [Styledown2](https://github.com/styledown/styledown2).
+
+## Install
+
+```
+gem 'styledown2'
+```
+
+## API
+
+See [API reference](docs/api.md) for full API reference.
+
+### Object-oriented API
+
+This gem provides a `Styledown` class.
+
+```rb
+styleguide = Styledown.new('/path/to/styleguides')
+styleguide.render  # Updates #output
+
+styleguide.output
+# => {
+#   'buttons.html' => { 'contents' => '...' },
+#   'forms.html' => { 'contents' => '...' },
+#   'styledown/script.js' => { 'contents' => '...' }
+# }
+```
+
+See [API reference](docs/api.md#styledown) for full reference on the `Styledown` class.
+
+### Functional API
+
+This implements the same functional API as the JavaScript `styledown2`.
+
+```rb
+files  = Styledown.read(...)
+data   = Styledown.parse(files)
+output = Styledown.render(data)
+```
+
+See [API reference](docs/api.md#class-methods) for full reference on `Styledown` class methods.
+
+## Thanks
+
+**styledown2-ruby** © 2017+, Rico Sta. Cruz. Released under the [MIT] License.<br>
+Authored and maintained by Rico Sta. Cruz with help from contributors ([list][contributors]).
+
+> [ricostacruz.com](http://ricostacruz.com) &nbsp;&middot;&nbsp;
+> GitHub [@rstacruz](https://github.com/rstacruz) &nbsp;&middot;&nbsp;
+> Twitter [@rstacruz](https://twitter.com/rstacruz)
+
+[MIT]: http://mit-license.org/
+[contributors]: http://github.com/styledown/styledown2-ruby/contributors

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+task default: :test
+
+Bundler::GemHelper.install_tasks
+
+desc 'Runs tests'
+task :test do
+  $:.unshift(File.expand_path(__FILE__, '../lib'))
+  Dir['test/**/*test.rb'].each { |fn| require_relative fn }
+end

data/docs/api.md

@@ -0,0 +1,144 @@
+# API
+
+## Styledown
+
+> `styleguide = Styledown.new(path, [options])`
+
+Styledown class.
+
+```rb
+styleguide = Styledown.new('/path/to/guides')
+styleguide.render
+
+styleguide.output
+# => {
+#   'buttons.html' => { 'contents' => '...' },
+#   'forms.html' => { 'contents' => '...' }
+# }
+```
+
+### render
+
+> `styleguide.render`
+
+Processes files and updates [#output](#output). Styledown keeps a cache, so this will not re-read or re-process if no files have changed. See [Styledown class](#styledown) for an example.
+
+### fast_render
+
+> `styleguide.fast_render`
+
+Like [#render](#render), but skips checking if any files have been updated. Use this in production.
+
+### render!
+
+> `styleguide.render!`
+
+Forces a [#render](#render) regardless of whether files have changed or not.
+
+### output
+
+> `styleguide.output`
+
+The final transformed files. This is a Hash. See [Styledown class](#styledown) for an example.
+
+### add\_data\_filter
+
+> `styleguide.add_data_filter { |data| ... }`
+
+Adds a function to be invoked on [#render](#render) that will transform Styledown raw data. The given block should return a new `data`, or the same one if it was mutated.
+
+### add\_file\_filter
+
+> `styleguide.add_file_filter { |filename, file| ... }`
+
+Adds a function to be invoked on [#render](#render) that will transform Styledown `file` data. The given block should return a `[filename, file]` tuple.
+
+```rb
+styleguide = Styledown.new('/path/to/guides')
+
+styleguide.add_file_filter do |filename, file|
+  filename = filename.gsub(/\.html$/, '.htm')
+  [filename, file]
+end
+
+styleguide.render
+```
+
+### add\_section\_filter
+
+> `styleguide.add_section_filter { |section| ... }`
+
+Adds a function to be invoked on [#render](#render) that will transform Styledown `section` data. The given block should return a new `section`, or the same one if it was mutated.
+
+```rb
+styleguide = Styledown.new('/path/to/guides')
+
+styleguide.add_section_filter do |section|
+  # Prefix id's for whatever reason
+  section['id'] = "sg-#{section['id']}"
+  section
+end
+
+styleguide.render
+```
+
+### add\_part\_filter
+
+> `styleguide.add_part_filter { |part| ... }`
+
+Adds a function to be invoked on [#render](#render) that will transform Styledown `part` data. The given block should return a new `part`, or the same one if it was mutated.
+
+```rb
+styleguide = Styledown.new('/path/to/guides')
+
+styleguide.add_part_filter do |part|
+  part['class'] += ' my-class'
+  part
+end
+
+styleguide.render
+```
+
+### add\_figure\_filter
+
+> `styleguide.add_figure_filter(language) { |content| ... }`
+
+Adds a function to be invoked on [#render](#render) for transpiling example figures. The given block should return `[language, content]` where `language` is the new language it was transformed to, and `content` is the transformed result.
+
+```rb
+styleguide = Styledown.new('/path/to/guides')
+
+styleguide.add_figure_filter('erb') do |contetns|
+  [ 'html', ERB.render(contents) ]
+end
+
+styleguide.render
+```
+
+### invalidate
+
+Invalidates the cache so that the next [#render](#render) will always run.
+
+### invalidate_data
+
+Partially invalidates the cache so that the next [#render](#render) will always run the build step. It will not re-run the read step, however.
+
+## Class functions
+
+### Styledown.read
+
+> `Styledown.read(path, [options])`
+
+Reads files in `path` and returns their contents in a Hash, ready to be processed by [styledown.build](#styledown-build). This mirrors the `styledown.read()` implementation in JavaScript.
+
+### Styledown.build
+
+> `Styledown.build(files, [options])`
+
+Processes `files` (as returned by [styledown.read](#styledown-read) and returns data to be rendered. This mirrors the `styledown.build()` implementation in JavaScript.
+
+### Styledown.render
+
+> `Styledown.render(data, [options])`
+
+Processes `data` (as returned by [styledown.build](#styledown-build) and returns output files. This mirrors the `styledown.render()` implementation in JavaScript.

data/lib/styledown/class_methods.rb

@@ -0,0 +1,26 @@
+class Styledown
+  # Functional API for Styledown that interfaces via ExecJS. This is the
+  # low-level API that the OOP API uses.
+  module ClassMethods
+    def context
+      @context ||= begin
+        require 'execjs'
+        ExecJS.compile(Styledown::Source::SOURCE)
+      end
+    end
+
+    def build(source, options = {})
+      context.call('Styledown.build', source, options)
+    end
+
+    def render(data, options = {})
+      context.call('Styledown.render', data, options)
+    end
+
+    # Reimplementation of Styledown.read(). Reads files and returns their
+    # contents into a Hash.
+    def read(paths, options = {})
+      FileReader.read(paths, options)
+    end
+  end
+end

data/lib/styledown/file_reader.rb

@@ -0,0 +1,42 @@
+class Styledown
+  module FileReader
+    SEARCH_GLOB = '{styledown.json,**/*.md,templates/**/*.{html,js,css}}'
+
+    def self.read(paths, options = {})
+      glob(paths).inject({}) do |result, (file, short_file)|
+        result[short_file] = { 'contents' => File.read(file) }
+        result
+      end
+    end
+
+    def self.mtime(paths)
+      glob(paths).inject(0) do |mtime, (file, _)|
+        new_mtime = File.mtime(file).to_i
+        new_mtime > mtime ? new_mtime : mtime
+      end
+    end
+
+    # Returns a list of files in a `path`. Each item is a tuple of `[full_path,
+    # short_path]`.
+    #
+    #     glob('/path/to/foo')
+    #     => [
+    #       [ '/path/to/foo/bar.txt', 'bar.txt' ],
+    #       [ '/path/to/foo/baz.txt', 'baz.txt' ]
+    #     ]
+    #
+    def self.glob(paths)
+      [*paths].inject([]) do |result, path|
+        abspath = File.absolute_path(path)
+        glob = File.join(abspath, SEARCH_GLOB)
+
+        result + Dir[glob].map do |file|
+          short_file = file[(abspath.length + File::SEPARATOR.length)..-1]
+            .gsub(/#{File::SEPARATOR}/, '/')
+
+          [file, short_file]
+        end
+      end
+    end
+  end
+end

data/lib/styledown/version.rb

@@ -0,0 +1,3 @@
+class Styledown
+  VERSION = '2.0.0.pre5'
+end

data/lib/styledown.rb

@@ -0,0 +1,146 @@
+require 'styledown/class_methods'
+require 'styledown/source'
+require 'styledown/file_reader'
+
+class Styledown
+  extend Styledown::ClassMethods
+
+  # You can change these and they will be honored on next #render
+  attr_reader :paths
+  attr_reader :options
+
+  # Pipeline artifacts
+  attr_reader :mtime     # Last modified time
+  attr_reader :input     # Output of Styledown.read
+  attr_reader :raw_data  # Output of Styledown.build
+  attr_reader :data      # Output of apply_data_filters
+  attr_reader :output    # Output of Styledown.render (final output)
+
+  # Returns a styleguide context.
+  def initialize(paths = nil, options = {})
+    @paths = paths
+    @options = options
+
+    @data_filters = []
+  end
+
+  def paths=(paths)
+    invalidate
+    @paths = paths
+  end
+
+  def options=(options)
+    invalidate
+    @options = options
+  end
+
+  # Reads files, processes them, and updates the `#output`.
+  def render
+    invalidate_if_updated
+    fast_render
+  end
+
+  # Renders without invalidation.
+  def fast_render
+    @input ||= Styledown.read(@paths, @options)
+    @raw_data ||= Styledown.build(@input, @options)
+    @data ||= apply_data_filters(@raw_data)
+    @output ||= Styledown.render(@data, @options)
+    self
+  end
+
+  # Like `#render`, but always re-runs.
+  # Also aliased as `#reload`.
+  def render!
+    invalidate
+    render
+  end
+
+  # Busts the cache
+  def invalidate
+    @mtime = nil
+    @input = nil
+    @raw_data = nil
+    invalidate_data
+  end
+
+  # Busts the cache, partially
+  def invalidate_data
+    @data = nil
+    @output = nil
+  end
+
+  def valid?
+    !!@output
+  end
+
+  def add_data_filter(&blk)
+    invalidate_data
+    @data_filters << blk
+  end
+
+  # Adds a function that will transform files on `#render`.
+  # The given block should return `[filename, file]`.
+  def add_file_filter(&blk)
+    add_data_filter do |data|
+      files = data['files'].map do |filename, file|
+        blk.(filename, file) # => [filename, file]
+      end
+      data['files'] = Hash[files]
+      data
+    end
+  end
+
+  # Adds a function that will transform sections on `#render`.
+  def add_section_filter(&blk)
+    add_file_filter do |filename, file|
+      file['sections'].map! do |section|
+        blk.(section, filename, file)
+      end if file['sections']
+      [filename, file]
+    end
+  end
+
+  # Adds a function that will transform section parts on `#render`.
+  def add_part_filter(&blk)
+    add_section_filter do |section, filename, file|
+      section['parts'].map! do |part|
+        res = blk.(part, section, filename, file)
+        res
+      end if section['parts']
+      section
+    end
+  end
+
+  # Adds a function that will transform section part figures on `#render`.
+  def add_figure_filter(lang, &blk)
+    add_part_filter do |part, section, filename, file|
+      if part['isExample'] && [*lang].map(&:to_s).include?(part['language'])
+        new_lang, new_content = blk.(part['content'])
+        part['content'] = new_content
+        part['language'] = new_lang
+        part
+      else
+        part
+      end
+    end
+  end
+
+  private
+
+  # Checks if it's been update since last call of `#if_updated`.
+  def invalidate_if_updated
+    mtime = Styledown::FileReader.mtime(@paths)
+    if mtime != @mtime
+      invalidate
+      @mtime = mtime
+    end
+  end
+
+  # Applies data filters defined by `add_*_filter` functions.
+  def apply_data_filters(data)
+    @data_filters.reduce(data) do |data_, filter|
+      filter.(data_)
+    end
+  end
+end

data/lib/styledown2.rb

@@ -0,0 +1 @@
+require 'styledown'

data/styledown2.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+require File.expand_path('../lib/styledown/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'styledown2'
+  spec.version       = Styledown::VERSION
+  spec.authors       = ['Rico Sta. Cruz']
+  spec.email         = ['rstacruz@users.noreply.github.com']
+
+  spec.summary       = 'Write maintainable CSS styleguides using Markdown'
+  spec.description   = 'Styledown lets you write maintainable CSS styleguides using Markdown.'
+  spec.homepage      = 'https://github.com/styledown/styledown2'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'styledown2-source', "= #{Styledown::VERSION}"
+  spec.add_dependency 'execjs', '< 3.0.0'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: styledown2
+version: !ruby/object:Gem::Version
+  version: 2.0.0.pre5
+platform: ruby
+authors:
+- Rico Sta. Cruz
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: styledown2-source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.pre5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.pre5
+- !ruby/object:Gem::Dependency
+  name: execjs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Styledown lets you write maintainable CSS styleguides using Markdown.
+email:
+- rstacruz@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- docs/api.md
+- lib/styledown.rb
+- lib/styledown/class_methods.rb
+- lib/styledown/file_reader.rb
+- lib/styledown/version.rb
+- lib/styledown2.rb
+- styledown2.gemspec
+homepage: https://github.com/styledown/styledown2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Write maintainable CSS styleguides using Markdown
+test_files: []