stylish 0.0.1 → 0.0.2

data/lib/stylish/developer/server.rb

@@ -0,0 +1,40 @@
+module Stylish
+  module Developer
+    class Server
+      def self.call(env)
+        route = Route.request(env)
+        status, headers, body = route.respond()
+
+        headers["Content-Length"]                 = Rack::Utils.bytesize(body[0]).to_s
+        headers["Access-Control-Allow-Origin"]    = "*"
+        headers["Access-Control-Allow-Methods"]   = "GET, POST, PUT"
+
+        [status, headers, body]
+      end
+
+      def self.config
+        Stylish::Developer.config
+      end
+
+      def self.sprockets
+        return config.environment if config.environment
+
+        @sprockets_environment ||= Sprockets::Environment.new(library.root).tap do |env|
+          library.packages.each do |pkg|
+            pkg.root.children.select(&:directory?).each do |dir|
+              env.append_path(dir)
+            end
+          end
+        end
+      end
+
+      def self.root
+        Pathname(config.root || Dir.pwd())
+      end
+
+      def self.library
+        config.library
+      end
+    end
+  end
+end

data/lib/stylish/engine.rb

@@ -0,0 +1,12 @@
+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/fs.rb

@@ -0,0 +1,59 @@
+module Stylish
+  module Fs
+
+    ExtensionsMap = {
+      slim: ".html.slim",
+      erb: ".html.erb",
+      haml: ".html.haml",
+      markdown: ".html.md",
+      html: ".html",
+      coffeescript: ".coffee",
+      sass: ".sass",
+      scss: ".scss",
+      less: ".less",
+      javascript: ".js",
+      css: ".css"
+    }
+
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :source_language, Symbol, :default => lambda {|model,attr| model.path && model.path.extname }
+      attribute :contents, String
+    end
+
+    def save
+      file_proxy.open("w+") do |fh|
+        fh.write(persistable_contents)
+      end
+    end
+
+    def filename
+      (path_exists? ? path.basename : "#{ name }".parameterize + ".json")
+    end
+
+    def path_exists?
+      path && path.exist?
+    end
+
+    def default_extension
+      # TODO
+      # Should we use Tilt::Template
+      ExtensionsMap[source_language]
+    end
+
+    def persistable_contents
+      contents
+    end
+
+    def contents
+      orig = super.to_s
+      orig.length > 0 ? orig : path.try(:read).to_s
+    end
+
+    # Eventually Could either be a GHFS::File or a normal File
+    def file_proxy
+      Pathname(path)
+    end
+  end
+end

data/lib/stylish/manifest.rb

@@ -0,0 +1,100 @@
+module Stylish
+  class Manifest
+
+    attr_reader :path, :options, :content
+
+    # A stylish manifest is a JSON or YAML configuration
+    # file that defines the composition of a stylish theme
+    def initialize(path=nil, options={})
+      @path     = path && Pathname(path)
+      @options  = options
+
+      @content          = options.fetch(:content) { self.path && self.path.read }
+      @root             = options.fetch(:root) { self.path && self.path.dirname }
+
+      @templates        = options.fetch(:templates) { manifest.templates || "templates" }
+      @stylesheets      = options.fetch(:stylesheets) { manifest.stylesheets || "stylesheets" }
+      @scripts          = options.fetch(:scripts) { manifest.scripts || "scripts" }
+      @pages            = options.fetch(:scripts) { manifest.pages || "pages" }
+      @layouts          = options.fetch(:scripts) { manifest.layouts || "layouts" }
+      @components       = options.fetch(:scripts) { manifest.components || "components" }
+    end
+
+    def to_hash
+      {
+        name: name,
+        version: version,
+        categories: categories,
+        root: root.to_s,
+        assets: assets
+      }
+    end
+
+    def assets
+      {
+        templates: templates.to_s,
+        stylesheets: stylesheets.to_s,
+        scripts: scripts.to_s
+      }
+    end
+
+    def name
+      options.fetch(:name) { manifest.name }
+    end
+
+    def version
+      options.fetch(:version) { manifest.version }
+    end
+
+    def categories
+      Array(options.fetch(:categories) { manifest.categories })
+    end
+
+    def root
+      @root && Pathname(@root)
+    end
+
+    def templates
+      root.join(@templates)
+    end
+
+    def stylesheets
+      root.join(@stylesheets)
+    end
+
+    def scripts
+      root.join(@scripts)
+    end
+
+    def components
+      root.join(@components)
+    end
+
+    def pages
+      root.join(@pages)
+    end
+
+    def layouts
+      root.join(@layouts)
+    end
+
+    def manifest
+      @manifest ||= load_manifest.to_mash
+    end
+
+    def load_manifest
+      if format == "json"
+        JSON.parse(content) rescue {}
+      elsif format == "yml"
+        YAML.load(content) rescue {}
+      end
+    end
+
+    def format
+      options.fetch(:format) do
+        path && path.extname.gsub(/^\./,'')
+      end
+    end
+
+  end
+end

data/lib/stylish/models.rb

@@ -0,0 +1,119 @@
+module Stylish
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      unless defined?(Virtus)
+        require 'inflecto'
+        require 'virtus'
+      end
+
+      include Virtus.model(finalize: false)
+      include Initializers
+      include AccessorMethods
+    end
+
+    def self.find_class_for_group(group)
+      group = group.to_s
+      case
+      when group == "layouts"
+        Stylish::Layout
+      when group == "components"
+        Stylish::Component
+      when group == "pages"
+
+      when group == "templates"
+        Stylish::Template
+      when group == "scripts"
+        Stylish::Script
+      when group == "stylesheets"
+        Stylish::Stylesheet
+      end
+    end
+
+    module Initializers
+      def set_default_attributes
+        attribute_set.set_defaults(self)
+        send(:after_initialize) if respond_to?(:after_initialize)
+        self.class.register(self)
+        self
+      end
+
+      def after_initialize
+        # TODO
+      end
+
+      def set_slug_from(column=:name)
+        self.slug = send(column).to_s.downcase.parameterize if self.slug.to_s.length == 0
+      end
+    end
+
+    module AccessorMethods
+      def update_attributes(attrs={})
+        writers = self.class.allowed_writer_methods.map(&:to_s)
+        keys = writers & attrs.keys.map {|k| "#{k}=" }
+
+        keys.each do |key|
+          value = attrs[key.gsub(/=$/,'')]
+          self.send(key, value)
+        end
+
+        !!(save)
+      end
+
+      def uid
+        self.path if self.respond_to?(:path)
+      end
+
+      def as_json(*args)
+        super.tap do |h|
+          h.symbolize_keys!
+          h.delete(:contents)
+
+          if h[:path].is_a?(Hash)
+            h[:path] = h[:path]['path']
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+
+      def model_instances
+        @_model_instances ||= []
+      end
+
+      def find_instance_by_uid(uid)
+        self.model_instances.detect {|m| m.uid == uid }
+      end
+
+      def register(model)
+        self.model_instances.push(model) unless model.uid && find_instance_by_uid(model.uid)
+      end
+
+      def browse(path, params={})
+        binding.pry
+      end
+    end
+  end
+
+  module Models
+    Types = %w(library package theme component layout stylesheet script template)
+
+    def self.lookup(model_alias)
+      a = model_alias.singularize.downcase
+
+      if Types.include?(a)
+        Stylish.const_get(a.camelize)
+      end
+    end
+
+    def self.load_all
+      Types.each do |type|
+        require "stylish/models/#{ type }"
+      end
+
+      Virtus.finalize
+    end
+  end
+end

data/lib/stylish/models/component.rb

@@ -0,0 +1,19 @@
+module Stylish
+  class Component
+    include Stylish::Model
+    include Stylish::Fs
+
+    attribute :name, String
+    attribute :category, String
+    attribute :tags, Array
+    attribute :path, Pathname
+
+    attribute :template_path, String
+    attribute :script_path, String
+    attribute :stylesheet_path, String
+
+    def persistable_contents
+      as_json.to_json
+    end
+  end
+end

data/lib/stylish/models/layout.rb

@@ -0,0 +1,19 @@
+module Stylish
+  class Layout
+    include Stylish::Model
+    include Stylish::Fs
+
+    attribute :name, String
+    attribute :category, String
+    attribute :tags, Array
+    attribute :path, Pathname
+
+    attribute :template_path, String
+    attribute :script_path, String
+    attribute :stylesheet_path, String
+
+    def persistable_contents
+      as_json.to_json
+    end
+  end
+end

data/lib/stylish/models/library.rb

@@ -0,0 +1,134 @@
+module Stylish
+  # A `Stylish::Library` is a collection of Packages.
+  #
+  # Packages will be stored as folders underneath the root
+  # folder which is the library.  Each package will have its
+  # own manifest.
+  class Library
+    include Stylish::Model
+
+    attribute :name, String
+    attribute :root, Pathname
+    attribute :packages, Array['Stylish::Package']
+
+    class << self
+      attr_accessor :loaded
+
+      def current
+        first = loaded.first
+        return first if first
+
+        pwd = Pathname(Dir.pwd)
+
+        if pwd.join("library").exist?
+          Stylish::Library.load_from_disk(pwd.join("library"))
+          loaded.first
+        end
+      end
+    end
+
+    self.loaded = Set.new if self.loaded.nil?
+
+    def packages
+      super.tap do |list|
+        list.map! {|p| p.library = self; p }
+      end
+    end
+
+    def package_roots
+      list = packages.map(&:root)
+      block_given? ? yield(list) : list
+    end
+
+    def create_package(attributes, options={})
+      library = self
+
+      Stylish::Package.new(attributes).tap do |p|
+        p.library = library
+        p.initialize_folder_structure if !p.root.exist?
+      end
+    end
+
+    def find_package(query)
+      if query.is_a?(Hash)
+        query = query[:name]
+      end
+
+      packages.detect {|package| package.name == query || package.slug == query}
+    end
+
+    def slug
+      name.to_s.parameterize.downcase
+    end
+
+    # Loads a deserialized library cache, which we expect to
+    # be a Hash that contains at least an array of library records.
+    #
+    # Example:
+    #
+    #   Stylish::Library.load({
+    #     libraries:[{...},{...}]
+    #   })
+    #
+    def self.load(structure, options={})
+      structure = structure.to_mash if structure.is_a?(Hash)
+
+      self.loaded = Set.new if options[:reset]
+
+      # We're loading a collection of libraries
+      if structure.libraries
+        self.loaded += structure.libraries.map do |library|
+          new(library)
+        end
+      # we're loading a single library
+      elsif structure.packages
+        self.loaded << new(structure)
+      end
+    end
+
+    def self.find_by_root(root)
+      loaded.detect do |lib|
+        lib.root.to_s == root.to_s || lib.package_roots.map(&:to_s).include?(root.to_s)
+      end
+    end
+
+    # Loads the stylish library metadata from a file on disk
+    def self.load_from_disk(config_file_path=nil, options={})
+      path = "#{config_file_path || Stylish.config.config_file_path}".to_pathname
+
+      raise "Invalid path" unless path.exist?
+
+      if path.directory?
+        library = path.join("library.json")
+
+        if library.exist?
+          structure = Stylish.util.deserialize(library)
+        else
+          structure = {root: path, packages: (path.children
+            .select(&:directory?)
+            .select {|p| p.join('manifest.json').exist? || p.join('manifest.yml').exist? }
+            .map do |p|
+              { root: p }
+            end)
+          }
+        end
+      else
+        structure = Stylish.util.deserialize(path)
+      end
+
+      load(structure, options)
+    end
+
+    # Loads the stylish library metadata from a file in a github repository
+    #
+    # if the name of a repository is not passed (e.g.
+    # stylish/sample-theme-one) then we will attempt to use the
+    # default repository specified in the global configuration
+    def self.load_from_github_repository(repository=nil)
+      Stylish.ghfs.repository = repository if repository
+      structure = Stylish.util.deserialize(Stylish.ghfs.open("library.json").read)
+
+      load(structure)
+    end
+  end
+end