stylish 0.0.1 → 0.0.2

data/lib/stylish/developer/listing.rb

@@ -0,0 +1,85 @@
+module Stylish
+  module Developer
+    class Listing
+      attr_reader :request_path, :request_type
+
+      def initialize(request_path, request_type="list")
+        @request_path = request_path
+        @requst_type = request_type
+      end
+
+      def response_code
+        case
+          when expanded_path.exist? && expanded_path.directory?
+            200
+          when !expanded_path.exist?
+            404
+          when !expanded_path.directory?
+            400
+          else
+            500
+        end
+      end
+
+      def response
+        root = Stylish::Developer.config.root
+        prefix = Stylish::Developer.config.base_url
+
+        walk = lambda do |path_node|
+          relative = path_node.relative_path_from(root)
+
+          if path_node.file?
+            {
+              is_file: true,
+              path: relative.to_s,
+              urls: {
+                content: "#{ prefix }/content/#{ relative  }",
+                compiled: "#{ prefix }/compiled/#{ relative  }",
+                meta: "#{ prefix }/meta/#{ relative }"
+              }
+            }
+          else
+            {
+              path: relative.to_s,
+              is_folder: true,
+              children: path_node.children.map {|c| walk.call(c) },
+              urls: {
+                list: "#{ prefix }/list/#{ relative }"
+              }
+            }
+          end
+        end
+
+
+        {
+          path: expanded_path.relative_path_from(root).to_s,
+          children: expanded_path.children.map {|n| walk.call(n) },
+          is_folder: true
+        }
+      end
+
+      def expanded_path
+        Pathname(request_path).expand_path(Stylish::Developer.config.root)
+      end
+
+      def response_headers
+        {
+          "Content-Length" => "#{content_length}",
+          "Content-Type" => "application/json"
+        }
+      end
+
+      def response_body
+        response.to_json
+      end
+
+      def content_length
+        Rack::Utils.bytesize(response_body)
+      end
+
+      def to_rack_response
+        [response_code, response_headers, [response_body]]
+      end
+    end
+  end
+end

data/lib/stylish/developer/model_delegator.rb

@@ -0,0 +1,51 @@
+module Stylish
+  module Developer
+    class ModelDelegator
+      attr_reader :path, :action, :request, :library, :prefix, :parts, :path_args
+
+      attr_accessor :code
+
+      def initialize(path, action, prefix, options)
+        @path       = path
+        @action     = action
+        @request    = options.fetch(:request, nil)
+        @path_args  = options.fetch(:path_args, [])
+        @prefix     = prefix
+        @library    = library || Stylish::Developer.config.library
+        @code       = 200
+        @parts      = path.split("/")
+      end
+
+      def response_body
+        case
+        when prefix == "packages" && action == "browse"
+          library.packages.map(&:to_hash)
+        when prefix == "packages" && action == "show"
+          slug = parts.first
+          package = library.find_package(slug)
+          package.to_hash(true)
+        when %w(layouts components pages).include?(prefix)
+          slug = parts.first
+          package = library.find_package(slug)
+          resp = package.handle_request(prefix, action, parts, request: request, params: request.params.to_mash)
+
+          resp
+        else
+          self.code = 400
+
+          {
+            error: "invalid request",
+            path: path,
+            action: action,
+            prefix: prefix,
+            request: request.path
+          }
+        end
+      end
+
+      def to_rack_response
+        [code, {"Content-Type"=>"application/json"}, [response_body.to_json] ]
+      end
+    end
+  end
+end

data/lib/stylish/developer/modification.rb

@@ -0,0 +1,139 @@
+module Stylish
+  module Developer
+
+    # Handles a request to modify an asset that belongs to
+    # a Stylish package.
+    class Modification
+      attr_reader :actual_path,
+                  :request,
+                  :request_type
+
+      attr_accessor :code, :body, :headers
+
+      def initialize(actual_path, request_type, request)
+        @actual_path    = actual_path
+        @request_type   = request_type
+        @request        = request
+
+        @code    = nil
+        @headers = {}
+        @body    = {}
+      end
+
+      def current_root
+        Stylish::Developer.server.root
+      end
+
+      def file
+        current_root.join(actual_path)
+      end
+
+      def file_exists?
+        file && file.exist?
+      end
+
+      def file_exist?
+        file_exists?
+      end
+
+      def file_writable?
+        file && file.writable?
+      end
+
+      def update?
+        request_type == "update"
+      end
+
+      def delete?
+        request_type == "delete"
+      end
+
+      def create?
+        request_type == "create"
+      end
+
+      def has_errors?
+        body.key?(:errors) && !body[:errors].empty?
+      end
+
+      def add_error(message)
+        self.code = 500
+
+        binding.pry
+
+        body[:errors] ||= []
+        body[:errors] << message
+      end
+
+      def handle
+        return if @handled
+
+        if file_exists? && file_writable?
+          handle_existing_file_modification
+        elsif file_exist? && !file_writable?
+          handle_access_denied_error
+        else
+          handle_non_existing_file_modification
+        end
+
+        @handled = true
+      end
+
+      def handle_access_denied_error
+        add_error("Can not access file at #{ actual_path }. File not writable")
+      end
+
+      def handle_existing_file_modification
+        if create?
+          add_error("Can not create file at #{ actual_path }. Already exists")
+        elsif update?
+          file.open("w") {|fh| fh.write(contents) }
+          load_path_meta
+        elsif delete?
+          path = file.to_s
+          file.unlink if file.file?
+          file.rmdir if file.directory?
+          self.code = 200
+          self.body = {status: "deleted", path: path}
+        end
+      end
+
+      def contents
+        request.params['contents']
+      end
+
+      def handle_non_existing_file_modification
+        if update? || delete?
+          add_error("Can not perform #{ request_type } on #{ actual_path }. File not found")
+        elsif create?
+          FileUtils.mkdir_p(File.dirname(file))
+
+          file.open("w+") {|fh| fh.write(contents) }
+          load_path_meta
+        end
+      end
+
+      def load_path_meta
+        @meta_path = Stylish::Developer::Path.new(actual_path, "meta")
+      end
+
+      def body_contents
+        @body = @body.to_json if @body.is_a?(Hash)
+        @body = @body.first if @body.is_a?(Array)
+        @body.to_s
+      end
+
+      def to_rack_response
+        handle
+
+        return @meta_path.to_rack_response if @meta_path
+
+        [
+          code,
+          headers,
+          [body_contents]
+        ]
+      end
+    end
+  end
+end

data/lib/stylish/developer/path.rb

@@ -0,0 +1,168 @@
+module Stylish
+  module Developer
+    class Path
+      attr_reader :request_path, :request_type
+
+      def initialize(request_path, request_type="content")
+        @request_path = request_path.to_s
+        @request_type = request_type
+      end
+
+      def asset
+        @asset ||= begin
+                     parts = request_path.split('/')
+
+                     found = !!(sprockets.find_asset(request_path))
+
+                     until found || parts.empty?
+                       test = parts.join('/')
+                       found = !!!(sprockets.find_asset(test).nil?)
+                       parts.shift unless found
+                     end
+
+                      sprockets.find_asset Array(parts).join('/')
+                   end
+      end
+
+      def exists_under_root?
+        expanded_path.exist?
+      end
+
+      def sprockets
+        self.class.sprockets
+      end
+
+      def self.sprockets
+        @sprockets ||= Stylish::Developer.config.environment
+      end
+
+      def expanded_path
+        Pathname(request_path).expand_path(Stylish::Developer.config.root)
+      end
+
+      def asset_exists?
+        expanded_path.exist?
+      end
+
+      def sprockets_asset
+        sprockets.find_asset(asset)
+      end
+
+      def meta?
+        request_type == "meta"
+      end
+
+      def content?
+        request_type == "content"
+      end
+
+      def compiled?
+        request_type == "compiled"
+      end
+
+      def response_headers
+        {
+          "Content-Length"  => "#{Rack::Utils.bytesize(response_body)}",
+          "Content-Type"    => content_type
+        }
+      end
+
+      def response_body
+        @response_body ||= begin
+                             case
+                             when not_found?
+                               {
+                                 status: 404,
+                                 message: "Not Found"
+                               }.to_json
+                             when content?
+                               asset.pathname.read
+                             when compiled?
+                               asset.to_s
+                             when meta?
+                               meta.to_json
+                             end
+                           end
+      end
+
+      def raw_asset_content
+        begin
+          asset.pathname.read
+        rescue => exception
+          "Error reading asset content:\n\n#{exception.message}"
+        end
+      end
+
+      def compiled_asset_content
+        begin
+          asset.to_s
+        rescue => exception
+          "Error compiling asset content:\n\n#{ exception.message }"
+        end
+      end
+
+      def extension
+        File.extname(asset.logical_path)
+      end
+
+      def content_type
+        asset.content_type
+      end
+
+      def relative_pathname
+        Pathname(asset.pathname.relative_path_from(Stylish::Developer.config.root))
+      end
+
+      def prefix
+        Stylish::Developer.config.base_url
+      end
+
+      def meta
+        {
+          logical_path: asset.logical_path,
+          mtime: asset.mtime.to_i.to_s,
+          digest: asset.digest,
+          pathname: relative_pathname.to_s,
+          size: asset.bytesize.to_s,
+          urls: {
+            meta_url: "#{ prefix }/meta/#{relative_pathname}",
+            compiled_url: "#{ prefix }/compiled/#{relative_pathname}",
+            content_url: "#{ prefix }/content/#{relative_pathname}"
+          },
+          dependencies: asset.dependencies.map do |dependency|
+            dependency.logical_path
+          end
+        }
+      end
+
+      def status_code
+        @status_code ||= begin
+                           case
+                           when exists_under_root?
+                             200
+                           when !exists_under_root?
+                             404
+                           else
+                             500
+                           end
+                         end
+      end
+
+      def to_rack_response
+        [status_code, response_headers, [response_body]]
+      end
+
+      def not_found?
+        status_code == 404
+      end
+
+      def error?
+        status_code == 500
+      end
+
+      def success?
+        status_code == 200 || status_code == 304
+      end
+    end
+  end
+end

data/lib/stylish/developer/route.rb

@@ -0,0 +1,97 @@
+module Stylish
+  module Developer
+    # The Route class is responsible for routing requests to the API
+    # to their appropriate handler.
+    class Route
+      def self.request(env)
+        new(env)
+      end
+
+      attr_reader :env
+
+      def initialize(env)
+        @env = env
+      end
+
+      def request
+        @request      ||= Rack::Request.new(env)
+      end
+
+      def prefix
+        Stylish::Developer.config.base_url
+      end
+
+      def respond
+        data = case
+
+        when %w{meta content compiled}.include?(request_type)
+          path_handler.to_rack_response()
+
+        when request_type == "list"
+          listing_handler.to_rack_response()
+
+        when request_type == "models"
+          models_handler.to_rack_response()
+
+        when request_type == "info"
+          info_handler_rack_response
+
+        when %w(create update delete).include?(request_type)
+          modification_handler.to_rack_response()
+
+        else
+          [404, {}, ['Not found']]
+        end
+
+        status, headers, body = data
+
+        [status, headers, body]
+      end
+
+      def info_handler_rack_response
+        body = {
+          root: Stylish::Developer.server.root.to_s,
+          sprockets_paths: Stylish::Developer.server.sprockets.paths,
+          library: Stylish::Developer.config.library.as_json
+        }.to_json
+
+        headers = {
+          "Content-Type" => "application/json"
+        }
+
+        [200, headers, [body]]
+      end
+
+      def models_handler
+        path_args = actual_path.split("/")
+        parts     = path_args.dup
+        action    = parts.shift
+        prefix    = parts.shift
+        path      = parts.join("/")
+
+        @models_handler ||= Stylish::Developer::ModelDelegator.new(path, action, prefix, request: request, path_args: path_args)
+      end
+
+      def modification_handler
+        @modification_handler ||= Stylish::Developer::Modification.new(actual_path, request_type, request)
+      end
+
+      def listing_handler
+        @listing_handler ||= Stylish::Developer::Listing.new(actual_path, request_type)
+      end
+
+      def path_handler
+        @path_handler ||= Stylish::Developer::Path.new(actual_path, request_type)
+      end
+
+      def actual_path
+        request.path[/^#{ prefix }\/(\w+)\/(.+)$/, 2]
+      end
+
+      def request_type
+        return "info" if request.path.match(/^#{prefix}\/info$/)
+        request.path[/^#{ prefix }\/(\w+)\/(.+)$/, 1]
+      end
+    end
+  end
+end