SassyJSON 1.0.11 → 1.1.0

data/CHANGELOG.md

@@ -1,5 +1,6 @@
 # Changelog
 
+* `1.1.0`: adding the ability to import a JSON file
 * `1.0.11`: fixing an issue with scientific number parsing
 * `1.0.10`: improving number and string helpers
 * `1.0.9`: fixing a bug in `_find-exponent`

data/README.md

@@ -26,7 +26,9 @@ npm install sassyjson --save-dev
 
 ### Sass
 
-If you only want to play around the code without cloning the repo or using npm, you can find a [single file](https://github.com/HugoGiraudel/SassyJSON/blob/master/dist/_SassyJSON.scss) containing the whole API in the [dist](https://github.com/HugoGiraudel/SassyJSON/tree/master/dist) folder. You can copy its content directly into [Sassmeister](http://sassmeister.com/) to play with the code.
+If you only want to play around the code without cloning the repo or using npm, you can find a [single file](https://github.com/HugoGiraudel/SassyJSON/blob/master/dist/_SassyJSON.scss) containing the whole API in the [dist](https://github.com/HugoGiraudel/SassyJSON/tree/master/dist) folder.
+
+Also, SassyJSON is available at [Sassmeister](http://sassmeister.com/).
 
 ## Example
 
@@ -69,6 +71,20 @@ $json-decode: json-decode('{"a": [1, 2, {"b": 1}], "b": ["#444444", false, {"a":
 // ("a": 1 2 ("b": 1), "b": #444444 false ("a": 1, "b": "test"), "c": 2 3 4 "string")
 ```
 
+## Importing and decoding a JSON file
+
+To importe and decode an external `.json` file directly into a Sass variable:
+
+``` scss
+@import 'relative/path/to/file.json?variable-name'
+// Do something with $variable-name
+```
+
+**Important:**
+
+* the path to the JSON file is relative to importing file
+* the get parameter is the variable name to use it in Sass
+
 ## Requirements
 
 All you need is a clean version of Sass 3.3. Otherwise it's just pure Sass madness.

data/lib/JsonImporter.rb

@@ -0,0 +1,229 @@
+require 'sass'
+
+
+# Monkey Path Sass
+# Adapted from: https://github.com/chriseppstein/sass-css-importer
+class Sass::Engine
+  alias initialize_without_json_importer initialize
+
+  def initialize(template, options={})
+    initialize_without_json_importer(template, options)
+
+    json_importer = self.options[:load_paths].find {|lp| lp.is_a?(Sass::Importers::JsonImporter) }
+
+    unless json_importer
+      root = File.dirname(options[:filename] || ".")
+      self.options[:load_paths] << Sass::Importers::JsonImporter.new(root)
+    end
+  end
+end
+
+module Sass
+  module Importers
+    # The default importer, used for any strings found in the load path.
+    # Simply loads Sass files from the filesystem using the default logic.
+    class JsonImporter < Base
+
+      attr_accessor :root
+
+      # Creates a new filesystem importer that imports files relative to a given path.
+      #
+      # @param root [String] The root path.
+      #   This importer will import files relative to this path.
+      def initialize(root)
+        @root = File.expand_path(root)
+        @same_name_warnings = Set.new
+      end
+
+      # Enable watching of json files in Sass 3.3+
+      def watched_directories
+        [root]
+      end
+
+      # Enable watching of json files in Sass 3.3+
+      def watched_file?(file)
+        file.start_with?(root+File::SEPARATOR) && File.extname(file) == ".json"
+      end
+      # @see Base#find_relative
+      def find_relative(name, base, options)
+        _find(File.dirname(base), name, options)
+      end
+
+      # @see Base#find
+      def find(name, options)
+        _find(@root, name, options)
+      end
+
+      # @see Base#mtime
+      def mtime(name, options)
+        name = strip_varname(name);
+        file, _ = Sass::Util.destructure(find_real_file(@root, name, options))
+        File.mtime(file) if file
+      rescue Errno::ENOENT
+        nil
+      end
+
+      # @see Base#key
+      def key(name, options)
+        name = strip_varname(name);
+        [self.class.name + ":" + File.dirname(File.expand_path(name)),
+          File.basename(name)]
+      end
+
+      # @see Base#to_s
+      def to_s
+        @root
+      end
+
+      def hash
+        @root.hash
+      end
+
+      def eql?(other)
+        root.eql?(other.root)
+      end
+
+      protected
+
+      # If a full uri is passed, this removes the root from it
+      # otherwise returns the name unchanged
+      def remove_root(name)
+        if name.index(@root + "/") == 0
+          name[(@root.length + 1)..-1]
+        else
+          name
+        end
+      end
+
+      # A hash from file extensions to the syntaxes for those extensions.
+      # The syntaxes must be `:sass` or `:scss`.
+      #
+      # This can be overridden by subclasses that want normal filesystem importing
+      # with unusual extensions.
+      #
+      # @return [{String => Symbol}]
+      def extensions
+        {'json' => :scss}
+      end
+
+      # Given an `@import`ed path, returns an array of possible
+      # on-disk filenames and their corresponding syntaxes for that path.
+      #
+      # @param name [String] The filename.
+      # @return [Array(String, Symbol)] An array of pairs.
+      #   The first element of each pair is a filename to look for;
+      #   the second element is the syntax that file would be in (`:sass` or `:scss`).
+      def possible_files(name)
+        name = escape_glob_characters(name)
+        dirname, basename, extname = split(name)
+        sorted_exts = extensions.sort
+        syntax = extensions[extname]
+
+        if syntax
+          ret = [["#{dirname}/{_,}#{basename}.#{extensions.invert[syntax]}", syntax]]
+        else
+          ret = sorted_exts.map {|ext, syn| ["#{dirname}/{_,}#{basename}.#{ext}", syn]}
+        end
+
+        # JRuby chokes when trying to import files from JARs when the path starts with './'.
+        ret.map {|f, s| [f.sub(%r{^\./}, ''), s]}
+      end
+
+      def escape_glob_characters(name)
+        name.gsub(/[\*\[\]\{\}\?]/) do |char|
+          "\\#{char}"
+        end
+      end
+
+      REDUNDANT_DIRECTORY = %r{#{Regexp.escape(File::SEPARATOR)}\.#{Regexp.escape(File::SEPARATOR)}}
+      # Given a base directory and an `@import`ed name,
+      # finds an existant file that matches the name.
+      #
+      # @param dir [String] The directory relative to which to search.
+      # @param name [String] The filename to search for.
+      # @return [(String, Symbol)] A filename-syntax pair.
+      def find_real_file(dir, name, options)
+        # on windows 'dir' can be in native File::ALT_SEPARATOR form
+        dir = dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) unless File::ALT_SEPARATOR.nil?
+
+        found = possible_files(remove_root(name)).map do |f, s|
+          path = (dir == "." || Pathname.new(f).absolute?) ? f : "#{escape_glob_characters(dir)}/#{f}"
+          Dir[path].map do |full_path|
+            full_path.gsub!(REDUNDANT_DIRECTORY, File::SEPARATOR)
+            [Pathname.new(full_path).cleanpath.to_s, s]
+          end
+        end
+        found = Sass::Util.flatten(found, 1)
+        return if found.empty?
+
+        if found.size > 1 && !@same_name_warnings.include?(found.first.first)
+          found.each {|(f, _)| @same_name_warnings << f}
+          relative_to = Pathname.new(dir)
+          if options[:_line]
+            # If _line exists, we're here due to an actual import in an
+            # import_node and we want to print a warning for a user writing an
+            # ambiguous import.
+            candidates = found.map {|(f, _)| "    " + Pathname.new(f).relative_path_from(relative_to).to_s}.join("\n")
+            Sass::Util.sass_warn <<WARNING
+WARNING: On line #{options[:_line]}#{" of #{options[:filename]}" if options[:filename]}:
+  It's not clear which file to import for '@import "#{name}"'.
+  Candidates:
+#{candidates}
+  For now I'll choose #{File.basename found.first.first}.
+  This will be an error in future versions of Sass.
+WARNING
+          else
+            # Otherwise, we're here via StalenessChecker, and we want to print a
+            # warning for a user running `sass --watch` with two ambiguous files.
+            candidates = found.map {|(f, _)| "    " + File.basename(f)}.join("\n")
+            Sass::Util.sass_warn <<WARNING
+WARNING: In #{File.dirname(name)}:
+  There are multiple files that match the name "#{File.basename(name)}":
+#{candidates}
+WARNING
+          end
+        end
+        found.first
+      end
+
+      # Splits a filename into three parts, a directory part, a basename, and an extension
+      # Only the known extensions returned from the extensions method will be recognized as such.
+      def split(name)
+        extension = nil
+        dirname, basename = File.dirname(name), File.basename(name)
+        if basename =~ /^(.*)\.(#{extensions.keys.map{|e| Regexp.escape(e)}.join('|')})$/
+          basename = $1
+          extension = $2
+        end
+        [dirname, basename, extension]
+      end
+
+      private
+
+      def strip_varname(name)
+        name.include?(".json?") ? name[0..name.rindex("?")-1] : name
+      end
+
+
+      def _find(dir, name, options)
+        if name.include? ".json?"
+          quotePos = name.rindex("?");
+          path = name[0..quotePos-1]
+          varname = name[quotePos+1..-1]
+
+          full_filename, syntax = Sass::Util.destructure(find_real_file(dir, path, options))
+          return unless full_filename && File.readable?(full_filename)
+
+          options[:syntax]   = syntax
+          options[:filename] = full_filename
+          options[:importer] = self
+
+          Sass::Engine.new("$#{varname} : json_decode('" + File.read(full_filename) + "');", options)
+        else
+          Sass::Engine.new("$hello:'test';", options)
+        end
+      end
+
+    end
+  end
+end

data/lib/SassyJSON.rb

@@ -5,8 +5,8 @@ Compass::Frameworks.register('SassyJSON', :path => extension_path)
 #  Version is a number. If a version contains alphas, it will be created as a prerelease version
 #  Date is in the form of YYYY-MM-DD
 module SassyJSON
-  VERSION = "1.0.11"
-  DATE = "2014-01-23"
+  VERSION = "1.1.0"
+  DATE = "2014-01-29"
 end
 
 module Sass::Script::Functions

metadata

@@ -1,7 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: SassyJSON
 version: !ruby/object:Gem::Version
-  version: 1.0.11
+  version: 1.1.0
+  prerelease: 
 platform: ruby
 authors:
 - Hugo Giraudel
@@ -9,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-23 00:00:00.000000000 Z
+date: 2014-01-29 00:00:00.000000000 Z
 dependencies: []
 description: Sass API for JSON
 email:
@@ -21,6 +22,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - CHANGELOG.md
+- lib/JsonImporter.rb
 - lib/SassyJSON.rb
 - stylesheets/decode/api/_json.scss
 - stylesheets/decode/decode.scss
@@ -60,26 +62,27 @@ files:
 - stylesheets/SassyJSON.scss
 homepage: https://github.com/HugoGiraudel/SassyJSON/
 licenses: []
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: SassyJSON
-rubygems_version: 2.0.3
+rubygems_version: 1.8.24
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: SassyJSON is a Sass-powered API for JSON. It provides you the classic json-encode
   and json-decode directly from your Sass files.
 test_files: []

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: b252de6ac6970e21a3b2cdcdfecbc263064be64d
-  data.tar.gz: 98888fa1e6ace45183f65b96809eb4945a211376
-SHA512:
-  metadata.gz: ed3b1b5469126f55682340b2f0957ff2bcc13faa9c289a280e35c3a4c97c960627b50941378dd1dfa1c5e611719627be10151946b849e91762d94e54cad492b0
-  data.tar.gz: c319e4e58baa7e2cd4316a227ac2809eb6a9ae67fb9e413ad537e65298b81d18b5c97c13358d2afa94216d02ce9274b9e10cedb709a6aedb87ba596c666e94b1