vic 0.0.4 → 0.0.5

data/lib/vic.rb

@@ -1,8 +1,9 @@
 module Vic
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end
 
-require 'set'
+require 'vic/color'
+require 'vic/color_error'
 require 'vic/colorscheme'
 require 'vic/colorscheme/highlight'
 require 'vic/colorscheme/highlight_set'

data/lib/vic/color.rb

@@ -0,0 +1,86 @@
+module Vic
+  module Color extend self
+    # System colors (0-15)
+    SYSTEM_COLORS = [
+      [0x00, 0x00, 0x00],
+      [0x80, 0x00, 0x00],
+      [0x00, 0x80, 0x00],
+      [0x80, 0x80, 0x00],
+      [0x00, 0x00, 0x80],
+      [0x80, 0x00, 0x80],
+      [0x00, 0x80, 0x80],
+      [0xc0, 0xc0, 0xc0],
+      [0x80, 0x80, 0x80],
+      [0xff, 0x00, 0x00],
+      [0x00, 0xff, 0x00],
+      [0xff, 0xff, 0x00],
+      [0x00, 0x00, 0xff],
+      [0xff, 0x00, 0xff],
+      [0x00, 0xff, 0xff],
+      [0xff, 0xff, 0xff]
+    ]
+
+    # RGB colors (16 - 231)
+    RGB_COLORS = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff].repeated_permutation(3).to_a
+
+    # Grayscale colors (232 - 255)
+    GRAYSCALE_COLORS = (0x08..0xee).step(0x0a).to_a.map {|v| Array.new(3).fill(v) }
+
+    # All 256 colors of the rainbow. Organized from 0 to 255.
+    COLORS_256 = SYSTEM_COLORS + RGB_COLORS + GRAYSCALE_COLORS
+
+    # Convert hexidecimal color to an Array of RGB values.
+    #
+    # @param [String] hex the hexidecimal color
+    # @return [Array] the RGB color conversion
+    def hex_to_rgb(hex)
+      hex.match(/#?(..)(..)(..)/)[1..4].to_a.map {|v| v.to_i(16) }
+    end
+
+    # Takes a hexidecimal color and returns is closest 256 color match.
+    #
+    # Credit goes to Micheal Elliot for the algorithm which was originally written
+    # in Python.
+    #
+    # @see https://gist.github.com/719710
+    # @param [String] hex the hexidecimal color
+    # @return [FixNum] the closest 256 color match
+    def hex_to_256(hex)
+      parts = hex_to_rgb(hex)
+
+      # If the hex is a member of the 256 colors club, we'll just return it's 256
+      # color value. No sense in doing extra work, right?
+      return COLORS_256.index(parts) if COLORS_256.include?(parts)
+
+      increments = 0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff
+
+      # For each part we need to check if it's between any two of the increments.
+      # If it is we'll determine the closest match, change it's value, break,
+      # and move on to the next part.
+      parts.map! do |part|
+        closest = nil
+        for i in (0..(increments.length - 1))
+          lower = increments[i]
+          upper = increments[i + 1]
+          next unless (lower <= part) && (part <= upper)
+          distance_from_lower = (lower - part).abs
+          distance_from_upper = (upper - part).abs
+          closest = distance_from_lower < distance_from_upper ? lower : upper
+          break
+        end
+        closest
+      end
+
+      # Return the index of the color
+      COLORS_256.index(parts)
+    end
+
+    # Checks if the subjec is a valid hexidecimal color.
+    #
+    # @param [String] subject the string in question
+    # @return [Match
+    def hex_color?(subject)
+      subject.match(/#[\da-f]{6}/) ? true : false
+    end
+  end
+end

data/lib/vic/color_error.rb

@@ -0,0 +1,7 @@
+module Vic
+  class ColorError < StandardError
+    def initialize
+      super('invalid color')
+    end
+  end
+end

data/lib/vic/colorscheme.rb

@@ -72,8 +72,16 @@ module Vic
       hilight = highlight_set.find_by_group(group)
       no_args = args.empty?
 
+      # If the highlight doesn't exist or no args were passed, create the
+      # highlight. This enables more flexible syntax for situations where you
+      # may need to create or update a highlight using this syntax:
+      #
+      #   `hi('Normal').gui('bold')
+      #
+      # Note: If a highlight has no arguments it isn't rendered.
       if not hilight and no_args
-        return
+        hilight = Highlight.new("#{language}#{group}")
+        highlight_set.add(hilight)
       elsif hilight and no_args
         return hilight
       elsif hilight

data/lib/vic/colorscheme/highlight.rb

@@ -1,5 +1,7 @@
 module Vic
   class Colorscheme::Highlight
+    include Vic::Color
+
     attr_accessor :group
 
     # Creates an instance of Vic::Colorscheme::Highlight. Uses
@@ -15,24 +17,52 @@ module Vic
 
     # Sets the methods term, term=, start, start=, etc. for settings arguments.
     self.class_eval do
-      %w{term start stop cterm ctermfg ctermbg gui guibg guifg}.each do |m|
-        define_method(m) {
-          argument = argument_set.find_by_key(m)
-          return argument.arg if argument
-        }
-        define_method("#{m}=") {|val|
-          argument = argument_set.find_by_key(m)
-          if argument
-            argument.arg = val
+      %w{term start stop cterm ctermfg ctermbg gui guifg guibg}.each do |m|
+
+        # Getter method
+        define_method(m) do
+          arg = argument_set.find_by_key(m)
+          return arg.val if arg
+        end
+
+        # Setter method
+        define_method("#{m}=") do |val|
+          arg = argument_set.find_by_key(m)
+          if arg
+            arg.val = val
           else
-            argument = Argument.new(m, val)
-            argument_set.add argument
+            arg = Argument.new(m, val)
+            argument_set.add arg
           end
-          val
-        }
+
+          # Return self for chaining
+          self
+        end
       end
     end
 
+    # Sets guifg and ctermfg simultaneously. `hex` is automatically converted to
+    # the 256 color code for ctermfg.
+    #
+    # @param [String] hex a hexidecimal color
+    def fg=(hex)
+      self.guifg = hex
+      self.ctermfg = Color.hex_to_256(hex)
+
+      # Return self for chaining
+      self
+    end
+
+    # Sets guibg and ctermbg simultaneously. `hex` is automatically converted to
+    # the 256 color code for ctermbg.
+    def bg=(hex)
+      self.guibg = hex
+      self.ctermbg = Color.hex_to_256(hex)
+
+      # Return self for chaining
+      self
+    end
+
     # Updates/sets the current highlight's arguments.
     #
     # @param [Hash] args the arguments to update/set, `:guibg => '#333333'`
@@ -54,7 +84,7 @@ module Vic
     #
     # @return [String] the highlight as a string
     def write
-      "hi #{group} #{arguments.sort_by_key.map(&:write).join(' ')}"
+      "hi #{group} #{arguments.sort_by_key.map(&:write).compact.join(' ')}"
     end
   end
 end

data/lib/vic/colorscheme/highlight/argument.rb

@@ -1,23 +1,19 @@
 module Vic
   class Colorscheme::Highlight::Argument
-    VALID = {
-      :normal_terminal => %w{term start stop},
-      :color_terminal  => %w{cterm ctermfg ctermbg},
-      :gui             => %w{gui guifg guibg guisp font}
-    }
+    VALID = %w{term start stop cterm ctermfg ctermbg gui guifg guibg guisp font}
 
-    attr_accessor :key, :arg
+    attr_accessor :key, :val
 
-    def initialize(key, arg)
-      @key, @arg = key, arg
+    def initialize(key, val)
+      @key, @val = key, val
     end
 
     # The argument as a string
     #
     # @return [String,nil] the string if argument has been set
     def write
-      return unless arg
-      "#{key}=#{arg.respond_to?(:join) ? arg.join(',') : arg}"
+      return unless val
+      "#{key}=#{val.respond_to?(:join) ? val.join(',') : val}"
     end
 
     # Checks if `key` is valid vim key for an argument
@@ -25,7 +21,7 @@ module Vic
     # @param [String,Symbol]
     # @return [true,false] the key is valid
     def self.is_valid?(key)
-      VALID.values.flatten.include?(key.to_s)
+      VALID.include?(key.to_s)
     end
   end
 end

data/lib/vic/colorscheme/highlight/argument_set.rb

@@ -1,14 +1,25 @@
 module Vic
-  class Colorscheme::Highlight::ArgumentSet < Set
+  class Colorscheme::Highlight::ArgumentSet
+    include Enumerable
+
+    def arguments
+      @arguments ||= []
+    end
+
+    def each
+      arguments.each {|a| yield a }
+    end
+
     # Adds a new argument to the set
     #
     # @param [Colorscheme::Highlight::Argument] argument the argument to add
     # @return [Colorscheme::Highlight::ArgumentSet] the new set of arguments
     def add(argument)
-      if argument.respond_to? :arg
-        super(argument)
+      if argument.respond_to? :val
+        arguments.push argument
       else
         # Raise an Exception
+        raise TypeError.new("expted type Colorscheme::Highlight::Argument")
       end
     end
 
@@ -24,7 +35,7 @@ module Vic
     #
     # @return [Colorscheme::Highlight::ArgumentSet] the sorted set of arguments
     def sort_by_key
-      sort {|a, b| a.key <=> b.key}
+      sort {|a, b| a.key.to_s <=> b.key.to_s }
     end
   end
 end

data/lib/vic/colorscheme/highlight_set.rb

@@ -1,17 +1,32 @@
 module Vic
-  class Colorscheme::HighlightSet < Set
+  class Colorscheme::HighlightSet
+    include Enumerable
+
+    def highlights
+      @highlights ||= []
+    end
+
+    def each
+      highlights.each {|h| yield h }
+    end
+
     # Adds a highlight to the set.
     #
     # @param [Colorscheme::Highlight] highlight the highlight to add
     # @return [Colorscheme::HighlightSet] the updated set of highlights
     def add(highlight)
-      if highlight.respond_to?(:group)
-        super(highlight)
+      if highlight.respond_to? :gui
+        highlights.push highlight
       else
         # Raise and Exception
+        raise TypeError.new("expected type Colorscheme::Vic::Highlight")
       end
     end
 
+    # Find a highlight by group name
+    #
+    # @param [String] group the group name
+    # @return [Colorscheme::Highlight,nil] the highlight
     def find_by_group(group)
       find {|h| h.group == group }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vic
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -18,6 +18,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/vic.rb
+- lib/vic/color.rb
+- lib/vic/color_error.rb
 - lib/vic/colorscheme.rb
 - lib/vic/colorscheme/highlight.rb
 - lib/vic/colorscheme/highlight_set.rb
@@ -48,3 +50,4 @@ signing_key:
 specification_version: 3
 summary: Create Vim colorschemes
 test_files: []
+has_rdoc: