maglove 0.8.1 → 1.0.2

data/lib/maglove/commands/fonts.rb

@@ -0,0 +1,69 @@
+module MagLove
+  module Commands
+    class Fonts < Base
+      desc "compile", "Compile fonts"
+      def compile
+        # clean up
+        FileUtils.rm_rf("dist/fonts")
+        FileUtils.mkdir_p("dist/fonts")
+
+        # 1: Build font map
+        debug("▸ building font map")
+        font_map = {}
+        font_files = Dir.glob("src/fonts/*/*.ttf")
+        font_files.each do |font_file|
+          (_root_dir, _font_dir, font_id, font_filename) = font_file.split("/")
+          font_variant = font_filename.gsub("#{font_id}-", '').gsub(".ttf", '')
+          font_map[font_id] = [] if font_map[font_id].nil?
+          font_map[font_id].push(font_variant)
+        end
+
+        # 2: Generate stylesheets
+        debug("▸ compiling fonts:")
+        FileUtils.touch("dist/fonts/fonts.css")
+        open("dist/fonts/fonts.css", 'wb') do |master_file|
+          font_map.each do |font_id, variants|
+            debug("~▸ compiling font '#{font_id}'")
+            FileUtils.mkdir_p("dist/fonts/#{font_id}")
+            variants.each do |variant|
+              FileUtils.copy("src/fonts/#{font_id}/#{font_id}-#{variant}.ttf", "dist/fonts/#{font_id}/#{font_id}-#{variant}.ttf")
+            end
+            font_style_file = "dist/fonts/#{font_id}/font.css"
+            FileUtils.touch(font_style_file)
+            open(font_style_file, 'wb') do |file|
+              master_file << "/* #{font_id} (#{variants.join(', ')}) */\n"
+              variants.each do |variant|
+                file << get_font_styles(font_id, variant)
+                master_file << get_font_styles(font_id, variant, "#{font_id}/")
+              end
+              master_file << "\n"
+            end
+          end
+        end
+        debug("▸ all font styles created")
+        if options.sync
+          # @TODO: Submit to cloud server
+          debug("▸ all fonts synchronized")
+        end
+      end
+
+      private
+
+      def get_font_styles(font_id, variant, append_dir = '')
+        font_name = font_id.tr('-', ' ').titleize
+        case variant
+        when "regular"
+          "@font-face{font-family:'#{font_name}';src:url('#{append_dir}#{font_id}-#{variant}.ttf');}\n"
+        when "bold"
+          "@font-face{font-family:'#{font_name}';src:url('#{append_dir}#{font_id}-#{variant}.ttf');font-weight:bold;}\n"
+        when "italic"
+          "@font-face{font-family:'#{font_name}';src:url('#{append_dir}#{font_id}-#{variant}.ttf');font-style:italic;}\n"
+        when "bolditalic"
+          "@font-face{font-family:'#{font_name}';src:url('#{append_dir}#{font_id}-#{variant}.ttf');font-weight:bold;font-style:italic;}\n"
+        when "light"
+          "@font-face{font-family:'#{font_name}';src:url('#{append_dir}#{font_id}-#{variant}.ttf');font-weight:300;}\n"
+        end
+      end
+    end
+  end
+end

data/lib/maglove/commands/main.rb

@@ -0,0 +1,24 @@
+module MagLove
+  module Commands
+    class Main < Base
+      desc "fonts SUBCOMMAND ...ARGS", "manage fonts"
+      subcommand "fonts", Commands::Fonts
+
+      desc "theme SUBCOMMAND ...ARGS", "manage theme"
+      subcommand "theme", Commands::Theme
+
+      desc "assets SUBCOMMAND ...ARGS", "compile theme"
+      subcommand "assets", Commands::Assets
+
+      desc "compile", "Compile all themes"
+      def compile
+        workspace_dir("src/themes").each_dir do |dir|
+          theme = dir.name
+          info("COMPILING THEME #{theme}")
+          invoke(Assets, :compile, [], theme: theme)
+          reset_command_invocations(Assets)
+        end
+      end
+    end
+  end
+end

data/lib/maglove/commands/theme.rb

@@ -0,0 +1,197 @@
+module MagLove
+  module Commands
+    class Theme < Base
+      desc "server", "Launch Development Server"
+      option :port, type: :string, default: "4000"
+      option :theme, type: :string, required: true, validator: OptionValidator
+      def server
+        invoke(Assets, :compile, [], { theme: options.theme })
+        invoke(Fonts, :compile, [], {})
+        info("▸ starting server for theme '#{options.theme}' on '127.0.0.1:#{options.port}'")
+        require 'maglove/server'
+        MagLove::Server.start(options.port, options.theme, theme_config(:templates))
+      end
+
+      desc "thumbnails", "Create page thumbnails"
+      option :theme, type: :string, required: true, validator: OptionValidator
+      def thumbnails
+        require "powersnap"
+        invoke(Fonts, :compile, [], {})
+        invoke(Assets, :compile, [], theme: options.theme)
+
+        info("▸ Generating Template Thumbnails")
+        output_dir = theme_dir(root: "dist").chdir("templates")
+        powersnap = Powersnap.new(output_dir.files("*.html").map(&:url))
+        powersnap.generate(dir: output_dir.to_s, width: 768, height: 1024, pattern: "{basename}.png", zoom: 1.0, page: false)
+
+        info("▸ Generating Block Thumbnails")
+        output_dir = theme_dir(root: "dist").chdir("blocks")
+        if output_dir.exists?
+          powersnap = Powersnap.new(output_dir.files("*.html").map(&:url))
+          powersnap.generate(dir: output_dir.to_s, width: 512, height: 200, pattern: "{basename}.png", zoom: 1.0, page: true)
+        end
+      end
+
+      desc "push", "Push Theme to MagLoft"
+      option :token, type: :string, required: true
+      option :theme, type: :string, required: true, validator: OptionValidator
+      option :thumbnails, type: :boolean, default: false
+      def push
+        info("▸ Pushing theme '#{options.theme}' to MagLoft")
+
+        # validate theme
+        theme_identifier = theme_config(:identifier)
+        error!("Theme '#{theme_identifier}' not found") unless theme_identifier
+        begin
+          theme = magloft_api.typeloft_themes.find_by_identifier(theme_identifier)
+        rescue MagLoft::ApiCaller::UnauthorizedError
+          error!("▸ You are not allowed to access the MagLoft API.")
+        end
+        if theme.nil?
+          info("▸ To create a new theme, run: maglove theme:create --theme '#{theme_identifier}'")
+          error!("Theme '#{theme_identifier}' was not yet created.")
+        end
+
+        # invoke asset compilation
+        invoke(Fonts, :compile, [], {})
+        invoke(Assets, :compile, [], { theme: options.theme })
+
+        # update theme
+        info("▸ Synchronizing Metadata")
+        theme.base_version = theme_config(:base_version)
+        theme.name = theme_config(:name)
+        theme.description = theme_config(:description)
+        theme.widgets = theme_config(:widgets)
+        theme.fonts = theme_config(:fonts)
+        theme.save
+
+        # upload blocks
+        theme_blocks = theme.typeloft_blocks.all
+        theme_blocks_map = Hash[theme_blocks.map { |block| [block.identifier, block] }]
+        if theme_dir.chdir("blocks").exists?
+          block_files = theme_dir.chdir("blocks").files("**/*.haml")
+          block_files.each do |block_file|
+            block_identifier = block_file.slug
+            if (block = theme_blocks_map[block_identifier])
+              block.name = block_file.basename.titlecase
+              block.contents = block_file.read
+              if block.changed?
+                info "▸ Updating Block '#{block_identifier}'"
+                block.save
+              end
+            else
+              info "▸ Creating Block '#{block_identifier}'"
+              theme.typeloft_blocks.create(identifier: block_identifier, name: block_file.basename.titlecase, contents: block_file.read)
+            end
+          end
+        end
+
+        # upload images
+        info("▸ Synchronizing Images")
+        theme_images = theme.typeloft_images.all
+        theme_images_map = Hash[theme_images.map { |image| [image.remote_file, image] }]
+        theme_dir(root: "dist").files("images/**/*.{jpg,png,gif,svg}").each do |image_file|
+          remote_file = "themes/#{options.theme}/#{image_file.relative_path}"
+          if (existing_image = theme_images_map[remote_file])
+            if image_file.md5 != existing_image.md5
+              info("▸ Updating Image '#{remote_file}'")
+              existing_image.md5 = image_file.md5
+              existing_image.upload(image_file.to_s)
+              existing_image.save
+            end
+          else
+            info("▸ Creating Image '#{remote_file}'")
+            new_image = theme.typeloft_images.create(remote_file: remote_file, title: image_file.basename.titlecase, md5: image_file.md5)
+            new_image.upload(image_file.to_s)
+          end
+        end
+
+        # upload css/js
+        info("▸ Synchronizing JavaScript and Stylesheet")
+        theme.upload_stylesheet(theme_dir(root: "dist").file("theme.css").to_s)
+        theme.upload_javascript(theme_dir(root: "dist").file("theme.js").to_s)
+
+        # upload templates
+        info("▸ Synchronizing Templates")
+        theme_templates = theme.typeloft_templates.all
+        theme_templates_map = Hash[theme_templates.map { |template| [template.identifier, template] }]
+        templates = theme_config(:templates)
+        templates.each_with_index do |template_identifier, position|
+          template_file = theme_dir.file("templates/#{template_identifier}.haml")
+          next unless !template_file.nil? and template_file.exists?
+          if (template = theme_templates_map[template_identifier])
+            template.title = template_identifier.titlecase
+            template.contents = template_file.read
+            template.position = position
+            if template.changed?
+              info "▸ Updating Template '#{template_identifier}'"
+              template.save
+            end
+          else
+            info "▸ Creating Template '#{template_identifier}'"
+            theme.typeloft_templates.create(identifier: template_identifier, title: template_identifier.titlecase, contents: template_file.read, position: position)
+          end
+        end
+
+        # update thumbnails
+        if options.thumbnails
+          invoke(:thumbnails, [], { theme: options.theme })
+
+          info("▸ Synchronizing Template Thumbnails")
+          theme.typeloft_templates.all.each do |template|
+            thumbnail_file = theme_dir(root: "dist").dir("templates").file("#{template.identifier}.png")
+            if thumbnail_file.exists?
+              info("~> Uploading Thumbnail for '#{template.identifier}'")
+              template.upload_thumbnail(thumbnail_file.to_s)
+            end
+          end
+
+          info("▸ Synchronizing Block Thumbnails")
+          theme.typeloft_blocks.all.each do |block|
+            thumbnail_file = theme_dir(root: "dist").dir("blocks").file("#{block.identifier}.png")
+            if thumbnail_file.exists?
+              info("~> Uploading Thumbnail for '#{block.identifier}'")
+              block.upload_thumbnail(thumbnail_file.to_s)
+            end
+          end
+        end
+
+        info("▸ Successfully Pushed Theme")
+      end
+
+      desc "create", "Create a new Theme on MagLoft"
+      option :token, type: :string, required: true
+      option :theme, type: :string, required: true, validator: OptionValidator
+      def create
+        info("▸ Creating new theme '#{options.theme}'")
+
+        error!("Missing yaml config 'name'") unless theme_config(:name)
+        error!("Missing yaml config 'base_version'") unless theme_config(:base_version)
+        theme = magloft_api.typeloft_themes.find_by_identifier(options.theme)
+        error!("This theme already exists") unless theme.nil?
+        magloft_api.typeloft_themes.create(identifier: options.theme, name: theme_config(:name), description: theme_config(:description), base_version: theme_config(:base_version))
+        info("▸ Theme successfully created!")
+      end
+
+      desc "delete", "Delete an existing Theme on MagLoft"
+      option :token, type: :string, required: true
+      option :theme, type: :string, required: true
+      def delete
+        info("▸ Deleting theme '#{options.theme}'")
+        theme = magloft_api.typeloft_themes.find_by_identifier(options.theme)
+        error!("Could not find a theme with identifier '#{options.theme}'") if theme.nil?
+        theme.destroy
+        info("▸ Theme successfully deleted!")
+      end
+
+      desc "list", "Delete an existing Theme on MagLoft"
+      option :token, type: :string, required: true
+      def list
+        info("▸ Listing themes")
+        magloft_api.typeloft_themes.all.each do |theme|
+          info("~> #{theme.identifier} (NAME: #{theme.name}, ACTIVE: #{theme.active ? 'YES' : 'NO'})")
+        end
+      end
+    end
+  end
+end

data/lib/maglove/helper/log_helper.rb

@@ -1,12 +1,11 @@
+require "logging"
 module MagLove
   module Helper
     module LogHelper
-      @@logger = nil
-
       def info(message)
         logger.send(:info, message)
       end
-    
+
       def debug(message)
         logger.send(:debug, message)
       end
@@ -21,21 +20,7 @@ module MagLove
       end
 
       def logger
-        # reset logger on task change
-        if @@logger.nil?
-          Logging.color_scheme("bright",
-            levels: { debug: :blue, info: :green, warn: :yellow, error: :red, fatal: [:white, :on_red] },
-            date: :blue,
-            mdc: :cyan,
-            logger: :cyan,
-            message: :black
-          )
-          Logging.appenders.stdout("stdout", layout: Logging.layouts.pattern( pattern: '[%d] %-5l %-16X{command} %x %m\n', color_scheme: 'bright' ))
-          @@logger = Logging::Logger.new(self.class.name)
-          @@logger.level = :info
-          @@logger.add_appenders('stdout')
-        end
-        @@logger
+        Maglove.logger
       end
     end
   end

data/lib/maglove/middleware/live_reload.rb

@@ -0,0 +1,97 @@
+require 'filewatcher'
+require "faye"
+module MagLove
+  module Middleware
+    class LiveReload
+      include Workspace
+      attr_reader :app, :options
+
+      def initialize(app, options = {})
+        @app = app
+        @options = options
+        @theme = options[:theme]
+        @templates = options[:templates]
+      end
+
+      def call(env)
+        if env["PATH_INFO"] == @options[:mount]
+          request = Rack::Request.new(env)
+          @ws = Faye::WebSocket.new(request.env, [], {})
+          @ws.onmessage = lambda do |event|
+            message = JSON.parse(event.data)
+            command = message["command"]
+            handle_command(command, message)
+          end
+          @ws.onclose = ->(event) { clear_watcher! if @watcher }
+          @ws.rack_response
+        else
+          @app.call(env)
+        end
+      end
+
+      def clear_watcher!
+        @ws = nil
+        @watcher.stop
+        @thread.join
+        @watcher = nil
+        @thread = nil
+      end
+
+      def send_command(command, data = {})
+        data[:command] = command
+        @ws.send(JSON.dump(data)) if @ws
+      end
+
+      def handle_command(command, data = {})
+        if command == "init"
+          send_command("init", { templates: @templates })
+        elsif command == "watch"
+          watch
+        end
+      end
+
+      def watch
+        patterns = [
+          theme_file("**/*.{haml,html,coffee,js,less,scss,css,yml}"),
+          theme_file("images/**/*.{jpg,jpeg,gif,png,svg}"),
+          theme_base_file("**/*.{coffee,js,less,scss,css}"),
+          theme_base_file("images/**/*.{jpg,jpeg,gif,png,svg}")
+        ]
+        @watcher = FileWatcher.new(patterns.map(&:to_s))
+        @thread = Thread.new(@watcher) do |fw|
+          fw.watch do |filename, event|
+            if workspace_file(".", filename).exists? and event != :delete
+              if filename =~ %r{^src/base/#{theme_config(:base_version)}/.*\.coffee}
+                path = "theme.coffee"
+              elsif filename =~ %r{^src/base/#{theme_config(:base_version)}/.*\.less}
+                path = "theme.less"
+              elsif filename =~ %r{^src/base/#{theme_config(:base_version)}/.*\.scss}
+                path = "theme.scss"
+              elsif filename =~ %r{^src/themes/#{@theme}/.*\.less}
+                path = "theme.less"
+              elsif filename =~ %r{^src/themes/#{@theme}/.*\.scss}
+                path = "theme.scss"
+              elsif filename =~ %r{^src/themes/#{@theme}/.*\.coffee}
+                path = "theme.coffee"
+              else
+                path = filename.gsub("src/themes/#{@theme}/", '')
+              end
+              asset = theme_file(path).asset
+              if asset.write!
+                case asset.output_type
+                when "html"
+                  template = path.match(%r{templates/(.*)\.haml})[1]
+                  send_command("html", { template: template, contents: asset.contents })
+                when "css"
+                  send_command("css", { contents: asset.contents })
+                when "js"
+                  send_command("js", { contents: asset.contents })
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/maglove/phantom_script.rb

@@ -4,42 +4,41 @@ module MagLove
   class PhantomScript
     attr_accessor :running, :script, :options, :path, :log_file
 
-    def initialize(script, options={})
+    def initialize(script, options = {})
       @running = false
       @script = script
       @options = options.merge({
         script_path: Gem.datadir("maglove")
       })
       @path = File.absolute_path(File.join(@options[:script_path], "#{@script}.js"))
-      throw "Script #{script} not found at #{@path}" if not File.exists?(@path)
+      throw "Script #{script} not found at #{@path}" unless File.exist?(@path)
       @log_file = Tempfile.new('pslog')
     end
-  
+
     def run(*args)
       start = Time.now
       @running = true
       cmd = "phantomjs #{@path} #{@log_file.path} #{args.join(' ')}"
-    
+
       # log phantomjs info
-      @log_thread = Thread.new{
+      @log_thread = Thread.new do
         f = File.open(@log_file.path, "r")
         f.seek(0, IO::SEEK_END)
         puts "phantom@0ms ▸ (start)"
-        while @running do
+        while @running
           select([f])
           line = f.gets
           puts "phantom@#{((Time.now - start) * 1000.0).to_i}ms ▸ #{line}" if line
         end
-      }
-    
+      end
+
       # run command and return result
       result = `#{cmd}`
       @running = false
-      (result == "ERROR") ? false : result
+      result == "ERROR" ? false : result
     ensure
       @log_file.close
       @log_file.unlink
     end
-  
   end
 end

data/lib/maglove/server.rb

@@ -1,90 +1,58 @@
+require 'rack'
+require 'maglove/middleware/live_reload'
+
 module MagLove
   class Server
-    include Commander::Methods
-    attr_accessor :port, :root, :theme, :webrick
-    
-    def initialize(theme, port=3001)
-      self.theme = theme
-      self.port = port
-      self.root = "dist/"
-      @widget_stamps = {}
-      
-      # create server
-      self.webrick = WEBrick::HTTPServer.new(
-        Port: self.port,
-        DocumentRoot: self.root,
-        Logger: WEBrick::Log.new("/dev/null"),
-        AccessLog: []
-      )
-      
-      # create widget hash maps
-      Dir["widgets/*.rb"].each do |file|
-        @widget_stamps[file] = File.mtime(file).to_i
+    include Workspace
+    attr_reader :app, :options
+
+    def self.start(port, theme, templates)
+      app = Rack::Builder.new do
+        use MagLove::Middleware::LiveReload, mount: "/maglove", theme: theme, templates: templates
+        use Rack::Static, urls: ["/fonts", "/themes"], root: "dist"
+        run MagLove::Server.new(theme: theme, templates: templates, port: port)
+      end
+      Rack::Server.start(app: app, Port: port, server: :puma)
+    end
+
+    def initialize(options)
+      @options = options
+    end
+
+    def call(env)
+      template = env["PATH_INFO"].sub("/", "")
+      if env["PATH_INFO"] == "/maglove.js"
+        [200, { 'Content-Type' => 'text/javascript' }, [gem_dir.file("maglove.js").read]]
+      elsif env["PATH_INFO"] == "/maglove.css"
+        [200, { 'Content-Type' => 'text/css' }, [gem_dir.file("maglove.css").read]]
+      elsif @options[:templates].include?(template)
+        [200, { 'Content-Type' => 'text/html' }, [process(template)]]
+      else
+        [200, { 'Content-Type' => 'text/html' }, [gem_dir.file("index.haml").read_hamloft(@options)]]
       end
-      
-      # template view actions
-      templates = theme_config(:templates, self.theme)
-      templates.each do |template|
+    end
+
+    def process(template)
+      css_contents = theme_dir(root: "dist").file("theme.css").read
+      js_contents = theme_dir(root: "dist").file("theme.js").read
+      template_file = theme_dir.file("templates/#{template}.haml")
+      gem_dir.file("maglove.haml").read_hamloft(theme: @options[:theme], contents: template_file.asset.contents, css_contents: css_contents, js_contents: js_contents, template: template, asset_uri: ".", port: @options[:port] || 3000)
+    end
+
+    def setup(theme)
+      @widget_stamps = {}
+      Dir["widgets/*.rb"].each { |file| @widget_stamps[file] = File.mtime(file).to_i }
+      @options[:templates].each do |template|
         mount("/#{template}") do |req, res|
-          
           Dir["widgets/*.rb"].each do |file|
             stamp = File.mtime(file).to_i
-            if @widget_stamps[file] and @widget_stamps[file] < stamp
-              @widget_stamps[file] = stamp
-              debug("▸ reloading widget: #{file}")
-              load(file)
-            end
+            next unless @widget_stamps[file] and @widget_stamps[file] < stamp
+            @widget_stamps[file] = stamp
+            debug("▸ reloading widget: #{file}")
+            load(file)
           end
-          
-          debug("▸ rendering template: #{template}")
-          
-          # Prepare variables
-          variables = {}
-          variables_yaml = theme_contents("templates/#{template}.yml", self.theme)
-          variables = YAML.load(variables_yaml).with_indifferent_access if variables_yaml
-          variables[:theme] = self.theme
-          
-          # Render template
-          template_file = theme_glob("templates/#{template}.{html,twig,haml}", self.theme).first
-          if !template_file.nil?
-            asset = MagLove::Asset::Theme.new(template_file, self.theme, variables)
-            contents = asset.contents
-          else
-            contents = "<p style='text-align: center; margin-top: 12px;'>ERROR: Template '#{template}' not found!</p>"
-          end
-          
-          # render editor view
-          if File.exists?(theme_path("theme.haml", self.theme))
-            layout_path = theme_path("theme.haml", self.theme)
-          else
-            layout_path = File.join(Gem.datadir("maglove"), "sdk.haml")
-          end
-          haml_contents = File.read(layout_path)
-          res.body = Hamloft.render(haml_contents, theme: self.theme, contents: contents, templates: templates, template: template)
         end
       end
-      
-      self.webrick.mount "/issue", Hpub::IssueServlet
-      self.webrick.mount "/manifest.json", Hpub::ManifestServlet
-    end
-    
-    def mount_template(path, view, options={})
-      mount(path) do |req, res|
-        engine = Haml::Engine.new(parse_view(view))
-        res.body = engine.render(Object.new, options)
-      end
-    end
-    
-    def mount(path, &block)
-      self.webrick.mount_proc(path, &block)
-    end
-    
-    def run!
-      trap 'INT' do 
-        self.webrick.shutdown
-      end
-      self.webrick.start
     end
-    
   end
 end

data/lib/maglove/tilt/coffee_template.rb

@@ -17,26 +17,25 @@ module MagLove
 
       def evaluate(scope, locals, &block)
         @output = CoffeeScript.compile(@data, options)
-        
+
         # handle includes
         @output.gsub(/^include\("([^"]+)"\);$/) do |match|
           path = Regexp.last_match[1]
           path = "#{path}.coffee" if File.extname(path).empty?
           include_path = File.absolute_path(path, File.dirname(file))
-          
+
           # check if base path exists
-          if not File.exists?(include_path)
+          unless File.exist?(include_path)
             include_path = File.absolute_path(path, locals[:base_path])
           end
-          
-          if File.exists?(include_path)
+
+          if File.exist?(include_path)
             include_template = ::Tilt.new(include_path)
             include_template.render(Object.new, locals)
           else
             raise "Path not found: #{include_path}"
           end
         end
-        
       end
 
       def allows_script?
@@ -45,3 +44,5 @@ module MagLove
     end
   end
 end
+
+Tilt.mappings["coffee"] = [MagLove::Tilt::CoffeeTemplate]

data/lib/maglove/tilt/haml_template.rb

@@ -2,19 +2,19 @@ module MagLove
   module Tilt
     class HamlTemplate < ::Tilt::Template
       self.default_mime_type = 'theme/html'
-        
+
       def prepare
-      
       end
 
       def evaluate(scope, locals, &block)
-        @output ||= Hamloft::Engine.new(data, {remove_whitespace: true}).render(scope, locals)
+        @output ||= Hamloft::Engine.new(data, { remove_whitespace: true }).render(scope, locals)
       end
 
       def allows_script?
         false
       end
     end
-
   end
 end
+
+Tilt.mappings["haml"] = [MagLove::Tilt::HamlTemplate]