attributed_string 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a4dae773b79cef9b5c9f997c44f7965874c3cabf
+  data.tar.gz: 755fede5186b248a7b69e494572718fe540c436a
+SHA512:
+  metadata.gz: 29b01509657b7a0860f2e3d6a76aeec09ef0c26445cabfa44a8cc669a65d03b1065e3baa23f40fb33799b95ce323e4bda6fc5f2dc1385d5f45f3c9755a6c79c5
+  data.tar.gz: b5a0b00339d6997c39d3b81c8a5b43971c70bbafdfa952c001c86bab868826593fed391b64bd9031ee6fa20d05a44cd475b2540d943f32cda21b40c490f86262

data/README.md

@@ -0,0 +1,23 @@
+# attributed_string
+
+Similar to a `NSAttributedString` in Objective-C, this provides an `AttributedString` class. It's similar to a normal `String`, but tracks an array of `AttributedString::Attribute` instances, each of which references a range and a blob of data about that range.
+
+This is useful for storing string formatting information separately from the plain text, while still being about to do transforms like prepend and append operations.
+
+## Example
+
+```ruby
+string    = "This is a test"
+range     = Range.new(0, 3)
+data      = { weight: :bold }
+# This marks the first word as being bold. The implementation of the data is up to you, but here we use a simple Hash.
+attribute = AttributedString::Attribute.new(range, data)
+
+attributed_string = AttributedString.new(string, [attribute])
+
+# This prepends another AttributedString, but keeps track of the position of the original attributes.
+attributed_string.prepend(another_attributed_string)
+
+# Coalesces overlapping attributes of identical data
+attributed_string.fix
+```

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+
+desc "Run specs"
+task :spec do
+  sh "bundle exec rspec"
+end
+
+task :default => :spec

data/lib/attributed_string.rb

@@ -0,0 +1,68 @@
+require 'attributed_string/version'
+require 'attributed_string/attribute'
+
+class AttributedString
+
+  attr_reader :string, :attributes
+
+  def initialize(string, attributes = [])
+    @string     = string
+    @attributes = attributes
+  end
+
+  def <<(attributed_string)
+    @string << attributed_string.string
+    @attributes += attributed_string.attributes
+  end
+
+  def prepend(attributed_string)
+    @string.prepend(attributed_string.string)
+    move_attributes(attributed_string.length)
+    @attributes += attributed_string.attributes
+  end
+
+  def length
+    @string.length
+  end
+
+  def fix
+    # Group into identical data structures
+    grouped_attributes = @attributes.group_by { |a| a.data }.values
+
+    # Sort each group into order
+    grouped_attributes.each do |group|
+      group.sort_by! { |a| a.range.begin }
+    end
+
+    # Merge attributes in identical groups together
+    merged_attributes = grouped_attributes.map do |group|
+      group.inject([]) do |attrs, a|
+        if !attrs.empty? && attributes_overlap?(attrs.last, a)
+          attrs[0...-1] + [merge_attributes(attrs.last, a)]
+        else
+          attrs + [a]
+        end
+      end
+    end
+
+    @attributes = merged_attributes.flatten
+  end
+
+  private
+
+  def move_attributes(offset)
+    @attributes.each do |attribute|
+      attribute.move(offset)
+    end
+  end
+
+  def attributes_overlap?(a, b)
+    a.data == b.data && (a.range.include?(b.range.begin) || b.range.include?(a.range.begin))
+  end
+
+  def merge_attributes(a, b)
+    range = [a.range.begin, b.range.begin].min..[a.range.end, b.range.end].max
+    AttributedString::Attribute.new(range, a.data)
+  end
+
+end

data/lib/attributed_string/attribute.rb

@@ -0,0 +1,16 @@
+class AttributedString
+  class Attribute
+
+    attr_reader :range, :data
+
+    def initialize(range, data)
+      @range = range
+      @data = data
+    end
+
+    def move(offset)
+      @range = Range.new(@range.begin + offset, @range.end + offset, @range.exclude_end?)
+    end
+
+  end
+end

data/lib/attributed_string/version.rb

@@ -0,0 +1,3 @@
+class AttributedString
+  VERSION = "0.1.0"
+end

data/spec/attribute_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe AttributedString::Attribute do
+  let(:range) { Range.new(0, 5) }
+  let(:data) { { foo: :bar } }
+  subject { AttributedString::Attribute.new(range, data) }
+
+  describe '.move' do
+    before { subject.move(3) }
+
+    it "moves the range up" do
+      expect(subject.range).to eq(Range.new(3, 8))
+    end
+  end
+end

data/spec/attributed_string_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+describe AttributedString do
+  let(:string) { "Hello brave new world" }
+  let(:attributes) do
+    [
+      AttributedString::Attribute.new(Range.new(0, 5), { weight: :bold }),
+      AttributedString::Attribute.new(Range.new(6, 11), { weight: :bold }),
+    ]
+  end
+
+  let(:alt_string) { "Testing" }
+  let(:alt_attributes) do
+    [
+      AttributedString::Attribute.new(Range.new(0, 7), { style: :italic }),
+    ]
+  end
+  let(:alt_attributed_string) { AttributedString.new(alt_string.dup, alt_attributes.dup) }
+
+  subject { AttributedString.new(string.dup, attributes.dup) }
+
+  it "should have a length of 21" do
+    expect(subject.length).to eq(21)
+  end
+
+  it "should have the correct attributes" do
+    expect(subject.attributes).to eq(attributes)
+  end
+
+  it "should have the correct string" do
+    expect(subject.string).to eq("Hello brave new world")
+  end
+
+  describe 'appending an AttributedString' do
+    before do
+      subject << alt_attributed_string
+    end
+
+    it "should have the right length" do
+      expect(subject.length).to eq(28)
+    end
+
+    it "should have a concatenated string" do
+      expect(subject.string).to eq("Hello brave new worldTesting")
+    end
+
+    it "should have 3 attributes" do
+      expect(subject.attributes.length).to eq(3)
+    end
+  end
+
+  describe 'prepending an AttributedString' do
+    before do
+      subject.prepend(alt_attributed_string)
+    end
+
+    it "should have the right length" do
+      expect(subject.length).to eq(28)
+    end
+
+    it "should have a concatenated string" do
+      expect(subject.string).to eq("TestingHello brave new world")
+    end
+
+    it "should have 3 attributes" do
+      expect(subject.attributes.length).to eq(3)
+    end
+
+    it "the first and second attributes should have moved up" do
+      expect(subject.attributes[0].range).to eq(Range.new(7, 12))
+      expect(subject.attributes[1].range).to eq(Range.new(13, 18))
+    end
+
+    it "the third attribute should be at the beginning" do
+      expect(subject.attributes[2].range).to eq(Range.new(0, 7))
+    end
+  end
+
+  describe '.fix' do
+    before do
+      subject.fix
+    end
+
+    context 'with non-overlapping attributes' do
+      it "preserves the attributes" do
+        expect(subject.attributes).to eq(attributes)
+      end
+    end
+
+    context 'with two overlapping attributes' do
+      let(:attributes) do
+        [
+          AttributedString::Attribute.new(Range.new(0, 8), { weight: :bold }),
+          AttributedString::Attribute.new(Range.new(6, 11), { weight: :bold }),
+        ]
+      end
+
+      it "reduces to 1 attribute" do
+        expect(subject.attributes.length).to eq(1)
+      end
+
+      it "has the right data" do
+        expect(subject.attributes.first.data).to eq({ weight: :bold })
+      end
+
+      it "has the right range" do
+        expect(subject.attributes.first.range).to eq(Range.new(0, 11))
+      end
+    end
+
+    context 'with two touching attributes' do
+      let(:attributes) do
+        [
+          AttributedString::Attribute.new(Range.new(0, 8), { weight: :bold }),
+          AttributedString::Attribute.new(Range.new(8, 11), { weight: :bold }),
+        ]
+      end
+
+      it "reduces to 1 attribute" do
+        expect(subject.attributes.length).to eq(1)
+      end
+
+      it "has the right data" do
+        expect(subject.attributes.first.data).to eq({ weight: :bold })
+      end
+
+      it "has the right range" do
+        expect(subject.attributes.first.range).to eq(Range.new(0, 11))
+      end
+    end
+
+    context 'with two overlapping attributes in reverse order' do
+      let(:attributes) do
+        [
+          AttributedString::Attribute.new(Range.new(6, 11), { weight: :bold }),
+          AttributedString::Attribute.new(Range.new(0, 8), { weight: :bold }),
+        ]
+      end
+
+      it "reduces to 1 attribute" do
+        expect(subject.attributes.length).to eq(1)
+      end
+
+      it "has the right data" do
+        expect(subject.attributes.first.data).to eq({ weight: :bold })
+      end
+
+      it "has the right range" do
+        expect(subject.attributes.first.range).to eq(Range.new(0, 11))
+      end
+    end
+
+    context 'with three overlapping attributes' do
+      let(:attributes) do
+        [
+          AttributedString::Attribute.new(Range.new(0, 8), { weight: :bold }),
+          AttributedString::Attribute.new(Range.new(6, 11), { weight: :bold }),
+          AttributedString::Attribute.new(Range.new(10, 11), { weight: :bold }),
+        ]
+      end
+
+      it "reduces to 1 attribute" do
+        expect(subject.attributes.length).to eq(1)
+      end
+
+      it "has the right data" do
+        expect(subject.attributes.first.data).to eq({ weight: :bold })
+      end
+
+      it "has the right range" do
+        expect(subject.attributes.first.range).to eq(Range.new(0, 11))
+      end
+    end
+
+    context 'with three attributes, two of which are the same' do
+      let(:attributes) do
+        [
+          AttributedString::Attribute.new(Range.new(0, 8), { weight: :bold }),
+          AttributedString::Attribute.new(Range.new(6, 13), { style: :italic }),
+          AttributedString::Attribute.new(Range.new(8, 11), { weight: :bold }),
+        ]
+      end
+
+      it "reduces to 2 attributes" do
+        expect(subject.attributes.length).to eq(2)
+      end
+
+      it "has the right data for the first" do
+        expect(subject.attributes.first.data).to eq({ weight: :bold })
+      end
+
+      it "has the right range for the first" do
+        expect(subject.attributes.first.range).to eq(Range.new(0, 11))
+      end
+
+      it "has the right data for the second" do
+        expect(subject.attributes[1].data).to eq({ style: :italic })
+      end
+
+      it "has the right range for the first" do
+        expect(subject.attributes[1].range).to eq(Range.new(6, 13))
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'attributed_string'

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: attributed_string
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tom Taylor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- tom@newspaperclub.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/attributed_string.rb
+- lib/attributed_string/attribute.rb
+- lib/attributed_string/version.rb
+- spec/attribute_spec.rb
+- spec/attributed_string_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/newspaperclub/attributed_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.2.2
+signing_key: 
+specification_version: 4
+summary: A String class, but with attributes marking data at specific ranges.
+test_files:
+- spec/attribute_spec.rb
+- spec/attributed_string_spec.rb
+- spec/spec_helper.rb