brute 5.0.4 → 5.1.0

data/lib/brute/middleware/040_default_compaction_pipeline.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+module Brute
+  module Middleware
+    # Compacts the conversation once it fills too much of the model's window.
+    #
+    # This layer owns the *when*: before each call it estimates the size of the
+    # conversation, and once it reaches `compact_at` of the window it asks a
+    # compactor to bring it down to `compact_to`. What is given up, and in what
+    # order, is the compactor's business.
+    #
+    #   use Brute::Middleware::Loop::ToolResult
+    #   use Brute::Middleware::DefaultCompactionPipeline,
+    #     window:     200_000,
+    #     summariser: Brute::Completion::OpenRouter.new(config: { access_token: key })
+    #   use Brute::Middleware::DefaultToolPipeline, tools: tools
+    #
+    # The compactor it builds is the usual ladder, cheapest first:
+    #
+    #   use Brute::Compaction::Middleware::ToolResults     rewrite older tool output
+    #   use Brute::Compaction::Middleware::SlidingWindow   drop the oldest turns, then steps
+    #   run Brute::Compaction::Summarize                   summarise what is left, until it fits
+    #
+    # Pass `compactor:` to say something else. A Brute::Turn::CompactionPipeline
+    # is the usual thing to pass, but anything answering
+    # `#compact(messages, target:)` will do. Passing no summariser leaves the
+    # terminal doing nothing, which is how an agent says it would rather live
+    # with a full context than pay to shrink it.
+    #
+    # It belongs inside the tool loop rather than around it, so it runs before
+    # every call rather than once a turn -- a long run of tool results can fill
+    # the window without the turn ever ending.
+    #
+    # Sizing anchors on what the provider itself counted for the last call and
+    # measures locally only what has been appended since, so the estimate is
+    # exact for the bulk of the conversation and approximate only for its tail.
+    #
+    # Tool schemas ride in every request and are part of what fills a window,
+    # so they are counted too -- against the trigger when nothing has been
+    # reported yet, and off the target the compactor is given, because what
+    # the schemas occupy is not room the conversation may have. This layer
+    # sits above the tool pipeline, so on the very first call of a turn
+    # env[:tools] is not set yet: pass `tools:` to have them counted then.
+    #
+    # Compaction is lossy, and this layer keeps no record of what it gave up:
+    # it rewrites env[:messages] and says so with :compacted. An application
+    # that keeps a transcript preserves it from there.
+    #
+    #   agent.on(:compacted) { |env, payload| archive(env, payload) }
+    #
+    class DefaultCompactionPipeline < Brute::Middleware::Base
+      def initialize(app, window:, summariser: nil, compactor: nil, keep_steps: 2,
+                     compact_at: 0.7, compact_to: 0.4, token_counter: nil, tools: nil)
+        unless compact_to.positive? && compact_to < compact_at && compact_at <= 1
+          raise ArgumentError, "expected 0 < compact_to < compact_at <= 1, got #{compact_to} and #{compact_at}"
+        end
+
+        @app = app
+        @compactor = compactor || self.class.compactor(summariser: summariser, keep_steps: keep_steps)
+        @window = window
+        @compact_at = compact_at
+        @compact_to = compact_to
+        @token_counter = token_counter || Brute::TokenCounter.default
+        @tools = tools
+      end
+
+      def call(env)
+        env[:compactor] = @compactor
+        compact(env)
+        @app.call(env)
+        env
+      end
+
+      # The ladder this layer wires when it is not given one.
+      def self.compactor(summariser: nil, keep_steps: 2)
+        terminal = Declines.new
+
+        unless summariser.nil?
+          terminal = Brute::Compaction::Summarize.new(summariser, keep_steps: keep_steps)
+        end
+
+        Brute::Turn::CompactionPipeline.new do
+          use Brute::Compaction::Middleware::ToolResults, keep_steps: 1
+          use Brute::Compaction::Middleware::SlidingWindow, keep_steps: keep_steps
+
+          run terminal
+        end
+      end
+
+      # The floor of a pipeline given nothing to summarise with: what the free
+      # layers managed is what the turn gets.
+      class Declines
+        def call(env) = env
+      end
+
+      private
+
+        def compact(env)
+          context = estimate(env)
+
+          if context >= @window * @compact_at
+            before = @token_counter.count(env[:messages])
+            compacted = attempt(env, target(env))
+
+            unless compacted.nil?
+              env[:messages].replace(compacted)
+              # The reported total describes a conversation that no longer
+              # exists, so the next estimate must not build on it. The call
+              # below refreshes it; one that fails leaves the estimate to be
+              # counted from scratch instead of anchored to a fiction.
+              env[:metadata]&.delete(:last_llm_usage)
+              emit(
+                COMPACTED_EVENT,
+                env,
+                { context: context, before: before, after: @token_counter.count(compacted) },
+              )
+            end
+          end
+        end
+
+        # What the conversation alone may occupy: the target, less whatever
+        # the schemas are already taking out of it. A window too small to
+        # hold its own tool schemas is a configuration a compactor cannot
+        # fix, so the floor is 1 rather than a negative target.
+        def target(env)
+          [(@window * @compact_to).to_i - schemas(env), 1].max
+        end
+
+        def schemas(env)
+          tools = @tools || env[:tools]
+
+          if tools.nil?
+            0
+          else
+            @token_counter.count([], tools: tools)
+          end
+        end
+
+        # A compactor that raises is a compactor that declined. Compaction is
+        # an optimisation, and an agent that cannot shrink its context should
+        # carry on with the context it has rather than die of it.
+        def attempt(env, target)
+          compacted = nil
+
+          emit(COMPACT_DURATION_EVENT, env, env[:compactor]) do
+            compacted = env[:compactor].compact(
+              env[:messages],
+              target: target,
+              events: env[:events] || Brute::Turn::Pipeline::NullSink.new,
+              token_counter: @token_counter,
+            )
+          end
+
+          compacted
+        rescue => error
+          (env[:events] ||= []) << { type: :error, data: { error: error, message: error.message } }
+          nil
+        end
+
+        # What the provider counted for the last call already covers the
+        # system prompt, the tool schemas and the chat-template overhead, so
+        # only what has landed since it answered needs counting here.
+        def estimate(env)
+          Brute::TokenCounter.estimate(env, counter: @token_counter, tools: @tools || env[:tools])
+        end
+    end
+  end
+end
+
+__END__
+
+describe "brute/middleware/040_default_compaction_pipeline" do
+  def conversation
+    Brute.log.tap do |log|
+      log.user("ask" + ("x" * 1_000))
+      log.assistant("answer" + ("y" * 1_000))
+    end
+  end
+
+  def usage(total) = { last_llm_usage: Brute::UsageDetection::Usage.new(total: total) }
+
+  def history(turns: 4, size: 6_000)
+    Brute.log.tap do |log|
+      log.system("instructions")
+      turns.times do |n|
+        log.user("question #{n}")
+        log << Brute::Message.new(role: :assistant, content: n.to_s * size)
+      end
+      log.user("the current task")
+      log << Brute::Message.new(role: :assistant, content: "z" * size)
+    end
+  end
+
+  def compactor(&block)
+    Object.new.tap do |double|
+      double.define_singleton_method(:compact) { |messages, target:, **| block.call(messages, target) }
+    end
+  end
+
+  it "compacts only once the window fills, and says what the turn gave up" do
+    asked = []
+    events = []
+    shrinks  = compactor { |messages, target| asked << target; messages.first(1) }
+    declines = compactor { |_messages, target| asked << target; nil }
+    raises   = compactor { |_messages, _target| raise IOError, "the summariser is down" }
+
+    layer = lambda do |compactor|
+      Brute::Middleware::DefaultCompactionPipeline.new(
+        ->(env) { env },
+        compactor: compactor,
+        window: 1_000,
+        compact_at: 0.7,
+        compact_to: 0.4,
+      ).tap do |it|
+        it.define_singleton_method(:emit) { |event, _env, *extras, &work| work&.call; events << [event, *extras] }
+      end
+    end
+
+    env = { messages: conversation, metadata: usage(900) }
+    layer.call(shrinks).call(env)
+
+    asked.should == [400]
+    env[:messages].map(&:role).should == [:user]
+    env[:compactor].equal?(shrinks).should.be.true
+    events.select { |e, _| e == :compacted }.should == [[:compacted, { context: 900, before: 514, after: 256 }]]
+    # The attempt is timed, so the compactor that spends a model call is visible.
+    events.select { |e, _| e == :compact_duration }.length.should == 1
+
+    # Sizing anchors on what the provider counted: under compact_at nothing is
+    # asked and nothing is said.
+    asked.clear
+    events.clear
+    layer.call(shrinks).call({ messages: conversation, metadata: usage(600) })
+    asked.should == []
+    events.should == []
+
+    # ...but what landed since it answered is counted on top of it, and that
+    # is what tips this one over.
+    tail = conversation.tap { |log| log.tool("z" * 400, tool_call_id: "tc1") }
+    layer.call(declines).call({ messages: tail, metadata: usage(600) })
+    asked.should == [400]
+
+    # With nothing reported at all, the whole conversation is counted here.
+    asked.clear
+    layer.call(declines).call({ messages: conversation })
+    asked.should == []
+
+    # A compactor that raises is a compactor that declined: reported, not
+    # fatal. An agent that cannot shrink its context carries on with it.
+    failing = { messages: conversation, events: [], metadata: usage(900) }
+    should.not.raise(IOError) { layer.call(raises).call(failing) }
+    failing[:messages].length.should == 2
+    failing[:events].map { |e| [e[:type], e[:data][:message]] }.should == [[:error, "the summariser is down"]]
+
+    # A target at or above the trigger would compact on every single step.
+    should.raise(ArgumentError) do
+      Brute::Middleware::DefaultCompactionPipeline.new(->(e) { e }, compactor: shrinks, window: 10,
+                                                             compact_at: 0.4, compact_to: 0.7)
+    end
+  end
+
+  it "wires the usual ladder, cheapest first, and only pays when the free layers cannot" do
+    rounds = 0
+    summariser = lambda do |env|
+      rounds += 1
+      env[:messages] << Brute::Message.new(role: :assistant, content: "what happened")
+    end
+
+    ladder = Brute::Middleware::DefaultCompactionPipeline.compactor(summariser: summariser, keep_steps: 1)
+    ladder.should.be.kind_of Brute::Turn::CompactionPipeline
+
+    events = []
+    sink = Object.new.tap { |it| it.define_singleton_method(:<<) { |e| events << e; it } }
+
+    messages = history
+    before = Brute::Compaction::Transcript.tokens(messages)
+    out = ladder.compact(messages, target: 1_500, events: sink)
+
+    Brute::Compaction::Transcript.tokens(out).should.be < before
+    events.select { |e| e[:type] == :compacted }.map { |e| e[:data][:strategy] }
+      .should.include "sliding_window"
+
+    # Given no summariser the terminal declines, and the free layers are all
+    # the agent gets -- a policy said out loud rather than configured.
+    free = Brute::Middleware::DefaultCompactionPipeline.compactor(summariser: nil, keep_steps: 1)
+    free.compact(history, target: 1_500).should.not.be.nil
+
+    # One layer, so it still owns the *when* as well as the what.
+    layer = Brute::Middleware::DefaultCompactionPipeline.new(->(e) { e }, window: 1_000, summariser: summariser)
+    layer.define_singleton_method(:emit) { |_e, _env, *, &work| work&.call }
+    env = { messages: history, metadata: {} }
+    layer.call(env)
+    env[:messages].length.should.be < 11
+  end
+
+  it "counts the schemas it will send, and stops anchoring on a conversation that is gone" do
+    asked = []
+    shrinks = compactor { |messages, target| asked << target; messages.first(1) }
+
+    tool = Brute::Turn::ToolPipeline.new(name: "search", description: "search the web. " * 40) do
+      run ->(env) { env[:result] = "" }
+    end
+    schemas = Brute::TokenCounter.default.count([], tools: [tool])
+
+    layer = lambda do |**options|
+      Brute::Middleware::DefaultCompactionPipeline.new(
+        ->(env) { env },
+        compactor: shrinks,
+        window: 1_000,
+        **options,
+      ).tap { |it| it.define_singleton_method(:emit) { |_event, _env, *, &work| work&.call } }
+    end
+
+    # 650 tokens of conversation, nothing reported yet: under the 700 the
+    # window triggers at, so on its own it is left alone.
+    said = -> { Brute.log.tap { |log| log.user("x" * 2_578) } }
+    Brute::TokenCounter.default.count(said.call).should == 650
+
+    layer.call.call({ messages: said.call, metadata: {} })
+    asked.should == []
+
+    # The same conversation ships with tool schemas in every request, and
+    # counting what they occupy is what tips it over. What is left of the
+    # target after them is what the compactor is asked for -- the schemas are
+    # not room the conversation may have.
+    layer.call(tools: [tool]).call({ messages: said.call, metadata: {} })
+    asked.should == [400 - schemas]
+
+    # Reported usage already covers the schemas, so the warm path must not
+    # count them again -- 600 reported and nothing said since is 600, tools
+    # or no tools.
+    asked.clear
+    layer.call(tools: [tool]).call({ messages: conversation, metadata: usage(600) })
+    asked.should == []
+
+    # What the provider counted describes the conversation as it was. Once
+    # compaction has given part of it up that number is a fiction, so it goes
+    # -- the next estimate counts from scratch rather than building on it.
+    compacted = { messages: conversation, metadata: usage(900) }
+    layer.call.call(compacted)
+    compacted[:messages].length.should == 1
+    compacted[:metadata].key?(:last_llm_usage).should.be.false
+
+    # Nothing given up, nothing invalidated.
+    kept = { messages: conversation, metadata: usage(900) }
+    layer.call(compactor: compactor { |_messages, _target| nil }).call(kept)
+    kept[:metadata].key?(:last_llm_usage).should.be.true
+  end
+end

data/lib/brute/middleware/070_default_tool_pipeline.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+require "brute/truncation"
+require "async"
+require "async/barrier"
+
+module Brute
+  module Middleware
+    class DefaultToolPipeline < Brute::Middleware::Base
+      def initialize(app, tools: [])
+        @app   = app
+        @tools = tools
+      end
+
+      def call(env)
+        env[:tools] = @tools
+        @app.call(env)
+
+        response = env[:messages].last
+
+        if response.respond_to?(:tool_calls) && response.tool_calls.present?
+          tools_to_run = response.tool_calls
+
+          # tool_to_run may be an Array (Brute::ToolCall) or an id-keyed Hash (some libraries' native shape)
+          if tools_to_run.respond_to?(:values)
+            tools_to_run = tools_to_run.values
+          end
+
+          # No idea why we use Array() here... probably in case it's a hash or something...
+          # because reject would work on the hash...
+          tools_to_run = Array(tools_to_run).reject { |tc| tc.name == "question" }
+
+          available_tools = Brute::Tools::Adapter.wrap_all(env[:tools])
+          env[:events] << on_tool_call_start_event(tools_to_run)
+
+          results = []
+
+          # Async::Barrier blocks until all tasks are complete.
+          # Tasks run in parrallel.
+          #
+          Sync do
+            barrier = Async::Barrier.new
+
+            tools_to_run.each do |tool_call|
+              barrier.async do 
+                name = tool_call.name.to_sym
+                args = tool_call.arguments
+
+                # Lifecycle hooks (Brute::Hooks): before_tool may rewrite
+                # :arguments or short-circuit with a :result; approve_tool
+                # denies on a false (or String) return; after_tool may
+                # rewrite :result.
+                call_env = {
+                  name:      name.to_s,
+                  arguments: args,
+                  result:    nil,
+                  denied:    nil,
+                  events:    env[:events],
+                  metadata:  {},
+                  turn_env:  env,
+                }
+                # A subscriber takes part by mutating the call env: set
+                # :result to answer without executing, set :denied to refuse.
+                emit(BEFORE_TOOL_EVENT, env, call_env)
+
+                if call_env[:result].nil?
+                  emit(APPROVE_TOOL_EVENT, env, call_env)
+
+                  if (denial = call_env[:denied])
+                    call_env[:result] = denial.is_a?(String) ? denial : %(Tool call to "#{name}" was denied.)
+                  end
+                end
+
+                # Only the tool's own execution is timed: a call that
+                # before_tool answered, or approve_tool denied, never ran.
+                result = call_env[:result]
+
+                if result.nil?
+                  emit(TOOL_DURATION_EVENT, env, call_env) do
+                    result = available_tools[name].call(call_env[:arguments])
+                  end
+                end
+
+                call_env[:result] = result
+                emit(AFTER_TOOL_EVENT, env, call_env)
+                result = call_env[:result]
+
+                # Coerce to String so Hash results (e.g. Shell's
+                # {stdout:, stderr:, exit_code:}) serialize predictably.
+                if result.is_a?(String)
+                  content = result
+                else
+                  content = result.to_s
+                end
+
+                # Universal truncation safety net — skip if already truncated
+                unless Brute::Truncation.already_truncated?(content)
+                  content = Brute::Truncation.truncate(content)
+                end
+
+                results << [tool_call, content]
+              rescue => e
+                # Capture the error as a tool result so the LLM can see it
+                # and reason about the failure, rather than crashing the
+                # entire middleware chain.
+                env[:events] << { type: :error, data: { error: e, message: e.message } }
+                results << [tool_call, "Error: #{e.class}: #{e.message}"]
+              end
+            end
+
+            barrier.wait
+          ensure
+            barrier&.cancel
+          end
+
+          # Append events and messages in the original tool_call order so the
+          # LLM sees a deterministic sequence regardless of completion order.
+          results.sort_by! { |tool_call, _| tools_to_run.index(tool_call) }
+
+          results.each do |tool_call, content|
+            env[:events] << { type: :tool_result, data: { name: tool_call.name, content: content } }
+            env[:messages] << Brute::Message.new(role: :tool, content: content, tool_call_id: tool_call.id)
+          end
+        end
+
+        env
+      end
+
+      private
+
+        def on_tool_call_start_event(pending_tools)
+          {
+            type: :tool_call_start,
+            data: pending_tools.map { |tc|
+              {
+                name: tc.name,
+                call_id: tc.id,
+                arguments: tc.arguments
+              }
+            }
+          }
+        end
+    end
+  end
+end
+
+__END__
+
+describe "brute/middleware/070_default_tool_pipeline" do
+  require "brute/messages"
+  require "brute/truncation"
+
+  it "passes through when no tool calls pending" do
+    inner = ->(env) {
+      env[:messages] << Brute::Message.new(role: :assistant, content: "hi")
+    }
+    mw = Brute::Middleware::DefaultToolPipeline.new(inner, tools: [])
+    env = {
+      messages: Brute.log,
+      events: [],
+    }
+    env[:messages].user("hello")
+    mw.call(env)
+    env[:messages].last.content.should == "hi"
+  end
+
+  it "advertises its tools on env[:tools] on the way in" do
+    seen = nil
+    inner = ->(env) { seen = env[:tools] }
+    tool = { name: "echo", description: "", execute: ->(**) { "ok" } }
+    mw = Brute::Middleware::DefaultToolPipeline.new(inner, tools: [tool])
+    env = { messages: Brute.log, events: [] }
+    env[:messages].user("hi")
+    mw.call(env)
+    seen.should == [tool]
+  end
+
+  # --- lifecycle hooks (Brute::Hooks) ---
+
+  # A layer only gets its emit from the builder that made it, so a hook spec
+  # builds a real pipeline rather than instantiating the middleware alone.
+  def hooked(inner, tools:, &subscribe)
+    pipeline = Brute::Turn::Pipeline.new
+    pipeline.use Brute::Middleware::DefaultToolPipeline, tools: tools
+    pipeline.run(Object.new.tap { |o| o.define_singleton_method(:call, &inner) })
+    subscribe.call(pipeline)
+    pipeline
+  end
+
+  def hook_env
+    { messages: Brute.log, events: [] }
+  end
+
+  it "before_tool may rewrite arguments and short-circuit with a result" do
+    tool = { name: "echo", description: "", execute: ->(text:) { "ran:#{text}" } }
+    inner = ->(env) do
+      env[:messages] << Brute::Message.new(role: :assistant, content: "",
+        tool_calls: [{ id: "tc1", name: "echo", arguments: { "text" => "orig" } }])
+    end
+
+    pipeline = hooked(inner, tools: [tool]) do |p|
+      p.on(:before_tool) { |_env, call| call[:arguments] = { text: "rewritten" } }
+    end
+    env = hook_env
+    env[:messages].user("hi")
+    pipeline.call(env)
+    env[:messages].last.content.should == "ran:rewritten"
+
+    canned = hooked(inner, tools: [tool]) { |p| p.on(:before_tool) { |_env, call| call[:result] = "canned" } }
+    env2 = hook_env
+    env2[:messages].user("hi")
+    canned.call(env2)
+    env2[:messages].last.content.should == "canned" # never executed
+  end
+
+  it "approve_tool denies on false (generic message) or String (custom)" do
+    tool = { name: "exec", description: "", execute: ->(**) { "ran" } }
+    inner = ->(env) do
+      env[:messages] << Brute::Message.new(role: :assistant, content: "",
+        tool_calls: [{ id: "tc1", name: "exec", arguments: {} }])
+    end
+
+    denied = hooked(inner, tools: [tool]) { |p| p.on(:approve_tool) { |_env, call| call[:denied] = true } }
+    env = hook_env
+    env[:messages].user("hi")
+    denied.call(env)
+    env[:messages].last.content.should == %(Tool call to "exec" was denied.)
+
+    by_policy = hooked(inner, tools: [tool]) { |p| p.on(:approve_tool) { |_env, call| call[:denied] = "denied by policy" } }
+    env2 = hook_env
+    env2[:messages].user("hi")
+    by_policy.call(env2)
+    env2[:messages].last.content.should == "denied by policy"
+  end
+
+  it "after_tool may rewrite the result" do
+    tool = { name: "echo", description: "", execute: ->(**) { "raw" } }
+    inner = ->(env) do
+      env[:messages] << Brute::Message.new(role: :assistant, content: "",
+        tool_calls: [{ id: "tc1", name: "echo", arguments: {} }])
+    end
+
+    pipeline = hooked(inner, tools: [tool]) do |p|
+      p.on(:after_tool) { |_env, call| call[:result] = "rewrote(#{call[:result]})" }
+    end
+    env = hook_env
+    env[:messages].user("hi")
+    pipeline.call(env)
+    env[:messages].last.content.should == "rewrote(raw)"
+  end
+
+  # --- Universal output truncation ---
+
+  it "truncates large tool results via Truncation" do
+    # A fake tool that returns a huge string
+    big_tool = Class.new(Brute::Tool) do
+      description "test tool"
+      param :input, type: "string", desc: "input"
+      def name; "big_tool"; end
+      def execute(input:)
+        "line\n" * 3000
+      end
+    end
+
+    tool_calls = [
+      Brute::ToolCall.new(
+        id: "tc_1",
+        name: "big_tool",
+        arguments: { "input" => "go" },
+      )
+    ]
+
+    inner = ->(env) {
+      env[:messages] << Brute::Message.new(role: :assistant, content: "", tool_calls: tool_calls)
+    }
+    pipeline = hooked(inner, tools: [big_tool]) { |_p| nil }
+    env = {
+      messages: Brute.log,
+      events: [],
+    }
+    env[:messages].user("hello")
+    pipeline.call(env)
+
+    tool_msg = env[:messages].select { |m| m.role == :tool }.last
+    tool_msg.content.lines.size.should.be < 2100
+    tool_msg.content.should =~ /truncated/i
+  end
+
+  # --- Skip double-truncation ---
+
+  it "does not double-truncate already-truncated output" do
+    # A fake tool that returns output already containing the truncation marker
+    pre_truncated_tool = Class.new(Brute::Tool) do
+      description "test tool"
+      param :input, type: "string", desc: "input"
+      def name; "pre_truncated_tool"; end
+      def execute(input:)
+        "some result\n[Output truncated: showing 100 of 5000 lines]"
+      end
+    end
+
+    tool_calls = [
+      Brute::ToolCall.new(
+        id: "tc_2",
+        name: "pre_truncated_tool",
+        arguments: { "input" => "go" },
+      )
+    ]
+
+    inner = ->(env) {
+      env[:messages] << Brute::Message.new(role: :assistant, content: "", tool_calls: tool_calls)
+    }
+    pipeline = hooked(inner, tools: [pre_truncated_tool]) { |_p| nil }
+    env = {
+      messages: Brute.log,
+      events: [],
+    }
+    env[:messages].user("hello")
+    pipeline.call(env)
+
+    tool_msg = env[:messages].select { |m| m.role == :tool }.last
+    # Should contain exactly one truncation marker, not two
+    tool_msg.content.scan(/Output truncated/).size.should == 1
+  end
+end