llt-core 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 99ad6c4858497e80179b2537f7e945f41972b79e
+  data.tar.gz: 6647133228668feb869b4c846525d2345e5da2e9
+SHA512:
+  metadata.gz: 920a2015f453e256c3769381852df4329eba586b1aa3f16c3fb725fde00d58db48964154b4cb07c41ee2167bf077a27e6bbce30eba02a6b41a30fed28df6b9cd
+  data.tar.gz: b1787c797c2af8da0e8e1d1311304cd2a6369d7679cde3c8d3bb0100317ed34bb4200e4a704d1b47d850edc2435439a8c8d110bf8b19d592c534ae32984ebd6e

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--tty

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+before_script:
+  - "export JRUBY_OPTS=--2.0"
+rvm:
+  - 2.1.0
+  - 2.0.0
+  - jruby-20mode

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'coveralls', require: false
+
+# Specify your gem's dependencies in llt-core.gemspec
+gemspec
+
+platform :jruby do
+  gem 'jruby-httpclient'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 LFDM
+
+MIT License
+
+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,29 @@
+# LLT::Core
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'llt-core'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install llt-core
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/llt/core/api/helpers.rb

@@ -0,0 +1,95 @@
+require 'cgi'
+
+module LLT
+  module Core
+    module Api
+      module Helpers
+        def uu(text)
+          CGI.unescape(text)
+        end
+
+        def u(text)
+          CGI.escape(text)
+        end
+
+        # tries to resolve an uri or a text included in the params
+        def extract_text(params)
+          if uri = params[:uri]
+            get_from_uri(uri)
+          else
+            params[:text]
+          end
+        end
+
+        def extract_markup_params(params)
+          mu_params = %i{ recursive indexing inline }
+          extracted = [params[:tags]]
+          relevant = mu_params.each_with_object({}) do |param, h|
+            val = params[param]
+            val = params[param.to_s] if val.nil?
+            h[param] = val unless val.nil?
+          end
+          extracted << relevant
+        end
+
+        def to_xml(elements, params = {})
+          root = params[:root] || 'doc'
+          root_close = root.match(/^\w+/)[0]
+          tags, options = *extract_markup_params(params)
+          body = elements.each_with_object('') do |e, str|
+            # need to clone, otherwise the tags will get eaten
+            # up in the markup method, but we cannot if tags
+            # is nil
+            cloned_tags = (tags ? tags.clone : tags)
+            # Options need to be cloned as well! Time for another
+            # jruby issue: The keywords seem to be eaten up somewhere
+            # along the road. Need to investigate further.
+            str << e.to_xml(cloned_tags, options.clone)
+          end
+          "#{XML_DECLARATION}<#{root}>#{body}</#{root_close}>"
+        end
+
+        def typecast_params!(params)
+          params.each do |k, v|
+            params[k] = typecast(v)
+          end
+        end
+
+        private
+
+        XML_DECLARATION = %{<?xml version="1.0" encoding="UTF-8"?>}
+
+        def typecast(val)
+          if val.kind_of?(Array)
+            val.map { |e| typecast(e) }
+          else
+            case val
+            when 'true'  then true
+            when 'false' then false
+            when 'nil'   then nil
+            else val
+            end
+          end
+        end
+
+        # Net::Http.get is broken in jruby when running in
+        # 2.0 mode - we need to use some different when going
+        # the java route.
+        if RUBY_PLATFORM == 'java'
+          require 'http_client'
+          HTTP_CLIENT = HTTP::Client.new
+
+          def get_from_uri(uri)
+            HTTP_CLIENT.get(uri)
+          end
+        else
+          require 'open-uri'
+
+          def get_from_uri(uri)
+            URI(uri).read
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llt/core/api.rb

@@ -0,0 +1 @@
+require 'llt/core/api/helpers'

data/lib/llt/core/containable.rb

@@ -0,0 +1,138 @@
+module LLT
+  module Core
+    module Containable
+      include Enumerable
+
+      attr_reader :container, :id
+      alias_method :n, :id
+
+      def initialize(string, id = nil)
+        @string = string
+        @container = []
+        @id        = id
+      end
+
+      def <<(obj)
+        @container << obj
+        @container.flatten!
+      end
+
+      def [](arg)
+        @container[arg]
+      end
+
+      def to_s
+        @string
+      end
+
+      def to_xml(tags = nil, indexing: true,
+                             recursive: true,
+                             inline: false,
+                             attrs: {})
+
+        # for easier recursion it's solved in a way that might
+        # look awkward on first sight
+        tags = Array(tags)
+        tag = tags.shift || default_xml_tag
+        end_of_recursion = false
+
+        val = if recursive && all? { |e| e.respond_to?(:to_xml)}
+                attrs.merge!(inline_id(tag)) if inline && indexing
+                recursive_xml(tags, indexing, inline, attrs)
+              else
+                end_of_recursion = true
+                as_xml
+              end
+
+        if inline
+          end_of_recursion ? wrap_with_xml(tag, val, indexing, attrs) : val
+        else
+          wrap_with_xml(tag, val, indexing, attrs)
+        end
+      end
+
+      def as_xml
+        @string
+      end
+
+      def as_json
+        @string
+      end
+
+      # @return [string] the default xml tag defined for the instances class
+      def xml_tag
+        self.class.default_xml_tag
+      end
+      alias_method :default_xml_tag, :xml_tag
+
+      def each(&blk)
+        @container.each(&blk)
+      end
+
+      def all?(&blk)
+        @container.empty? ? false : super
+      end
+
+      def include? x
+        @container.include? x
+      end
+
+      def empty?
+        @container.empty?
+      end
+
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      private
+
+      # id is represented as @n attribute in the xml, as xml:id
+      # is reserved for something else
+      def wrap_with_xml(tag, string, indexing, attrs = {})
+        merge_id!(attrs) if indexing && @id
+        attr = attrs.any? ? " #{to_xml_attrs(attrs)}" : ''
+        "<#{tag}#{attr}>#{string}</#{tag}>"
+      end
+
+      def to_xml_attrs(attrs)
+        attrs.map { |k, v| %{#{k}="#{v}"} }.join(' ')
+      end
+
+      def recursive_xml(tags, indexing, inline, attrs)
+        each_with_object('') do |element, s|
+          s << element.to_xml(tags.clone, indexing: indexing, recursive: true,
+                                          inline: inline, attrs: attrs)
+        end
+      end
+
+      def merge_id!(attrs)
+        attrs.merge!(id_as_xml => @id,)
+      end
+
+      def id_as_xml
+        'n'
+      end
+
+      def inline_id(tag)
+        { "#{tag}_#{id_as_xml}" => @id }
+      end
+
+      module ClassMethods
+        def container_alias(al)
+          alias_method al, :container
+          alias_method "no_#{al}?", :empty?
+        end
+
+        # Defines the default xml tag used by #to_xml
+        def xml_tag(tag)
+          @default_xml_tag = tag
+        end
+
+        def default_xml_tag
+          @default_xml_tag
+        end
+      end
+    end
+  end
+end

data/lib/llt/core/serviceable.rb

@@ -0,0 +1,133 @@
+module LLT
+  module Core
+    # Module that holds the shared functionality of all
+    # LLT Services.
+    #
+    # cf. specs for documentation
+    module Serviceable
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      attr_reader :default_options
+
+      # Initializes a new service instance and configures its services
+      def initialize(options = {})
+        configure(options)
+        set_default_options(options)
+        register
+      end
+
+      # Registers self in the service_class with force
+      def register!
+        guarded do
+          write_to_register
+        end
+      end
+
+      def fork_instance
+        # Not sure atm how services should be handled here -
+        # decide later.
+        self.class.new(@default_options)
+      end
+
+      private
+
+      def set_default_options(opts)
+        # do not want to capture any service instance here
+        # taking the to_s root to enable indifferent access and provide
+        # security against DOS attacks...
+        relevant_keys = self.class.default_options.keys.map(&:to_s)
+        relevant_opts = opts.each_with_object({}) do |(k, v), h|
+          h[k.to_sym] = v if relevant_keys.include?(k.to_s)
+        end
+        @default_options = self.class.default_options.merge(relevant_opts)
+      end
+
+      def parse_option(opt, options)
+        # string keys in options are valid
+        #
+        # we cannot just do simple ||'s, because some options might
+        # be a totally legitimate false
+        option = options[opt]
+        option = options[opt.to_s] if option.nil?
+
+        option.nil? ? @default_options[opt] : option
+      end
+
+      # Sets instance variables for all used services.
+      def configure(options)
+        used_services.each do |service, def_instance|
+          inst = options[service] || registered(service) || def_instance.call
+          instance_variable_set("@#{service}", inst)
+        end
+      end
+
+      def registered(service)
+        guarded do
+          service_class.fetch(service)
+        end
+      end
+
+      def register
+        guarded do
+          write_to_register unless service_class.registered?(service_name)
+        end
+      end
+
+      def used_services
+        self.class.used_services
+      end
+
+      def guarded
+        if service_class
+          yield
+        end
+      end
+
+      def write_to_register
+        service_class.register(service_name => self)
+      end
+
+      # Class that is used to register a service.
+      # Returns LLT::Service if it is defined.
+      def service_class
+        if defined?(LLT::Service)
+          LLT::Service
+        else
+          nil
+        end
+      end
+
+      # Name used to register service
+      # Should be implemented by including class
+      def service_name
+        :undefined_service
+      end
+    end
+
+    module ClassMethods
+      def default_options
+        {}
+      end
+
+      def used_services
+        @used_services ||= {}
+      end
+
+      def method_missing(meth, *args, &blk)
+        if meth.match(/^uses_(.*)/)
+          key = $1.to_sym
+          used_services[key] = blk
+          attr_accessor key
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(meth, include_private = false)
+        meth.match(/^uses_(.*)/) || super
+      end
+    end
+  end
+end

data/lib/llt/core/version.rb

@@ -0,0 +1,5 @@
+module LLT
+  module Core
+    VERSION = "0.0.1"
+  end
+end

data/lib/llt/core.rb

@@ -0,0 +1,8 @@
+require "llt/core/version"
+
+module LLT
+  module Core
+    require 'llt/core/containable'
+    require 'llt/core/serviceable'
+  end
+end

data/llt-core.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'llt/core/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "llt-core"
+  spec.version       = LLT::Core::VERSION
+  spec.authors       = ["LFDM"]
+  spec.email         = ["1986gh@gmail.com"]
+  spec.description   = %q{LLT::Core classes and modules}
+  spec.summary       = %q{Contains classes and modules that are shared across several llt gems}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "simplecov", "~> 0.7"
+  spec.add_dependency "sinatra"
+  spec.add_dependency "sinatra-contrib"
+end

data/spec/lib/llt/core/api/helpers_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'llt/core/api'
+
+describe LLT::Core::Api::Helpers do
+  let(:dummy) do
+    Class.new { include LLT::Core::Api::Helpers }.new
+  end
+
+  describe "#extract_text" do
+    it "tries to resolve a passed or a given text param" do
+      pending
+    end
+  end
+
+  describe "#uu" do
+    it "unescapes url strings" do
+      url = 'http%3A%2F%2Ftest.com'
+      dummy.uu(url).should == 'http://test.com'
+    end
+  end
+
+  describe "#u" do
+    it "escapes url strings" do
+      url = 'http://test.com'
+      dummy.u(url).should == 'http%3A%2F%2Ftest.com'
+    end
+  end
+
+  describe "#extract_markup_params" do
+    it "extracts the relevant params for markup methods from html params" do
+      params = { 'recursive' => true, 'text' => 'test' }
+      dummy.extract_markup_params(params).should == [nil, { recursive: true }]
+    end
+
+    it "returns an array that should be exploded when used with #to_xml" do
+      params = { recursive: true, tags: %w{ a b }}
+      extracted = [%w{ a b }, { recursive: true }]
+      dummy.extract_markup_params(params).should == extracted
+    end
+  end
+
+  describe "#to_xml" do
+    it "calls to xml on all elements of a given array and joins them to a string" do
+      el1, el2 = double, double
+      el1.stub(to_xml: '<a>')
+      el2.stub(to_xml: '<b>')
+      dummy.to_xml([el1, el2]).should =~ /<a><b>/
+    end
+
+    it "includes the xml declaration" do
+      el1 = double
+      el1.stub(to_xml: '<a>')
+      dummy.to_xml([el1]).should =~ /<\?xml version="1\.0" encoding="UTF-8"\?>/
+    end
+
+    it "looks for an optional param 'root', which is used to wrap the xml stream" do
+      el1 = double
+      el1.stub(to_xml: '<a>')
+      res = /<body cite="128">.*<\/body>/
+      dummy.to_xml([el1], { root: 'body cite="128"'}).should =~ res
+    end
+
+    it "its root element defaults to doc" do
+      el1 = double
+      el1.stub(to_xml: '<a>')
+      dummy.to_xml([el1]).should =~ /<doc>.*<\/doc>/
+    end
+  end
+
+  describe "#typecast_params!" do
+    it "does typecasting for boolean strings" do
+      params = { a: 1, b: 'true' }
+      dummy.typecast_params!(params).should == { a: 1, b: true }
+    end
+
+    it "looks into Arrays as well" do
+      params = { a: 'true', b: ['nil', 'false'] }
+      dummy.typecast_params!(params).should == { a: true, b: [nil, false] }
+    end
+  end
+end

data/spec/lib/llt/core/containable_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+describe LLT::Core::Containable do
+  let(:dummy) do
+    Class.new do
+      include LLT::Core::Containable
+    end
+  end
+
+  let(:other_dummy) do
+    Class.new do
+      include LLT::Core::Containable
+    end
+  end
+
+  let(:third_dummy) do
+    Class.new do
+      include LLT::Core::Containable
+    end
+  end
+
+  let(:instance) { dummy.new('') }
+
+  describe "#to_s" do
+    it "returns the string it has been initialized with" do
+      obj = dummy.new('test')
+      obj.to_s.should == 'test'
+    end
+  end
+
+  describe "#id" do
+    it "returns the id it has been initialized with" do
+      obj = dummy.new('test', 1)
+      obj.id.should == 1
+    end
+  end
+
+  describe "#n" do
+    it "is an alias for #id (for xml terminology)" do
+      obj = dummy.new('test', 1)
+      obj.n.should == 1
+    end
+  end
+
+  context "xml handling" do
+    describe ".xml_tag" do
+      it "sets the classes default xml tag" do
+        dummy.xml_tag('s')
+        instance.xml_tag.should == 's'
+      end
+    end
+
+    describe "#as_xml" do
+      it "represent the xml value that is used in #to_xml, defaults to the string it has been initialized with" do
+        obj = dummy.new('test')
+        obj.as_xml.should == 'test'
+      end
+
+      it "can be overwritten" do
+        obj = dummy.new('test')
+        obj.stub(:as_xml) { 'custom' }
+        obj.as_xml.should == 'custom'
+      end
+    end
+
+    describe "#to_xml" do
+      it "returns the #as_xml value as xml with its default tag" do
+        dummy.xml_tag 'test'
+        obj = dummy.new('string')
+        obj.to_xml.should == '<test>string</test>'
+      end
+
+      it "allows the tag to be given as param" do
+        obj = dummy.new('string')
+        obj.to_xml('tag').should == '<tag>string</tag>'
+      end
+
+      it "can be called recursively to include the container elements inside the default tag" do
+        dummy.xml_tag 's'
+        other_dummy.xml_tag 'w'
+
+        sentence = dummy.new('a simple sentence')
+        token1 = other_dummy.new('a')
+        token2 = other_dummy.new('simple')
+        token3 = other_dummy.new('sentence')
+        sentence << [token1, token2, token3]
+        result = '<s><w>a</w><w>simple</w><w>sentence</w></s>'
+        sentence.to_xml(recursive: true).should == result
+      end
+
+      it "allows multiple tags given in an Array, which will be used recursively" do
+        sentence = dummy.new('a simple sentence')
+        token1 = dummy.new('a')
+        token2 = dummy.new('simple')
+        token3 = dummy.new('sentence')
+        token1 << dummy.new('a')
+        sentence << [token1, token2, token3]
+        result = '<a><b><c>a</c></b><b>simple</b><b>sentence</b></a>'
+        sentence.to_xml(%w{ a b c }, recursive: true).should == result
+      end
+
+      it "falls back to the default tags when not enough custom tags are given" do
+        dummy.xml_tag 's'
+
+        sentence = dummy.new('a simple sentence')
+        token1 = dummy.new('a')
+        token2 = dummy.new('simple')
+        token3 = dummy.new('sentence')
+        token1 << dummy.new('a')
+        sentence << [token1, token2, token3]
+        result = '<a><b><s>a</s></b><b>simple</b><b>sentence</b></a>'
+        sentence.to_xml(%w{ a b }, recursive: true).should == result
+      end
+
+      it "can use a mix of custom and default tags if you pass nils" do
+        dummy.xml_tag 's'
+
+        sentence = dummy.new('a simple sentence')
+        token1 = dummy.new('a')
+        token2 = dummy.new('simple')
+        token3 = dummy.new('sentence')
+        token1 << dummy.new('a')
+        sentence << [token1, token2, token3]
+        result = '<a><s><c>a</c></s><s>simple</s><s>sentence</s></a>'
+        sentence.to_xml(['a', nil, 'c'], recursive: true).should == result
+      end
+
+      it "can include the id of an element, as @n attribute" do
+        dummy.xml_tag 's'
+        other_dummy.xml_tag 'w'
+
+        sentence = dummy.new('', 1)
+        token = other_dummy.new('word', 1)
+        sentence << token
+        result = '<s n="1"><w n="1">word</w></s>'
+        sentence.to_xml(indexing: true, recursive: true).should == result
+      end
+
+      it "recursive representation can be inlined" do
+        dummy.xml_tag 's'
+        other_dummy.xml_tag 'w'
+        third_dummy.xml_tag 'f'
+
+        sentence = dummy.new('', 1)
+        token1 = other_dummy.new('', 1)
+        token2 = other_dummy.new('', 2)
+        form1  = third_dummy.new('a', 1)
+        form2  = third_dummy.new('b', 2)
+        token1 << form1
+        token2 << form2
+        sentence << [token1, token2]
+        result = '<f s_n="1" w_n="1" n="1">a</f><f s_n="1" w_n="2" n="2">b</f>'
+        sentence.to_xml(indexing: true, recursive: true, inline: true).should == result
+      end
+    end
+  end
+
+  context "json handling" do
+    describe "#as_json" do
+      it "represent the json value that is used in #to_json, defaults to the string it has been initialized with" do
+        obj = dummy.new('test')
+        obj.as_json.should == 'test'
+      end
+    end
+
+    describe "#to_json" do
+      pending "Not implemented"
+    end
+  end
+
+  describe "#container" do
+    it "returns the contents of the container" do
+      instance.container.should == []
+    end
+  end
+
+  describe "#<<" do
+    it "adds an element to the container" do
+      instance << 1
+      instance.container.should == [1]
+    end
+
+    it "also takes an array, which is flattened" do
+      instance << [1,2]
+      instance.container.should == [1,2]
+    end
+  end
+
+  describe "#each" do
+    it "redirects Enumerable methods to the container" do
+      instance << [1,2]
+      instance.inject(:+).should == 3
+    end
+  end
+
+  describe "#all?" do
+    it "changes implementation of all, which returns false when empty!" do
+      instance.container.should be_empty
+      instance.all?.should be_false
+    end
+  end
+
+  describe "#include?" do
+    it "delegates to the container" do
+      instance << 1
+      instance.include?(1).should be_true
+    end
+  end
+
+  describe "#empty?" do
+    it "delegates to the container" do
+      instance << 1
+      instance.should_not be_empty
+    end
+  end
+
+  describe "#[]" do
+    it "delegates to the container" do
+      instance << 1
+      instance[0].should == 1
+      instance[1].should be_nil
+    end
+  end
+
+  describe ".container_alias" do
+    it "sets an alias to access the container for more idiomaticity" do
+      dummy.container_alias :tokens
+      sentence = instance
+      sentence << [:token, :token]
+      sentence.tokens.should == sentence.container
+    end
+  end
+end

data/spec/lib/llt/core/serviceable_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe LLT::Core::Serviceable do
+  let(:dummy) do
+    Class.new do
+      include LLT::Core::Serviceable
+      attr_reader :a_service
+
+      def service_class
+        nil
+      end
+
+      def service_name
+        :dummy_service
+      end
+
+      def self.default_options
+        {
+          option1: false,
+          option2: true
+        }
+      end
+    end
+  end
+
+  let(:service_class) { double }
+
+  it "provides readers for used services" do
+    dummy.uses_a_service { 1 }
+    instance = dummy.new
+    instance.should respond_to(:a_service)
+  end
+
+  it "provides writers for used services" do
+    dummy.uses_a_service { 1 }
+
+    instance = dummy.new
+    instance.a_service.should == 1
+
+    instance.a_service = 2
+    instance.a_service.should == 2
+  end
+
+  it "provides a reader for the instance's default options" do
+    instance = dummy.new
+    instance.default_options.should == { option1: false, option2: true }
+  end
+
+  describe ".uses_***" do
+    it "provides including classes with the dynamic method .uses_***" do
+      dummy.should respond_to(:uses_a_service)
+      dummy.should respond_to(:uses_another_service)
+    end
+  end
+
+  describe ".used_services" do
+    it "returns service used by the Serviceable including class" do
+      dummy.uses_a_service { 1 }
+      dummy.used_services.should have(1).item
+      dummy.used_services[:a_service].call.should == 1
+    end
+  end
+
+  describe "#initialize" do
+    context "when the class is using a service" do
+      context "with options" do
+        it "sets service as given" do
+          dummy.uses_a_service { 2 }
+          instance = dummy.new(a_service: 1)
+          instance.a_service.should == 1
+        end
+      end
+
+      context "without options" do
+        # service class is usually LLT::Service or nothing
+        it "tries to obtain a service registered in the service class" do
+          service_class.stub(:fetch) { :registered_service }
+          service_class.stub(:registered?) { true }
+          dummy.any_instance.stub(:service_class) { service_class }
+
+          dummy.uses_a_service { 1 }
+          instance = dummy.new
+          instance.a_service.should == :registered_service
+        end
+
+        it "initializes with its default service when service class doesn't have anything" do
+          service_class.stub(:fetch) { nil }
+          service_class.stub(:registered?) { true }
+          dummy.any_instance.stub(:service_class) { service_class }
+
+          dummy.uses_a_service { 1 }
+          instance = dummy.new
+          instance.a_service.should == 1
+        end
+      end
+
+      it "tries to register itself in the service class" do
+        service_class.stub(:registered?) { false }
+        dummy.any_instance.stub(:service_class) { service_class }
+
+        service_class.should receive(:register).with(dummy_service: an_instance_of(dummy))
+
+        dummy.new
+      end
+
+      it "fails to register when such a service is already registered" do
+        service_class.stub(:registered?) { true }
+        dummy.any_instance.stub(:service_class) { service_class }
+
+        service_class.should_not receive(:register)
+
+        dummy.new
+      end
+    end
+
+    context "when the class is not using a service" do
+      it "doesn't instantiate a given service" do
+        dummy.uses_another_service { 2 }
+        instance = dummy.new(a_service: 1)
+        instance.a_service.should be_nil
+      end
+    end
+
+    context "with default options passed in" do
+      it "sets them only if they appear in Class.default_options" do
+        instance = dummy.new(option3: 3)
+        instance.default_options.should == { option1: false, option2: true }
+      end
+
+      it "strings as keys are valid as well" do
+        instance = dummy.new('option1' => 1)
+        instance.default_options.should == { option1: 1, option2: true }
+      end
+
+      it "services are not saved as default options" do
+        dummy.uses_a_service { 1 }
+        instance = dummy.new(a_service: 2)
+        instance.a_service.should == 2
+        instance.default_options.should == { option1: false, option2: true }
+      end
+    end
+  end
+
+  describe "#register!" do
+    it "registers self in the service class (if it's available), even if such a service is present" do
+      service_class.stub(:registered?) { true }
+      dummy.any_instance.stub(:service_class) { service_class }
+
+      service = dummy.new
+
+      service_class.should receive(:register).once
+      service.register!
+    end
+  end
+
+  describe "#fork_instance" do
+    it "returns a new service instance with the same default options as self" do
+      instance = dummy.new(option1: 1, option2: 2)
+      forked = instance.fork_instance
+      forked.should_not == instance
+      forked.default_options.should == instance.default_options
+    end
+  end
+
+  context "private unit tests" do
+    describe "#parse_option" do
+      context "parses a given option from a given options hash in the light of the default options" do
+        it "retains legitimate false values" do
+          instance = dummy.new
+          # just repeating here for clarification
+          instance.default_options.should == { option1: false, option2: true }
+
+          option = instance.send(:parse_option, :option1, { option3: 3 })
+          option.should == false
+        end
+
+        it "works with Symbols and Strings as keys in the options hash" do
+          instance = dummy.new
+          option = instance.send(:parse_option, :option2, { 'option2' => false })
+          option.should == false
+        end
+      end
+    end
+  end
+end

data/spec/lib/llt/core_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe LLT::Core do
+  it 'should have a version number' do
+    LLT::Core::VERSION.should_not be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'simplecov'
+require 'coveralls'
+
+Coveralls.wear!
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'llt/core'
+
+if defined?(LLT::Logger)
+  LLT::Logger.level = nil
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: llt-core
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- LFDM
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  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: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra-contrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: LLT::Core classes and modules
+email:
+- 1986gh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/llt/core.rb
+- lib/llt/core/api.rb
+- lib/llt/core/api/helpers.rb
+- lib/llt/core/containable.rb
+- lib/llt/core/serviceable.rb
+- lib/llt/core/version.rb
+- llt-core.gemspec
+- spec/lib/llt/core/api/helpers_spec.rb
+- spec/lib/llt/core/containable_spec.rb
+- spec/lib/llt/core/serviceable_spec.rb
+- spec/lib/llt/core_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.1.5
+signing_key: 
+specification_version: 4
+summary: Contains classes and modules that are shared across several llt gems
+test_files:
+- spec/lib/llt/core/api/helpers_spec.rb
+- spec/lib/llt/core/containable_spec.rb
+- spec/lib/llt/core/serviceable_spec.rb
+- spec/lib/llt/core_spec.rb
+- spec/spec_helper.rb