tty 0.1.0 → 0.1.1

data/lib/tty/coercer.rb

@@ -1,13 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module TTY
-
-  # Abstract class for type coercions
-  #
-  # @abstract
-  class Coercer
-    include TTY::Equatable
-
-  end # Coercer
-
-end # TTY

data/lib/tty/coercer/float.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-module TTY
-  class Coercer
-    # Coerce values into float number
-    #
-    # @api public
-    class Float
-      def self.coerce(value, strict = true)
-        Kernel.send(:Float, value.to_s)
-      rescue
-        if strict
-          raise InvalidArgument, "#{value} could not be coerced into Float"
-        else
-          value.to_f
-        end
-      end
-    end # Float
-  end # Coercer
-end # TTY

data/lib/tty/coercer/integer.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-module TTY
-  class Coercer
-    # Coerce value into integer number
-    #
-    # @api public
-    class Integer
-      def self.coerce(value, strict = true)
-        Kernel.send(:Integer, value.to_s)
-      rescue
-        if strict
-          raise InvalidArgument, "#{value} could not be coerced into Integer"
-        else
-          value.to_i
-        end
-      end
-    end # Integer
-  end # Coercer
-end # TTY

data/lib/tty/support/conversion.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-module TTY
-  # A mixin to allow instances conversion to array type
-  #
-  # @api public
-  module Conversion
-    # Converts the object into an Array. If copy is set to true
-    # a copy of object will be made.
-    #
-    # @param [Object] object
-    #
-    # @param [Boolean] copy
-    #
-    # @return [Array]
-    #
-    # @api private
-    def convert_to_array(object, copy = false)
-      case object
-      when Array
-        copy ? object.dup : object
-      when Hash
-        Array(object)
-      else
-        begin
-          converted = object.to_ary
-        rescue Exception => e
-          raise TTY::TypeError,
-                "Cannot convert #{object.class} into an Array (#{e.message})"
-        end
-        converted
-      end
-    end
-  end # Conversion
-end # TTY

data/lib/tty/support/equatable.rb

@@ -1,152 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module TTY
-
-  # Make it easy to define equality and hash methods.
-  module Equatable
-
-    # Hook into module inclusion.
-    #
-    # @param [Module] base
-    #   the module or class including Equatable
-    #
-    # @return [self]
-    #
-    # @api private
-    def self.included(base)
-      super
-      base.extend(self)
-      base.class_eval do
-        define_comparison_attrs
-        include Methods
-        define_methods
-      end
-      self
-    end
-
-    # Holds all attributes used for comparison.
-    #
-    # @return [Array<Symbol>]
-    #
-    # @api private
-    attr_reader :comparison_attrs
-
-    # Objects that include this module are assumed to be value objects.
-    # It is also assumed that the only values that affect the results of
-    # equality comparison are the values of the object's attributes.
-    #
-    # @param [Array<Symbol>] *args
-    #
-    # @return [undefined]
-    #
-    # @api public
-    def attr_reader(*args)
-      super
-      @comparison_attrs.concat(args)
-    end
-
-    # Copy the comparison_attrs into the subclass.
-    #
-    # @param [Class] subclass
-    #
-    # @api private
-    def inherited(subclass)
-      super
-      subclass.instance_variable_set(:@comparison_attrs, comparison_attrs.dup)
-    end
-
-    private
-
-    # Define class instance #comparison_attrs as an empty array.
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def define_comparison_attrs
-      instance_variable_set('@comparison_attrs', [])
-    end
-
-    # Define all methods needed for ensuring object's equality.
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def define_methods
-      define_compare
-      define_hash
-      define_inspect
-    end
-
-    # Define a #compare? method to check if the receiver is the same
-    # as the other object.
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def define_compare
-      define_method(:compare?) do |comparator, other|
-        klass = self.class
-        attrs = klass.comparison_attrs || []
-        attrs.all? { |attr| send(attr).send(comparator, other.send(attr)) }
-      end
-    end
-
-    # Define a hash method that ensures that the hash value is the same for
-    # the same instance attributes and their corresponding values.
-    #
-    # @api private
-    def define_hash
-      define_method(:hash) do
-        klass = self.class
-        attrs = klass.comparison_attrs || []
-        ([klass] + attrs.map { |attr| send(attr)}).hash
-      end
-    end
-
-    # Define an inspect method that shows the class name and the values for the
-    # instance's attributes.
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def define_inspect
-      define_method(:inspect) do
-        klass = self.class
-        name = klass.name || klass.inspect
-        attrs = klass.comparison_attrs || []
-        "#<#{name}#{attrs.map { |attr| " #{attr}=#{send(attr).inspect}" }.join}>"
-      end
-    end
-
-    module Methods
-
-      # Compare two objects for equality based on their value
-      # and being an instance of the given class.
-      #
-      # @param [Object] other
-      #   the other object in comparison
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def eql?(other)
-        instance_of?(other.class) && compare?(__method__, other)
-      end
-
-      # Compare two objects for equality based on their value
-      # and being a subclass of the given class.
-      #
-      # @param [Object] other
-      #   the other object in comparison
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def ==(other)
-        kind_of?(other.class) && compare?(__method__, other)
-      end
-
-    end # Methods
-
-  end # Equatable
-end # TTY

data/lib/tty/terminal/color.rb

@@ -1,157 +0,0 @@
-# encoding: utf-8
-
-module TTY
-  class Terminal
-    # A class responsible for coloring strings.
-    class Color
-      # Embed in a String to clear all previous ANSI sequences.
-      CLEAR      = "\e[0m"
-      # The start of an ANSI bold sequence.
-      BOLD       = "\e[1m"
-      # The start of an ANSI underlined sequence.
-      UNDERLINE  = "\e[4m"
-
-      STYLES = %w( BOLD CLEAR UNDERLINE ).freeze
-
-      # Escape codes for text color.
-      BLACK         = "\e[30m"
-      RED           = "\e[31m"
-      GREEN         = "\e[32m"
-      YELLOW        = "\e[33m"
-      BLUE          = "\e[34m"
-      MAGENTA       = "\e[35m"
-      CYAN          = "\e[36m"
-      WHITE         = "\e[37m"
-
-      LIGHT_BLACK   = "\e[90m"
-      LIGHT_RED     = "\e[91m"
-      LIGHT_GREEN   = "\e[92m"
-      LIGHT_YELLOW  = "\e[93m"
-      LIGHT_BLUE    = "\e[94m"
-      LIGHT_MAGENTA = "\e[95m"
-      LIGHT_CYAN    = "\e[96m"
-
-      TEXT_COLORS = (constants.grep(/^[^ON_]*/) - STYLES).freeze
-
-      # Escape codes for background color.
-      ON_BLACK         = "\e[40m"
-      ON_RED           = "\e[41m"
-      ON_GREEN         = "\e[42m"
-      ON_YELLOW        = "\e[43m"
-      ON_BLUE          = "\e[44m"
-      ON_MAGENTA       = "\e[45m"
-      ON_CYAN          = "\e[46m"
-      ON_WHITE         = "\e[47m"
-
-      ON_LIGHT_BLACK   = "\e[100m"
-      ON_LIGHT_RED     = "\e[101m"
-      ON_LIGHT_GREEN   = "\e[102m"
-      ON_LIGHT_YELLOW  = "\e[103m"
-      ON_LIGHT_BLUE    = "\e[104m"
-      ON_LIGHT_MAGENTA = "\e[105m"
-      ON_LIGHT_CYAN    = "\e[106m"
-
-      BACKGROUND_COLORS = constants.grep(/^ON_*/).freeze
-
-      attr_reader :enabled
-
-      # Initialize a Terminal Color
-      #
-      # @api public
-      def initialize(enabled = false)
-        @enabled = enabled
-      end
-
-      # Disable coloring of this terminal session
-      #
-      # @api public
-      def disable!
-        @enabled = false
-      end
-
-      # Check if coloring is on
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def enabled?
-        @enabled
-      end
-
-      # Apply ANSI color to the given string.
-      #
-      # @param [String] string
-      #   text to add ANSI strings
-      #
-      # @param [Array[Symbol]] colors
-      #
-      # @example
-      #   apply "text", :yellow, :on_green, :underline
-      #
-      # @return [String]
-      #
-      # @api public
-      def set(string, *colors)
-        validate(*colors)
-        ansi_colors = colors.map { |color| lookup(color) }
-        "#{ansi_colors.join}#{string}#{CLEAR}"
-      end
-
-      # Same as instance method.
-      #
-      # @return [undefined]
-      #
-      # @api public
-      def self.set(string, *colors)
-        new.set(string, *colors)
-      end
-
-      # Remove color codes from a string.
-      #
-      # @param [String] string
-      #
-      # @return [String]
-      #
-      # @api public
-      def remove(string)
-        string.to_s.gsub(/(\[)?\033(\[)?[;?\d]*[\dA-Za-z](\])?/, '')
-      end
-
-      # Return raw color code without embeding it into a string.
-      #
-      # @return [Array[String]]
-      #   ANSI escape codes
-      #
-      # @api public
-      def code(*colors)
-        validate(*colors)
-        colors.map { |color| lookup(color) }
-      end
-
-      # All ANSI color names as strings.
-      #
-      # @return [Array[String]]
-      #
-      # @api public
-      def names
-        (STYLES + BACKGROUND_COLORS + TEXT_COLORS).map { |col| col.to_s.downcase }
-      end
-
-      protected
-
-      # Find color representation.
-      #
-      # @api private
-      def lookup(color)
-        self.class.const_get(color.to_s.upcase)
-      end
-
-      # @api private
-      def validate(*colors)
-        return if colors.all? { |color| names.include?(color.to_s) }
-        raise ArgumentError, 'Bad color or unintialized constant, ' \
-          " valid colors are: #{names.join(', ')}."
-      end
-    end # Color
-  end # Terminal
-end # TTY

data/spec/tty/support/equatable_spec.rb

@@ -1,201 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Equatable do
-  let(:name) { 'Value' }
-
-  context 'without attributes' do
-    let(:klass) { ::Class.new }
-
-    subject { klass.new }
-
-    before {
-      allow(klass).to receive(:name).and_return('Value')
-      klass.send :include, described_class
-    }
-
-    it { is_expected.to respond_to :compare? }
-
-    it { is_expected.to be_instance_of klass }
-
-    describe '#eql?' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { expect(subject.eql?(other)).to eq(true) }
-      end
-
-      context 'when objects are different' do
-        let(:other) { double('other') }
-
-        it { expect(subject.eql?(other)).to eq(false) }
-      end
-    end
-
-    describe '#==' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { expect(subject == other).to eq(true) }
-      end
-
-      context 'when objects are different' do
-        let(:other) { double('other') }
-
-        it { expect(subject == other).to eq(false) }
-      end
-    end
-
-    describe '#inspect' do
-      it { expect(subject.inspect).to eql('#<Value>') }
-    end
-
-    describe '#hash' do
-      it { expect(subject.hash).to eql([klass].hash) }
-    end
-  end
-
-  context 'with attributes' do
-    let(:value) { 11 }
-    let(:klass) {
-      ::Class.new do
-        include TTY::Equatable
-
-        attr_reader :value
-
-        def initialize(value)
-          @value = value
-        end
-      end
-    }
-
-    before {
-      allow(klass).to receive(:name).and_return name
-    }
-
-    subject { klass.new(value) }
-
-    it 'dynamically defines #hash method' do
-      expect(klass.method_defined?(:hash)).to eq(true)
-    end
-
-    it 'dynamically defines #inspect method' do
-      expect(klass.method_defined?(:inspect)).to eq(true)
-    end
-
-    it { is_expected.to respond_to :compare? }
-
-    it { is_expected.to respond_to :eql? }
-
-    describe '#eql?' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { expect(subject.eql?(other)).to eq(true) }
-      end
-
-      context 'when objects are different' do
-        let(:other) { double('other') }
-
-        it { expect(subject.eql?(other)).to eq(false) }
-      end
-    end
-
-    describe '#==' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { expect(subject == other).to eq(true) }
-      end
-
-      context 'when objects are different' do
-        let(:other) { double('other') }
-
-        it { expect(subject == other).to eq(false) }
-      end
-    end
-
-    describe '#inspect' do
-      it { expect(subject.inspect).to eql('#<Value value=11>') }
-    end
-
-    describe '#hash' do
-      it { expect(subject.hash).to eql( ([klass] + [value]).hash) }
-    end
-
-    context 'equivalence relation' do
-      let(:other) { subject.dup }
-
-      it 'is not equal to nil reference' do
-        expect(subject.eql?(nil)).to eq(false)
-      end
-
-      it 'is reflexive' do
-        expect(subject.eql?(subject)).to eq(true)
-      end
-
-      it 'is symmetric' do
-        expect(subject.eql?(other)).to eql( other.eql?(subject) )
-      end
-    end
-  end
-
-  context 'subclass' do
-    let(:value) { 11 }
-    let(:klass) {
-      ::Class.new do
-        include TTY::Equatable
-
-        attr_reader :value
-
-        def initialize(value)
-          @value = value
-        end
-      end
-    }
-    let(:subclass) { ::Class.new(klass) }
-
-    before {
-      allow(klass).to receive(:name).and_return name
-    }
-
-    subject { subclass.new(value) }
-
-    it { expect(subclass.superclass).to eq(klass) }
-
-    it { is_expected.to respond_to :value }
-
-    describe '#inspect' do
-      it { expect(subject.inspect).to eql('#<Value value=11>') }
-    end
-
-    describe '#eql?' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { expect(subject.eql?(other)).to eq(true) }
-      end
-
-      context 'when objects are different' do
-        let(:other) { double('other') }
-
-        it { expect(subject.eql?(other)).to eq(false) }
-      end
-    end
-
-    describe '#==' do
-      context 'when objects are similar' do
-        let(:other) { subject.dup }
-
-        it { expect(subject == other).to eq(true) }
-      end
-
-      context 'when objects are different' do
-        let(:other) { double('other') }
-
-        it { expect(subject == other).to eq(false) }
-      end
-    end
-  end
-end