token_string 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 53556486561d1dffead617ffce1d46ed8f529ead
+  data.tar.gz: 8240e2bbd64b9d12e477cab348326edd8bcaf51e
+SHA512:
+  metadata.gz: 54875ab90d4fd9c5c142c91161ffff930ff92bcf36b1536d44a6516744db38cb4da1d860f9f67dd36951ffc16c49076992361dd54f956fc7f205e1a0279677fc
+  data.tar.gz: 4dfae4665483113ef0a26d366b00a7d31f8a64cbd76273f99e7ec779a859fd7e473b2ff0959951a6eab9ad3eb95c6246955ed111ca2d23f1ad278660d1a479ac

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Gyula László
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,86 @@
+token_string
+============
+
+Provides a way to deal with CamelCase, snake_case and more in a more elegant way then ActiveSupport::Inflector.
+
+
+examples of usage:
+```ruby
+
+irb(main):001:0> require 'token_string'
+=> true
+
+# Use TokenString.from <format>, <string> to create a tokenized version
+# of a string.
+
+irb(main):002:0>  a = TokenString.from :camel, 'PropertyDb'
+=> #<TokenString::Impl:0x007fce5383a7b0 @format=:camel, @tokens=["Property", "Db"]>
+irb(main):003:0>  b = TokenString.make :snake, 'mkz','monkeyplug'
+=> #<TokenString::Impl:0x007fce5309ef38 @format=:snake, @tokens=["mkz", "monkeyplug"]>
+
+# Add a prefix to the string. The ! on the end indicates that this
+# version of prefix will clone the array of tokens then alters and returns the clone.
+
+irb(main):004:0>  r = a.prefix!(b)
+=> #<TokenString::Impl:0x007fce5308f240 @format=:camel, @tokens=["mkz", "monkeyplug", "Property", "Db"]>
+
+# The format of the clone stays the same
+irb(main):005:0> r.format
+=> :camel
+
+# We can access the formatted version using to_s
+
+irb(main):006:0> r.to_s
+=> "MkzMonkeyplugPropertyDb"
+
+# derive(<prefix>, <postfixes>...) creates a clone and adds <prefix> to
+# the beginning and <postifixes to the end.
+
+irb(main):007:0> r.derive("make", "object", "controller")
+=> #<TokenString::Impl:0x007fce53064838 @format=:camel, @tokens=["make", "mkz", "monkeyplug", "Property", "Db", "object", "controller"]>
+
+# Calling #snake #human #const or #camel on the object returns a copy of
+# the object with the new format.
+#
+# WARNING: adding prefixes and postfixes without cloning the objct first
+# modifies the existing token list in that object.
+
+irb(main):008:0> r.snake
+# => #<TokenString::Impl:0x007fce53055180 @format=:snake, @tokens=["mkz", "monkeyplug", "Property", "Db"]>
+irb(main):009:0> t = r.derive("make", "object", "controller")
+# => #<TokenString::Impl:0x007fce53036a00 @format=:camel, @tokens=["make", "mkz", "monkeyplug", "Property", "Db", "object", "controller"]>
+irb(main):010:0> t.format
+# => :camel
+irb(main):011:0> ts = t.snake
+# => #<TokenString::Impl:0x007fce530258e0 @format=:snake, @tokens=["make", "mkz", "monkeyplug", "Property", "Db", "object", "controller"]>
+irb(main):013:0> ts.to_s
+# => "make_mkz_monkeyplug_property_db_object_controller"
+irb(main):014:0> r.to_s
+# => "MkzMonkeyplugPropertyDb"
+irb(main):015:0> r.force(:snake)
+# => #<TokenString::Impl:0x007fce5308f240 @format=:snake, @tokens=["mkz", "monkeyplug", "Property", "Db"]>
+irb(main):016:0> r.to_s
+# => "mkz_monkeyplug_property_db"
+irb(main):017:0> v = r.const
+# => #<TokenString::Impl:0x007fce53aeb518 @format=:const, @tokens=["mkz", "monkeyplug", "Property", "Db"]>
+irb(main):018:0> v.to_s
+# => "MKZ_MONKEYPLUG_PROPERTY_DB"
+irb(main):019:0> r.to_s
+# => "mkz_monkeyplug_property_db"
+irb(main):020:0> v == r
+# => true
+
+```
+
+Built-in formats
+================
+
+Currently the built in formats:
+* :camel => CamelCase
+* :snake => snake_case
+* :human => Human Case
+* :const => CONST_CASE
+
+
+But declaring new formats is easy (look at the end of token_string.rb).
+

data/lib/token_string.rb

@@ -0,0 +1,216 @@
+class TokenString
+
+  class Format
+
+    # Convert an input string in this format to a token list and validate it
+    def convert_from str
+      t = tokenize( str ).reject {|tok| tok == nil || tok.empty?}
+      unless t.all?{|tok| validate(tok)}
+        raise ArgumentError.new("Bad token in input: #{str.inspect} (tokens: #{t.inspect})")
+      end
+      t
+    end
+
+    # Converts the tokens to this format.
+    def convert_to tokens
+      join( tokens.map{|t| process(t.to_s) })
+    end
+
+    # Validate each token. For now its just to check if they are an identifier.
+    def validate token
+      token =~ /[A-Za-z0-9]/
+    end
+  end
+
+
+  # Register a Format.
+  #
+  # Registering a format adds that format to the available formats and
+  # creates two accessors on Impl instances: the name of the #<format>
+  # which creates a copy of the Impl with the requested format,
+  # and #<format>! which clones then sets the format.
+  def self.add name, format
+    @converters = {} unless @converters
+    @converters[name] = format
+    # Register a converter for Impl
+    Impl.class_eval([
+      "def #{name}; Impl.new(:#{name}, @tokens); end",
+      "def #{name}!; clone.force(:#{name}); end",
+    ].join("\n") )
+  end
+
+  # Helper to convert a list of tokens to a specific format
+  def self.convert_tokens_to( stream, format )
+    c_to = @converters[format]
+    return str unless c_to
+    c_to.convert_to( stream )
+  end
+
+  # Gets a list of all the known formats.
+  def self.known_formats
+    @converters.keys
+  end
+
+  # Creates a new TokenString from the given string using the
+  # supplied format.
+  #
+  # If no such format is registered, the method throws
+  # an NoSuchConverterError.
+  #
+  # If the converter finds the string invalid, it throws
+  # an ArgumentError.
+  def self.from( format, string )
+    converter = @converters[format]
+    unless converter
+      raise NoSuchConverterError.new(
+        "Unknown format for input: #{format.inspect}." +
+        "Available formats: #{@converters.keys.inspect}")
+    end
+    Impl.new( format, converter.convert_from( string ) )
+  end
+
+
+  # Construct a new TokenString from the format and tokens.
+  def self.make( format, *tokens )
+    Impl.new( format, linearize_tokens(tokens.flatten) )
+  end
+
+
+  # The value type that implements the whole shebang.
+  class Impl
+    attr_reader :format, :tokens
+
+    #:nodoc:
+    def initialize( format, tokens)
+      # this should be called only from TokenString.from & TokenString.make
+      @format, @tokens = format, tokens
+    end
+
+    # "cast" this Imple to a different type.
+    # These casts use the same underlying buffer to be cheap.
+    def to(new_format)
+      Impl.new( new_format, tokens )
+    end
+
+
+    # Make this Impl a different type.
+    #
+    # This method simply sets format to the given new
+    # format.
+    def force(new_format)
+      @format = new_format
+      self
+    end
+
+    # Convert to string
+    def to_s
+      TokenString.convert_tokens_to( @tokens, @format )
+    end
+
+    # Two such strings should be equal independent of the representation
+    def ==(other)
+      return false unless other
+      other.tokens == tokens
+    end
+
+    # Clones
+    def clone
+      Impl.new( format, tokens.map{|t|t})
+    end
+
+    # Editing the contents of the string
+    # ----------------------------------
+
+    # Appends a token to the beginning to the tokens
+    def prefix( *pf )
+      tokens.unshift(*TokenString.linearize_tokens(pf))
+      self
+    end
+
+    # Equal to calling .clone.prefix(...)
+    def prefix!( *pf )
+      clone.prefix(*pf)
+    end
+
+    # Appends a token to the end of the tokens
+    def postfix( *pf )
+      tokens.push(*TokenString.linearize_tokens(pf))
+      self
+    end
+
+    # Equal to calling .clone.postfix(...)
+    def postfix!( *pf )
+      clone.postfix(*pf)
+    end
+
+    # Equal to calling prefix(<prefix>).postfix(<postfix>)
+    def surround( prefix_, *postfix_ )
+      prefix( prefix_ )
+      postfix( *postfix_ ) unless postfix_.empty?
+      self
+    end
+
+    # Equal to calling clone.surround()
+    def derive!(*args)
+      clone.surround( *args)
+    end
+
+    alias :derive :derive!
+
+
+    # Some string methods that may get called on us
+    def lines; [to_s]; end
+
+  end
+
+  class NoSuchConverterError < ArgumentError
+    def initialize msg, *args
+      super(msg, *args)
+    end
+  end
+
+  private
+  #
+  # :nodoc
+  def self.linearize_tokens toks
+    o = []
+    return o unless toks
+    toks.each do |tok|
+      case
+      when !tok then # nothing...
+      when tok.is_a?(Impl) then o.push(*linearize_tokens(tok.tokens))
+      else o << tok
+      end
+    end
+    o
+  end
+end
+
+class HumanFormat < TokenString::Format
+  def tokenize(str);          str.split( /\s+/);  end
+  def process(token);   token.capitalize;  end
+  def join(tokens);    tokens.join(' ');   end
+end
+
+class SnakeCase < TokenString::Format
+  def tokenize(str);          str.split( /_+/);  end
+  def process(token);   token.downcase;  end
+  def join(tokens);    tokens.join('_');   end
+end
+
+class CamelCase < TokenString::Format
+  def tokenize(str);    str.gsub( /[A-Z]+/, '_\0' ).split(/_+/);  end
+  def process(token);   token.capitalize;  end
+  def join(tokens);    tokens.join('');   end
+end
+
+class ConstCase < TokenString::Format
+  def tokenize(str);    str.split(/_+/);  end
+  def process(token);   token.upcase;  end
+  def join(tokens);     tokens.join('_');   end
+end
+
+TokenString.add :human, HumanFormat.new
+TokenString.add :const, ConstCase.new
+TokenString.add :camel, CamelCase.new
+TokenString.add :snake, SnakeCase.new

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: token_string
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Gyula Laszlo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-12 00:00:00.000000000 Z
+dependencies: []
+description: Provides a way to deal with CamelCase, snake_case and more in a more
+  elegant way then ActiveSupport::Inflector
+email: gyula.laszlo.gm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/token_string.rb
+- LICENSE
+- README.md
+homepage: https://github.com/gyulalaszlo/token_string
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: TokenString
+test_files: []