lalala 4.0.0.dev.46

data/lib/lalala/markdown/markdown_renderer.rb

@@ -0,0 +1,251 @@
+class Lalala::Markdown::MarkdownRenderer < Redcarpet::Render::Base
+
+  NEW_BLOCK = "\n\n"
+
+  def initialize(options)
+    super()
+
+    @list_items       = []
+
+    @table_cell_index = 0
+    @table_cells      = []
+    @table_rows       = []
+    @table_alignments = []
+  end
+
+  # ```ruby
+  # 1 + 2 # => 3
+  # ```
+  def block_code(code, language)
+    "```#{language}\n#{code.strip}\n```" + NEW_BLOCK
+  end
+
+  # > quote
+  # > new line
+  def block_quote(quote)
+    "> " + quote.strip.gsub("\n", "\n> ") + NEW_BLOCK
+  end
+
+  def block_html(html)
+    html.strip + NEW_BLOCK
+  end
+
+  def header(text, level)
+    ("#" * level) + " " + text.strip + NEW_BLOCK
+  end
+
+  def hrule
+    "---" + NEW_BLOCK
+  end
+
+  def list(content, type)
+    case type
+    when :ordered
+      ordered_list
+    when :unordered
+      unordered_list
+    end
+
+  ensure
+    @list_items = []
+  end
+
+  def unordered_list
+    items = @list_items.map do |item|
+      "- " + item.gsub("\n", "\n  ")
+    end
+
+    items.join("\n") + NEW_BLOCK
+  end
+
+  def ordered_list
+    items = []
+    width = @list_items.size.to_s.size + 2
+
+    @list_items.each_with_index do |item, idx|
+      prefix = (idx + 1).to_s + ". "
+
+      if prefix.size < width
+        prefix += (" " * (width - prefix.size))
+      end
+
+      item = item.gsub("\n", "\n" + (" " * width))
+
+      item = prefix + item
+      items << item
+    end
+
+    items.join("\n") + NEW_BLOCK
+  end
+
+  def list_item(content, type)
+    @list_items << content.strip
+    content
+  end
+
+  def paragraph(content)
+    content.strip + NEW_BLOCK
+  end
+
+  def table(header, body)
+    column_count = @table_rows.first.size
+    widths       = Array.new(column_count, 0)
+
+    # determine the maximum widths of all the columns
+    @table_rows.each do |row|
+      row.each_with_index do |cell, idx|
+        w = cell.size
+        if widths[idx] < w
+          widths[idx] = w
+        end
+      end
+    end
+
+    rows       = @table_rows
+    alignments = @table_alignments
+
+    delimiter_row = Array.new(column_count, "")
+    alignments.each_with_index do |_, idx|
+      width = widths[idx]
+
+      case alignments[idx]
+      when :right
+        cell = ("-" * (width - 1)) + ":"
+      when :center
+        cell = ":" + ("-" * (width - 2)) + ":"
+      else
+        cell = ("-" * width)
+      end
+
+      delimiter_row[idx] = cell
+    end
+
+    Rails.logger.debug alignments.inspect
+
+    if header.size > 0
+      rows.insert(1, delimiter_row)
+    else
+      rows.insert(0, delimiter_row)
+    end
+
+    rows = rows.map do |row|
+      cells = []
+      row.each_with_index do |cell, idx|
+        width = widths[idx]
+
+        case alignments[idx]
+        when :right
+          cell = (" " * (width - cell.size)) + cell
+        when :center
+          half_width = (width - cell.size) / 2.0
+          cell = (" " * half_width.floor) + cell + (" " * half_width.ceil)
+        else
+          cell = cell + (" " * (width - cell.size))
+        end
+
+        cell = " " + cell + " "
+
+        cells << cell
+      end
+
+      "|" + cells.join("|") + "|"
+    end
+
+    rows.join("\n") + NEW_BLOCK
+
+  ensure
+    @table_rows = []
+    @table_alignments = []
+  end
+
+  def table_row(content)
+    if @table_alignments_builder
+      @table_alignments = @table_alignments_builder
+    end
+
+    @table_rows.push(@table_cells)
+
+    content
+  ensure
+    @table_cells = []
+    @table_cell_index = 0
+  end
+
+  def table_cell(content, alignment)
+    @table_cells << content
+
+    if @table_cell_index >= @table_alignments.size
+      @table_alignments.push(nil)
+    end
+
+    if alignment
+      @table_alignments[@table_cell_index] = alignment
+    end
+
+    content
+
+  ensure
+    @table_cell_index += 1
+  end
+
+  def autolink(link, link_type)
+    link
+  end
+
+  def codespan(code)
+    "`" + code + "`"
+  end
+
+  def double_emphasis(text)
+    "**" + text + "**"
+  end
+
+  def emphasis(text)
+    "*" + text + "*"
+  end
+
+  def image(link, title, alt_text)
+    if title.blank?
+      "![#{alt_text}](#{link})"
+    else
+      "![#{alt_text}](#{link} #{title})"
+    end
+  end
+
+  def linebreak()
+    "  \n"
+  end
+
+  def link(link, title, content)
+    if title.blank?
+      "[#{content}](#{link})"
+    else
+      "[#{content}](#{link} #{title})"
+    end
+  end
+
+  def raw_html(raw_html)
+    raw_html
+  end
+
+  def triple_emphasis(text)
+    "***" + text + "***"
+  end
+
+  def strikethrough(text)
+    "~~~" + text + "~~~"
+  end
+
+  def superscript(text)
+    "^" + text
+  end
+
+  def entity(text)
+    text
+  end
+
+  def normal_text(text)
+    text
+  end
+
+end

data/lib/lalala/markdown/preview.rb

@@ -0,0 +1,39 @@
+module Lalala::Markdown::Preview
+
+  def self.hookup
+    d = ActiveAdmin::Event
+    e = ActiveAdmin::Resource::RegisterEvent
+
+    d.subscribe e do |resource|
+      Lalala::Markdown::Preview.add_preview_action(resource)
+    end
+  end
+
+  def self.add_preview_action(resource_spec)
+    resource_spec.dsl.run_registration_block do
+      member_action :preview, :method => :post do
+
+        if resource_params.size > 1
+          raise "Expects exactly 1 param"
+        end
+
+        instance_params = resource_params.first
+
+        if instance_params.size > 1
+          raise "Expects exactly 1 param"
+        end
+
+        key = instance_params.keys.first
+        val = instance_params[key]
+
+        resource[key] = val
+
+        @content = resource.send("#{key}_html")
+
+        render layout: 'lalala/markdown', template: 'lalala/markdown/preview'
+
+      end
+    end
+  end
+
+end

data/lib/lalala/markdown.rb

@@ -0,0 +1,99 @@
+class Lalala::Markdown
+
+  require 'lalala/markdown/preview'
+  require 'lalala/markdown/active_model'
+  require 'lalala/markdown/html_renderer'
+  require 'lalala/markdown/markdown_renderer'
+
+  module Handlers
+    require 'lalala/markdown/handlers/base'
+    require 'lalala/markdown/handlers/youtube'
+  end
+
+  PARSER_OPTIONS = [
+    :autolink,
+    :fenced_code_blocks,
+    :lax_spacing,
+    :no_intra_emphasis,
+    :space_after_headers,
+    :strikethrough,
+    :superscript,
+    :tables
+  ]
+
+  RENDERER_OPTIONS = [
+    :filter_html,
+    :hard_wrap,
+    :link_attributes,
+    :link_schemes,
+    :no_images,
+    :no_links,
+    :no_styles,
+    :safe_links_only,
+    :with_toc_data,
+    :xhtml
+  ]
+
+  OPTIONS = PARSER_OPTIONS + RENDERER_OPTIONS
+
+  def initialize(options={})
+    options.assert_valid_keys(*OPTIONS)
+
+    @parser_options = options.slice(*PARSER_OPTIONS)
+    @parser_options = {
+      no_intra_emphasis: true,
+      tables: false,
+      fenced_code_blocks: true,
+      autolink: true,
+      strikethrough: true,
+      lax_spacing: false,
+      space_after_headers: false,
+      superscript: true
+    }.merge(@parser_options)
+
+    @renderer_options = options.slice(*RENDERER_OPTIONS)
+    @renderer_options = {
+      filter_html: true,
+      no_images: false,
+      no_links: false,
+      no_styles: true,
+      safe_links_only: true,
+      with_toc_data: true,
+      hard_wrap: false,
+      xhtml: false
+    }.merge(@renderer_options)
+  end
+
+  def options
+    {}.merge(@parser_options).merge(@renderer_options)
+  end
+
+  def render(text)
+    md = parser(html_renderer)
+    md.render(text)
+  end
+
+  def format(text)
+    md = parser(markdown_renderer)
+    md.render(text)
+  end
+
+private
+
+  def parser(renderer)
+    Redcarpet::Markdown.new(renderer, @parser_options)
+  end
+
+  def markdown_renderer
+    Lalala::Markdown::MarkdownRenderer.new(@renderer_options)
+  end
+
+  def html_renderer
+    Lalala::Markdown::HtmlRenderer.new(@renderer_options)
+  end
+
+end
+
+ActiveSupport.on_load :active_record do
+  ActiveRecord::Base.send :include, Lalala::Markdown::ActiveModel
+end

data/lib/lalala/pages/child_type_validator.rb

@@ -0,0 +1,43 @@
+class Lalala::Pages::ChildTypeValidator < ActiveModel::Validator
+
+  def validate(record)
+    types = normalize_types(options[:types], record)
+
+    record.children.each do |child|
+      valid = types.any? do |type|
+        child.is_a?(type)
+      end
+
+      unless valid
+        record.errors.add :base, "Invalid child type: #{child.class.to_s.humanize}"
+      end
+    end
+  end
+
+private
+
+  def normalize_types(types, record)
+    if Proc === types
+      types = types.call(record)
+    end
+
+    if types.nil?
+      types = []
+    end
+
+    unless Array === types
+      raise ArgumentError, "ChildTypeValidator expected a list of class names for :types."
+    end
+
+    types = types.map do |type|
+      if Class === type
+        type
+      else
+        type.to_s.classify.constantize
+      end
+    end
+
+    types
+  end
+
+end

data/lib/lalala/pages/children_length_validator.rb

@@ -0,0 +1,45 @@
+class Lalala::Pages::ChildrenLengthValidator < ActiveModel::Validations::LengthValidator
+
+  def check_validity!
+    keys = CHECKS.keys & options.keys
+
+    if keys.empty?
+      raise ArgumentError, 'Range unspecified. Specify the :in, :within, :maximum, :minimum, or :is option.'
+    end
+
+    keys.each do |key|
+      value = options[key]
+
+      if value.is_a?(Proc)
+        next
+      end
+
+      if value.is_a?(Integer) && value >= 0
+        next
+      end
+
+      raise ArgumentError, ":#{key} must be a nonnegative Integer"
+    end
+  end
+
+  def validate_each(record, attribute, value)
+    value = tokenize(value)
+    value_length = value.respond_to?(:length) ? value.length : value.to_s.length
+
+    CHECKS.each do |key, validity_check|
+      check_value = options[key]
+      check_value = check_value.call(record) if Proc === check_value
+      next unless check_value
+      next if value_length.send(validity_check, check_value)
+
+      errors_options = options.except(*RESERVED_OPTIONS)
+      errors_options[:count] = check_value
+
+      default_message = options[MESSAGES[key]]
+      errors_options[:message] ||= default_message if default_message
+
+      record.errors.add(attribute, MESSAGES[key], errors_options)
+    end
+  end
+
+end

data/lib/lalala/pages/page_type_constraint.rb

@@ -0,0 +1,17 @@
+class Lalala::Pages::PageTypeConstraint
+
+  def initialize(type)
+    unless Class === type
+      type  = type.to_s.classify
+      type += "Page" unless type.ends_with?("Page")
+      type  = type.constantize
+    end
+
+    @type = type
+  end
+
+  def matches?(request)
+    request.env['lalala.page'] and @type === request.env['lalala.page']
+  end
+
+end

data/lib/lalala/pages/path_handler.rb

@@ -0,0 +1,38 @@
+module Lalala::Pages::PathHandler
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    def ct_scoped_to_path(path, parent_constraint)
+      if respond_to?(:translated?) and !translated?(name_sym)
+        return super(path, parent_constraint)
+      end
+
+      path = path.is_a?(Enumerable) ? path.dup : [path]
+
+      # make scope writable
+      scope = scoped.readonly(false)
+
+      # restrict by top
+      scope = scope.joins(<<-SQL)
+        INNER JOIN #{translations_table_name} AS t_ ON #{quoted_table_name}.id = t_.#{class_name.foreign_key}
+      SQL
+      scope = scope.where("t_.#{quoted_name_column} = #{ct_quote(path.last)}")
+
+
+      path[0..-2].reverse.each_with_index do |ea, idx|
+        subtable = idx == 0 ? quoted_table_name : "p#{idx - 1}"
+        scope = scope.joins(<<-SQL)
+          INNER JOIN #{quoted_table_name}       AS p#{idx} ON p#{idx}.id = #{subtable}.#{parent_column_name}
+          INNER JOIN #{translations_table_name} AS t#{idx} ON p#{idx}.id = t#{idx}.#{class_name.foreign_key}
+        SQL
+        scope = scope.where("t#{idx}.#{quoted_name_column} = #{ct_quote(ea)}")
+      end
+
+
+      root_table_name = path.size > 1 ? "p#{path.size - 2}" : quoted_table_name
+      scope.where("#{root_table_name}.#{parent_constraint}")
+    end
+
+  end
+end

data/lib/lalala/pages/route_mapper.rb

@@ -0,0 +1,31 @@
+module Lalala::Pages::RouteMapper
+
+  # pages(:about, to: 'about#show')
+  # pages(:about, to: 'about#show') do
+  #   get '/team/:member', to: 'about#team_member'
+  # end
+  # pages(:about) do
+  #   get '/team/:member', to: 'about#team_member'
+  # end
+  def pages(*args)
+    options = args.extract_options!
+    options = options.dup
+
+    unless args.size == 1 and Symbol === args[0]
+      raise ArgumentError, "expected a page type"
+    end
+
+    type    = args[0]
+    options = { as: type }.merge(options)
+    options[:constraints] = Lalala::Pages::PageTypeConstraint.new(type)
+
+    match '/', options
+
+    if block_given?
+      scope(options) { yield }
+    end
+
+    self
+  end
+
+end

data/lib/lalala/pages.rb

@@ -0,0 +1,11 @@
+module Lalala::Pages
+  extend ActiveSupport::Autoload
+
+  autoload :PathHandler
+  autoload :ChildTypeValidator
+  autoload :ChildrenLengthValidator
+
+  autoload :PageTypeConstraint
+  autoload :RouteMapper
+
+end

data/lib/lalala/test.rb

@@ -0,0 +1,18 @@
+module Lalala
+  module Test
+
+    def self.setup!
+      require 'capybara/rails'
+      require 'capybara/poltergeist'
+
+      Rails.backtrace_cleaner.remove_silencers!
+
+      ActionDispatch::IntegrationTest.send :include, Capybara::DSL
+
+      Capybara.javascript_driver = :poltergeist
+
+      I18n.reload!
+    end
+
+  end
+end

data/lib/lalala/utils/intall_template.rb

@@ -0,0 +1,41 @@
+class AppBuilder < Rails::AppBuilder
+  include Thor::Actions
+  include Thor::Shell
+
+  RUBY_VERSION = "2.0.0"
+
+  def gemfile
+    create_file 'Gemfile', <<-DOC
+source 'https://rubygems.org'
+
+ruby "#{RUBY_VERSION}"
+
+git 'git://github.com/mrhenry/lalala-ng', submodules: true do
+  gem 'lalala'
+  gem 'lalala-development', groups: [:development]
+  gem 'lalala-assets',      groups: [:development, :assets]
+  gem 'lalala-test',        groups: [:test]
+end
+DOC
+  end
+
+  def ruby_version
+    create_file ".ruby-version", RUBY_VERSION
+  end
+
+  def leftovers
+    ruby_version
+  end
+
+end
+
+class Rails::Generators::AppGenerator
+
+  alias_method :lng_run_bundle, :run_bundle
+
+  def run_bundle
+    lng_run_bundle
+    generate "lalala:install"
+  end
+
+end

data/lib/lalala/vendor.rb

@@ -0,0 +1,21 @@
+module Lalala::Vendor
+
+  def self.enable(name, dirname=nil)
+    dirname ||= name
+
+    # Find vendored version
+    path = File.expand_path("../../../vendor/deps/#{dirname}/lib", __FILE__)
+
+    # Find development version
+    if ENV['LALALA_DEV']
+      path = File.expand_path("../../../../#{dirname}/lib", __FILE__)
+    end
+
+    unless File.directory?(path)
+      raise "Unable to find vendored dependency: #{name}"
+    end
+
+    $:.unshift(path)
+  end
+
+end

data/lib/lalala/version.rb

@@ -0,0 +1,10 @@
+module Lalala
+  VERSION = "4.0.0"
+  BUILD   = "46"
+
+  if BUILD != ("{{BUILD_NUMBER" + "}}") # prevent sed replacement (see script/ci)
+    BUILD_VERSION = "#{VERSION}.dev.#{BUILD}"
+  else
+    BUILD_VERSION = VERSION
+  end
+end