vic 0.0.6 → 1.0.0

data/lib/vic.rb

@@ -1,11 +1,12 @@
 module Vic
-  VERSION = '0.0.6'
+  VERSION = '1.0.0'.freeze
 end
 
+require 'ostruct'
+require 'vic/color_scheme'
+require 'vic/color_scheme_writer'
 require 'vic/color'
-require 'vic/color_error'
-require 'vic/colorscheme'
-require 'vic/colorscheme/highlight'
-require 'vic/colorscheme/highlight_set'
-require 'vic/colorscheme/highlight/argument'
-require 'vic/colorscheme/highlight/argument_set'
+require 'vic/convert'
+require 'vic/xterm_color'
+require 'vic/highlight'
+require 'vic/link'

data/lib/vic/color.rb

@@ -1,87 +1,104 @@
 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]
-    ]
+  class Color
+    attr_accessor :value
 
-    # 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) }
+    def initialize(value)
+      @value = value
+    end
 
-    # All 256 colors of the rainbow. Organized from 0 to 255.
-    COLORS_256 = SYSTEM_COLORS + RGB_COLORS + GRAYSCALE_COLORS
+    class ColorError < RuntimeError; end
 
-    # Convert hexidecimal color to an Array of RGB values.
+    # Convert the color value to a hexadecimal color
+    #
+    # @return [Symbol,String]
+    #   the color as either "NONE" or hexadecimal
     #
-    # @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) }
+    # @api public
+    def to_gui
+      return to_standard_hex if hexadecimal?
+      return Convert.xterm_to_hex(@value) if cterm?
+      return :NONE if none?
+
+      raise ColorError.new "can't convert \"#{ @value }\" to gui"
     end
 
-    # Takes a hexidecimal color and returns is closest 256 color match.
+    # Convert the color value to a cterm compatible color
     #
-    # Credit goes to Micheal Elliot for the algorithm which was originally written
-    # in Python.
+    # @return [Fixnum]
+    #   the color as either "NONE" or cterm color
     #
-    # @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)
+    # @api public
+    def to_cterm
+      return @value if cterm?
+      return Convert.hex_to_xterm(to_standard_hex) if hexadecimal?
+      return :NONE if none?
 
-      # 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)
+      raise ColorError.new "can't convert \"#{ @value }\" to cterm"
+    end
 
-      increments = 0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff
+    # Returns true if the color value is cterm compatible color and false if
+    # it's not
+    #
+    # @return [TrueClass,FalseClass]
+    #   whether or not the color value is cterm compatible
+    #
+    # @api public
+    def cterm?
+      @value.kind_of?(Fixnum) and @value.between?(0, 255)
+    end
 
-      # 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
+    # Returns true if the color value is a gui compatible color and false if
+    # it's not
+    #
+    # @return [TrueClass,FalseClass]
+    #   whether or not the color value is gui compatible
+    #
+    # @api public
+    def gui?
+      hexadecimal?
+    end
 
-      # Return the index of the color
-      COLORS_256.index(parts)
+    # Returns true if the color value is a hexadecimal color and false if it's not
+    #
+    # @return [TrueClass,FalseClass]
+    #   whether or not the color value is hexadecimal
+    #
+    # @api public
+    def hexadecimal?
+      # Both standard and shorthand (CSS) style hexadecimal color value.
+      not cterm? and /\A#?(?:[0-9a-f]{3}|[0-9a-f]{6})\z/io.match(@value.to_s)
     end
 
-    # Checks if the subjec is a valid hexidecimal color.
+    # Returns true if the color value is either empty or set to "NONE"
+    #
+    # @return [TrueClass,FalseClass]
+    #   whether or not the color value is empty or "NONE"
     #
-    # @param [String] subject the string in question
-    # @return [Match
-    def is_hexadecimal?(subject)
-      return false unless subject.respond_to? :match
-      subject.match(/#?[\da-f]{6}/i) ? true : false
+    # @api public
+    def none?
+      @value.to_s.empty? or /\Anone\z/io.match(@value.to_s)
+    end
+
+    private
+
+    # Convert the color value to a standard hexadecimal value
+    #
+    # @example
+    #   Color.new('333').send(:to_standard_hex) # => '#333333'
+    #
+    # @return [String]
+    #   the color in standard hexadecimal format
+    #
+    # @api private
+    def to_standard_hex
+      color = @value.dup
+      color.insert(0, '#') unless color.start_with? '#'
+
+      # Convert shorthand hex to standard hex.
+      if color.size == 4
+        color.slice!(1, 3).chars { |char| color << char * 2 }
+      end
+      color
     end
-  end
-end
+  end # class Color
+end # module Vic

data/lib/vic/color_scheme.rb

@@ -0,0 +1,303 @@
+module Vic
+  class ColorScheme
+    attr_accessor :title
+
+    def initialize(title, &block)
+      @title = title
+      @highlights = []
+      @links = []
+      @info = OpenStruct.new
+
+      if block_given?
+        block.arity.zero? ? instance_eval(&block) : yield(self)
+      end
+    end
+
+    # Return the colorscheme information
+    #
+    # @return [Hash]
+    #   the colorscheme information
+    #
+    # @api public
+    def info
+      @info.marshal_dump
+    end
+
+    # Set the colorscheme information
+    #
+    # @param [Hash] data
+    #   the data to use
+    #
+    # @return [Hash]
+    #   the colorscheme information
+    #
+    # @api public
+    def info=(data = {})
+      @info.marshal_load(data)
+    end
+
+    # Updates the colorscheme information
+    #
+    # @param [Hash] data
+    #   the data to use
+    #
+    # @return [Hash]
+    #   the colorscheme information
+    #
+    # @api public
+    def add_info(data = {})
+      self.info = @info.marshal_dump.merge(data)
+    end
+
+    # Return the background setting
+    #
+    # @return [NilClass,String,Symbol]
+    #   the background setting
+    def background
+      @background
+    end
+
+    # Sets the background
+    #
+    # @param [String,Symbol] setting
+    #   a background setting of either "light" or "dark"
+    #
+    # @return [String,Symbol]
+    #   the background setting
+    #
+    # @api public
+    def background=(setting)
+      unless /\A(light|dark)\z/o.match(setting)
+        raise ArgumentError.new("expected 'light' or 'dark'")
+      end
+      @background = setting
+    end
+
+    # Sets the background automatically
+    #
+    # By default this will return "dark". If a highlight with the `group`
+    # "Normal" and a `guibg` setting has been added to the colorscheme, it will
+    # determine the setting to use. If the `guibg` is strictly less than
+    # "#808080" the background will be set to "dark" otherwise it will be set
+    # to "light".
+    #
+    # @return [String]
+    #   the background setting
+    #
+    # @api public
+    def background!
+      normal = find_highlight(:Normal)
+      return @background = 'dark' unless normal && normal.guibg
+      @background = normal.guibg[1..-1].to_i(16) < 8421504 ? 'dark' : 'light'
+    end
+
+    # Return the colorscheme's highlights
+    #
+    # @return [Array]
+    #   the colorscheme's highlights
+    #
+    # @api public
+    def highlights
+      @highlights.dup
+    end
+
+    # Add or update a highlight
+    #
+    # @example
+    #   scheme.highlight(:Normal, fg: 'eee', bg: '333')
+    #
+    # @param [String,Symbol] group
+    #   the group to highlight
+    #
+    # @param [Hash] attributes
+    #   the attributes to set or update
+    #
+    # @return [Vic::Highlight]
+    #   the highlight
+    #
+    # @api public
+    def highlight(group, attributes={})
+      if hilight = find_highlight(group)
+        hilight.update_attributes!(attributes)
+      else
+        hilight = Highlight.new(:"#{ language }#{ group }", attributes)
+        @highlights << hilight
+      end
+
+      hilight
+    end
+    alias_method :hi, :highlight
+
+    # Add or update a forced highlight
+    #
+    # @example
+    #   scheme.highlight!(:Normal, fg: 'eee', bg: '333').force? # => true
+    #
+    # @param [Hash] attributes
+    #   the attributes to set or update
+    #
+    # @return [Vic::Highlight]
+    #   the highlight
+    #
+    # @api public
+    def highlight!(group, attributes={})
+      highlight(group, attributes.dup.tap { |hash| hash[:force] = true })
+    end
+    alias_method :hi!, :highlight!
+
+    # Return the colorscheme's links
+    #
+    # @return [Array]
+    #   the colorscheme's links
+    #
+    # @api public
+    def links
+      @links.dup
+    end
+
+    # Add highlight links to the colorscheme
+    #
+    # @example
+    #   scheme.link(:rubyInstanceVariable, :rubyClassVariable)
+    #
+    # @param [String,Symbol] from_groups
+    #   a list of groups to link from
+    #
+    # @param [String,Symbol] to_groups
+    #   the group to link to
+    #
+    # @return [Array]
+    #   the added links
+    #
+    # @api public
+    def link(*from_groups, to_group)
+      from_groups.flatten.map do |from_group|
+        # Don't add anything we don't already have.
+        next if find_link(from_group, to_group)
+        link = Link.new(from_group, to_group)
+        link.tap { |l| @links << l }
+      end.compact
+    end
+
+    # Add forced highlight links to the colorscheme
+    #
+    # @example
+    #   scheme.link!(:rubyInstanceVariable, :rubyClassVariable)
+    #   link = scheme.links.find do |l|
+    #     l.from_group == :rubyInstanceVariable and l.to_group = :rubyClassVariable
+    #   end
+    #   link.force? # => true
+    #
+    # @param [String,Symbol] from_groups
+    #   a list of groups to link from
+    #
+    # @param [String,Symbol] to_groups
+    #   the group to link to
+    #
+    # @return [Array]
+    #   the added/updated links
+    #
+    # @api public
+    def link!(*from_groups, to_group)
+      # Use the default method first.
+      self.link(from_groups, to_group)
+
+      # Then update the links.
+      from_groups.flatten.map do |from_group|
+        link = find_link(from_group, to_group)
+        link.tap(&:force!)
+      end
+    end
+
+    # Set a language to prepend new highlight group names with
+    #
+    # @example
+    #   scheme.language = :ruby
+    #   scheme.hi(:InstanceVariable).group == :rubyInstanceVariable # => true
+    #
+    # @param [String,Symbol] name
+    #   the language name
+    #
+    # @return [String,Symbol]
+    #   the language name
+    #
+    # @api public
+    def language=(name)
+      @language = name
+    end
+
+    # Return the language
+    #
+    # If a name and a block is passed the language will be temporarily set to
+    # name inside the block.
+    #
+    # @example
+    #   scheme.language :ruby do |s|
+    #     s.hi(:InstanceVariable)
+    #     s.hi(:ClassVariable)
+    #   end
+    #   scheme.highlights.any? { |h| h.group == :rubyClassVarible } # => true
+    #
+    # @param [String,Symbol] name
+    #   the language to temporarily set if a block is given
+    #
+    # @yieldparam [Vic::Colorscheme]
+    #   the colorscheme
+    #
+    # @return [String,Symbol]
+    #   the language setting
+    #
+    # @api public
+    def language(name = nil, &block)
+      return @language unless name and block_given?
+
+      previous_language = self.language
+      @language = name
+      block.arity == 0 ? instance_eval(&block) : yield(self)
+      @language = previous_language
+    end
+
+    # Render the colorscheme
+    #
+    # @return [String]
+    #   the colorscheme as a string
+    #
+    # @api public
+    def render
+      ColorSchemeWriter.write(self)
+    end
+
+    private
+
+    # Find a highlight
+    #
+    # @param [String,Symbol] group
+    #   the highlight group to find
+    #
+    # @return [NilClass,Vic::Highlight]
+    #   the found highlight
+    #
+    # @api private
+    def find_highlight(group)
+      highlights.find { |h| /\A#{ group }\z/.match(h.group) }
+    end
+
+    # Find a link
+    #
+    # @param [String,Symbol] from_group
+    #   the link from_group
+    #
+    # @param [String,Symbol] to_group
+    #   the link to_group
+    #
+    # @return [NilClass,Vic::Highlight]
+    #   the found highlight
+    #
+    # @api private
+    def find_link(from_group, to_group)
+      @links.find do |l|
+        /\A#{ from_group }\z/.match(l.from_group) and /\A#{ to_group }\z/.match(l.to_group)
+      end
+    end
+  end # class ColorScheme
+end # module Vic

data/lib/vic/color_scheme_writer.rb

@@ -0,0 +1,80 @@
+module Vic
+  class ColorSchemeWriter
+    def initialize(colorscheme)
+      @colorscheme = colorscheme
+    end
+
+    def self.write(colorscheme)
+      new(colorscheme).write
+    end
+
+    def write
+      lines = [title, info, background, reset, name, highlights, links]
+      "%s\n%s\n\n%s\n\n%s\n%s\n\n%s\n%s" % lines
+    end
+
+    private
+
+    def title
+      %(" Title: #{ @colorscheme.title })
+    end
+
+    def info
+      return if @colorscheme.info.empty?
+      @colorscheme.info.map do |key, val|
+        %(" #{ key }: #{ val })
+      end.join("\n")
+    end
+
+    def background
+      "set background=#{ @colorscheme.background || @colorscheme.background! }"
+    end
+
+    def reset
+      <<-VIML.gsub(/^ {6}/, '')
+      hi clear
+
+      if exists("syntax_on")
+        syntax reset
+      endif
+      VIML
+    end
+
+    def name
+      %(let g:colors_name="#{ @colorscheme.title }")
+    end
+
+    def highlights
+      @colorscheme.highlights.map do |highlight|
+        attributes = Highlight.attributes.map do |attribute|
+          next unless value = highlight.send(attribute)
+
+          case value
+          when String, Symbol, Integer
+            " #{ attribute }=#{ value }"
+          when Array
+            " #{ attribute }=#{ value.map(&:to_s).map(&:strip).join(',') }"
+          end
+        end
+
+        next unless attributes.any?
+
+        if highlight.force?
+          "hi! #{ highlight.group }" << attributes.join
+        else
+          "hi #{ highlight.group }" << attributes.join
+        end
+      end.compact.join("\n")
+    end
+
+    def links
+      @colorscheme.links.map do |link|
+        if link.force?
+          "hi! default link #{ link.from_group } #{ link.to_group }"
+        else
+          "hi default link #{ link.from_group } #{ link.to_group }"
+        end
+      end.compact.join("\n")
+    end
+  end # class ColorSchemeWriter
+end # module Vic

data/lib/vic/convert.rb

@@ -0,0 +1,33 @@
+module Vic
+  module Convert
+    def self.hex_to_rgb(hex)
+      hex.match(/#?(..)(..)(..)/).captures.map { |v| v.to_i(16) }
+    end
+
+    def self.hex_to_xterm(hex)
+      rgb = hex_to_rgb(hex)
+
+      return XtermColor.table.index(rgb) if XtermColor.table.include?(rgb)
+
+      increments = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff]
+
+      rgb.map! do |part|
+        for i in (0...5)
+          lower, upper = increments[i], increments[i + 1]
+
+          next unless part.between?(lower, upper)
+
+          distance_from_lower = (lower - part).abs
+          distance_from_upper = (upper - part).abs
+          closest = distance_from_lower < distance_from_upper ? lower : upper
+        end
+        closest
+      end
+      XtermColor.table.index(rgb)
+    end
+
+    def self.xterm_to_hex(code)
+      '#' + XtermColor.table[code].map { |v| (v.to_s(16) * 2)[0...2] }.join
+    end
+  end # module Convert
+end # module Vic

data/lib/vic/highlight.rb

@@ -0,0 +1,230 @@
+module Vic
+  class Highlight
+
+    attr_accessor :group
+
+    def initialize(group, attributes={})
+      @group = group
+      update_attributes!(attributes)
+    end
+
+    # Updates the highlights attributes
+    #
+    # @example
+    #   h = Vic::Highlight.new('Normal', { guibg: '333' })
+    #   h.guibg # => "#333333"
+    #   h.update_attributes!({ guibg: '000' })
+    #   h.guibg # => "#000000"
+    #
+    # @param [Hash] attributes
+    #   the attributes to update
+    #
+    # @return [Vic::Highlight]
+    #   the updated highlight
+    #
+    # @api public
+    def update_attributes!(attributes={})
+      attributes.each_pair do |key, val|
+        self.respond_to?(:"#{ key }=") && send(:"#{ key }=", val)
+      end
+
+      # Returning self seems like the right thing to do when a method changes
+      # more than one property of an object.
+      self
+    end
+
+    # Return the list of highlight attributes
+    #
+    # @return [Array]
+    #   the list of highlight attributes
+    #
+    # @api semipublic
+    def self.attributes
+      [:term, :start, :stop, :cterm, :ctermbg, :ctermfg, :gui, :guibg, :guifg, :guisp, :font]
+    end
+
+    # Set the force
+    #
+    # @param [TrueClass,FalseClass] bool
+    #   a value of true or false
+    #
+    # @return [TrueClass,FalseClass]
+    #   the force setting
+    #
+    # @api public
+    def force=(bool)
+      @force = !!bool
+    end
+
+    # Return the force setting
+    #
+    # @return [TrueClass,FalseClass]
+    #   the force setting
+    #
+    # @api public
+    def force?
+      @force
+    end
+
+    # Set the force setting to true
+    #
+    # @return [TrueClass]
+    #   the force setting
+    #
+    # @api public
+    def force!
+      @force = true
+    end
+
+    # Set both ctermbg and guibg simultaneously
+    #
+    # @param [String] color
+    #   the color to use
+    #
+    # @return [Vic::Highlight]
+    #   the updated highlight
+    #
+    # @api public
+    def bg=(color)
+      color = Color.new(color)
+      @ctermbg, @guibg = color.to_cterm, color.to_gui
+      self
+    end
+
+    # Set both ctermfg and guifg simultaneously
+    #
+    # @param [String] color
+    #   the color to use
+    #
+    # @return [Vic::Highlight]
+    #   the updated highlight
+    #
+    # @api public
+    def fg=(color)
+      color = Color.new(color)
+      @ctermfg, @guifg = color.to_cterm, color.to_gui
+      self
+    end
+
+    # Set both cterm and gui simultaneously
+    #
+    # @param [Array] styles
+    #   the styles to use
+    #
+    # @return [Vic::Highlight]
+    #   the updated highlight
+    #
+    # @api public
+    def style=(styles)
+      @cterm, @gui = [select_styles(styles)] * 2
+      self
+    end
+
+    attr_accessor :term, :start, :stop
+
+    attr_reader :cterm, :ctermfg, :ctermbg
+
+    # Set the cterm value
+    #
+    # @param [Array,String,Symbol] styles
+    #   the styles to use
+    #
+    # @return [Array,Symbol]
+    #   the cterm value
+    #
+    # @api public
+    def cterm=(*styles)
+      @cterm = select_styles(styles)
+    end
+
+    # Set the ctermbg value
+    #
+    # @param [String,Symbol] color
+    #   the color to use
+    #
+    # @return [String,Symbol]
+    #   the ctermbg color
+    #
+    # @api public
+    def ctermbg=(color)
+      @ctermbg = Color.new(color).to_cterm
+    end
+
+    # Set the ctermfg value
+    #
+    # @param [String,Symbol] color
+    #   the color to use
+    #
+    # @return [String,Symbol]
+    #   the ctermfg color
+    #
+    # @api public
+    def ctermfg=(color)
+      @ctermfg = Color.new(color).to_cterm
+    end
+
+    attr_reader :gui, :guibg, :guifg
+    attr_accessor :guisp, :font
+
+    # Set the gui value
+    #
+    # @param [Array,String,Symbol] styles
+    #   the styles to use
+    #
+    # @return [Array,Symbol]
+    #   the gui value
+    #
+    # @api public
+    def gui=(*styles)
+      @gui = select_styles(styles)
+    end
+
+    # Set the guibg value
+    #
+    # @param [String,Symbol] color
+    #   the color to use
+    #
+    # @return [String,Symbol]
+    #   the guibg color
+    #
+    # @api public
+    def guibg=(color)
+      @guibg = Color.new(color).to_gui
+    end
+
+    # Set the guifg value
+    #
+    # @param [String,Symbol] color
+    #   the color to use
+    #
+    # @return [String,Symbol]
+    #   the guifg color
+    #
+    # @api public
+    def guifg=(color)
+      @guifg = Color.new(color).to_gui
+    end
+
+    private
+
+    # Valid font styles *excluding* none
+    FONT_STYLE = /bold|(under(line|curl))|((re|in)verse)|italic|standout/o
+
+    # Selcect valid styles from a list
+    #
+    # @param [Mixed] styles
+    #   the list of styles
+    #
+    # @return [Array,Symbol]
+    #   the list of valid styles or "NONE"
+    #
+    # @api private
+    def select_styles(*styles)
+      styles.tap(&:compact).flatten!
+      if styles.empty? or styles.length == 1 && /\Anone\z/io.match(styles[0])
+        return :NONE
+      end
+      styles.select { |s| FONT_STYLE.match(s) }
+    end
+  end # class Highlight
+end # module Vic

data/lib/vic/link.rb

@@ -0,0 +1,44 @@
+module Vic
+  class Link
+    attr_accessor :from_group, :to_group
+
+    def initialize(from_group, to_group = :NONE)
+      @from_group = from_group
+      @to_group = to_group
+      @force = false
+    end
+
+    # Set the force
+    #
+    # @param [TrueClass,FalseClass] bool
+    #   a value of true or false
+    #
+    # @return [TrueClass,FalseClass]
+    #   the force setting
+    #
+    # @api public
+    def force=(bool)
+      @force = !!bool
+    end
+
+    # Return the force setting
+    #
+    # @return [TrueClass,FalseClass]
+    #   the force setting
+    #
+    # @api public
+    def force?
+      @force
+    end
+
+    # Set the force setting to true
+    #
+    # @return [TrueClass]
+    #   the force setting
+    #
+    # @api public
+    def force!
+      @force = true
+    end
+  end # class Link
+end # module Vic

data/lib/vic/xterm_color.rb

@@ -0,0 +1,18 @@
+module Vic
+  module XtermColor
+    SYSTEM = [[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 = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff].repeated_permutation(3).to_a
+
+    GREYSCALE = (0x08..0xee).step(0x0a).map { |v| [v] * 3 }
+
+    def self.table
+      SYSTEM + RGB + GREYSCALE
+    end
+  end # module XtermColor
+end # module Vic

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vic
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-22 00:00:00.000000000Z
+date: 2012-04-24 00:00:00.000000000Z
 dependencies: []
 description: Create Vim colorschemes with Ruby
 email: cjholdbrooks@gmail.com
@@ -19,12 +19,12 @@ 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
-- lib/vic/colorscheme/highlight/argument.rb
-- lib/vic/colorscheme/highlight/argument_set.rb
+- lib/vic/color_scheme.rb
+- lib/vic/color_scheme_writer.rb
+- lib/vic/convert.rb
+- lib/vic/highlight.rb
+- lib/vic/link.rb
+- lib/vic/xterm_color.rb
 homepage: https://github.com/noprompt/vic
 licenses: []
 post_install_message: 

data/lib/vic/color_error.rb

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

data/lib/vic/colorscheme.rb

@@ -1,141 +0,0 @@
-module Vic
-  class Colorscheme
-    attr_accessor :colors_name, :information
-
-    # A new instance of Colorscheme. If a block is given with no arguments, the
-    # the block will be evaluated in the context of the new colorscheme.
-    # Otherwise the block will yield self.
-    #
-    # @param [String] colors_name the name of the colorscheme
-    # @param [Proc] block the block to be evaluated
-    # @return [Colorscheme]
-    def initialize(colors_name, &block)
-      @colors_name = colors_name
-      if block_given?
-        block.arity == 0 ? instance_eval(&block) : yield(self)
-      end
-    end
-
-    # Returns/sets the information attribute
-    #
-    # @param [Hash] information the information, :author => 'Joel Holdbrooks'
-    # @return [Hash]
-    def information(inf={})
-      (@information ||= {}).merge!(inf) if inf.respond_to? :merge
-    end
-    alias_method :info, :information
-
-    # Returns the background color.
-    #
-    # @return [String] 'light' or 'dark'
-    def background
-      @background ||= background!
-    end
-
-    # Sets the background color.
-    #
-    # @param [String] a value of 'light' or 'dark'
-    # @return [String] the background attribute
-    def background=(light_or_dark)
-      unless (light_or_dark =~ /^light$|^dark$/).nil?
-        @background = light_or_dark
-      end
-    end
-
-    # Sets the background color by attempting to determine it.
-    #
-    # @return[String] the background attribute
-    def background!
-      @background =
-        if normal = highlights.find_by_group('Normal')
-          return 'dark' unless color = normal.guibg
-          color.partition('#').last.to_i(16) <= 8421504 ? 'dark' : 'light'
-        else
-          'dark'
-        end
-    end
-
-    # Returns the set of highlights for the colorscheme
-    def highlight_set
-      @highlight_set ||= HighlightSet.new
-    end
-    alias_method :highlights, :highlight_set
-
-    # Creates a new highlight
-    #
-    # If inside of a language block the langauge name is automatcially prepended
-    # to the group name of the new highlight.
-    #
-    # @see Vic::Highlight
-    # @return [Vic::Highlight] the new highlight
-    def highlight(group, args={})
-      return if args.empty?
-
-      if h = find_highlight(group)
-        h.update_arguments! args
-      else
-        h = Highlight.new "#{language}#{group}", args
-        highlight_set.add h
-      end
-    end
-    alias_method :hi, :highlight
-
-    def find_highlight(group)
-      highlight_set.find_by_group(group)
-    end
-
-    # Sets the current language to name. Any new highlights created will have
-    # the language name automatically prepended.
-    #
-    # @return [String] the new language name
-    def language=(name)
-      @language = name
-    end
-
-    # Returns the current language or temporarily sets the language to name if
-    # a block is given. If a block is given with no arguments, it will be
-    # evaluated in the context of the colorscheme, otherwise it will yield the
-    # colorscheme.
-    #
-    # @param [String,Symbol] name the name of the language
-    # @param [Proc] block the block to be evalauted
-    # @return [String] the current language
-    def language(name=nil, &block)
-      if @language and not name
-        return @language
-      elsif name and block_given?
-        previous_language = self.language
-        self.language = name
-        block.arity == 0 ? instance_eval(&block) : yield(self)
-        self.language = previous_language
-      end
-    end
-
-    # Returns the colorscheme header.
-    #
-    # @return [String] the colorscheme header
-    def header
-      <<-EOT.gsub(/^ {6}/, '')
-      " Vim color file
-      #{info.to_a.map do |pair|
-        pair.join(": ").tap {|s| s[0] = '" ' + s[0].upcase }
-      end.join("\n")}
-      set background=#{background}
-      hi clear
-
-      if exists("syntax_on")
-        syntax reset
-      endif
-
-      let g:colors_name="#{colors_name}"
-      EOT
-    end
-
-    # Returns the colorscheme as a string
-    #
-    # @return [String] the colorscheme
-    def write
-      [header, highlights.map(&:write)].join("\n")
-    end
-  end
-end

data/lib/vic/colorscheme/highlight.rb

@@ -1,97 +0,0 @@
-module Vic
-  class Colorscheme::Highlight
-
-    attr_accessor :group
-
-    # Creates an instance of Vic::Colorscheme::Highlight. Uses
-    # `update_arguments!` to set the arguments.
-    #
-    # @param [String] group the group name, 'Normal', 'Function', etc.
-    # @param [Hash] args the arguments to set
-    # @return [Vic::Colorscheme::Highlight] the new highlight
-    def initialize(group, args={})
-      # Convert to group name to symbol to ensure consistency
-      @group = group.to_sym
-      update_arguments!(args)
-    end
-
-    # Sets the methods term, term=, start, start=, etc. for settings arguments.
-    self.class_eval do
-      %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
-            arg = Argument.new(m, val)
-            argument_set.add arg
-          end
-        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=(color)
-      if color == 'NONE'
-        self.ctermfg = color
-      elsif Color.is_hexadecimal?(color)
-        self.ctermfg = Color.hex_to_256(color)
-      else
-        raise ColorError.new "invalid hexadecimal color #{color}"
-      end
-
-      self.guifg = color
-    end
-
-    # Sets guibg and ctermbg simultaneously. `hex` is automatically converted to
-    # the 256 color code for ctermbg.
-    #
-    # @param [String] hex a hexidecimal color
-    def bg=(color)
-      if color == 'NONE'
-        self.ctermbg = color
-      elsif Color.is_hexadecimal?(color)
-        self.ctermbg = Color.hex_to_256(color)
-      else
-        raise ColorError.new "invalid hexadecimal color #{color}"
-      end
-
-      self.guibg = color
-    end
-
-    # Updates/sets the current highlight's arguments.
-    #
-    # @param [Hash] args the arguments to update/set, `:guibg => '#333333'`
-    # @return [Vic::Colorscheme::Highlight::ArgumentSet] the updated argument set
-    def update_arguments!(args={})
-      args.each {|key, val| send("#{key}=", val)}
-      arguments
-    end
-
-    # Returns the set of arguments for the given highlight
-    #
-    # @return [Vic::Colorscheme::Highlight::ArgumentSet] the argument set
-    def argument_set
-      @argument_set ||= ArgumentSet.new
-    end
-    alias_method :arguments, :argument_set
-
-    # Writes the highlight contents.
-    #
-    # @return [String] the highlight as a string
-    def write
-      "hi #{group} #{arguments.sort_by_key.map(&:write).compact.join(' ')}"
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module Vic
-  class Colorscheme::Highlight::Argument
-    VALID = %w{term start stop cterm ctermfg ctermbg gui guifg guibg guisp font}
-
-    attr_accessor :key, :val
-
-    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 val
-      "#{key}=#{val.respond_to?(:join) ? val.join(',') : val}"
-    end
-
-    # Checks if `key` is valid vim key for an argument
-    #
-    # @param [String,Symbol]
-    # @return [true,false] the key is valid
-    def self.is_valid?(key)
-      VALID.include?(key.to_s)
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-module Vic
-  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? :val
-        arguments.push argument
-      else
-        # Raise an Exception
-        raise TypeError.new("expted type Colorscheme::Highlight::Argument")
-      end
-    end
-
-    # Finds an argument by a key.
-    #
-    # @param [String,Symbol] key the key to search for
-    # @return [Colorscheme::Highlight::Argument,nil] the new argument
-    def find_by_key(key)
-      find {|a| a.key.to_s == key.to_s }
-    end
-
-    # Sorts the arguments by key name
-    #
-    # @return [Colorscheme::Highlight::ArgumentSet] the sorted set of arguments
-    def sort_by_key
-      sort {|a, b| a.key.to_s <=> b.key.to_s }
-    end
-  end
-end

data/lib/vic/colorscheme/highlight_set.rb

@@ -1,34 +0,0 @@
-module Vic
-  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? :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.to_sym }
-    end
-  end
-end