hexpress 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 59cd6698ba5d1e610f469986e66e765b4c50583b
+  data.tar.gz: 00e04fcce40cc9d0eecc323d0aa02c352b48f586
+SHA512:
+  metadata.gz: 9e8d9bd6b4098c41657c3484457213684bbea32c7f19e78e0175e10fa31422f9334775b6ecc0ce6ea9d07432c243ee4a81ada3c92a7779a59b739df9e5e56600
+  data.tar.gz: 40e2fcb76837dd970bbf0492bf333d881d18ad5876f628fa04b012b7eddd6a6c73cfc4bf9e890ba40f36ac42cb47e56edb8318613172ebe8adec3df2b6ac5929

data/lib/hexpress.rb

@@ -0,0 +1,97 @@
+class Hexpress
+  CHARACTERS = [:word, :digit, :space]
+  def initialize(&block)
+    @hexpressions = []
+    instance_exec(&block) if block_given?
+  end
+
+  # Matches \w
+  def word
+    add(Character.new(:word))
+  end
+
+  # Matches \d
+  def digit
+    add(Character.new(:digit))
+  end
+
+  # Matches \s
+  def space
+    add(Character.new(:space))
+  end
+
+  # Matches .
+  def any
+    add(Character.new(:any))
+  end
+
+  # Matches (?:.)*
+  def anything
+    many(Character.new(:any), 0)
+  end
+
+  # Matches (?:.)+
+  def something
+    many(Character.new(:any), 1)
+  end
+
+  # Matches \t
+  def tab
+    add(Character.new(:tab))
+  end
+
+  # Matches (?:(?:\n)|(?:\r\n))
+  def line
+    either(Character.new('(?:\n)'), Character.new('(?:\r\n)'))
+  end
+
+  CHARACTERS.each do |character|
+    define_method(character) do
+      add(Character.new(character))
+    end
+
+    define_method("non#{character}") do
+      add(Character.new(character, true))
+    end
+
+    define_method("#{character}s") do
+      many(Character.new(character))
+    end
+
+    define_method("non#{character}s") do
+      many(Character.new(character, true))
+    end
+  end
+
+  # This method returns the regular hexpression form of this object.
+  def to_r
+    Regexp.new(to_s)
+  end
+
+  # This method returns the string version of the regexp.
+  def to_s
+    @hexpressions.map(&:to_s).join
+  end
+
+  private
+
+  # This method takes an hexpression and adds it to the hexpression queue
+  # while returning the main object.
+  def add(hexpression)
+    tap do
+      @hexpressions << hexpression
+    end
+  end
+end
+
+require_relative "hexpress/character"
+require_relative "hexpress/version"
+require_relative "hexpress/wrapped"
+require_relative "hexpress/value"
+require_relative "hexpress/values"
+require_relative "hexpress/nested"
+require_relative "hexpress/modifier"
+
+if defined?(Rails)
+  require_relative "hexpress/main"
+end

data/lib/hexpress/character.rb

@@ -0,0 +1,26 @@
+class Hexpress
+  class Character
+    attr_reader :upcase
+    def initialize(name, upcase = false)
+      @value = case name
+        when :word then '\w'
+        when :digit then '\d'
+        when :space then '\s'
+        when :any then '.'
+        when :tab then '\t'
+        when :newline then '\n'
+        when :return then '\r'
+        else name
+      end
+      @upcase = upcase
+    end
+
+    def value
+      if upcase then @value.upcase else @value end
+    end
+
+    def to_s
+      value
+    end
+  end
+end

data/lib/hexpress/main.rb

@@ -0,0 +1,5 @@
+require "hexpress"
+
+def hexp(&block)
+  Hexpress.new(&block)
+end

data/lib/hexpress/modifier.rb

@@ -0,0 +1,26 @@
+class Hexpress
+  module Modifier
+    OPEN = "(?:"
+    CLOSE = ")"
+    attr_reader :operator
+
+    def open
+      OPEN
+    end
+
+    def close
+      CLOSE
+    end
+
+    def to_s
+      if @value
+        "#{open}#{value}#{close}#{operator}"
+      else
+        operator
+      end
+    end
+  end
+end
+
+require_relative "modifier/many"
+require_relative "modifier/one"

data/lib/hexpress/modifier/many.rb

@@ -0,0 +1,25 @@
+class Hexpress
+  def many(value = nil, minimum = 1)
+    add_values(Modifier::Many, value, minimum)
+  end
+  alias_method :multiple, :many
+
+  module Modifier
+    class Many
+      include Value
+      include Modifier
+
+      def initialize(value, minimum = 1)
+        @value = value
+        @minimum = minimum
+      end
+
+      def operator
+        case @minimum
+          when 0 then "*"
+          when 1 then "+"
+        end
+      end
+    end
+  end
+end

data/lib/hexpress/modifier/one.rb

@@ -0,0 +1,19 @@
+class Hexpress
+  def one(value = nil, &block)
+    add_value(Modifier::One, value, &block)
+  end
+  alias_method :maybe, :one
+  alias_method :possibly, :one
+
+  module Modifier
+    class One
+      include Value
+      include Modifier
+
+      def initialize(value)
+        @value = value
+        @operator = "?"
+      end
+    end
+  end
+end

data/lib/hexpress/nested.rb

@@ -0,0 +1,38 @@
+class Hexpress
+  private
+
+  def add_nested(hexpression, &block)
+    tap do
+      @hexpressions << hexpression.new(&block)
+    end
+  end
+
+  module Nested
+    include Wrapped
+
+    def delimiter
+      @delimiter || ""
+    end
+
+    def hexpression
+      if joinable? then join_hexpression else @hexpression end
+    end
+
+    def to_s
+      wrapping(hexpression)
+    end
+
+    private
+
+    def join_hexpression
+      @hexpression.join(delimiter)
+    end
+
+    def joinable?
+      @hexpression.respond_to?(:join)
+    end
+  end
+end
+
+require_relative "nested/find"
+require_relative "nested/matching"

data/lib/hexpress/nested/find.rb

@@ -0,0 +1,17 @@
+class Hexpress
+  def find(value = nil, &block)
+    value ? add_value(Nested::Find, value) : add_nested(Nested::Find, &block)
+  end
+  alias_method :capture, :find
+
+  module Nested
+    class Find
+      include Nested
+
+      def initialize(value = nil, &block)
+        @hexpression = value || Hexpress.new.instance_eval(&block)
+        @open, @close = "(", ")"
+      end
+    end
+  end
+end

data/lib/hexpress/nested/matching.rb

@@ -0,0 +1,31 @@
+class Hexpress
+  def matching(&block)
+    add_nested(Nested::Matching, &block)
+  end
+  alias_method :like, :matching
+
+  module Nested
+    class Matching
+      include Nested
+
+      def initialize(&block)
+        @hexpression = Hexpress.new.instance_eval(&block)
+        @open, @close = "[", "]"
+      end
+
+      def join_hexpression
+        @hexpression.map(&method(:escape)).join(delimiter)
+      end
+
+      private
+
+      def escape(hexpression)
+        if hexpression.respond_to?(:gsub)
+          Regexp.escape(hexpression)
+        else
+          hexpression
+        end
+      end
+    end
+  end
+end

data/lib/hexpress/value.rb

@@ -0,0 +1,28 @@
+class Hexpress
+  private
+
+  def add_value(hexpression, v, &block)
+    add(hexpression.new(block_given? ? Hexpress.new.instance_exec(&block) : v))
+  end
+
+  module Value
+    def value
+      if escapable? then escaped_value else @value end || ""
+    end
+
+    private
+
+    def escapable?
+      @value.respond_to?(:gsub)
+    end
+
+    def escaped_value
+      Regexp.escape(@value)
+    end
+  end
+end
+
+require_relative "value/ending"
+require_relative "value/except"
+require_relative "value/starting"
+require_relative "value/with"

data/lib/hexpress/value/ending.rb

@@ -0,0 +1,22 @@
+class Hexpress
+  def ending(value = nil)
+    add_value(Value::Ending, value)
+  end
+  alias_method :ending_with, :ending
+  alias_method :finally, :ending
+  alias_method :endOfLine, :ending
+
+  module Value
+    class Ending
+      include Value
+
+      def initialize(value = nil)
+        @value = value
+      end
+
+      def to_s
+        "#{value}$"
+      end
+    end
+  end
+end

data/lib/hexpress/value/except.rb

@@ -0,0 +1,22 @@
+class Hexpress
+  def except(value)
+    add_value(Value::Except, value)
+  end
+  alias_method :excluding, :except
+  alias_method :exclude, :except
+  alias_method :without, :except
+
+  module Value
+    class Except
+      include Value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def to_s
+        "^#{value}"
+      end
+    end
+  end
+end

data/lib/hexpress/value/starting.rb

@@ -0,0 +1,22 @@
+class Hexpress
+  def starting(value = nil)
+    add_value(Value::Starting, value)
+  end
+  alias_method :begins, :starting
+  alias_method :begin, :starting
+  alias_method :start, :starting
+
+  module Value
+    class Starting
+      include Value
+
+      def initialize(value = nil)
+        @value = value
+      end
+
+      def to_s
+        "^#{value}"
+      end
+    end
+  end
+end

data/lib/hexpress/value/with.rb

@@ -0,0 +1,21 @@
+class Hexpress
+  def with(value)
+    add_value(Value::With, value)
+  end
+  alias_method :has, :with
+  alias_method :including, :with
+
+  module Value
+    class With
+      include Value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def to_s
+        "#{value}"
+      end
+    end
+  end
+end

data/lib/hexpress/values.rb

@@ -0,0 +1,20 @@
+class Hexpress
+  def add_values(hexpression, *vs)
+    add(hexpression.new(*vs))
+  end
+
+  module Values
+    attr_reader :delimiter
+
+    def values
+      @values.map { |v| v.respond_to?(:gsub) ? Regexp.escape(v) : v }
+    end
+
+    def to_s
+      "#{values.join(delimiter)}"
+    end
+  end
+end
+
+require_relative "values/either"
+require_relative "values/range"