stylish 0.0.2 → 0.3.0

data/lib/stylish/cli/import.rb

@@ -0,0 +1,97 @@
+command "import external theme" do |c|
+  c.syntax = "stylish import SOURCE DESTINATION [OPTIONS]"
+  c.description = "import a theme"
+
+  c.option '--importer IMPORTER', String, 'The importer class to use'
+  c.option '--output-path PATH', String, 'Which folder to store the resulting theme in'
+  c.option '--clean', 'Whether or not to remove the output path'
+
+  c.action do |args, options|
+    require 'stylish/theme/importer'
+
+    source = Pathname(args.shift)
+    destination = args.shift
+    destination ||= "stylish-export"
+
+    options.default(importer: "startup_framework",
+                    output_path: Stylish.pwd.join("vendor/themes/startup_framework"))
+
+    importer = Stylish::Theme::Importer.load_by_type(options.importer)
+
+    job = importer.new(source, output_path: options.output_path, clean: options.clean)
+
+    job.prompt_for_settings()
+
+    job.run()
+  end
+end
+
+command "prepare theme" do |c|
+  c.syntax = "stylish prepare theme THEME [OPTIONS]"
+  c.description = "take a stylish theme and load it into the desired format for your current project"
+
+  c.option '--target TARGET', String, 'What type of project will use the theme?'
+  c.option '--output-path FILE', String, 'Where to put the theme?'
+
+  c.action do |args, options|
+    require 'stylish/theme/importer'
+    require 'stylish/theme/exporter'
+
+    options.default(output_path: Pathname(Dir.pwd).join('vendor'))
+
+    theme_name  = args.first
+    theme       = Stylish::Theme.new(Stylish.lib_root.join('../vendor/themes', theme_name))
+    output_path = Pathname(options.output_path)
+    importer    = Stylish::Theme::Importer.load_by_type(theme_name)
+
+    FileUtils.cp_r(theme.root, output_path)
+
+    theme = Stylish::Theme.new(output_path.join(theme_name))
+
+    target = options.target.to_s.to_sym
+
+    if target == :middleman
+      helper = theme.root.join('assets/stylesheets/startup-framework/dependencies/startup-framework/helper.less')
+
+      helper_content = helper.read
+
+      helper_content.sub!("../fonts/", "/fonts/")
+
+      helper.open("w+") {|fh| fh.write(helper_content)}
+
+      files = Dir[theme.root.join('views','components','**/*.html')]
+
+      src_values = []
+
+      files.map! {|file| Pathname(file) }
+
+      files.each do |path|
+        fragment    = Nokogiri::HTML.fragment(path.read)
+        image_tags  = fragment.css("img")
+
+        src_values += image_tags.map do |tag|
+          src = tag.attr('src')
+          original = src.dup
+
+          conversions = importer.const_get(:ImagePathConversions)
+
+          conversions.each do |pattern, replacement|
+            src.gsub! pattern, replacement
+          end
+
+          puts "== Replacing #{ original } with #{ src } value"
+          tag['src'] = "<%= image_path('#{src}') %>".html_safe
+        end
+
+        path.open("w+") do |f|
+          html = fragment.to_html
+          html.gsub! '&lt;%=%20', '<%= '
+          html.gsub! '%20%&gt;', ' %>'
+          f.write(html)
+        end
+
+        FileUtils.mv(path, path.to_s + '.erb')
+      end
+    end
+  end
+end

data/lib/stylish/cli/server.rb

@@ -0,0 +1,31 @@
+class Stylish::Server
+  def self.start(options={})
+    require 'rack'
+    require 'rack/server'
+    require 'pry'
+
+
+    Stylish.config.apply(:library_path => Pathname(options.library_path))
+
+    config  = Stylish.lib_root.join 'stylish', 'api.ru'
+
+    Rack::Server.start :config  => config.to_s,
+                       :Port    => options.port,
+                       :Host    => options.host
+
+  end
+end
+
+command "server" do |c|
+  c.syntax = "stylish server [OPTIONS]"
+  c.description = "start the stylish server"
+
+  c.option '--port PORT', String, 'Which port to listen on?'
+  c.option '--host HOSTNAME', String, 'Which host to listen on?'
+  c.option '--library-path PATH', nil, 'Which library should we load?'
+
+  c.action do |args, options|
+    options.default(:port => 8090, :host => "0.0.0.0", :library_path => Dir.pwd)
+    Stylish::Server.start(options)
+  end
+end

data/lib/stylish/configuration.rb

@@ -2,36 +2,42 @@ module Stylish
   class Configuration
     include Singleton
 
+    Defaults = {}
+
     def self.method_missing(meth, *args, &block)
+      binding.pry
+
       if instance.respond_to?(meth)
-        instance.send(meth, *args, &block)
-      else
-        super
+        return instance.send meth, *args, &block
       end
+
+      nil
+    end
+
+    def respond_to?(*args)
+      current.send(:key?, args.first) || current.send(:respond_to?, *args)
     end
 
     def method_missing(meth, *args, &block)
-      if config.respond_to?(meth)
-        config.send(meth, *args, &block)
-      else
-        super
-      end
+      return current[meth] if current.key?(meth)
+      super
     end
 
-    def config
-      @config ||= Hashie::Mash.new
+    def apply(object={})
+      current.tap {|c| c.merge!(object) }
     end
 
-    def load_from_file(path)
-      path = path.to_s.to_pathname
+    def public
+      current.slice(:library_path)
+    end
 
-      payload = if path.extname == ".yml"
-        YAML.load path.read
-      elsif path.extname == ".json"
-        JSON.parse path.read
+    def current
+      @current ||= Hashie::Mash.new(Defaults).tap do |c|
+        ENV.each do |key, value|
+          key = key.to_s.downcase.to_sym
+          c[key] = value
+        end
       end
-
-      config.merge!(payload)
     end
   end
 end

data/lib/stylish/core_ext.rb

@@ -1,10 +1,47 @@
-require 'hashie'
-require 'pathname'
+require 'set'
+
+class Set
+  def push(*args)
+    send(:<<, *args)
+  end
+end
 
 class Hash
   def to_mash
     Hashie::Mash.new(self)
   end
+
+  def lookup_path dot_separated_path, create=false
+    parts = dot_separated_path.to_s.split('.')
+
+    parts.reduce(self) do |memo, part|
+      memo && memo[part.to_sym] ||= memo[part.to_s] || (create if create)
+    end
+  end
+
+  def make_path dot_separated_path, blank_value, overwrite=false
+    dot_separated_path = dot_separated_path.to_s
+    existing = lookup_path(dot_separated_path)
+
+    return existing if existing && !overwrite
+
+    parts = dot_separated_path.split(".")
+
+    current = self
+
+    if parts.length == 1
+      return self[parts.first] ||= blank_value
+    end
+
+    key = parts.pop
+
+    parts.each do |part|
+      current = current[part.to_sym] = current.delete(part.to_s) || {}
+    end
+
+    current[key.to_sym] = blank_value
+    lookup_path(dot_separated_path, false)
+  end
 end
 
 class Pathname

data/lib/stylish/engine.rb

@@ -1,12 +1,4 @@
 module Stylish
   class Engine < ::Rails::Engine
-    initializer 'stylish.developer_mode' do |app|
-      sprockets = app.assets
-
-      Stylish::Developer.config do |cfg|
-        cfg.root = app.root
-        cfg.environment = sprockets
-      end
-    end
   end
 end

data/lib/stylish/middleman_extension.rb

@@ -0,0 +1,33 @@
+module Stylish
+  class MiddlemanExtension < ::Middleman::Extension
+    def self.activate_stylish_extension
+      ::Middleman::Extensions.register(:stylish, Stylish::MiddlemanExtension)
+    end
+
+    option :theme, String, 'The name of the theme'
+
+    helpers do
+      def stylish
+        theme_root = Pathname(root).join('vendor').join extensions[:stylish].options[:theme]
+        @stylish ||= Stylish::Theme.new(theme_root)
+      end
+    end
+
+    def after_configuration
+      import_stylish_images_and_fonts
+    end
+
+    def import_stylish_images_and_fonts
+      environment   = app.stylish.compiler
+      trusted_paths = environment.paths.select { |p| p.end_with?('images') || p.end_with?('fonts') }
+      trusted_paths.each do |load_path|
+        environment.each_entry(load_path) do |path|
+          if path.file? && !path.basename.to_s.start_with?('_')
+            logical_path = path.sub(/^#{load_path}/, '')
+            environment.imported_assets << Middleman::Sprockets::ImportedAsset.new(logical_path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stylish/rails/view_helpers.rb

@@ -0,0 +1,42 @@
+module Stylish
+  module Rails
+    module ViewHelpers
+      # used by a layout to load the layout confiig it depends on.
+      # this will help build the dependency manifests properly.
+      #
+      # @param [String] the identifier for the layout
+      def load_theme_layout layout_identifier
+      end
+
+      # used by a page to load the components it will depend on. this
+      # helps us build the dependency manifests properly
+      def load_theme_components *component_identifiers
+      end
+
+      # sequentially renders every component for this page
+      def render_all_components
+      end
+
+      # renders a component. used in the page layouts.
+      def render_component component_identifier
+      end
+
+      # (see #javascript_imports_for)
+      def stylesheet_imports_for(page_identifier, options={})
+      end
+
+      # Returns a list of sprockets logical paths to satisfy
+      # the dependencies for a given stylish layout. These values can
+      # be used to dynamically generate JS content using ERB, or in a generator
+      # which will just output a sprockets manifest.
+      #
+      # This method will depend on the page having declared its dependency on
+      # a layout, and the components it depends on.
+      #
+      # @param [String] the slug for the stylish page which will be using the requested components
+      # @return [Array] a list of values which can be required in a sprockets manifest
+      def javascript_imports_for(page_identifier, options={})
+      end
+    end
+  end
+end

data/lib/stylish/theme.rb

@@ -0,0 +1,42 @@
+module Stylish
+  class Theme
+    attr_accessor :root, :options, :manifest, :manifest_path, :compiler
+
+    def initialize(root, options={})
+      @options        = options
+      @root           = Pathname(root).expand_path
+      @manifest_path  = options.fetch(:manifest_path) { root.join('stylish.yml') }
+
+      raise 'Manifest file not found.  Please provide a root directory in which stylish.json can be found' unless manifest_path.exist?
+
+      @manifest       = Hashie::Mash.new YAML.load_file(manifest_path)
+
+      setup_compiler rescue nil
+    end
+
+    def apply_manifest values={}
+      @manifest.merge!(values)
+    end
+
+    def dependency_paths
+      Array(manifest.dependency_paths).map {|path| root.join(path) }
+    end
+
+    def import_paths
+      Array(manifest.import_paths).map {|path| root.join(path) }
+    end
+
+    def setup_compiler
+      @compiler ||= Stylish.sprockets.dup.tap do |env|
+        dependency_paths.each {|p| env.append_path(p) }
+
+        if defined?(::Less)
+          (import_paths.map(&:to_s) - Less.paths.map(&:to_s)).each do |path|
+            Less.paths << path
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/stylish/theme/component.rb

@@ -0,0 +1,4 @@
+module Stylish
+  class Theme::Component
+  end
+end

data/lib/stylish/theme/exporter.rb

@@ -0,0 +1,15 @@
+module Stylish
+  class Theme::Exporter
+    attr_accessor :options, :source, :destination, :theme
+
+    def initialize(source, options={})
+      @source   = Pathname(source)
+      @options  = options
+    end
+
+    def run
+      replace_path_placeholders
+    end
+
+  end
+end

data/lib/stylish/theme/exporters/middleman.rb

@@ -0,0 +1,7 @@
+module Stylish
+  module Exporters
+    class Middleman < Stylish::Theme::Exporter
+
+    end
+  end
+end

data/lib/stylish/theme/importer.rb

@@ -0,0 +1,175 @@
+require 'set'
+
+module Stylish
+  class Theme::Importer
+
+    attr_reader :options, :exports, :paths, :config
+    attr_accessor :source, :destination, :name, :dependency_paths, :import_paths
+
+    def initialize(source, options={})
+      @source   = Pathname(source)
+      @options  = options
+
+
+      @name     = options.fetch(:name, "stylish-theme")
+      @paths    = {
+        output_path: Pathname(options[:output_path] || "#{ Dir.pwd }#{ name }")
+      }
+
+      clean if options[:clean]
+
+      @exports  = {}.to_mash
+      @dependency_paths = Set.new
+      @import_paths = Set.new
+
+      @config = {}.to_mash
+
+      map_source_paths
+      prepare_output_paths
+
+      if(options[:run] == true)
+        run
+      end
+
+    end
+
+    DefaultRunCommands = %w(
+      move_common_javascript_dependencies_into_global_theme
+      move_common_stylesheet_dependencies_into_global_theme
+      extract_component_dependency_stylesheets
+      extract_component_dependency_javascripts
+      extract_component_markup
+      write_manifest
+    )
+
+    DefaultRunCommands.each do |meth|
+      define_method(meth) { raise NotImplementedError, "Importer class responsible for implementing: #{ meth }" } unless method_defined?(meth)
+    end
+
+    def run
+      DefaultRunCommands.each do |cmd|
+        send(cmd)
+      end
+    end
+
+    def manifest
+      exports.to_hash.merge(
+        dependency_paths: dependency_paths.to_a.map {|path| Pathname(path).relative_path_from(output_path).to_s },
+        import_paths: import_paths.to_a.map {|path| Pathname(path).relative_path_from(output_path).to_s }
+      )
+    end
+
+
+    def prepare
+      map_source_paths
+      prepare_output_paths
+    end
+
+    def prompts
+      {}
+    end
+
+    def clean
+      FileUtils.rm_rf(output_path)
+    end
+
+    def prompt_for_settings
+      if respond_to?(:ask)
+        prompts.each do |var, question|
+          self.options[var] = ask(question, String)
+        end
+      end
+    end
+
+    def method_missing meth, *args, &block
+      return paths[meth.to_sym] if meth.to_s.match(/_path$/) && paths.key?(meth.to_sym)
+      config.lookup_path(meth.to_s) || exports.lookup_path(meth.to_s) || super
+    end
+
+    def respond_to?(*args)
+      paths.key?(args.first.to_sym) || super
+    end
+
+    def set key, value
+      key = key.to_s
+      config.make_path(key, value)
+    end
+
+    def export key, value
+      key = key.to_s
+      exports.make_path(key, value, true)
+    end
+
+    def push key, value
+      key = key.to_s
+      exports.make_path(key, [])
+      exports.lookup_path(key) << value
+    end
+
+    def define_path identifier, value
+      value = Pathname(value)
+      @paths[identifier.to_sym] = value
+      value
+    end
+
+    def prepare_output_paths
+      FileUtils.mkdir_p output_path
+      FileUtils.mkdir_p components_output_path
+      FileUtils.mkdir_p layouts_output_path
+      FileUtils.mkdir_p javascripts_output_path.join('dependencies')
+      FileUtils.mkdir_p stylesheets_output_path.join('dependencies')
+      FileUtils.mkdir_p images_output_path
+      FileUtils.mkdir_p fonts_output_path
+
+      exports.component_categories.each do |category|
+        FileUtils.mkdir_p components_output_path.join(category.downcase.parameterize)
+        FileUtils.mkdir_p javascripts_output_path.join(category.downcase.parameterize)
+        FileUtils.mkdir_p stylesheets_output_path.join(category.downcase.parameterize)
+      end
+    end
+
+    def write_manifest
+      output_path.join("stylish.yml").open("w+") {|fh| fh.write(manifest.to_yaml) }
+    end
+
+    def components_output_path
+      output_path.join('views/components')
+    end
+
+    def layouts_output_path
+      output_path.join('views/layouts')
+    end
+
+    def stylesheets_output_path
+      output_path.join("assets/stylesheets/#{name}")
+    end
+
+    def javascripts_output_path
+      output_path.join("assets/javascripts/#{name}")
+    end
+
+    def images_output_path
+      output_path.join("assets/images/#{name}")
+    end
+
+    def fonts_output_path
+      output_path.join("assets/fonts/#{name}")
+    end
+
+    # Loads a specific importer configuration class
+    #
+    # @param [String] which importer config to use
+    #   will reference a .rb file in the configured importer definition paths
+    def self.load_by_type(type)
+     importer_file = Stylish.lib_root
+                      .join("stylish/theme/importers")
+                      .join(type.to_s + '.rb')
+
+      raise "Invalid Importer" unless importer_file.exist?
+
+      require(importer_file)
+
+      (Stylish::Importers.const_get("#{ type }_importer".camelize) rescue nil) || (Stylish::Importers.const_get("#{ type }".camelize))
+    end
+  end
+end